svx/source/customshapes/EnhancedCustomShapeGeometry.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/config.h>
  21
  22 #include <cmath>
  23 #include <limits>
  24
  25 #include <svx/EnhancedCustomShapeGeometry.hxx>
  26 #include <com/sun/star/drawing/EnhancedCustomShapeGluePointType.hpp>
  27
  28 const sal_Int32 MIN_INT32 = std::numeric_limits<sal_Int32>::min();
  29
  30 const sal_Int32 mso_sptDefault1400[] =
  31 {
  32     1, 1400
  33 };
  34 const sal_Int32 mso_sptDefault1800[] =
  35 {
  36     1, 1800
  37 };
  38 const sal_Int32 mso_sptDefault2500[] =
  39 {
  40     1, 2500
  41 };
  42 const sal_Int32 mso_sptDefault2700[] =
  43 {
  44     1, 2700
  45 };
  46 const sal_Int32 mso_sptDefault3600[] =
  47 {
  48     1, 3600
  49 };
  50 const sal_Int32 mso_sptDefault3700[] =
  51 {
  52     1, 3700
  53 };
  54 const sal_Int32 mso_sptDefault5400[] =
  55 {
  56     1, 5400
  57 };
  58 const sal_Int32 mso_sptDefault7200[] =
  59 {
  60     1, 7200
  61 };
  62 const sal_Int32 mso_sptDefault8100[] =
  63 {
  64     1, 8100
  65 };
  66 const sal_Int32 mso_sptDefault9600[] =
  67 {
  68     1, 9600
  69 };
  70 const sal_Int32 mso_sptDefault10800[] =
  71 {
  72     1, 10800
  73 };
  74 const sal_Int32 mso_sptDefault12000[] =
  75 {
  76     1, 12000
  77 };
  78 const sal_Int32 mso_sptDefault13500[] =
  79 {
  80     1, 13500
  81 };
  82 const sal_Int32 mso_sptDefault16200[] =
  83 {
  84     1, 16200
  85 };
  86 const sal_Int32 mso_sptDefault16200and5400[] =
  87 {
  88     2, 16200, 5400
  89 };
  90
  91 const SvxMSDffVertPair mso_sptArcVert[] =
  92 {
  93     { 0, 0 }, { 21600, 21600 }, { 3 MSO_I, 1 MSO_I }, { 7 MSO_I, 5 MSO_I }, { 10800, 10800 },
  94     { 0, 0 }, { 21600, 21600 }, { 3 MSO_I, 1 MSO_I }, { 7 MSO_I, 5 MSO_I }
  95 };
  96 const sal_uInt16 mso_sptArcSegm[] =
  97 {
  98     0xa604, 0xab00, 0x0001, 0x6001, 0x8000,
  99     0xa604, 0xaa00, 0x8000
 100 };
 101 const SvxMSDffCalculationData mso_sptArcCalc[] =
 102 {
 103     { 0x4009, { 10800, DFF_Prop_adjustValue, 0 } },
 104     { 0x2000, { 0x400, 10800, 0 } },
 105     { 0x400a, { 10800, DFF_Prop_adjustValue, 0 } },
 106     { 0x2000, { 0x402, 10800, 0 } },
 107     { 0x4009, { 10800, DFF_Prop_adjust2Value, 0 } },
 108     { 0x2000, { 0x404, 10800, 0 } },
 109     { 0x400a, { 10800, DFF_Prop_adjust2Value, 0 } },
 110     { 0x2000, { 0x406, 10800, 0 } }
 111 };
 112 const sal_Int32 mso_sptArcDefault[] =
 113 {
 114     2, 270, 0
 115 };
 116 const SvxMSDffVertPair mso_sptStandardGluePoints[] =
 117 {
 118     { 10800, 0 }, { 0, 10800 }, { 10800, 21600 }, { 21600, 10800 }
 119 };
 120 const SvxMSDffHandle mso_sptArcHandle[] =
 121 {
 122     {   SvxMSDffHandleFlags::POLAR | SvxMSDffHandleFlags::RADIUS_RANGE,
 123         10800, 0x100, 10800, 10800, 10800, 10800, MIN_INT32, 0x7fffffff },
 124     {   SvxMSDffHandleFlags::POLAR | SvxMSDffHandleFlags::RADIUS_RANGE,
 125         10800, 0x101, 10800, 10800, 10800, 10800, MIN_INT32, 0x7fffffff }
 126 };
 127 const mso_CustomShape msoArc =
 128 {
 129     const_cast<SvxMSDffVertPair*>(mso_sptArcVert), SAL_N_ELEMENTS( mso_sptArcVert ),
 130     const_cast<sal_uInt16*>(mso_sptArcSegm), sizeof( mso_sptArcSegm ) >> 1,
 131     const_cast<SvxMSDffCalculationData*>(mso_sptArcCalc), SAL_N_ELEMENTS( mso_sptArcCalc ),
 132     const_cast<sal_Int32*>(mso_sptArcDefault),
 133     nullptr, 0,
 134     21600, 21600,
 135     MIN_INT32, MIN_INT32,
 136     nullptr, 0,
 137     const_cast<SvxMSDffHandle*>(mso_sptArcHandle), SAL_N_ELEMENTS( mso_sptArcHandle )        // handles
 138 };
 139
 140 const SvxMSDffVertPair mso_sptTextSimpleVert[] =
 141 {
 142     { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 }, { 0, 0 }
 143 };
 144 const mso_CustomShape msoTextSimple =
 145 {
 146     const_cast<SvxMSDffVertPair*>(mso_sptTextSimpleVert), SAL_N_ELEMENTS( mso_sptTextSimpleVert ),
 147     nullptr, 0,
 148     nullptr, 0,
 149     nullptr,
 150     nullptr, 0,
 151     21600, 21600,
 152     MIN_INT32, MIN_INT32,
 153     nullptr, 0,
 154     nullptr, 0     // handles
 155 };
 156
 157 const SvxMSDffVertPair mso_sptRectangleVert[] =
 158 {
 159     { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 }, { 0, 0 }
 160 };
 161 const mso_CustomShape msoRectangle =
 162 {
 163     const_cast<SvxMSDffVertPair*>(mso_sptRectangleVert), SAL_N_ELEMENTS( mso_sptRectangleVert ),
 164     nullptr, 0,
 165     nullptr, 0,
 166     nullptr,
 167     nullptr, 0,
 168     21600, 21600,
 169     MIN_INT32, MIN_INT32,
 170     nullptr, 0,
 171     nullptr, 0     // handles
 172 };
 173
 174 const SvxMSDffVertPair mso_sptRoundRectangleVert[] = // adj value 0 -> 10800
 175 {
 176     { 7 MSO_I, 0 }, { 0, 8 MSO_I }, { 0, 9 MSO_I }, { 7 MSO_I, 21600 },
 177     { 10 MSO_I, 21600 }, { 21600, 9 MSO_I }, { 21600, 8 MSO_I }, { 10 MSO_I, 0 }
 178 };
 179 const sal_uInt16 mso_sptRoundRectangleSegm[] =
 180 {
 181     0x4000, 0xa701, 0x0001, 0xa801, 0x0001, 0xa701, 0x0001, 0xa801, 0x6000, 0x8000
 182 };
 183 const SvxMSDffCalculationData mso_sptRoundRectangleCalc[] =
 184 {
 185     { 0x000e, { 0, 45, 0 } },
 186     { 0x6009, { DFF_Prop_adjustValue, 0x400, 0 } },
 187     { 0x2001, { 0x401, 3163, 7636 } },
 188     { 0x6000, { DFF_Prop_geoLeft, 0x402, 0 } },
 189     { 0x6000, { DFF_Prop_geoTop, 0x402, 0 } },
 190     { 0xa000, { DFF_Prop_geoRight, 0, 0x402 } },
 191     { 0xa000, { DFF_Prop_geoBottom, 0, 0x402 } },
 192     { 0x6000, { DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 } },
 193     { 0x6000, { DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 } },
 194     { 0xa000, { DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue } },
 195     { 0xa000, { DFF_Prop_geoRight, 0, DFF_Prop_adjustValue } }
 196 };
 197 const SvxMSDffTextRectangles mso_sptRoundRectangleTextRect[] =
 198 {
 199     { { 3 MSO_I, 4 MSO_I }, { 5 MSO_I, 6 MSO_I } }
 200 };
 201 const SvxMSDffHandle mso_sptRoundRectangleHandle[] =
 202 {
 203     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::SWITCHED,
 204         0x100, 0, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
 205 };
 206 const mso_CustomShape msoRoundRectangle =
 207 {
 208     const_cast<SvxMSDffVertPair*>(mso_sptRoundRectangleVert), SAL_N_ELEMENTS( mso_sptRoundRectangleVert ),
 209     const_cast<sal_uInt16*>(mso_sptRoundRectangleSegm), sizeof( mso_sptRoundRectangleSegm ) >> 1,
 210     const_cast<SvxMSDffCalculationData*>(mso_sptRoundRectangleCalc), SAL_N_ELEMENTS( mso_sptRoundRectangleCalc ),
 211     const_cast<sal_Int32*>(mso_sptDefault3600),
 212     const_cast<SvxMSDffTextRectangles*>(mso_sptRoundRectangleTextRect), SAL_N_ELEMENTS( mso_sptRoundRectangleTextRect ),
 213     21600, 21600,
 214     10800, 10800,
 215     nullptr, 0,
 216     const_cast<SvxMSDffHandle*>(mso_sptRoundRectangleHandle), SAL_N_ELEMENTS( mso_sptRoundRectangleHandle )      // handles
 217 };
 218
 219 const SvxMSDffVertPair mso_sptRightTriangleVert[] =
 220 {
 221     { 0, 0 }, { 21600, 21600 }, { 0, 21600 }, { 0, 0 }
 222 };
 223 const SvxMSDffTextRectangles mso_sptRightTriangleTextRect[] =
 224 {
 225     { { 1900, 12700 }, { 12700, 19700 } }
 226 };
 227 const SvxMSDffVertPair mso_sptRightTriangleGluePoints[] =
 228 {
 229     { 0, 0 }, { 0, 10800 }, { 0, 21600 }, { 10800, 21600 }, { 21600, 21600 }, { 10800, 10800 }
 230 };
 231 const mso_CustomShape msoRightTriangle =
 232 {
 233     const_cast<SvxMSDffVertPair*>(mso_sptRightTriangleVert), SAL_N_ELEMENTS( mso_sptRightTriangleVert ),
 234     nullptr, 0,
 235     nullptr, 0,
 236     nullptr,
 237     const_cast<SvxMSDffTextRectangles*>(mso_sptRightTriangleTextRect), SAL_N_ELEMENTS( mso_sptRightTriangleTextRect ),
 238     21600, 21600,
 239     MIN_INT32, MIN_INT32,
 240     const_cast<SvxMSDffVertPair*>(mso_sptRightTriangleGluePoints), SAL_N_ELEMENTS( mso_sptRightTriangleGluePoints ),
 241     nullptr, 0     // handles
 242 };
 243
 244 const SvxMSDffVertPair mso_sptEllipseVert[] =
 245 {
 246     { 10800, 10800 }, { 10800, 10800 },  { 0, 360 }
 247 };
 248 const sal_uInt16 mso_sptEllipseSegm[] =
 249 {
 250     0xa203, 0x6000, 0x8000
 251 };
 252 const SvxMSDffTextRectangles mso_sptEllipseTextRect[] =
 253 {
 254     { { 3163, 3163 }, { 18437, 18437 } }
 255 };
 256 const SvxMSDffVertPair mso_sptEllipseGluePoints[] =
 257 {
 258     { 10800, 0 }, { 3163, 3163 }, { 0, 10800 }, { 3163, 18437 }, { 10800, 21600 }, { 18437, 18437 }, { 21600, 10800 }, { 18437, 3163 }
 259 };
 260 const mso_CustomShape msoEllipse =
 261 {
 262     const_cast<SvxMSDffVertPair*>(mso_sptEllipseVert), SAL_N_ELEMENTS( mso_sptEllipseVert ),
 263     const_cast<sal_uInt16*>(mso_sptEllipseSegm), sizeof( mso_sptEllipseSegm ) >> 1,
 264     nullptr, 0,
 265     nullptr,
 266     const_cast<SvxMSDffTextRectangles*>(mso_sptEllipseTextRect), SAL_N_ELEMENTS( mso_sptEllipseTextRect ),
 267     21600, 21600,
 268     MIN_INT32, MIN_INT32,
 269     const_cast<SvxMSDffVertPair*>(mso_sptEllipseGluePoints), SAL_N_ELEMENTS( mso_sptEllipseGluePoints ),
 270     nullptr, 0     // handles
 271 };
 272
 273 const SvxMSDffVertPair mso_sptParallelogramVert[] =  // adjustment1 : 0 - 21600
 274 {
 275     { 0 MSO_I, 0 }, { 21600, 0 }, { 1 MSO_I, 21600 }, { 0, 21600 }
 276 };
 277 const sal_uInt16 mso_sptParallelogramSegm[] =
 278 {
 279     0x4000, 0x0003, 0x6001, 0x8000
 280 };
 281 const SvxMSDffCalculationData mso_sptParallelogramCalc[] =
 282 {
 283     { 0x4000, { 0, DFF_Prop_adjustValue, 0 } },
 284     { 0x8000, { 0, 21600, DFF_Prop_adjustValue } },
 285     { 0x2001, { DFF_Prop_adjustValue, 10, 24 } },
 286     { 0x2000, { 0x0402, 1750, 0 } },
 287     { 0x8000, { 21600, 0, 0x0403 } },
 288     { 0x2001, { 0x400, 1, 2 } },
 289     { 0x4000, { 10800, 0x405, 0 } },
 290     { 0x2000, { 0x400, 0, 10800 } },
 291     { 0x6006, { 0x407, 0x40d, 0 } },
 292     { 0x8000, { 10800, 0, 0x405 } },
 293     { 0x6006, { 0x407, 0x40c, 21600 } },
 294     { 0x8000, { 21600, 0, 0x405 } },
 295     { 0x8001, { 21600, 10800, 0x400 } },
 296     { 0x8000, { 21600, 0, 0x40c } }
 297 };
 298 const SvxMSDffTextRectangles mso_sptParallelogramTextRect[] =
 299 {
 300     { { 3 MSO_I, 3 MSO_I }, { 4 MSO_I, 4 MSO_I } }
 301 };
 302 const SvxMSDffVertPair mso_sptParallelogramGluePoints[] =
 303 {
 304     { 6 MSO_I, 0 }, { 10800, 8 MSO_I }, { 11 MSO_I, 10800 }, { 9 MSO_I, 21600 }, { 10800, 10 MSO_I }, { 5 MSO_I, 10800 }
 305 };
 306 const SvxMSDffHandle mso_sptParallelogramHandle[] =
 307 {
 308     {   SvxMSDffHandleFlags::RANGE,
 309         0x100, 0, 10800, 10800, 0, 21600, MIN_INT32, 0x7fffffff }
 310 };
 311 const mso_CustomShape msoParallelogram =
 312 {
 313     const_cast<SvxMSDffVertPair*>(mso_sptParallelogramVert), SAL_N_ELEMENTS( mso_sptParallelogramVert ),
 314     const_cast<sal_uInt16*>(mso_sptParallelogramSegm), sizeof( mso_sptParallelogramSegm ) >> 1,
 315     const_cast<SvxMSDffCalculationData*>(mso_sptParallelogramCalc), SAL_N_ELEMENTS( mso_sptParallelogramCalc ),
 316     const_cast<sal_Int32*>(mso_sptDefault5400),
 317     const_cast<SvxMSDffTextRectangles*>(mso_sptParallelogramTextRect), SAL_N_ELEMENTS( mso_sptParallelogramTextRect ),
 318     21600, 21600,
 319     MIN_INT32, MIN_INT32,
 320     const_cast<SvxMSDffVertPair*>(mso_sptParallelogramGluePoints), SAL_N_ELEMENTS( mso_sptParallelogramGluePoints ),
 321     const_cast<SvxMSDffHandle*>(mso_sptParallelogramHandle), SAL_N_ELEMENTS( mso_sptParallelogramHandle )        // handles
 322 };
 323
 324 const SvxMSDffVertPair mso_sptDiamondVert[] =
 325 {
 326     { 10800, 0 }, { 21600, 10800 }, { 10800, 21600 }, { 0, 10800 }, { 10800, 0 }
 327 };
 328 const SvxMSDffTextRectangles mso_sptDiamondTextRect[] =
 329 {
 330     { { 5400, 5400 }, { 16200, 16200 } }
 331 };
 332 const mso_CustomShape msoDiamond =
 333 {
 334     const_cast<SvxMSDffVertPair*>(mso_sptDiamondVert), SAL_N_ELEMENTS( mso_sptDiamondVert ),
 335     nullptr, 0,
 336     nullptr, 0,
 337     nullptr,
 338     const_cast<SvxMSDffTextRectangles*>(mso_sptDiamondTextRect), SAL_N_ELEMENTS( mso_sptDiamondTextRect ),
 339     21600, 21600,
 340     MIN_INT32, MIN_INT32,
 341     const_cast<SvxMSDffVertPair*>(mso_sptStandardGluePoints), SAL_N_ELEMENTS( mso_sptStandardGluePoints ),
 342     nullptr, 0     // handles
 343 };
 344
 345 const SvxMSDffVertPair mso_sptTrapezoidVert[] =      // adjustment1 : 0 - 10800
 346 {
 347     { 0, 0 }, { 21600, 0 }, {0 MSO_I, 21600 }, { 1 MSO_I, 21600 }
 348 };
 349 const sal_uInt16 mso_sptTrapezoidSegm[] =
 350 {
 351     0x4000, 0x0003, 0x6001, 0x8000
 352 };
 353 const SvxMSDffCalculationData mso_sptTrapezoidCalc[] =
 354 {
 355     { 0x8000, { 21600, 0, DFF_Prop_adjustValue } },
 356     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
 357     { 0x2001, { DFF_Prop_adjustValue, 10, 18 } },
 358     { 0x2000, { 0x0402, 1750, 0 } },
 359     { 0x8000, { 21600, 0, 0x403 } },
 360     { 0x2001, { DFF_Prop_adjustValue, 1, 2 } },
 361     { 0x8000, { 21600, 0, 0x405 } }
 362 };
 363 const SvxMSDffTextRectangles mso_sptTrapezoidTextRect[] =
 364 {
 365     { { 3 MSO_I, 3 MSO_I }, { 4 MSO_I, 4 MSO_I } }
 366 };
 367 const SvxMSDffVertPair mso_sptTrapezoidGluePoints[] =
 368 {
 369     { 6 MSO_I, 10800 }, { 10800, 21600 }, { 5 MSO_I, 10800 }, { 10800, 0 }
 370 };
 371 const SvxMSDffHandle mso_sptTrapezoidHandle[] =
 372 {
 373     {   SvxMSDffHandleFlags::RANGE,
 374         0x100, 1, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
 375 };
 376 const mso_CustomShape msoTrapezoid =
 377 {
 378     const_cast<SvxMSDffVertPair*>(mso_sptTrapezoidVert), SAL_N_ELEMENTS( mso_sptTrapezoidVert ),
 379     const_cast<sal_uInt16*>(mso_sptTrapezoidSegm), sizeof( mso_sptTrapezoidSegm ) >> 1,
 380     const_cast<SvxMSDffCalculationData*>(mso_sptTrapezoidCalc), SAL_N_ELEMENTS( mso_sptTrapezoidCalc ),
 381     const_cast<sal_Int32*>(mso_sptDefault5400),
 382     const_cast<SvxMSDffTextRectangles*>(mso_sptTrapezoidTextRect), SAL_N_ELEMENTS( mso_sptTrapezoidTextRect ),
 383     21600, 21600,
 384     MIN_INT32, MIN_INT32,
 385     const_cast<SvxMSDffVertPair*>(mso_sptTrapezoidGluePoints), SAL_N_ELEMENTS( mso_sptTrapezoidGluePoints ),
 386     const_cast<SvxMSDffHandle*>(mso_sptTrapezoidHandle), SAL_N_ELEMENTS( mso_sptTrapezoidHandle )        // handles
 387 };
 388
 389 /*
 390
 391  The side of the enclosing square for the regular (all sides the
 392  same, all angles the same) octagon described below is 21600. Let's
 393  call that 'a'.
 394
 395  The "adjustment1" is the horizontal (or vertical) distance from a
 396  side of the square to the nearest vertex. Let's call that 'd'.
 397
 398  Let's call the side of the regular octagon 'b'.
 399
 400  We know a. We want d. d=(a-b)/2
 401
 402  Pythagoras says that b^2 = 2d^2
 403
 404  Solving for b, we get b = (sqrt(2)-1)a
 405
 406
 407      !------------a=21600-------!
 408
 409      !--d--!
 410            x--------------x
 411           /                \
 412          /                  \
 413         /                    \
 414        /                      \
 415       /                        \
 416      x                          x
 417      !                          !
 418      !                          !
 419      !                          !
 420      !                          !
 421      !                          !
 422      !                          !
 423      x                          x
 424       \                        /
 425        \                      /
 426         \                    /
 427          \                  /
 428           \                /
 429            x--------------x
 430
 431 */
 432
 433 const SvxMSDffVertPair mso_sptOctagonVert[] =        // adjustment1 : 0 - 10800
 434 {
 435     { 0 MSO_I, 0 }, { 2 MSO_I, 0 }, { 21600, 1 MSO_I }, { 21600, 3 MSO_I },
 436     { 2 MSO_I, 21600 }, { 0 MSO_I, 21600 }, { 0, 3 MSO_I }, { 0, 1 MSO_I }
 437 };
 438 const sal_uInt16 mso_sptOctagonSegm[] =
 439 {
 440     0x4000, 0x0007, 0x6001, 0x8000
 441 };
 442 const SvxMSDffCalculationData mso_sptOctagonCalc[] =
 443 {
 444     { 0x6000, { DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 } },
 445     { 0x6000, { DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 } },
 446     { 0xa000, { DFF_Prop_geoRight, 0, DFF_Prop_adjustValue } },
 447     { 0xa000, { DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue } },
 448     { 0x2001, { DFF_Prop_adjustValue, 1, 2 } },
 449     { 0x6000, { DFF_Prop_geoLeft, 0x404, 0 } },
 450     { 0x6000, { DFF_Prop_geoTop, 0x404, 0 } },
 451     { 0xa000, { DFF_Prop_geoRight, 0, 0x404 } },
 452     { 0xa000, { DFF_Prop_geoBottom, 0, 0x404 } }
 453 };
 454 const sal_Int32 mso_sptOctagonDefault[] =
 455 {
 456     1, static_cast<sal_Int32>((21600 - ((M_SQRT2-1)*21600)) / 2)
 457 };
 458 const SvxMSDffTextRectangles mso_sptOctagonTextRect[] =
 459 {
 460     { { 5 MSO_I, 6 MSO_I }, { 7 MSO_I, 8 MSO_I } }
 461 };
 462 const SvxMSDffHandle mso_sptOctagonHandle[] =
 463 {
 464     {   SvxMSDffHandleFlags::RANGE,
 465         0x100, 0, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
 466 };
 467 const mso_CustomShape msoOctagon =
 468 {
 469     const_cast<SvxMSDffVertPair*>(mso_sptOctagonVert), SAL_N_ELEMENTS( mso_sptOctagonVert ),
 470     const_cast<sal_uInt16*>(mso_sptOctagonSegm), sizeof( mso_sptOctagonSegm ) >> 1,
 471     const_cast<SvxMSDffCalculationData*>(mso_sptOctagonCalc), SAL_N_ELEMENTS( mso_sptOctagonCalc ),
 472     const_cast<sal_Int32*>(mso_sptOctagonDefault),
 473     const_cast<SvxMSDffTextRectangles*>(mso_sptOctagonTextRect), SAL_N_ELEMENTS( mso_sptOctagonTextRect ),
 474     21600, 21600,
 475     10800, 10800,
 476     const_cast<SvxMSDffVertPair*>(mso_sptStandardGluePoints), SAL_N_ELEMENTS( mso_sptStandardGluePoints ),
 477     const_cast<SvxMSDffHandle*>(mso_sptOctagonHandle), SAL_N_ELEMENTS( mso_sptOctagonHandle )        // handles
 478 };
 479
 480 const SvxMSDffVertPair mso_sptIsocelesTriangleVert[] =   // adjustment1 : 0 - 21600
 481 {
 482     { 0 MSO_I, 0 }, { 21600, 21600 }, { 0, 21600 }
 483 };
 484 const sal_uInt16 mso_sptIsocelesTriangleSegm[] =
 485 {
 486     0x4000, 0x0002, 0x6001, 0x8000
 487 };
 488 const SvxMSDffCalculationData mso_sptIsocelesTriangleCalc[] =
 489 {
 490     { 0x4000, { 0, DFF_Prop_adjustValue, 0 } },
 491     { 0x2001, { DFF_Prop_adjustValue, 1, 2 } },
 492     { 0x2000, { 0x401, 10800, 0 } },
 493     { 0x2001, { DFF_Prop_adjustValue, 2, 3 } },
 494     { 0x2000, { 0x403, 7200, 0 } },
 495     { 0x8000, { 21600, 0, 0x400 } },
 496     { 0x2001, { 0x405, 1, 2 } },
 497     { 0x8000, { 21600, 0, 0x406 } }
 498 };
 499 const SvxMSDffTextRectangles mso_sptIsocelesTriangleTextRect[] =
 500 {
 501     { { 1 MSO_I, 10800 }, { 2 MSO_I, 18000 } },
 502     { { 3 MSO_I, 7200 }, { 4 MSO_I, 21600   } }
 503 };
 504 const SvxMSDffVertPair mso_sptIsocelesTriangleGluePoints[] =
 505 {
 506     { 0 MSO_I, 0 }, { 1 MSO_I, 10800 }, { 0, 21600 }, { 10800, 21600 }, { 21600, 21600 }, { 7 MSO_I, 10800 }
 507 };
 508 const SvxMSDffHandle mso_sptIsocelesTriangleHandle[] =
 509 {
 510     {   SvxMSDffHandleFlags::RANGE,
 511         0x100, 0, 10800, 10800, 0, 21600, MIN_INT32, 0x7fffffff }
 512 };
 513 const mso_CustomShape msoIsocelesTriangle =
 514 {
 515     const_cast<SvxMSDffVertPair*>(mso_sptIsocelesTriangleVert), SAL_N_ELEMENTS( mso_sptIsocelesTriangleVert ),
 516     const_cast<sal_uInt16*>(mso_sptIsocelesTriangleSegm), sizeof( mso_sptIsocelesTriangleSegm ) >> 1,
 517     const_cast<SvxMSDffCalculationData*>(mso_sptIsocelesTriangleCalc), SAL_N_ELEMENTS( mso_sptIsocelesTriangleCalc ),
 518     const_cast<sal_Int32*>(mso_sptDefault10800),
 519     const_cast<SvxMSDffTextRectangles*>(mso_sptIsocelesTriangleTextRect), SAL_N_ELEMENTS( mso_sptIsocelesTriangleTextRect ),
 520     21600, 21600,
 521     MIN_INT32, MIN_INT32,
 522     const_cast<SvxMSDffVertPair*>(mso_sptIsocelesTriangleGluePoints), SAL_N_ELEMENTS( mso_sptIsocelesTriangleGluePoints ),
 523     const_cast<SvxMSDffHandle*>(mso_sptIsocelesTriangleHandle), SAL_N_ELEMENTS( mso_sptIsocelesTriangleHandle )      // handles
 524 };
 525
 526 const SvxMSDffVertPair mso_sptHexagonVert[] =                // adjustment1 : 0 - 10800
 527 {
 528     { 0 MSO_I, 0 }, { 1 MSO_I, 0 }, { 21600, 10800 }, { 1 MSO_I, 21600 },
 529     { 0 MSO_I, 21600 }, { 0, 10800 }
 530 };
 531 const sal_uInt16 mso_sptHexagonSegm[] =
 532 {
 533     0x4000, 0x0005, 0x6001, 0x8000
 534 };
 535 const SvxMSDffCalculationData mso_sptHexagonCalc[] =
 536 {
 537     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
 538     { 0x8000, { 21600, 0, DFF_Prop_adjustValue } },
 539     { 0x2001, { DFF_Prop_adjustValue, 100, 234 } },
 540     { 0x2000, { 0x402, 1700, 0 } },
 541     { 0x8000, { 21600, 0, 0x403 } }
 542 };
 543 const SvxMSDffTextRectangles mso_sptHexagonTextRect[] =
 544 {
 545     { { 3 MSO_I, 3 MSO_I }, { 4 MSO_I, 4 MSO_I } }
 546 };
 547 const SvxMSDffHandle mso_sptHexagonHandle[] =
 548 {
 549     {   SvxMSDffHandleFlags::RANGE,
 550         0x100, 0, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
 551 };
 552 const mso_CustomShape msoHexagon =
 553 {
 554     const_cast<SvxMSDffVertPair*>(mso_sptHexagonVert), SAL_N_ELEMENTS( mso_sptHexagonVert ),
 555     const_cast<sal_uInt16*>(mso_sptHexagonSegm), sizeof( mso_sptHexagonSegm ) >> 1,
 556     const_cast<SvxMSDffCalculationData*>(mso_sptHexagonCalc), SAL_N_ELEMENTS( mso_sptHexagonCalc ),
 557     const_cast<sal_Int32*>(mso_sptDefault5400),
 558     const_cast<SvxMSDffTextRectangles*>(mso_sptHexagonTextRect), SAL_N_ELEMENTS( mso_sptHexagonTextRect ),
 559     21600, 21600,
 560     MIN_INT32, MIN_INT32,
 561     const_cast<SvxMSDffVertPair*>(mso_sptStandardGluePoints), SAL_N_ELEMENTS( mso_sptStandardGluePoints ),
 562     const_cast<SvxMSDffHandle*>(mso_sptHexagonHandle), SAL_N_ELEMENTS( mso_sptHexagonHandle )        // handles
 563 };
 564
 565 const SvxMSDffVertPair mso_sptPentagonVert[] =
 566 {
 567     { 10800, 0 }, { 0, 8260 }, { 4230, 21600 }, { 17370, 21600 },
 568     { 21600, 8260 }, { 10800, 0 }
 569 };
 570 const SvxMSDffTextRectangles mso_sptPentagonTextRect[] =
 571 {
 572     { { 4230, 5080 }, { 17370, 21600 } }
 573 };
 574 const SvxMSDffVertPair mso_sptPentagonGluePoints[] =
 575 {
 576     { 10800, 0 }, { 0, 8260 }, { 4230, 21600 }, { 10800, 21600 },
 577     { 17370, 21600 }, { 21600, 8260 }
 578 };
 579 const mso_CustomShape msoPentagon =
 580 {
 581     const_cast<SvxMSDffVertPair*>(mso_sptPentagonVert), SAL_N_ELEMENTS( mso_sptPentagonVert ),
 582     nullptr, 0,
 583     nullptr, 0,
 584     nullptr,
 585     const_cast<SvxMSDffTextRectangles*>(mso_sptPentagonTextRect), SAL_N_ELEMENTS( mso_sptPentagonTextRect ),
 586     21600, 21600,
 587     MIN_INT32, MIN_INT32,
 588     const_cast<SvxMSDffVertPair*>(mso_sptPentagonGluePoints), SAL_N_ELEMENTS( mso_sptPentagonGluePoints ),
 589     nullptr, 0     // handles
 590 };
 591
 592 const SvxMSDffVertPair mso_sptPlusVert[] =               // adjustment1 : 0 - 10800
 593 {
 594     { 1 MSO_I, 0 }, { 2 MSO_I, 0 }, { 2 MSO_I, 1 MSO_I }, { 21600, 1 MSO_I },
 595     { 21600, 3 MSO_I }, { 2 MSO_I, 3 MSO_I }, { 2 MSO_I, 21600 }, { 1 MSO_I, 21600 },
 596     { 1 MSO_I, 3 MSO_I }, { 0, 3 MSO_I }, { 0, 1 MSO_I }, { 1 MSO_I, 1 MSO_I }, { 1 MSO_I, 0 }
 597 };
 598 const SvxMSDffCalculationData mso_sptPlusCalc[] =
 599 {
 600     { 0x2001, { DFF_Prop_adjustValue, 10799, 10800 } },
 601     { 0x2000, { 0x400, 0, 0 } },
 602     { 0xa000, { DFF_Prop_geoRight, 0, 0x400 } },
 603     { 0xa000, { DFF_Prop_geoBottom, 0, 0x400 } }
 604 };
 605 const SvxMSDffTextRectangles mso_sptPlusTextRect[] =
 606 {
 607     { { 1 MSO_I, 1 MSO_I }, { 2 MSO_I, 3 MSO_I } }
 608 };
 609 const SvxMSDffHandle mso_sptPlusHandle[] =
 610 {
 611     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::SWITCHED,
 612         0x100, 0, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
 613 };
 614 const mso_CustomShape msoPlus =
 615 {
 616     const_cast<SvxMSDffVertPair*>(mso_sptPlusVert), SAL_N_ELEMENTS( mso_sptPlusVert ),
 617     nullptr, 0,
 618     const_cast<SvxMSDffCalculationData*>(mso_sptPlusCalc), SAL_N_ELEMENTS( mso_sptPlusCalc ),
 619     const_cast<sal_Int32*>(mso_sptDefault5400),
 620     const_cast<SvxMSDffTextRectangles*>(mso_sptPlusTextRect), SAL_N_ELEMENTS( mso_sptPlusTextRect ),
 621     21600, 21600,
 622     10800, 10800,
 623     const_cast<SvxMSDffVertPair*>(mso_sptStandardGluePoints), SAL_N_ELEMENTS( mso_sptStandardGluePoints ),
 624     const_cast<SvxMSDffHandle*>(mso_sptPlusHandle), SAL_N_ELEMENTS( mso_sptPlusHandle )      // handles
 625 };
 626
 627 const SvxMSDffVertPair mso_sptCanVert[] =        // adjustment1 : 0 - 10800
 628 {
 629     { 44, 0 },
 630     { 20, 0 }, { 0, 2 MSO_I }, { 0, 0 MSO_I },          // ccp
 631     { 0, 3 MSO_I },                                     // p
 632     { 0, 4 MSO_I }, { 20, 21600 }, { 44, 21600 },       // ccp
 633     { 68, 21600 }, { 88, 4 MSO_I }, { 88, 3 MSO_I },    // ccp
 634     { 88, 0 MSO_I },                                    // p
 635     { 88, 2 MSO_I }, { 68, 0 }, { 44, 0 },              // ccp
 636     { 44, 0 },                                          // p
 637     { 20, 0 }, { 0, 2 MSO_I }, { 0, 0 MSO_I },          // ccp
 638     { 0, 5 MSO_I }, { 20, 6 MSO_I }, { 44, 6 MSO_I },   // ccp
 639     { 68, 6 MSO_I },{ 88, 5 MSO_I }, { 88, 0 MSO_I },   // ccp
 640     { 88, 2 MSO_I },{ 68, 0 }, { 44, 0 }                // ccp
 641 };
 642 const sal_uInt16 mso_sptCanSegm[] =
 643 {
 644     0x4000, 0x2001, 0x0001, 0x2002, 0x0001, 0x2001, 0x6001, 0x8000,
 645     0x4000, 0x2004, 0x6001, 0x8000
 646 };
 647 const SvxMSDffCalculationData mso_sptCanCalc[] =
 648 {
 649     { 0x2001, { DFF_Prop_adjustValue, 2, 4 } },     // 1/4
 650     { 0x2001, { 0x0400, 6, 11 } },
 651     { 0xa000, { 0x0400, 0, 0x0401 } },
 652     { 0x8000, { 21600, 0, 0x0400 } },
 653     { 0x6000, { 0x0403, 0x0401, 0 } },
 654     { 0x6000, { 0x0400, 0x0401, 0 } },
 655     { 0x2001, { DFF_Prop_adjustValue, 2, 2 } },
 656     { 0x0000, { 44, 0, 0 } }
 657 };
 658 const SvxMSDffTextRectangles mso_sptCanTextRect[] =
 659 {
 660     { { 0, 6 MSO_I }, { 88, 3 MSO_I } }
 661 };
 662 const SvxMSDffVertPair mso_sptCanGluePoints[] =
 663 {
 664     { 44, 6 MSO_I }, { 44, 0 }, { 0, 10800 }, { 44, 21600 }, { 88, 10800 }
 665 };
 666 const SvxMSDffHandle mso_sptCanHandle[] =
 667 {
 668     {   SvxMSDffHandleFlags::RANGE,
 669         7 + 3, 0x100, 44, 10800, MIN_INT32, 0x7fffffff, 0, 10800 }
 670 };
 671 const mso_CustomShape msoCan =
 672 {
 673     const_cast<SvxMSDffVertPair*>(mso_sptCanVert), SAL_N_ELEMENTS( mso_sptCanVert ),
 674     const_cast<sal_uInt16*>(mso_sptCanSegm), sizeof( mso_sptCanSegm ) >> 1,
 675     const_cast<SvxMSDffCalculationData*>(mso_sptCanCalc), SAL_N_ELEMENTS( mso_sptCanCalc ),
 676     const_cast<sal_Int32*>(mso_sptDefault5400),
 677     const_cast<SvxMSDffTextRectangles*>(mso_sptCanTextRect), SAL_N_ELEMENTS( mso_sptCanTextRect ),
 678     88, 21600,
 679     MIN_INT32, MIN_INT32,
 680     const_cast<SvxMSDffVertPair*>(mso_sptCanGluePoints), SAL_N_ELEMENTS( mso_sptCanGluePoints ),
 681     const_cast<SvxMSDffHandle*>(mso_sptCanHandle), SAL_N_ELEMENTS( mso_sptCanHandle )        // handles
 682 };
 683
 684 const SvxMSDffVertPair mso_sptArrowVert[] =  // adjustment1: x 0 - 21600
 685 {                                                   // adjustment2: y 0 - 10800
 686     { 0, 0 MSO_I }, { 1 MSO_I, 0 MSO_I }, { 1 MSO_I, 0 }, { 21600, 10800 },
 687     { 1 MSO_I, 21600 }, { 1 MSO_I, 2 MSO_I }, { 0, 2 MSO_I }
 688 };
 689 const sal_uInt16 mso_sptArrowSegm[] =
 690 {
 691     0x4000, 0x0006, 0x6001, 0x8000
 692 };
 693 const SvxMSDffCalculationData mso_sptArrowCalc[] =
 694 {
 695     { 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
 696     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
 697     { 0x8000, { 21600, 0, DFF_Prop_adjust2Value } },
 698     { 0x8000, { 21600, 0, 0x401 } },
 699     { 0x6001, { 0x403, 0x400, 10800 } },
 700     { 0x6000, { 0x401, 0x404, 0 } },
 701     { 0x6001, { 0x401, 0x400, 10800 } },
 702     { 0xa000, { 0x401, 0, 0x406 } }
 703 };
 704 const SvxMSDffTextRectangles mso_sptArrowTextRect[] =
 705 {
 706     { { 0, 0 MSO_I }, { 5 MSO_I, 2 MSO_I } }
 707 };
 708 const SvxMSDffHandle mso_sptArrowHandle[] =
 709 {
 710     {   SvxMSDffHandleFlags::RANGE,
 711         0x100, 0x101, 10800, 10800, 0, 21600, 0, 10800 }
 712 };
 713 const mso_CustomShape msoArrow =
 714 {
 715     const_cast<SvxMSDffVertPair*>(mso_sptArrowVert), SAL_N_ELEMENTS( mso_sptArrowVert ),
 716     const_cast<sal_uInt16*>(mso_sptArrowSegm), sizeof( mso_sptArrowSegm ) >> 1,
 717     const_cast<SvxMSDffCalculationData*>(mso_sptArrowCalc), SAL_N_ELEMENTS( mso_sptArrowCalc ),
 718     const_cast<sal_Int32*>(mso_sptDefault16200and5400),
 719     const_cast<SvxMSDffTextRectangles*>(mso_sptArrowTextRect), SAL_N_ELEMENTS( mso_sptArrowTextRect ),
 720     21600, 21600,
 721     MIN_INT32, MIN_INT32,
 722     nullptr, 0,
 723     const_cast<SvxMSDffHandle*>(mso_sptArrowHandle), SAL_N_ELEMENTS( mso_sptArrowHandle )        // handles
 724 };
 725
 726 const SvxMSDffVertPair mso_sptLeftArrowVert[] =  // adjustment1: x 0 - 21600
 727 {                                                       // adjustment2: y 0 - 10800
 728     { 21600, 0 MSO_I }, { 1 MSO_I, 0 MSO_I }, { 1 MSO_I, 0 }, { 0, 10800 },
 729     { 1 MSO_I, 21600 }, { 1 MSO_I, 2 MSO_I }, { 21600, 2 MSO_I }
 730 };
 731 const sal_uInt16 mso_sptLeftArrowSegm[] =
 732 {
 733     0x4000, 0x0006, 0x6001, 0x8000
 734 };
 735 const sal_Int32 mso_sptLeftArrowDefault[] =
 736 {
 737     2, 5400, 5400
 738 };
 739 const SvxMSDffTextRectangles mso_sptLeftArrowTextRect[] =
 740 {
 741     { { 7 MSO_I, 0 MSO_I }, { 21600, 2 MSO_I } }
 742 };
 743 const SvxMSDffHandle mso_sptLeftArrowHandle[] =
 744 {
 745     {   SvxMSDffHandleFlags::RANGE,
 746         0x100, 0x101, 10800, 10800, 0, 21600, 0, 10800 }
 747 };
 748 const mso_CustomShape msoLeftArrow =
 749 {
 750     const_cast<SvxMSDffVertPair*>(mso_sptLeftArrowVert), SAL_N_ELEMENTS( mso_sptLeftArrowVert ),
 751     const_cast<sal_uInt16*>(mso_sptLeftArrowSegm), sizeof( mso_sptLeftArrowSegm ) >> 1,
 752     const_cast<SvxMSDffCalculationData*>(mso_sptArrowCalc), SAL_N_ELEMENTS( mso_sptArrowCalc ),
 753     const_cast<sal_Int32*>(mso_sptLeftArrowDefault),
 754     const_cast<SvxMSDffTextRectangles*>(mso_sptLeftArrowTextRect), SAL_N_ELEMENTS( mso_sptLeftArrowTextRect ),
 755     21600, 21600,
 756     MIN_INT32, MIN_INT32,
 757     nullptr, 0,
 758     const_cast<SvxMSDffHandle*>(mso_sptLeftArrowHandle), SAL_N_ELEMENTS( mso_sptLeftArrowHandle )        // handles
 759 };
 760
 761 const SvxMSDffVertPair mso_sptDownArrowVert[] =  // adjustment1: x 0 - 21600
 762 {                                                       // adjustment2: y 0 - 10800
 763     { 0 MSO_I, 0 }, { 0 MSO_I, 1 MSO_I }, { 0, 1 MSO_I }, { 10800, 21600 },
 764     { 21600, 1 MSO_I }, { 2 MSO_I, 1 MSO_I }, { 2 MSO_I, 0 }
 765 };
 766 const sal_uInt16 mso_sptDownArrowSegm[] =
 767 {
 768     0x4000, 0x0006, 0x6001, 0x8000
 769 };
 770 const SvxMSDffTextRectangles mso_sptDownArrowTextRect[] =
 771 {
 772     { { 0 MSO_I, 0 }, { 2 MSO_I, 5 MSO_I } }
 773 };
 774 const SvxMSDffHandle mso_sptDownArrowHandle[] =
 775 {
 776     {   SvxMSDffHandleFlags::RANGE,
 777         0x101, 0x100, 10800, 10800, 0, 10800, 0, 21600 }
 778 };
 779 const mso_CustomShape msoDownArrow =
 780 {
 781     const_cast<SvxMSDffVertPair*>(mso_sptDownArrowVert), SAL_N_ELEMENTS( mso_sptDownArrowVert ),
 782     const_cast<sal_uInt16*>(mso_sptDownArrowSegm), sizeof( mso_sptDownArrowSegm ) >> 1,
 783     const_cast<SvxMSDffCalculationData*>(mso_sptArrowCalc), SAL_N_ELEMENTS( mso_sptArrowCalc ),
 784     const_cast<sal_Int32*>(mso_sptDefault16200and5400),
 785     const_cast<SvxMSDffTextRectangles*>(mso_sptDownArrowTextRect), SAL_N_ELEMENTS( mso_sptDownArrowTextRect ),
 786     21600, 21600,
 787     MIN_INT32, MIN_INT32,
 788     nullptr, 0,
 789     const_cast<SvxMSDffHandle*>(mso_sptDownArrowHandle), SAL_N_ELEMENTS( mso_sptDownArrowHandle )        // handles
 790 };
 791
 792 const SvxMSDffVertPair mso_sptUpArrowVert[] =    // adjustment1: x 0 - 21600
 793 {                                                       // adjustment2: y 0 - 10800
 794     { 0 MSO_I, 21600 }, { 0 MSO_I, 1 MSO_I }, { 0, 1 MSO_I }, { 10800, 0 },
 795     { 21600, 1 MSO_I }, { 2 MSO_I, 1 MSO_I }, { 2 MSO_I, 21600 }
 796 };
 797 const sal_uInt16 mso_sptUpArrowSegm[] =
 798 {
 799     0x4000, 0x0006, 0x6001, 0x8000
 800 };
 801 const sal_Int32 mso_sptUpArrowDefault[] =
 802 {
 803     2, 5400, 5400
 804 };
 805 const SvxMSDffTextRectangles mso_sptUpArrowTextRect[] =
 806 {
 807     { { 0 MSO_I, 7 MSO_I }, { 2 MSO_I, 21600 } }
 808 };
 809 const SvxMSDffHandle mso_sptUpArrowHandle[] =
 810 {
 811     {   SvxMSDffHandleFlags::RANGE,
 812         0x101, 0x100, 10800, 10800, 0, 10800, 0, 21600 }
 813 };
 814 const mso_CustomShape msoUpArrow =
 815 {
 816     const_cast<SvxMSDffVertPair*>(mso_sptUpArrowVert), SAL_N_ELEMENTS( mso_sptUpArrowVert ),
 817     const_cast<sal_uInt16*>(mso_sptUpArrowSegm), sizeof( mso_sptUpArrowSegm ) >> 1,
 818     const_cast<SvxMSDffCalculationData*>(mso_sptArrowCalc), SAL_N_ELEMENTS( mso_sptArrowCalc ),
 819     const_cast<sal_Int32*>(mso_sptUpArrowDefault),
 820     const_cast<SvxMSDffTextRectangles*>(mso_sptUpArrowTextRect), SAL_N_ELEMENTS( mso_sptUpArrowTextRect ),
 821     21600, 21600,
 822     MIN_INT32, MIN_INT32,
 823     nullptr, 0,
 824     const_cast<SvxMSDffHandle*>(mso_sptUpArrowHandle), SAL_N_ELEMENTS( mso_sptUpArrowHandle )        // handles
 825 };
 826
 827 const SvxMSDffVertPair mso_sptLeftRightArrowVert[] = // adjustment1: x 0 - 10800
 828 {                                                           // adjustment2: y 0 - 10800
 829     { 0, 10800 }, { 0 MSO_I, 0 }, { 0 MSO_I, 1 MSO_I }, { 2 MSO_I, 1 MSO_I },
 830     { 2 MSO_I, 0 }, { 21600, 10800 }, { 2 MSO_I, 21600 }, { 2 MSO_I, 3 MSO_I },
 831     { 0 MSO_I, 3 MSO_I }, { 0 MSO_I, 21600 }
 832 };
 833 const sal_uInt16 mso_sptLeftRightArrowSegm[] =
 834 {
 835     0x4000, 0x0009, 0x6001, 0x8000
 836 };
 837 const SvxMSDffCalculationData mso_sptDoubleArrowCalc[] =
 838 {
 839     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
 840     { 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
 841     { 0x8000, { 21600, 0, DFF_Prop_adjustValue } },
 842     { 0x8000, { 21600, 0, DFF_Prop_adjust2Value } },
 843     { 0x8000, { 10800, 0, DFF_Prop_adjust2Value } },
 844     { 0x6001, { DFF_Prop_adjustValue, 0x404, 10800 } },
 845     { 0x8000, { 21600, 0, 0x405 } },
 846     { 0x8000, { 10800, 0, DFF_Prop_adjustValue } },
 847     { 0x6001, { DFF_Prop_adjust2Value, 0x407, 10800 } },
 848     { 0x8000, { 21600, 0, 0x408 } }
 849 };
 850 const sal_Int32 mso_sptLeftRightArrowDefault[] =
 851 {
 852     2, 4300, 5400
 853 };
 854 const SvxMSDffTextRectangles mso_sptLeftRightArrowTextRect[] =
 855 {
 856     { { 5 MSO_I, 1 MSO_I }, { 6 MSO_I, 3 MSO_I } }
 857 };
 858 const SvxMSDffHandle mso_sptLeftRightArrowHandle[] =
 859 {
 860     {   SvxMSDffHandleFlags::RANGE,
 861         0x100, 0x101, 10800, 10800, 0, 10800, 0, 10800 }
 862 };
 863 const mso_CustomShape msoLeftRightArrow =
 864 {
 865     const_cast<SvxMSDffVertPair*>(mso_sptLeftRightArrowVert), SAL_N_ELEMENTS( mso_sptLeftRightArrowVert ),
 866     const_cast<sal_uInt16*>(mso_sptLeftRightArrowSegm), sizeof( mso_sptLeftRightArrowSegm ) >> 1,
 867     const_cast<SvxMSDffCalculationData*>(mso_sptDoubleArrowCalc), SAL_N_ELEMENTS( mso_sptDoubleArrowCalc ),
 868     const_cast<sal_Int32*>(mso_sptLeftRightArrowDefault),
 869     const_cast<SvxMSDffTextRectangles*>(mso_sptLeftRightArrowTextRect), SAL_N_ELEMENTS( mso_sptLeftRightArrowTextRect ),
 870     21600, 21600,
 871     MIN_INT32, MIN_INT32,
 872     nullptr, 0,
 873     const_cast<SvxMSDffHandle*>(mso_sptLeftRightArrowHandle), SAL_N_ELEMENTS( mso_sptLeftRightArrowHandle )      // handles
 874 };
 875
 876 const SvxMSDffVertPair mso_sptUpDownArrowVert[] =    // adjustment1: x 0 - 10800
 877 {                                                           // adjustment2: y 0 - 10800
 878     { 0, 1 MSO_I }, { 10800, 0 }, { 21600, 1 MSO_I }, { 2 MSO_I, 1 MSO_I },
 879     { 2 MSO_I, 3 MSO_I }, { 21600, 3 MSO_I }, { 10800, 21600 }, { 0, 3 MSO_I },
 880     { 0 MSO_I, 3 MSO_I }, { 0 MSO_I, 1 MSO_I }
 881 };
 882 const sal_uInt16 mso_sptUpDownArrowSegm[] =
 883 {
 884     0x4000, 0x0009, 0x6001, 0x8000
 885 };
 886 const sal_Int32 mso_sptUpDownArrowDefault[] =
 887 {
 888     2, 5400, 4300
 889 };
 890 const SvxMSDffTextRectangles mso_sptUpDownArrowTextRect[] =
 891 {
 892     { { 0 MSO_I, 8 MSO_I }, { 2 MSO_I, 9 MSO_I } }
 893 };
 894 const SvxMSDffHandle mso_sptUpDownArrowHandle[] =
 895 {
 896     {   SvxMSDffHandleFlags::RANGE,
 897         0x100, 0x101, 10800, 10800, 0, 10800, 0, 10800 }
 898 };
 899 const mso_CustomShape msoUpDownArrow =
 900 {
 901     const_cast<SvxMSDffVertPair*>(mso_sptUpDownArrowVert), SAL_N_ELEMENTS( mso_sptUpDownArrowVert ),
 902     const_cast<sal_uInt16*>(mso_sptUpDownArrowSegm), sizeof( mso_sptUpDownArrowSegm ) >> 1,
 903     const_cast<SvxMSDffCalculationData*>(mso_sptDoubleArrowCalc), SAL_N_ELEMENTS( mso_sptDoubleArrowCalc ),
 904     const_cast<sal_Int32*>(mso_sptUpDownArrowDefault),
 905     const_cast<SvxMSDffTextRectangles*>(mso_sptUpDownArrowTextRect), SAL_N_ELEMENTS( mso_sptUpDownArrowTextRect ),
 906     21600, 21600,
 907     MIN_INT32, MIN_INT32,
 908     nullptr, 0,
 909     const_cast<SvxMSDffHandle*>(mso_sptUpDownArrowHandle), SAL_N_ELEMENTS( mso_sptUpDownArrowHandle )        // handles
 910 };
 911
 912 const SvxMSDffVertPair mso_sptQuadArrowVert[] =  // adjustment1: x 0 - 10800, adjustment2: x 0 - 10800
 913 {                                                       // adjustment3: y 0 - 10800
 914     { 0, 10800 }, { 0 MSO_I, 1 MSO_I }, { 0 MSO_I, 2 MSO_I }, { 2 MSO_I, 2 MSO_I },
 915     { 2 MSO_I, 0 MSO_I }, { 1 MSO_I, 0 MSO_I }, { 10800, 0 }, { 3 MSO_I, 0 MSO_I },
 916     { 4 MSO_I, 0 MSO_I }, { 4 MSO_I, 2 MSO_I }, { 5 MSO_I, 2 MSO_I }, { 5 MSO_I, 1 MSO_I },
 917     { 21600, 10800 }, { 5 MSO_I, 3 MSO_I }, { 5 MSO_I, 4 MSO_I }, { 4 MSO_I, 4 MSO_I },
 918     { 4 MSO_I, 5 MSO_I }, { 3 MSO_I, 5 MSO_I }, { 10800, 21600 }, { 1 MSO_I, 5 MSO_I },
 919     { 2 MSO_I, 5 MSO_I }, { 2 MSO_I, 4 MSO_I }, { 0 MSO_I, 4 MSO_I }, { 0 MSO_I, 3 MSO_I }
 920 };
 921 const sal_uInt16 mso_sptQuadArrowSegm[] =
 922 {
 923     0x4000, 0x0017, 0x6001, 0x8000
 924 };
 925 const SvxMSDffCalculationData mso_sptQuadArrowCalc[] =
 926 {
 927     { 0x2000, { DFF_Prop_adjust3Value, 0, 0 } },
 928     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
 929     { 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
 930     { 0x8000, { 21600, 0, DFF_Prop_adjustValue } },
 931     { 0x8000, { 21600, 0, DFF_Prop_adjust2Value } },
 932     { 0x8000, { 21600, 0, DFF_Prop_adjust3Value } }
 933 };
 934 const sal_Int32 mso_sptQuadArrowDefault[] =
 935 {
 936     3, 6500, 8600, 4300
 937 };
 938 const SvxMSDffTextRectangles mso_sptQuadArrowTextRect[] =    // todo
 939 {
 940     { { 0, 0 }, { 21600, 21600 } }
 941 };
 942 const SvxMSDffHandle mso_sptQuadArrowHandle[] =
 943 {
 944     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL,
 945         0x101, 0x102, 10800, 10800, 0x100, 10800, 0, 0x100 },
 946     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
 947         0x100, 0, 10800, 10800, 0x102, 0x101, MIN_INT32, 0x7fffffff }
 948 };
 949 const mso_CustomShape msoQuadArrow =
 950 {
 951     const_cast<SvxMSDffVertPair*>(mso_sptQuadArrowVert), SAL_N_ELEMENTS( mso_sptQuadArrowVert ),
 952     const_cast<sal_uInt16*>(mso_sptQuadArrowSegm), sizeof( mso_sptQuadArrowSegm ) >> 1,
 953     const_cast<SvxMSDffCalculationData*>(mso_sptQuadArrowCalc), SAL_N_ELEMENTS( mso_sptQuadArrowCalc ),
 954     const_cast<sal_Int32*>(mso_sptQuadArrowDefault),
 955     const_cast<SvxMSDffTextRectangles*>(mso_sptQuadArrowTextRect), SAL_N_ELEMENTS( mso_sptQuadArrowTextRect ),
 956     21600, 21600,
 957     MIN_INT32, MIN_INT32,
 958     nullptr, 0,
 959     const_cast<SvxMSDffHandle*>(mso_sptQuadArrowHandle), SAL_N_ELEMENTS( mso_sptQuadArrowHandle )        // handles
 960 };
 961
 962 const SvxMSDffVertPair mso_sptLeftRightUpArrowVert[] =   // adjustment1: x 0 - 10800, adjustment2: x 0 - 10800
 963 {                                                               // adjustment3: y 0 - 21600
 964     { 10800, 0 }, { 3 MSO_I, 2 MSO_I }, { 4 MSO_I, 2 MSO_I }, { 4 MSO_I, 1 MSO_I },
 965     { 5 MSO_I, 1 MSO_I }, { 5 MSO_I, 0 MSO_I }, { 21600, 10800 }, { 5 MSO_I, 3 MSO_I },
 966     { 5 MSO_I, 4 MSO_I }, { 2 MSO_I, 4 MSO_I }, { 2 MSO_I, 3 MSO_I }, { 0, 10800 },
 967     { 2 MSO_I, 0 MSO_I }, { 2 MSO_I, 1 MSO_I }, { 1 MSO_I, 1 MSO_I }, { 1 MSO_I, 2 MSO_I },
 968     { 0 MSO_I, 2 MSO_I }
 969 };
 970 const sal_uInt16 mso_sptLeftRightUpArrowSegm[] =
 971 {
 972     0x4000, 0x0010, 0x6001, 0x8000
 973 };
 974 const SvxMSDffCalculationData mso_sptLeftRightUpArrowCalc[] =
 975 {
 976     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },             // 0
 977     { 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },            // 1
 978     { 0x6001, { 0x0403, DFF_Prop_adjust3Value, 21600 } },   // 2
 979     { 0x8000, { 21600, 0, DFF_Prop_adjustValue } },         // 3
 980     { 0x8000, { 21600, 0, DFF_Prop_adjust2Value } },        // 4
 981     { 0x8000, { 21600, 0, 0x0402 } }                        // 5
 982 };
 983 const sal_Int32 mso_sptLeftRightUpArrowDefault[] =
 984 {
 985     3, 6500, 8600, 6200
 986 };
 987 const SvxMSDffTextRectangles mso_sptLeftRightUpArrowTextRect[] =     // todo
 988 {
 989     { { 0, 0 }, { 21600, 21600 } }
 990 };
 991 const SvxMSDffHandle mso_sptLeftRightUpArrowHandle[] =
 992 {
 993     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL,
 994         0x101, 0x102, 10800, 10800, 0x100, 10800, 0, 0x100 },
 995     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
 996         0x100, 0, 10800, 10800, 0x102, 0x101, MIN_INT32, 0x7fffffff }
 997 };
 998 const mso_CustomShape msoLeftRightUpArrow =
 999 {
1000     const_cast<SvxMSDffVertPair*>(mso_sptLeftRightUpArrowVert), SAL_N_ELEMENTS( mso_sptLeftRightUpArrowVert ),
1001     const_cast<sal_uInt16*>(mso_sptLeftRightUpArrowSegm), sizeof( mso_sptLeftRightUpArrowSegm ) >> 1,
1002     const_cast<SvxMSDffCalculationData*>(mso_sptLeftRightUpArrowCalc), SAL_N_ELEMENTS( mso_sptLeftRightUpArrowCalc ),
1003     const_cast<sal_Int32*>(mso_sptLeftRightUpArrowDefault),
1004     const_cast<SvxMSDffTextRectangles*>(mso_sptLeftRightUpArrowTextRect), SAL_N_ELEMENTS( mso_sptLeftRightUpArrowTextRect ),
1005     21600, 21600,
1006     MIN_INT32, MIN_INT32,
1007     nullptr, 0,
1008     const_cast<SvxMSDffHandle*>(mso_sptLeftRightUpArrowHandle), SAL_N_ELEMENTS( mso_sptLeftRightUpArrowHandle )      // handles
1009 };
1010
1011 const SvxMSDffVertPair mso_sptBentArrowVert[] =  // adjustment1 : x 12427 - 21600
1012 {                                                       // adjustment2 : y 0 - 6079
1013     { 0, 21600 }, { 0, 12160 }, { 12427, 1 MSO_I }, { 0 MSO_I, 1 MSO_I },
1014     { 0 MSO_I, 0 }, { 21600, 6079 }, { 0 MSO_I, 12158 }, { 0 MSO_I, 2 MSO_I },
1015     { 12427, 2 MSO_I }, { 4 MSO_I, 12160 }, { 4 MSO_I, 21600 }
1016 };
1017 const sal_uInt16 mso_sptBentArrowSegm[] =
1018 {
1019     0x4000, 0x0001, 0xa801, 0x0006, 0xa701, 0x0001, 0x6001, 0x8000
1020 };
1021 const SvxMSDffCalculationData mso_sptBentArrowCalc[] =
1022 {
1023     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
1024     { 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
1025     { 0x8000, { 12158, 0, DFF_Prop_adjust2Value } },
1026     { 0x8000, { 6079, 0, DFF_Prop_adjust2Value } },
1027     { 0x2001, { 0x0403, 2, 1 } }
1028 };
1029 const sal_Int32 mso_sptBentArrowDefault[] =
1030 {
1031     2, 15100, 2900
1032 };
1033 const SvxMSDffTextRectangles mso_sptBentArrowTextRect[] =    // todo
1034 {
1035     { { 0, 0 }, { 21600, 21600 } }
1036 };
1037 const SvxMSDffHandle mso_sptBentArrowHandle[] =
1038 {
1039     {   SvxMSDffHandleFlags::RANGE,
1040         0x100, 0x101, 10800, 10800, 12427, 21600, 0, 6079 }
1041 };
1042 const mso_CustomShape msoBentArrow =
1043 {
1044     const_cast<SvxMSDffVertPair*>(mso_sptBentArrowVert), SAL_N_ELEMENTS( mso_sptBentArrowVert ),
1045     const_cast<sal_uInt16*>(mso_sptBentArrowSegm), sizeof( mso_sptBentArrowSegm ) >> 1,
1046     const_cast<SvxMSDffCalculationData*>(mso_sptBentArrowCalc), SAL_N_ELEMENTS( mso_sptBentArrowCalc ),
1047     const_cast<sal_Int32*>(mso_sptBentArrowDefault),
1048     const_cast<SvxMSDffTextRectangles*>(mso_sptBentArrowTextRect), SAL_N_ELEMENTS( mso_sptBentArrowTextRect ),
1049     21600, 21600,
1050     MIN_INT32, MIN_INT32,
1051     nullptr, 0,
1052     const_cast<SvxMSDffHandle*>(mso_sptBentArrowHandle), SAL_N_ELEMENTS( mso_sptBentArrowHandle )        // handles
1053 };
1054
1055 const SvxMSDffVertPair mso_sptUturnArrowVert[] =
1056 {
1057     { 0, 21600 }, { 0, 8550 },                                          // pp
1058     { 0, 3540 }, { 4370, 0 }, { 9270, 0 },                              // ccp
1059     { 13890, 0 }, { 18570, 3230 }, { 18600, 8300 },                     // ccp
1060     { 21600, 8300 }, { 15680, 14260 }, { 9700, 8300 }, { 12500, 8300 }, // pppp
1061     { 12320, 6380 }, { 10870, 5850 }, { 9320, 5850 },                   // ccp
1062     { 7770, 5850 }, { 6040, 6410 }, { 6110, 8520 },                     // ccp
1063     { 6110, 21600 }
1064 };
1065 const sal_uInt16 mso_sptUturnArrowSegm[] =
1066 {
1067     0x4000, 0x0001, 0x2002, 0x0004, 0x2002, 0x0001, 0x6000, 0x8000
1068 };
1069 const SvxMSDffTextRectangles mso_sptUturnArrowTextRect[] =
1070 {
1071     { { 0, 8280 }, { 6110, 21600 } }
1072 };
1073 const mso_CustomShape msoUturnArrow =
1074 {
1075     const_cast<SvxMSDffVertPair*>(mso_sptUturnArrowVert), SAL_N_ELEMENTS( mso_sptUturnArrowVert ),
1076     const_cast<sal_uInt16*>(mso_sptUturnArrowSegm), sizeof( mso_sptUturnArrowSegm ) >> 1,
1077     nullptr, 0,
1078     nullptr,
1079     const_cast<SvxMSDffTextRectangles*>(mso_sptUturnArrowTextRect), SAL_N_ELEMENTS( mso_sptUturnArrowTextRect ),
1080     21600, 21600,
1081     MIN_INT32, MIN_INT32,
1082     nullptr, 0,
1083     nullptr, 0     // handles
1084 };
1085
1086 const SvxMSDffVertPair mso_sptLeftUpArrowVert[] =    // adjustment1 : x 0 - 21600, adjustment2 : x 0 - 21600
1087 {                                                           // adjustment3 : y 0 - 21600
1088     { 0, 5 MSO_I }, { 2 MSO_I, 0 MSO_I }, { 2 MSO_I, 7 MSO_I }, { 7 MSO_I, 7 MSO_I },
1089     { 7 MSO_I, 2 MSO_I }, { 0 MSO_I, 2 MSO_I }, { 5 MSO_I, 0 }, { 21600, 2 MSO_I },
1090     { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 1 MSO_I }, { 2 MSO_I, 1 MSO_I }, { 2 MSO_I, 21600 }
1091 };
1092 const sal_uInt16 mso_sptLeftUpArrowSegm[] =
1093 {
1094     0x4000, 0x000b, 0x6001, 0x8000
1095 };
1096 const SvxMSDffCalculationData mso_sptLeftUpArrowCalc[] =
1097 {
1098     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },     // 0
1099     { 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },        // 1
1100     { 0x2000, { DFF_Prop_adjust3Value, 0, 0 } },        // 2
1101     { 0x8000, { 21600, 0, DFF_Prop_adjustValue } }, // 3
1102     { 0x2001, { 0x0403, 1, 2 } },                       // 4
1103     { 0x6000, { DFF_Prop_adjustValue, 0x0404, 0 } },    // 5
1104     { 0x8000, { 21600, 0, DFF_Prop_adjust2Value } },    // 6
1105     { 0x6000, { DFF_Prop_adjustValue, 0x0406, 0 } },    // 7
1106     { 0x8000, { 21600, 0, 0x406 } },                    // 8
1107     { 0xa000, { 0x408, 0, 0x406 } }                 // 9
1108 };
1109 const sal_Int32 mso_sptLeftUpArrowDefault[] =
1110 {
1111     3, 9340, 18500, 6200
1112 };
1113 const SvxMSDffTextRectangles mso_sptLeftUpArrowTextRect[] =
1114 {
1115     { { 2 MSO_I, 7 MSO_I }, { 1 MSO_I, 1 MSO_I } },
1116     { { 7 MSO_I, 2 MSO_I }, { 1 MSO_I, 1 MSO_I } }
1117 };
1118 const SvxMSDffHandle mso_sptLeftUpArrowHandle[] =
1119 {
1120     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL,
1121         0x101, 0x102, 10800, 10800, 3 + 5, 21600, 0, 0x100 },
1122     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
1123         0x100, 0, 10800, 10800, 0x102, 3 + 9, MIN_INT32, 0x7fffffff }
1124 };
1125 const mso_CustomShape msoLeftUpArrow =
1126 {
1127     const_cast<SvxMSDffVertPair*>(mso_sptLeftUpArrowVert), SAL_N_ELEMENTS( mso_sptLeftUpArrowVert ),
1128     const_cast<sal_uInt16*>(mso_sptLeftUpArrowSegm), sizeof( mso_sptLeftUpArrowSegm ) >> 1,
1129     const_cast<SvxMSDffCalculationData*>(mso_sptLeftUpArrowCalc), SAL_N_ELEMENTS( mso_sptLeftUpArrowCalc ),
1130     const_cast<sal_Int32*>(mso_sptLeftUpArrowDefault),
1131     const_cast<SvxMSDffTextRectangles*>(mso_sptLeftUpArrowTextRect), SAL_N_ELEMENTS( mso_sptLeftUpArrowTextRect ),
1132     21600, 21600,
1133     MIN_INT32, MIN_INT32,
1134     nullptr, 0,
1135     const_cast<SvxMSDffHandle*>(mso_sptLeftUpArrowHandle), SAL_N_ELEMENTS( mso_sptLeftUpArrowHandle )        // handles
1136 };
1137
1138 const SvxMSDffVertPair mso_sptBentUpArrowVert[] =    // adjustment1 : x 0 - 21600, adjustment2 : x 0 - 21600
1139 {                                                           // adjustment3 : y 0 - 21600
1140     { 0, 8 MSO_I }, { 7 MSO_I, 8 MSO_I }, { 7 MSO_I, 2 MSO_I }, { 0 MSO_I, 2 MSO_I },
1141     { 5 MSO_I, 0 }, { 21600, 2 MSO_I }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 21600 },
1142     { 0, 21600 }
1143 };
1144 const sal_uInt16 mso_sptBentUpArrowSegm[] =
1145 {
1146     0x4000, 0x0008, 0x6001, 0x8000
1147 };
1148 const SvxMSDffCalculationData mso_sptBentUpArrowCalc[] =
1149 {
1150     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },     // 0
1151     { 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },        // 1
1152     { 0x2000, { DFF_Prop_adjust3Value, 0, 0 } },        // 2
1153     { 0x8000, { 21600, 0, DFF_Prop_adjustValue } }, // 3
1154     { 0x2001, { 0x0403, 1, 2 } },                       // 4
1155     { 0x6000, { DFF_Prop_adjustValue, 0x0404, 0 } },    // 5
1156     { 0x8000, { 21600, 0, DFF_Prop_adjust2Value } },    // 6
1157     { 0x6000, { DFF_Prop_adjustValue, 0x0406, 0 } },    // 7
1158     { 0x6000, { 0x0407, 0x0406, 0 } },                  // 8
1159     { 0x8000, { 21600, 0, 0x406 } },                    // 9
1160     { 0xa000, { 0x409, 0, 0x406 } }                 // a
1161 };
1162 const sal_Int32 mso_sptBentUpArrowDefault[] =
1163 {
1164     3, 9340, 18500, 7200
1165 };
1166 const SvxMSDffTextRectangles mso_sptBentUpArrowTextRect[] =
1167 {
1168     { { 2 MSO_I, 7 MSO_I }, { 1 MSO_I, 1 MSO_I } },
1169     { { 7 MSO_I, 2 MSO_I }, { 1 MSO_I, 1 MSO_I } }
1170 };
1171 const SvxMSDffHandle mso_sptBentUpArrowHandle[] =
1172 {
1173     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL,
1174         0x101, 0x102, 10800, 10800, 3 + 5, 21600, 0, 0x100 },
1175     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
1176         0x100, 0, 10800, 10800, 0x102, 3 + 10, MIN_INT32, 0x7fffffff }
1177 };
1178 const mso_CustomShape msoBentUpArrow =
1179 {
1180     const_cast<SvxMSDffVertPair*>(mso_sptBentUpArrowVert), SAL_N_ELEMENTS( mso_sptBentUpArrowVert ),
1181     const_cast<sal_uInt16*>(mso_sptBentUpArrowSegm), sizeof( mso_sptBentUpArrowSegm ) >> 1,
1182     const_cast<SvxMSDffCalculationData*>(mso_sptBentUpArrowCalc), SAL_N_ELEMENTS( mso_sptBentUpArrowCalc ),
1183     const_cast<sal_Int32*>(mso_sptBentUpArrowDefault),
1184     const_cast<SvxMSDffTextRectangles*>(mso_sptBentUpArrowTextRect), SAL_N_ELEMENTS( mso_sptBentUpArrowTextRect ),
1185     21600, 21600,
1186     MIN_INT32, MIN_INT32,
1187     nullptr, 0,
1188     const_cast<SvxMSDffHandle*>(mso_sptBentUpArrowHandle), SAL_N_ELEMENTS( mso_sptBentUpArrowHandle )
1189 };
1190
1191 const SvxMSDffVertPair mso_sptCurvedRightVert[] =
1192 {
1193     { 0, 0 }, { 23 MSO_I, 3 MSO_I }, { 22 MSO_I, 0 }, { 0, 4 MSO_I }, { 0, 15 MSO_I }, { 23 MSO_I, 1 MSO_I }, { 0, 7 MSO_I }, { 2 MSO_I, 13 MSO_I },
1194     { 2 MSO_I, 14 MSO_I }, { 22 MSO_I, 8 MSO_I }, { 2 MSO_I, 12 MSO_I },
1195     { 0, 0 }, { 23 MSO_I, 3 MSO_I }, { 2 MSO_I, 11 MSO_I }, { 26 MSO_I, 17 MSO_I }, { 0, 15 MSO_I }, { 23 MSO_I, 1 MSO_I }, { 26 MSO_I, 17 MSO_I }, { 22 MSO_I, 15 MSO_I },
1196     { 0, 0 }, { 23 MSO_I, 3 MSO_I }, { 22 MSO_I, 0 }, { 0, 4 MSO_I },
1197     { 0, 0 }, { 23 MSO_I, 3 MSO_I }, { 0, 4 MSO_I }, { 26 MSO_I, 17 MSO_I },
1198     { 0, 15 MSO_I }, { 23 MSO_I, 1 MSO_I }, { 26 MSO_I, 17 MSO_I }, { 22 MSO_I, 15 MSO_I }
1199 };
1200 const sal_uInt16 mso_sptCurvedRightSegm[] =
1201 {
1202     0xa408,
1203     0x0003,
1204     0xa508,
1205     0x6000,
1206     0x8000,
1207     0xa404,
1208     0xa304,
1209     0xa504,
1210     0x6000,
1211     0x8000
1212 };
1213 const SvxMSDffCalculationData mso_sptCurvedRightCalc[] =
1214 {
1215     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
1216     { 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
1217     { 0x2000, { DFF_Prop_adjust3Value, 0, 0 } },
1218     { 0xa000, { DFF_Prop_adjustValue, 21600, DFF_Prop_adjust2Value } },
1219     { 0x2001, { 0x403, 1, 2 } },
1220     { 0x6000, { DFF_Prop_adjust2Value, DFF_Prop_adjust2Value, 21600 } },
1221     { 0xe000, { 0x405, DFF_Prop_adjust2Value, DFF_Prop_adjustValue } },
1222     { 0x2001, { 0x406, 1, 2 } },
1223     { 0x4002, { 21600, DFF_Prop_adjustValue, 0 } },
1224     { 0x8000, { 21600, 0, DFF_Prop_adjust3Value } },
1225     { 0xa00f, { 0x409, 21600, 0x404 } },
1226     { 0x6000, { 0x404, 0x40a, 0 } },
1227     { 0x6000, { 0x40b, DFF_Prop_adjust2Value, 21600 } },
1228     { 0x6000, { 0x407, 0x40a, 0 } },
1229     { 0xa000, { 0x40c, 21600, DFF_Prop_adjustValue } },
1230     { 0xa000, { 0x405, 0, DFF_Prop_adjustValue } },
1231     { 0x2001, { 0x40f, 1, 2 } },
1232     { 0x6002, { 0x404, 0x407, 0 } },
1233     { 0x6000, { DFF_Prop_adjustValue, DFF_Prop_adjust2Value, 21600 } },
1234     { 0x2001, { 0x412, 1, 2 } },
1235     { 0xa000, { 0x411, 0, 0x413 } },
1236     { 0x0000, { 21600, 0, 0 } },
1237     { 0x0000, { 21600, 0, 0 } },
1238     { 0x0001, { 21600, 2, 1 } },
1239     { 0xa000, { 0x411, 0, 0x404 } },
1240     { 0x600f, { 0x418, 0x404, 21600 } },
1241     { 0x8000, { 21600, 0, 0x419 } },
1242     { 0x2000, { 0x408, 128, 0 } },
1243     { 0x2001, { 0x405, 1, 2 } },
1244     { 0x2000, { 0x405, 0, 128 } },
1245     { 0xe000, { DFF_Prop_adjustValue, 0x411, 0x40c } },
1246     { 0x600f, { 0x414, 0x404, 21600 } },
1247     { 0x8000, { 21600, 0, DFF_Prop_adjustValue } },
1248     { 0x2001, { 0x420, 1, 2 } },
1249     { 0x0001, { 21600, 21600, 1 } },
1250     { 0x6001, { 0x409, 0x409, 1 } },
1251     { 0xa000, { 0x422, 0, 0x423 } },
1252     { 0x200d, { 0x424, 0, 0 } },
1253     { 0x2000, { 0x425, 21600, 0 } },
1254     { 0x8001, { 21600, 21600, 0x426 } },
1255     { 0x2000, { 0x427, 64, 0 } },
1256     { 0x2001, { DFF_Prop_adjustValue, 1, 2 } },
1257     { 0x600f, { 0x421, 0x429, 21600 } },
1258     { 0x8000, { 21600, 0, 0x42a } },
1259     { 0x2000, { 0x42b, 64, 0 } },
1260     { 0x2001, { 0x404, 1, 2 } },
1261     { 0xa000, { DFF_Prop_adjust2Value, 0, 0x42d } },
1262     { 0x0001, { 21600, 2195, 16384 } },
1263     { 0x0001, { 21600, 14189, 16384 } }
1264 };
1265 const sal_Int32 mso_sptCurvedRightDefault[] =
1266 {
1267     3, 12960, 19440, 14400
1268 };
1269 const SvxMSDffTextRectangles mso_sptCurvedRightTextRect[] =
1270 {
1271     { { 47 MSO_I, 45 MSO_I }, { 48 MSO_I, 46 MSO_I } }
1272 };
1273 const SvxMSDffVertPair mso_sptCurvedRightGluePoints[] =
1274 {
1275     { 0, 17 MSO_I }, { 2 MSO_I, 14 MSO_I }, { 22 MSO_I, 8 MSO_I }, { 2 MSO_I, 12 MSO_I }, { 22 MSO_I, 16 MSO_I }
1276 };
1277 const SvxMSDffHandle mso_sptCurvedRightHandles[] =
1278 {
1279     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
1280         21600, 0x100, 10800, 10800, 0, 10800, 3 + 40, 3 + 29 },
1281     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
1282         21600, 0x101, 10800, 10800, 0, 10800, 3 + 27, 3 + 21 },
1283     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
1284         0x102, 21600, 10800, 10800, 3 + 44, 3 + 22, 3375, 21600 }
1285 };
1286 const mso_CustomShape msoCurvedRightArrow =
1287 {
1288     const_cast<SvxMSDffVertPair*>(mso_sptCurvedRightVert), SAL_N_ELEMENTS( mso_sptCurvedRightVert ),
1289     const_cast<sal_uInt16*>(mso_sptCurvedRightSegm), sizeof( mso_sptCurvedRightSegm ) >> 1,
1290     const_cast<SvxMSDffCalculationData*>(mso_sptCurvedRightCalc), SAL_N_ELEMENTS( mso_sptCurvedRightCalc ),
1291     const_cast<sal_Int32*>(mso_sptCurvedRightDefault),
1292     const_cast<SvxMSDffTextRectangles*>(mso_sptCurvedRightTextRect), SAL_N_ELEMENTS( mso_sptCurvedRightTextRect ),
1293     21600, 21600,
1294     MIN_INT32, MIN_INT32,
1295     const_cast<SvxMSDffVertPair*>(mso_sptCurvedRightGluePoints), SAL_N_ELEMENTS( mso_sptCurvedRightGluePoints ),
1296     const_cast<SvxMSDffHandle*>(mso_sptCurvedRightHandles), SAL_N_ELEMENTS( mso_sptCurvedRightHandles )
1297 };
1298
1299 const SvxMSDffVertPair mso_sptCurvedDownVert[] =
1300 {
1301    { 0, 0 }, { 3 MSO_I, 23 MSO_I }, { 0, 22 MSO_I }, { 4 MSO_I, 0 },
1302    { 15 MSO_I, 0 }, { 1 MSO_I, 23 MSO_I }, { 7 MSO_I, 0 }, { 13 MSO_I, 2 MSO_I },
1303    { 14 MSO_I, 2 MSO_I }, { 8 MSO_I, 22 MSO_I }, { 12 MSO_I, 2 MSO_I },
1304    { 0, 0 }, { 3 MSO_I, 23 MSO_I }, { 11 MSO_I, 2 MSO_I }, { 17 MSO_I, 26 MSO_I }, { 15 MSO_I, 0 },
1305    { 1 MSO_I, 23 MSO_I }, { 17 MSO_I, 26 MSO_I }, { 15 MSO_I, 22 MSO_I },
1306    { 0, 0 }, { 3 MSO_I, 23 MSO_I }, { 0, 22 MSO_I }, { 4 MSO_I, 0 },
1307    { 0, 0 }, { 3 MSO_I, 23 MSO_I }, { 4 MSO_I, 0 }, { 17 MSO_I, 26 MSO_I },
1308    { 15 MSO_I, 0 }, { 1 MSO_I, 23 MSO_I }, { 17 MSO_I, 26 MSO_I }, { 15 MSO_I, 22 MSO_I }
1309 };
1310 const sal_uInt16 mso_sptCurvedDownSegm[] =
1311 {
1312     0xa608,
1313     0x0003,
1314     0xa308,
1315     0x6000,
1316     0x8000,
1317    0xa604,
1318    0xa504,
1319    0xa304,
1320    0x6000,
1321    0x8000
1322 };
1323 const SvxMSDffTextRectangles mso_sptCurvedDownTextRect[] =
1324 {
1325    { { 45 MSO_I, 47 MSO_I }, { 46 MSO_I, 48 MSO_I } }
1326 };
1327 const SvxMSDffVertPair mso_sptCurvedDownGluePoints[] =
1328 {
1329    { 17 MSO_I, 0 }, { 16 MSO_I, 22 MSO_I }, { 12 MSO_I, 2 MSO_I }, { 8 MSO_I, 22 MSO_I }, { 14 MSO_I, 2 MSO_I }
1330 };
1331 const SvxMSDffHandle mso_sptCurvedDownHandles[] =
1332 {
1333    {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
1334        0x100, 21600, 10800, 10800, 3 + 40, 3 + 29, 0, 10800 },
1335    {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
1336        0x101, 21600, 10800, 10800, 3 + 27, 3 + 21, 0, 10800 },
1337    {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
1338        21600, 0x102, 10800, 10800, 3375, 21600, 3 + 44, 3 + 22 }
1339 };
1340
1341 const mso_CustomShape msoCurvedDownArrow =
1342 {
1343    const_cast<SvxMSDffVertPair*>(mso_sptCurvedDownVert), SAL_N_ELEMENTS( mso_sptCurvedDownVert ),
1344    const_cast<sal_uInt16*>(mso_sptCurvedDownSegm), sizeof( mso_sptCurvedDownSegm ) >> 1,
1345    const_cast<SvxMSDffCalculationData*>(mso_sptCurvedRightCalc), SAL_N_ELEMENTS( mso_sptCurvedRightCalc ),
1346    const_cast<sal_Int32*>(mso_sptCurvedRightDefault),
1347    const_cast<SvxMSDffTextRectangles*>(mso_sptCurvedDownTextRect), SAL_N_ELEMENTS( mso_sptCurvedDownTextRect ),
1348    21600, 21600,
1349    MIN_INT32, MIN_INT32,
1350    const_cast<SvxMSDffVertPair*>(mso_sptCurvedDownGluePoints), SAL_N_ELEMENTS( mso_sptCurvedDownGluePoints ),
1351    const_cast<SvxMSDffHandle*>(mso_sptCurvedDownHandles), SAL_N_ELEMENTS( mso_sptCurvedDownHandles )
1352 };
1353
1354 const SvxMSDffVertPair mso_sptCurvedUpVert[] =
1355 {
1356    { 0, 22 MSO_I }, { 3 MSO_I, 21 MSO_I }, { 0, 0 }, { 4 MSO_I, 21 MSO_I },
1357    { 14 MSO_I, 22 MSO_I }, { 1 MSO_I, 21 MSO_I }, { 7 MSO_I, 21 MSO_I },
1358    { 12 MSO_I, 2 MSO_I }, { 13 MSO_I, 2 MSO_I }, { 8 MSO_I, 0 }, { 11 MSO_I, 2 MSO_I },
1359    { 0, 22 MSO_I }, { 3 MSO_I, 21 MSO_I }, { 10 MSO_I, 2 MSO_I }, { 16 MSO_I, 24 MSO_I },
1360    { 14 MSO_I, 22 MSO_I }, { 1 MSO_I, 21 MSO_I }, { 16 MSO_I, 24 MSO_I }, { 14 MSO_I, 0 },
1361    { 0, 22 MSO_I }, { 3 MSO_I, 21 MSO_I }, { 0, 0 }, { 4 MSO_I, 21 MSO_I },
1362    { 14 MSO_I, 22 MSO_I }, { 1 MSO_I, 21 MSO_I }, { 7 MSO_I, 21 MSO_I }, { 16 MSO_I, 24 MSO_I },
1363    { 14 MSO_I, 22 MSO_I }, { 1 MSO_I, 21 MSO_I }, { 16 MSO_I, 24 MSO_I }, { 14 MSO_I, 0 }
1364 };
1365 const sal_uInt16 mso_sptCurvedUpSegm[] =
1366 {
1367    0xa408,
1368    0x0003,
1369    0xa508,
1370    0x6000,
1371    0x8000,
1372    0xa404,
1373    0xa508,
1374    0xa504,
1375    0x6000,
1376    0x8000
1377 };
1378 const SvxMSDffCalculationData mso_sptCurvedUpCalc[] =
1379 {
1380     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
1381     { 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
1382     { 0x2000, { DFF_Prop_adjust3Value, 0, 0 } },
1383     { 0xa000, { DFF_Prop_adjustValue, 21600, DFF_Prop_adjust2Value } },
1384     { 0x2001, { 0x403, 1, 2 } },
1385     { 0x6000, { DFF_Prop_adjust2Value, DFF_Prop_adjust2Value, 21600 } },
1386     { 0xe000, { 0x405, DFF_Prop_adjust2Value, DFF_Prop_adjustValue } },
1387     { 0x2001, { 0x406, 1, 2 } },
1388     { 0x4002, { 21600, DFF_Prop_adjustValue, 0 } },
1389     { 0xa00f, { DFF_Prop_adjust3Value, 21600, 0x404 } },
1390     { 0x6000, { 0x404, 0x409, 0 } },
1391     { 0x6000, { 0x40a, DFF_Prop_adjust2Value, 21600 } },
1392     { 0x6000, { 0x407, 0x409, 0 } },
1393     { 0xa000, { 0x40b, 21600, DFF_Prop_adjustValue } },
1394     { 0xa000, { 0x405, 0, DFF_Prop_adjustValue } },
1395     { 0x2001, { 0x40e, 1, 2 } },
1396     { 0x6002, { 0x404, 0x407, 0 } },
1397     { 0x6000, { DFF_Prop_adjustValue, DFF_Prop_adjust2Value, 21600 } },
1398     { 0x2001, { 0x411, 1, 2 } },
1399     { 0xa000, { 0x410, 0, 0x412 } },
1400     { 0x0000, { 21600, 0, 0 } },
1401     { 0x0000, { 21600, 0, 0 } },
1402     { 0x0000, { 0, 0, 21600 } },
1403     { 0xa000, { 0x410, 0, 0x404 } },
1404     { 0x600f, { 0x417, 0x404, 21600 } },
1405     { 0x2000, { 0x408, 128, 0 } },
1406     { 0x2001, { 0x405, 1, 2 } },
1407     { 0x2000, { 0x405, 0, 128 } },
1408     { 0xe000, { DFF_Prop_adjustValue, 0x410, 0x40b } },
1409     { 0x8000, { 21600, 0, DFF_Prop_adjustValue } },
1410     { 0x2001, { 0x41d, 1, 2 } },
1411     { 0x0001, { 21600, 21600, 1 } },
1412     { 0x6001, { DFF_Prop_adjust3Value, DFF_Prop_adjust3Value, 1 } },
1413     { 0xa000, { 0x41f, 0, 0x420 } },
1414     { 0x200d, { 0x421, 0, 0 } },
1415     { 0x2000, { 0x422, 21600, 0 } },
1416     { 0x8001, { 21600, 21600, 0x423 } },
1417     { 0x2000, { 0x424, 64, 0 } },
1418     { 0x2001, { DFF_Prop_adjustValue, 1, 2 } },
1419     { 0x600f, { 0x41e, 0x426, 21600 } },
1420     { 0x2000, { 0x427, 0, 64 } },
1421     { 0x2001, { 0x404, 1, 2 } },
1422     { 0xa000, { DFF_Prop_adjust2Value, 0, 0x429 } },
1423     { 0x0001, { 21600, 2195, 16384 } },
1424     { 0x0001, { 21600, 14189, 16384 } }
1425 };
1426 const sal_Int32 mso_sptCurvedUpDefault[] =
1427 {
1428     3, 12960, 19440, 7200
1429 };
1430 const SvxMSDffTextRectangles mso_sptCurvedUpTextRect[] =
1431 {
1432    { { 41 MSO_I, 43 MSO_I }, { 42 MSO_I, 44 MSO_I } }
1433 };
1434 const SvxMSDffVertPair mso_sptCurvedUpGluePoints[] =
1435 {
1436    { 8 MSO_I, 0 }, { 11 MSO_I, 2 MSO_I }, { 15 MSO_I, 0 }, { 16 MSO_I, 21 MSO_I }, { 13 MSO_I, 2 MSO_I }
1437 };
1438 const SvxMSDffHandle mso_sptCurvedUpHandles[] =
1439 {
1440    {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
1441        0x100, 0, 10800, 10800, 3 + 37, 3 + 27, 0, 10800 },
1442    {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
1443        0x101, 0, 10800, 10800, 3 + 25, 3 + 20, 0, 10800 },
1444    {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
1445        21600, 0x102, 10800, 10800, 3375, 21600, 0, 3 + 40 }
1446 };
1447 const mso_CustomShape msoCurvedUpArrow =
1448 {
1449    const_cast<SvxMSDffVertPair*>(mso_sptCurvedUpVert), SAL_N_ELEMENTS( mso_sptCurvedUpVert ),
1450    const_cast<sal_uInt16*>(mso_sptCurvedUpSegm), sizeof( mso_sptCurvedUpSegm ) >> 1,
1451    const_cast<SvxMSDffCalculationData*>(mso_sptCurvedUpCalc), SAL_N_ELEMENTS( mso_sptCurvedUpCalc ),
1452    const_cast<sal_Int32*>(mso_sptCurvedUpDefault),
1453    const_cast<SvxMSDffTextRectangles*>(mso_sptCurvedUpTextRect), SAL_N_ELEMENTS( mso_sptCurvedUpTextRect ),
1454    21600, 21600,
1455    MIN_INT32, MIN_INT32,
1456    const_cast<SvxMSDffVertPair*>(mso_sptCurvedUpGluePoints), SAL_N_ELEMENTS( mso_sptCurvedUpGluePoints ),
1457    const_cast<SvxMSDffHandle*>(mso_sptCurvedUpHandles), SAL_N_ELEMENTS( mso_sptCurvedUpHandles )
1458 };
1459
1460 const SvxMSDffVertPair mso_sptCurvedLeftVert[] =
1461 {
1462    { 22 MSO_I, 0 }, { 21 MSO_I, 3 MSO_I }, { 0, 0 }, { 21 MSO_I, 4 MSO_I },
1463    { 22 MSO_I, 14 MSO_I }, { 21 MSO_I, 1 MSO_I }, { 21 MSO_I, 7 MSO_I }, { 2 MSO_I, 12 MSO_I },
1464    { 2 MSO_I, 13 MSO_I }, { 0, 8 MSO_I }, { 2 MSO_I, 11 MSO_I },
1465    { 22 MSO_I, 0 }, { 21 MSO_I, 3 MSO_I }, { 2 MSO_I, 10 MSO_I }, { 24 MSO_I, 16 MSO_I },
1466    { 22 MSO_I, 14 MSO_I }, { 21 MSO_I, 1 MSO_I }, { 24 MSO_I, 16 MSO_I }, { 0, 14 MSO_I },
1467    { 22 MSO_I, 0 }, { 21 MSO_I, 3 MSO_I }, { 0, 0 }, { 21 MSO_I, 4 MSO_I },
1468    { 22 MSO_I, 14 MSO_I }, { 21 MSO_I, 1 MSO_I }, { 21 MSO_I, 7 MSO_I }, { 24 MSO_I, 16 MSO_I },
1469    { 22 MSO_I, 14 MSO_I }, { 21 MSO_I, 1 MSO_I }, { 24 MSO_I, 16 MSO_I }, { 0, 14 MSO_I }
1470 };
1471 const sal_uInt16 mso_sptCurvedLeftSegm[] =
1472 {
1473    0xa608,
1474    0x0003,
1475    0xa308,
1476    0x6000,
1477    0x8000,
1478    0xa604,
1479    0xa308,
1480    0x6000,
1481    0x8000
1482 };
1483 const SvxMSDffTextRectangles mso_sptCurvedLeftTextRect[] =
1484 {
1485     { { 43 MSO_I, 41 MSO_I }, { 44 MSO_I, 42 MSO_I } }
1486 };
1487 const SvxMSDffVertPair mso_sptCurvedLeftGluePoints[] =
1488 {
1489     { 0, 15 MSO_I }, { 2 MSO_I, 11 MSO_I }, { 0, 8 MSO_I }, { 2 MSO_I, 13 MSO_I }, { 21 MSO_I, 16 MSO_I }
1490 };
1491 const SvxMSDffHandle mso_sptCurvedLeftHandles[] =
1492 {
1493     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
1494         0, 0x100, 10800, 10800, 0, 10800, 3 + 37, 3 + 27 },
1495     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
1496         0, 0x101, 10800, 10800, 0, 10800, 3 + 25, 3 + 20 },
1497     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
1498         0x102, 21600, 10800, 10800, 0, 3 + 40, 3375, 21600 }
1499 };
1500 const mso_CustomShape msoCurvedLeftArrow =
1501 {
1502     const_cast<SvxMSDffVertPair*>(mso_sptCurvedLeftVert), SAL_N_ELEMENTS( mso_sptCurvedLeftVert ),
1503     const_cast<sal_uInt16*>(mso_sptCurvedLeftSegm), sizeof( mso_sptCurvedLeftSegm ) >> 1,
1504     const_cast<SvxMSDffCalculationData*>(mso_sptCurvedUpCalc), SAL_N_ELEMENTS( mso_sptCurvedUpCalc ),
1505     const_cast<sal_Int32*>(mso_sptCurvedUpDefault),
1506     const_cast<SvxMSDffTextRectangles*>(mso_sptCurvedLeftTextRect), SAL_N_ELEMENTS( mso_sptCurvedLeftTextRect ),
1507     21600, 21600,
1508     MIN_INT32, MIN_INT32,
1509     const_cast<SvxMSDffVertPair*>(mso_sptCurvedLeftGluePoints), SAL_N_ELEMENTS( mso_sptCurvedLeftGluePoints ),
1510     const_cast<SvxMSDffHandle*>(mso_sptCurvedLeftHandles), SAL_N_ELEMENTS( mso_sptCurvedLeftHandles )
1511 };
1512
1513 const SvxMSDffVertPair mso_sptStripedRightArrowVert[] =  // adjustment1 : x 3375 - 21600
1514 {                                                               // adjustment2 : y 0 - 10800
1515     { 3375, 0 MSO_I }, { 1 MSO_I, 0 MSO_I }, { 1 MSO_I, 0 }, { 21600, 10800 },
1516     { 1 MSO_I, 21600 }, { 1 MSO_I, 2 MSO_I }, { 3375, 2 MSO_I }, { 0, 0 MSO_I },
1517     { 675, 0 MSO_I }, { 675, 2 MSO_I }, { 0, 2 MSO_I }, { 1350, 0 MSO_I },
1518     { 2700, 0 MSO_I }, { 2700, 2 MSO_I }, { 1350, 2 MSO_I }
1519 };
1520 const sal_uInt16 mso_sptStripedRightArrowSegm[] =
1521 {
1522     0x4000, 0x0006, 0x6001, 0x8000,
1523     0x4000, 0x0003, 0x6001, 0x8000,
1524     0x4000, 0x0003, 0x6001, 0x8000
1525 };
1526 const SvxMSDffCalculationData mso_sptStripedRightArrowCalc[] =
1527 {
1528     { 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
1529     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
1530     { 0x8000, { 21600, 0, DFF_Prop_adjust2Value } },
1531     { 0x8000, { 21600, 0, 0x401 } },
1532     { 0x6001, { 0x403, 0x400, 10800 } },
1533     { 0x6000, { 0x401, 0x404, 0 } }
1534 };
1535 const SvxMSDffTextRectangles mso_sptStripedRightArrowTextRect[] =
1536 {
1537     { { 3375, 0 MSO_I }, { 5 MSO_I, 2 MSO_I } }
1538 };
1539 const SvxMSDffHandle mso_sptStripedRightArrowHandle[] =
1540 {
1541     {   SvxMSDffHandleFlags::RANGE,
1542         0x100, 0x101, 10800, 10800, 3375, 21600, 0, 10800 }
1543 };
1544 const mso_CustomShape msoStripedRightArrow =
1545 {
1546     const_cast<SvxMSDffVertPair*>(mso_sptStripedRightArrowVert), SAL_N_ELEMENTS( mso_sptStripedRightArrowVert ),
1547     const_cast<sal_uInt16*>(mso_sptStripedRightArrowSegm), sizeof( mso_sptStripedRightArrowSegm ) >> 1,
1548     const_cast<SvxMSDffCalculationData*>(mso_sptStripedRightArrowCalc), SAL_N_ELEMENTS( mso_sptStripedRightArrowCalc ),
1549     const_cast<sal_Int32*>(mso_sptDefault16200and5400),
1550     const_cast<SvxMSDffTextRectangles*>(mso_sptStripedRightArrowTextRect), SAL_N_ELEMENTS( mso_sptStripedRightArrowTextRect ),
1551     21600, 21600,
1552     MIN_INT32, MIN_INT32,
1553     nullptr, 0,
1554     const_cast<SvxMSDffHandle*>(mso_sptStripedRightArrowHandle), SAL_N_ELEMENTS( mso_sptStripedRightArrowHandle )
1555 };
1556
1557 const SvxMSDffVertPair mso_sptNotchedRightArrowVert[] =  // adjustment1 : x 0 - 21600    (default 16200)
1558 {                                                               // adjustment2 : y 0 - 10800    (default 5400)
1559     { 0, 1 MSO_I }, { 0 MSO_I, 1 MSO_I }, { 0 MSO_I, 0 }, { 21600, 10800 },
1560     { 0 MSO_I, 21600 }, { 0 MSO_I, 2 MSO_I }, { 0, 2 MSO_I }, { 5 MSO_I, 10800 }, { 0, 1 MSO_I }
1561 };
1562 const SvxMSDffCalculationData mso_sptNotchedRightArrowCalc[] =
1563 {
1564     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
1565     { 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
1566     { 0x8000, { 21600, 0, DFF_Prop_adjust2Value } },
1567     { 0x8000, { 21600, 0, DFF_Prop_adjustValue } },
1568     { 0x8000, { 10800, 0, DFF_Prop_adjust2Value } },
1569     { 0x6001, { 0x403, 0x404, 10800 } },
1570     { 0x8000, { 21600, 0, 0x405 }}
1571 };
1572 const SvxMSDffTextRectangles mso_sptNotchedRightArrowTextRect[] =    // todo
1573 {
1574     { { 5 MSO_I, 1 MSO_I }, { 6 MSO_I, 2 MSO_I } }
1575 };
1576 const SvxMSDffHandle mso_sptNotchedRightArrowHandle[] =
1577 {
1578     {   SvxMSDffHandleFlags::RANGE,
1579         0x100, 0x101, 10800, 10800, 0, 21600, 0, 10800 }
1580 };
1581 const mso_CustomShape msoNotchedRightArrow =
1582 {
1583     const_cast<SvxMSDffVertPair*>(mso_sptNotchedRightArrowVert), SAL_N_ELEMENTS( mso_sptNotchedRightArrowVert ),
1584     nullptr, 0,
1585     const_cast<SvxMSDffCalculationData*>(mso_sptNotchedRightArrowCalc), SAL_N_ELEMENTS( mso_sptNotchedRightArrowCalc ),
1586     const_cast<sal_Int32*>(mso_sptDefault16200and5400),
1587     const_cast<SvxMSDffTextRectangles*>(mso_sptNotchedRightArrowTextRect), SAL_N_ELEMENTS( mso_sptNotchedRightArrowTextRect ),
1588     21600, 21600,
1589     MIN_INT32, MIN_INT32,
1590     nullptr, 0,
1591     const_cast<SvxMSDffHandle*>(mso_sptNotchedRightArrowHandle), SAL_N_ELEMENTS( mso_sptNotchedRightArrowHandle )
1592 };
1593
1594 const SvxMSDffVertPair mso_sptHomePlateVert[] =  // adjustment1 : x 0 - 21600
1595 {
1596     { 0, 0 }, { 0 MSO_I, 0 }, { 21600, 10800 }, { 0 MSO_I, 21600 },
1597     { 0, 21600 }
1598 };
1599 const sal_uInt16 mso_sptHomePlateSegm[] =
1600 {
1601     0x4000, 0x0004, 0x6001, 0x8000
1602 };
1603 const SvxMSDffCalculationData mso_sptHomePlateCalc[] =
1604 {
1605     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } }
1606 };
1607 const sal_Int32 mso_sptHomePlateDefault[] =
1608 {
1609     1, 16200
1610 };
1611 const SvxMSDffTextRectangles mso_sptHomePlateTextRect[] =    // todo
1612 {
1613     { { 0, 0 }, { 21600, 21600 } }
1614 };
1615 const SvxMSDffHandle mso_sptHomePlateHandle[] =
1616 {
1617     {   SvxMSDffHandleFlags::RANGE,
1618         0x100, 0, 10800, 10800, 0, 21600, MIN_INT32, 0x7fffffff }
1619 };
1620 const mso_CustomShape msoHomePlate =
1621 {
1622     const_cast<SvxMSDffVertPair*>(mso_sptHomePlateVert), SAL_N_ELEMENTS( mso_sptHomePlateVert ),
1623     const_cast<sal_uInt16*>(mso_sptHomePlateSegm), sizeof( mso_sptHomePlateSegm ) >> 1,
1624     const_cast<SvxMSDffCalculationData*>(mso_sptHomePlateCalc), SAL_N_ELEMENTS( mso_sptHomePlateCalc ),
1625     const_cast<sal_Int32*>(mso_sptHomePlateDefault),
1626     const_cast<SvxMSDffTextRectangles*>(mso_sptHomePlateTextRect), SAL_N_ELEMENTS( mso_sptHomePlateTextRect ),
1627     21600, 21600,
1628     MIN_INT32, MIN_INT32,
1629     nullptr, 0,
1630     const_cast<SvxMSDffHandle*>(mso_sptHomePlateHandle), SAL_N_ELEMENTS( mso_sptHomePlateHandle )
1631 };
1632
1633 const SvxMSDffVertPair mso_sptChevronVert[] =    // adjustment1 : x 0 - 21600
1634 {
1635     { 0, 0 }, { 0 MSO_I, 0 }, { 21600, 10800 }, { 0 MSO_I, 21600 },
1636     { 0, 21600 }, { 1 MSO_I, 10800 }
1637 };
1638 const sal_uInt16 mso_sptChevronSegm[] =
1639 {
1640     0x4000, 0x0005, 0x6001, 0x8000
1641 };
1642 const SvxMSDffCalculationData mso_sptChevronCalc[] =
1643 {
1644     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
1645     { 0x8000, { 21600, 0, 0x0400 } }
1646 };
1647 const sal_Int32 mso_sptChevronDefault[] =
1648 {
1649     1, 16200
1650 };
1651 const SvxMSDffTextRectangles mso_sptChevronTextRect[] =  // todo
1652 {
1653     { { 0, 0 }, { 21600, 21600 } }
1654 };
1655 const SvxMSDffHandle mso_sptChevronHandle[] =
1656 {
1657     {   SvxMSDffHandleFlags::RANGE,
1658         0x100, 0, 10800, 10800, 0, 21600, MIN_INT32, 0x7fffffff }
1659 };
1660 const mso_CustomShape msoChevron =
1661 {
1662     const_cast<SvxMSDffVertPair*>(mso_sptChevronVert), SAL_N_ELEMENTS( mso_sptChevronVert ),
1663     const_cast<sal_uInt16*>(mso_sptChevronSegm), sizeof( mso_sptChevronSegm ) >> 1,
1664     const_cast<SvxMSDffCalculationData*>(mso_sptChevronCalc), SAL_N_ELEMENTS( mso_sptChevronCalc ),
1665     const_cast<sal_Int32*>(mso_sptChevronDefault),
1666     const_cast<SvxMSDffTextRectangles*>(mso_sptChevronTextRect), SAL_N_ELEMENTS( mso_sptChevronTextRect ),
1667     21600, 21600,
1668     MIN_INT32, MIN_INT32,
1669     nullptr, 0,
1670     const_cast<SvxMSDffHandle*>(mso_sptChevronHandle), SAL_N_ELEMENTS( mso_sptChevronHandle )
1671 };
1672
1673 const SvxMSDffVertPair mso_sptRightArrowCalloutVert[] =  // adjustment1 : x 0 - 21000
1674 {                                                               // adjustment2 : y 0 - 10800
1675     { 0, 0 }, { 0 MSO_I, 0 }, { 0 MSO_I, 3 MSO_I }, { 2 MSO_I, 3 MSO_I },
1676     { 2 MSO_I, 1 MSO_I }, { 21600, 10800 }, { 2 MSO_I, 4 MSO_I }, { 2 MSO_I, 5 MSO_I },
1677     { 0 MSO_I, 5 MSO_I }, { 0 MSO_I, 21600 }, { 0, 21600 }
1678 };
1679 const sal_uInt16 mso_sptRightArrowCalloutSegm[] =
1680 {
1681     0x4000, 0x000a, 0x6001, 0x8000
1682 };
1683 const SvxMSDffCalculationData mso_sptRightArrowCalloutCalc[] =
1684 {
1685     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
1686     { 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
1687     { 0x2000, { DFF_Prop_adjust3Value, 0, 0 } },
1688     { 0x2000, { DFF_Prop_adjust4Value, 0, 0 } },
1689     { 0x8000, { 21600, 0, 0x0401 } },
1690     { 0x8000, { 21600, 0, 0x0403 } }
1691 };
1692 const sal_Int32 mso_sptRightArrowCalloutDefault[] =
1693 {
1694     4, 14400, 5400, 18000, 8100
1695 };
1696 const SvxMSDffTextRectangles mso_sptRightArrowCalloutTextRect[] =
1697 {
1698     { { 0, 0 }, { 0 MSO_I, 21600 } }
1699 };
1700 const SvxMSDffHandle mso_sptRightArrowCalloutHandle[] =
1701 {
1702     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
1703         0x100, 0, 10800, 10800, 0, 0x102, MIN_INT32, 0x7fffffff },
1704     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL,
1705         0x102, 0x103, 10800, 10800, 0x100, 21600, 0x101, 10800 },
1706     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
1707         1, 0x101, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 0x103 }
1708 };
1709 const mso_CustomShape msoRightArrowCallout =
1710 {
1711     const_cast<SvxMSDffVertPair*>(mso_sptRightArrowCalloutVert), SAL_N_ELEMENTS( mso_sptRightArrowCalloutVert ),
1712     const_cast<sal_uInt16*>(mso_sptRightArrowCalloutSegm), sizeof( mso_sptRightArrowCalloutSegm ) >> 1,
1713     const_cast<SvxMSDffCalculationData*>(mso_sptRightArrowCalloutCalc), SAL_N_ELEMENTS( mso_sptRightArrowCalloutCalc ),
1714     const_cast<sal_Int32*>(mso_sptRightArrowCalloutDefault),
1715     const_cast<SvxMSDffTextRectangles*>(mso_sptRightArrowCalloutTextRect), SAL_N_ELEMENTS( mso_sptRightArrowCalloutTextRect ),
1716     21600, 21600,
1717     MIN_INT32, MIN_INT32,
1718     nullptr, 0,
1719     const_cast<SvxMSDffHandle*>(mso_sptRightArrowCalloutHandle), SAL_N_ELEMENTS( mso_sptRightArrowCalloutHandle )
1720 };
1721
1722 const SvxMSDffVertPair mso_sptLeftArrowCalloutVert[] =   // adjustment1 : x 0 - 21600, adjustment2 : y 0 - 10800
1723 {                                                               // adjustment3 : x 0 - 21600, adjustment4 : y 0 - 10800
1724     { 0 MSO_I, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0 MSO_I, 21600 },
1725     { 0 MSO_I, 5 MSO_I }, { 2 MSO_I, 5 MSO_I }, { 2 MSO_I, 4 MSO_I }, { 0, 10800 },
1726     { 2 MSO_I, 1 MSO_I }, { 2 MSO_I, 3 MSO_I }, { 0 MSO_I, 3 MSO_I }
1727 };
1728 const sal_uInt16 mso_sptLeftArrowCalloutSegm[] =
1729 {
1730     0x4000, 0x000a, 0x6001, 0x8000
1731 };
1732 const SvxMSDffCalculationData mso_sptLeftArrowCalloutCalc[] =
1733 {
1734     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
1735     { 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
1736     { 0x2000, { DFF_Prop_adjust3Value, 0, 0 } },
1737     { 0x2000, { DFF_Prop_adjust4Value, 0, 0 } },
1738     { 0x8000, { 21600, 0, 0x0401 } },
1739     { 0x8000, { 21600, 0, 0x0403 } }
1740 };
1741 const sal_Int32 mso_sptLeftArrowCalloutDefault[] =
1742 {
1743     4, 7200, 5400, 3600, 8100
1744 };
1745 const SvxMSDffTextRectangles mso_sptLeftArrowCalloutTextRect[] =
1746 {
1747     { { 0 MSO_I, 0 }, { 21600, 21600 } }
1748 };
1749 const SvxMSDffHandle mso_sptLeftArrowCalloutHandle[] =
1750 {
1751     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL,
1752         0x100, 0, 10800, 10800, 0x102, 21600, MIN_INT32, 0x7fffffff },
1753     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL,
1754         0x102, 0x103, 10800, 10800, 0, 0x100, 0x101, 10800 },
1755     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
1756         0, 0x101, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 0x103 }
1757 };
1758 const mso_CustomShape msoLeftArrowCallout =
1759 {
1760     const_cast<SvxMSDffVertPair*>(mso_sptLeftArrowCalloutVert), SAL_N_ELEMENTS( mso_sptLeftArrowCalloutVert ),
1761     const_cast<sal_uInt16*>(mso_sptLeftArrowCalloutSegm), sizeof( mso_sptLeftArrowCalloutSegm ) >> 1,
1762     const_cast<SvxMSDffCalculationData*>(mso_sptLeftArrowCalloutCalc), SAL_N_ELEMENTS( mso_sptLeftArrowCalloutCalc ),
1763     const_cast<sal_Int32*>(mso_sptLeftArrowCalloutDefault),
1764     const_cast<SvxMSDffTextRectangles*>(mso_sptLeftArrowCalloutTextRect), SAL_N_ELEMENTS( mso_sptLeftArrowCalloutTextRect ),
1765     21600, 21600,
1766     MIN_INT32, MIN_INT32,
1767     nullptr, 0,
1768     const_cast<SvxMSDffHandle*>(mso_sptLeftArrowCalloutHandle), SAL_N_ELEMENTS( mso_sptLeftArrowCalloutHandle )
1769 };
1770
1771 const SvxMSDffVertPair mso_sptUpArrowCalloutVert[] =
1772 {
1773     { 21600, 0 MSO_I }, { 21600, 21600 }, { 0, 21600 }, { 0, 0 MSO_I },
1774     { 3 MSO_I, 0 MSO_I }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I }, { 10800, 0 },
1775     { 4 MSO_I, 2 MSO_I }, { 5 MSO_I, 2 MSO_I }, { 5 MSO_I, 0 MSO_I }
1776 };
1777 const sal_uInt16 mso_sptUpArrowCalloutSegm[] =
1778 {
1779     0x4000, 0x000a, 0x6001, 0x8000
1780 };
1781 const SvxMSDffCalculationData mso_sptUpArrowCalloutCalc[] =
1782 {
1783     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
1784     { 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
1785     { 0x2000, { DFF_Prop_adjust3Value, 0, 0 } },
1786     { 0x2000, { DFF_Prop_adjust4Value, 0, 0 } },
1787     { 0x8000, { 21600, 0, 0x0401 } },
1788     { 0x8000, { 21600, 0, 0x0403 } }
1789 };
1790 const sal_Int32 mso_sptUpArrowCalloutDefault[] =
1791 {
1792     4, 7200, 5400, 3600, 8100
1793 };
1794 const SvxMSDffTextRectangles mso_sptUpArrowCalloutTextRect[] =
1795 {
1796     { { 0, 0 MSO_I }, { 21600, 21600 } }
1797 };
1798 const SvxMSDffHandle mso_sptUpArrowCalloutHandle[] =
1799 {
1800     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL,
1801         0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0x102, 21600 },
1802     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
1803         0x103, 0x102, 10800, 10800, 0x101, 10800, 0, 0x100 },
1804     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
1805         0x101, 0, 10800, 10800, 0, 0x103, MIN_INT32, 0x7fffffff }
1806 };
1807 const mso_CustomShape msoUpArrowCallout =
1808 {
1809     const_cast<SvxMSDffVertPair*>(mso_sptUpArrowCalloutVert), SAL_N_ELEMENTS( mso_sptUpArrowCalloutVert ),
1810     const_cast<sal_uInt16*>(mso_sptUpArrowCalloutSegm), sizeof( mso_sptUpArrowCalloutSegm ) >> 1,
1811     const_cast<SvxMSDffCalculationData*>(mso_sptUpArrowCalloutCalc), SAL_N_ELEMENTS( mso_sptUpArrowCalloutCalc ),
1812     const_cast<sal_Int32*>(mso_sptUpArrowCalloutDefault),
1813     const_cast<SvxMSDffTextRectangles*>(mso_sptUpArrowCalloutTextRect), SAL_N_ELEMENTS( mso_sptUpArrowCalloutTextRect ),
1814     21600, 21600,
1815     MIN_INT32, MIN_INT32,
1816     nullptr, 0,
1817     const_cast<SvxMSDffHandle*>(mso_sptUpArrowCalloutHandle), SAL_N_ELEMENTS( mso_sptUpArrowCalloutHandle )
1818 };
1819
1820 const SvxMSDffVertPair mso_sptDownArrowCalloutVert[] =
1821 {
1822     { 0, 0 MSO_I }, { 0, 0 }, { 21600, 0 }, { 21600, 0 MSO_I },
1823     { 5 MSO_I, 0 MSO_I }, { 5 MSO_I, 2 MSO_I }, { 4 MSO_I, 2 MSO_I }, { 10800, 21600 },
1824     { 1 MSO_I, 2 MSO_I }, { 3 MSO_I, 2 MSO_I }, { 3 MSO_I, 0 MSO_I }
1825 };
1826 const sal_uInt16 mso_sptDownArrowCalloutSegm[] =
1827 {
1828     0x4000, 0x000a, 0x6001, 0x8000
1829 };
1830 const SvxMSDffCalculationData mso_sptDownArrowCalloutCalc[] =
1831 {
1832     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
1833     { 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
1834     { 0x2000, { DFF_Prop_adjust3Value, 0, 0 } },
1835     { 0x2000, { DFF_Prop_adjust4Value, 0, 0 } },
1836     { 0x8000, { 21600, 0, 0x0401 } },
1837     { 0x8000, { 21600, 0, 0x0403 } }
1838 };
1839 const sal_Int32 mso_sptDownArrowCalloutDefault[] =
1840 {
1841     4, 14400, 5400, 18000, 8100
1842 };
1843 const SvxMSDffTextRectangles mso_sptDownArrowCalloutTextRect[] =
1844 {
1845     { { 0, 0 }, { 21600, 0 MSO_I } }
1846 };
1847 const SvxMSDffHandle mso_sptDownArrowCalloutHandle[] =
1848 {
1849     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
1850         0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 0x102 },
1851     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL,
1852         0x103, 0x102, 10800, 10800, 0x101, 10800, 0x100, 21600 },
1853     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
1854         0x101, 1, 10800, 10800, 0, 0x103, MIN_INT32, 0x7fffffff }
1855 };
1856 const mso_CustomShape msoDownArrowCallout =
1857 {
1858     const_cast<SvxMSDffVertPair*>(mso_sptDownArrowCalloutVert), SAL_N_ELEMENTS( mso_sptDownArrowCalloutVert ),
1859     const_cast<sal_uInt16*>(mso_sptDownArrowCalloutSegm), sizeof( mso_sptDownArrowCalloutSegm ) >> 1,
1860     const_cast<SvxMSDffCalculationData*>(mso_sptDownArrowCalloutCalc), SAL_N_ELEMENTS( mso_sptDownArrowCalloutCalc ),
1861     const_cast<sal_Int32*>(mso_sptDownArrowCalloutDefault),
1862     const_cast<SvxMSDffTextRectangles*>(mso_sptDownArrowCalloutTextRect), SAL_N_ELEMENTS( mso_sptDownArrowCalloutTextRect ),
1863     21600, 21600,
1864     MIN_INT32, MIN_INT32,
1865     nullptr, 0,
1866     const_cast<SvxMSDffHandle*>(mso_sptDownArrowCalloutHandle), SAL_N_ELEMENTS( mso_sptDownArrowCalloutHandle )
1867 };
1868
1869 const SvxMSDffVertPair mso_sptLeftRightArrowCalloutVert[] =
1870 {
1871     { 0 MSO_I, 0 }, { 4 MSO_I, 0 }, { 4 MSO_I, 3 MSO_I }, { 6 MSO_I, 3 MSO_I },
1872     { 6 MSO_I, 1 MSO_I }, { 21600, 10800 }, { 6 MSO_I, 5 MSO_I }, { 6 MSO_I, 7 MSO_I },
1873     { 4 MSO_I, 7 MSO_I }, { 4 MSO_I, 21600 }, { 0 MSO_I, 21600 }, { 0 MSO_I, 7 MSO_I },
1874     { 2 MSO_I, 7 MSO_I }, { 2 MSO_I, 5 MSO_I }, { 0, 10800 }, { 2 MSO_I, 1 MSO_I },
1875     { 2 MSO_I, 3 MSO_I }, { 0 MSO_I, 3 MSO_I }
1876 };
1877 const sal_uInt16 mso_sptLeftRightArrowCalloutSegm[] =
1878 {
1879     0x4000, 0x0011, 0x6001, 0x8000
1880 };
1881 const SvxMSDffCalculationData mso_sptLeftRightArrowCalloutCalc[] =
1882 {
1883     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
1884     { 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
1885     { 0x2000, { DFF_Prop_adjust3Value, 0, 0 } },
1886     { 0x2000, { DFF_Prop_adjust4Value, 0, 0 } },
1887     { 0x8000, { 21600, 0, 0x0400 } },
1888     { 0x8000, { 21600, 0, 0x0401 } },
1889     { 0x8000, { 21600, 0, 0x0402 } },
1890     { 0x8000, { 21600, 0, 0x0403 } }
1891 };
1892 const sal_Int32 mso_sptLeftRightArrowCalloutDefault[] =
1893 {
1894     4, 5400, 5500, 2700, 8100
1895 };
1896 const SvxMSDffTextRectangles mso_sptLeftRightArrowCalloutTextRect[] =
1897 {
1898     { { 0 MSO_I, 0 }, { 4 MSO_I, 21600 } }
1899 };
1900 const SvxMSDffHandle mso_sptLeftRightArrowCalloutHandle[] =
1901 {
1902     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL,
1903         0x100, 0, 10800, 10800, 0x102, 10800, MIN_INT32, 0x7fffffff },
1904     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL,
1905         0x102, 0x103, 10800, 10800, 0, 0x100, 0x101, 10800 },
1906     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
1907         0, 0x101, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 0x103 }
1908 };
1909 const mso_CustomShape msoLeftRightArrowCallout =
1910 {
1911     const_cast<SvxMSDffVertPair*>(mso_sptLeftRightArrowCalloutVert), SAL_N_ELEMENTS( mso_sptLeftRightArrowCalloutVert ),
1912     const_cast<sal_uInt16*>(mso_sptLeftRightArrowCalloutSegm), sizeof( mso_sptLeftRightArrowCalloutSegm ) >> 1,
1913     const_cast<SvxMSDffCalculationData*>(mso_sptLeftRightArrowCalloutCalc), SAL_N_ELEMENTS( mso_sptLeftRightArrowCalloutCalc ),
1914     const_cast<sal_Int32*>(mso_sptLeftRightArrowCalloutDefault),
1915     const_cast<SvxMSDffTextRectangles*>(mso_sptLeftRightArrowCalloutTextRect), SAL_N_ELEMENTS( mso_sptLeftRightArrowCalloutTextRect ),
1916     21600, 21600,
1917     MIN_INT32, MIN_INT32,
1918     nullptr, 0,
1919     const_cast<SvxMSDffHandle*>(mso_sptLeftRightArrowCalloutHandle), SAL_N_ELEMENTS( mso_sptLeftRightArrowCalloutHandle )
1920 };
1921
1922 const SvxMSDffVertPair mso_sptUpDownArrowCalloutVert[] =
1923 {
1924     { 0, 0 MSO_I }, { 0, 4 MSO_I }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 6 MSO_I },
1925     { 1 MSO_I, 6 MSO_I }, { 10800, 21600 }, { 5 MSO_I, 6 MSO_I }, { 7 MSO_I, 6 MSO_I },
1926     { 7 MSO_I, 4 MSO_I }, { 21600, 4 MSO_I }, { 21600, 0 MSO_I }, { 7 MSO_I, 0 MSO_I },
1927     { 7 MSO_I, 2 MSO_I }, { 5 MSO_I, 2 MSO_I }, { 10800, 0 }, { 1 MSO_I, 2 MSO_I },
1928     { 3 MSO_I, 2 MSO_I }, { 3 MSO_I, 0 MSO_I }
1929 };
1930 const sal_uInt16 mso_sptUpDownArrowCalloutSegm[] =
1931 {
1932     0x4000, 0x0011, 0x6001, 0x8000
1933 };
1934 const SvxMSDffCalculationData mso_sptUpDownArrowCalloutCalc[] =
1935 {
1936     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
1937     { 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
1938     { 0x2000, { DFF_Prop_adjust3Value, 0, 0 } },
1939     { 0x2000, { DFF_Prop_adjust4Value, 0, 0 } },
1940     { 0x8000, { 21600, 0, 0x0400 } },
1941     { 0x8000, { 21600, 0, 0x0401 } },
1942     { 0x8000, { 21600, 0, 0x0402 } },
1943     { 0x8000, { 21600, 0, 0x0403 } }
1944 };
1945 const sal_Int32 mso_sptUpDownArrowCalloutDefault[] =
1946 {
1947     4, 5400, 5500, 2700, 8100
1948 };
1949 const SvxMSDffTextRectangles mso_sptUpDownArrowCalloutTextRect[] =
1950 {
1951     { { 0, 0 MSO_I }, { 21600, 4 MSO_I } }
1952 };
1953 const SvxMSDffHandle mso_sptUpDownArrowCalloutHandle[] =
1954 {
1955     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL,
1956         0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0x102, 10800 },
1957     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
1958         0x103, 0x102, 10800, 10800, 0x101, 10800, 0, 0x100 },
1959     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
1960         0x101, 0, 10800, 10800, 0, 0x103, MIN_INT32, 0x7fffffff }
1961 };
1962 const mso_CustomShape msoUpDownArrowCallout =
1963 {
1964     const_cast<SvxMSDffVertPair*>(mso_sptUpDownArrowCalloutVert), SAL_N_ELEMENTS( mso_sptUpDownArrowCalloutVert ),
1965     const_cast<sal_uInt16*>(mso_sptUpDownArrowCalloutSegm), sizeof( mso_sptUpDownArrowCalloutSegm ) >> 1,
1966     const_cast<SvxMSDffCalculationData*>(mso_sptUpDownArrowCalloutCalc), SAL_N_ELEMENTS( mso_sptUpDownArrowCalloutCalc ),
1967     const_cast<sal_Int32*>(mso_sptUpDownArrowCalloutDefault),
1968     const_cast<SvxMSDffTextRectangles*>(mso_sptUpDownArrowCalloutTextRect), SAL_N_ELEMENTS( mso_sptUpDownArrowCalloutTextRect ),
1969     21600, 21600,
1970     MIN_INT32, MIN_INT32,
1971     nullptr, 0,
1972     const_cast<SvxMSDffHandle*>(mso_sptUpDownArrowCalloutHandle), SAL_N_ELEMENTS( mso_sptUpDownArrowCalloutHandle )
1973 };
1974
1975 const SvxMSDffVertPair mso_sptQuadArrowCalloutVert[] =
1976 {
1977     { 0 MSO_I, 0 MSO_I }, { 3 MSO_I, 0 MSO_I }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
1978     { 10800, 0 }, { 5 MSO_I, 2 MSO_I }, { 7 MSO_I, 2 MSO_I }, { 7 MSO_I, 0 MSO_I },
1979     { 4 MSO_I, 0 MSO_I }, { 4 MSO_I, 3 MSO_I }, { 6 MSO_I, 3 MSO_I }, { 6 MSO_I, 1 MSO_I },
1980     { 21600, 10800 }, { 6 MSO_I, 5 MSO_I }, { 6 MSO_I, 7 MSO_I }, { 4 MSO_I, 7 MSO_I },
1981     { 4 MSO_I, 4 MSO_I }, { 7 MSO_I, 4 MSO_I }, { 7 MSO_I, 6 MSO_I }, { 5 MSO_I, 6 MSO_I },
1982     { 10800, 21600 }, { 1 MSO_I, 6 MSO_I }, { 3 MSO_I, 6 MSO_I }, { 3 MSO_I, 4 MSO_I },
1983     { 0 MSO_I, 4 MSO_I }, { 0 MSO_I, 7 MSO_I }, { 2 MSO_I, 7 MSO_I }, { 2 MSO_I, 5 MSO_I },
1984     { 0, 10800 }, { 2 MSO_I, 1 MSO_I }, { 2 MSO_I, 3 MSO_I }, { 0 MSO_I, 3 MSO_I }
1985 };
1986 const sal_uInt16 mso_sptQuadArrowCalloutSegm[] =
1987 {
1988     0x4000, 0x001f, 0x6001, 0x8000
1989 };
1990 const SvxMSDffCalculationData mso_sptQuadArrowCalloutCalc[] =
1991 {
1992     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
1993     { 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
1994     { 0x2000, { DFF_Prop_adjust3Value, 0, 0 } },
1995     { 0x2000, { DFF_Prop_adjust4Value, 0, 0 } },
1996     { 0x8000, { 21600, 0, 0x0400 } },
1997     { 0x8000, { 21600, 0, 0x0401 } },
1998     { 0x8000, { 21600, 0, 0x0402 } },
1999     { 0x8000, { 21600, 0, 0x0403 } }
2000 };
2001 const sal_Int32 mso_sptQuadArrowCalloutDefault[] =
2002 {
2003     4, 5400, 8100, 2700, 9400
2004 };
2005 const SvxMSDffTextRectangles mso_sptQuadArrowCalloutTextRect[] =
2006 {
2007     { { 0 MSO_I, 0 MSO_I }, { 4 MSO_I, 4 MSO_I } }
2008 };
2009 const SvxMSDffHandle mso_sptQuadArrowCalloutHandle[] =
2010 {
2011     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
2012         0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0x102, 0x101 },
2013     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL,
2014         0x101, 0, 10800, 10800, 0x100, 10800, MIN_INT32, 0x7fffffff },
2015     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
2016         0x103, 0x102, 10800, 10800, 0x101, 10800, 0, 0x100 }
2017 };
2018 const mso_CustomShape msoQuadArrowCallout =
2019 {
2020     const_cast<SvxMSDffVertPair*>(mso_sptQuadArrowCalloutVert), SAL_N_ELEMENTS( mso_sptQuadArrowCalloutVert ),
2021     const_cast<sal_uInt16*>(mso_sptQuadArrowCalloutSegm), sizeof( mso_sptQuadArrowCalloutSegm ) >> 1,
2022     const_cast<SvxMSDffCalculationData*>(mso_sptQuadArrowCalloutCalc), SAL_N_ELEMENTS( mso_sptQuadArrowCalloutCalc ),
2023     const_cast<sal_Int32*>(mso_sptQuadArrowCalloutDefault),
2024     const_cast<SvxMSDffTextRectangles*>(mso_sptQuadArrowCalloutTextRect), SAL_N_ELEMENTS( mso_sptQuadArrowCalloutTextRect ),
2025     21600, 21600,
2026     MIN_INT32, MIN_INT32,
2027     nullptr, 0,
2028     const_cast<SvxMSDffHandle*>(mso_sptQuadArrowCalloutHandle), SAL_N_ELEMENTS( mso_sptQuadArrowCalloutHandle )
2029 };
2030
2031 const SvxMSDffVertPair mso_sptCircularArrowVert[] =
2032 {
2033     { 0x03 MSO_I, 0x03 MSO_I },
2034     { 0x14 MSO_I, 0x14 MSO_I },
2035     { 0x13 MSO_I, 0x12 MSO_I },
2036     { 0x11 MSO_I, 0x10 MSO_I },
2037     { 0, 0 }, { 21600, 21600 },
2038     { 0x09 MSO_I, 0x08 MSO_I },
2039     { 0x0B MSO_I, 0x0A MSO_I },
2040     { 0x18 MSO_I, 0x17 MSO_I },
2041     { 0x2F MSO_I, 0x2E MSO_I },
2042     { 0x1D MSO_I, 0x1C MSO_I }
2043 };
2044 const sal_uInt16 mso_sptCircularArrowSegm[] =
2045 {
2046     0xa404, 0xa504, 0x0003, 0x6001, 0x8000
2047 };
2048 const SvxMSDffCalculationData mso_sptCircularArrowCalc[] =
2049 {
2050     { 0x2000, { 0x0147, 0x0000, 0x0000 } },
2051     { 0x2000, { 0x0148, 0x0000, 0x0000 } },
2052     { 0x2000, { 0x0149, 0x0000, 0x0000 } },
2053     { 0x4000, { 0x2A30, 0x0149, 0x0000 } },
2054     { 0x4009, { 0x2A30, 0x0147, 0x0000 } },
2055     { 0x400A, { 0x2A30, 0x0147, 0x0000 } },
2056     { 0x4009, { 0x2A30, 0x0148, 0x0000 } },
2057     { 0x400A, { 0x2A30, 0x0148, 0x0000 } },
2058     { 0x2000, { 0x0404, 0x2A30, 0x0000 } },
2059     { 0x2000, { 0x0405, 0x2A30, 0x0000 } },
2060     { 0x2000, { 0x0406, 0x2A30, 0x0000 } },
2061     { 0x2000, { 0x0407, 0x2A30, 0x0000 } },
2062     { 0x6009, { 0x0403, 0x0147, 0x0000 } },
2063     { 0x600A, { 0x0403, 0x0147, 0x0000 } },
2064     { 0x6009, { 0x0403, 0x0148, 0x0000 } },
2065     { 0x600A, { 0x0403, 0x0148, 0x0000 } },
2066     { 0x2000, { 0x040C, 0x2A30, 0x0000 } },
2067     { 0x2000, { 0x040D, 0x2A30, 0x0000 } },
2068     { 0x2000, { 0x040E, 0x2A30, 0x0000 } },
2069     { 0x2000, { 0x040F, 0x2A30, 0x0000 } },
2070     { 0x8000, { 0x5460, 0x0000, 0x0403 } },
2071     { 0x4009, { 0x34BC, 0x0148, 0x0000 } },
2072     { 0x400A, { 0x34BC, 0x0148, 0x0000 } },
2073     { 0x2000, { 0x0415, 0x2A30, 0x0000 } },
2074     { 0x2000, { 0x0416, 0x2A30, 0x0000 } },
2075     { 0x2000, { 0x0149, 0x0000, 0x0A8C } },
2076     { 0x6009, { 0x0419, 0x0148, 0x0000 } },
2077     { 0x600A, { 0x0419, 0x0148, 0x0000 } },
2078     { 0x2000, { 0x041A, 0x2A30, 0x0000 } },
2079     { 0x2000, { 0x041B, 0x2A30, 0x0000 } },
2080     { 0xA000, { 0x041D, 0x0000, 0x0418 } },
2081     { 0xA000, { 0x041D, 0x0000, 0x0418 } },
2082     { 0x6001, { 0x041E, 0x041F, 0x0001 } },
2083     { 0xA000, { 0x041C, 0x0000, 0x0417 } },
2084     { 0xA000, { 0x041C, 0x0000, 0x0417 } },
2085     { 0x6001, { 0x0421, 0x0422, 0x0001 } },
2086     { 0x6000, { 0x0420, 0x0423, 0x0000 } },
2087     { 0x200D, { 0x0424, 0x0000, 0x0000 } },
2088     { 0x200E, { 0x0148, 0x002D, 0x0000 } },
2089     { 0x6009, { 0x0425, 0x0426, 0x0000 } },
2090     { 0x200E, { 0x0148, 0x002D, 0x0000 } },
2091     { 0x600A, { 0x0425, 0x0428, 0x0000 } },
2092     { 0x000E, { 0x0000, 0x002D, 0x0000 } },
2093     { 0x6009, { 0x0427, 0x042A, 0x0000 } },
2094     { 0x000E, { 0x0000, 0x002D, 0x0000 } },
2095     { 0x6009, { 0x0429, 0x042C, 0x0000 } },
2096     { 0x6000, { 0x041C, 0x042B, 0x0000 } },
2097     { 0x6000, { 0x041D, 0x042D, 0x0000 } }
2098 };
2099 const sal_Int32 mso_sptCircularArrowDefault[] =
2100 {
2101     3, 180, 0, 5500
2102 };
2103 const SvxMSDffTextRectangles mso_sptCircularArrowTextRect[] =    // todo
2104 {
2105     { { 0, 0 }, { 21600, 21600 } }
2106 };
2107 const SvxMSDffHandle mso_sptCircularArrowHandle[] =
2108 {
2109     {   SvxMSDffHandleFlags::POLAR | SvxMSDffHandleFlags::RADIUS_RANGE,
2110         10800, 0x100, 10800, 10800, 10800, 10800, -0x7f4c0000, 0x00b40000 },
2111     {   SvxMSDffHandleFlags::POLAR | SvxMSDffHandleFlags::RADIUS_RANGE,
2112         0x102, 0x101, 10800, 10800, 0, 10800, -0x7f4c0000, 0x00b40000 }
2113 };
2114 const mso_CustomShape msoCircularArrow =
2115 {
2116     const_cast<SvxMSDffVertPair*>(mso_sptCircularArrowVert), SAL_N_ELEMENTS( mso_sptCircularArrowVert ),
2117     const_cast<sal_uInt16*>(mso_sptCircularArrowSegm), sizeof( mso_sptCircularArrowSegm ) >> 1,
2118     const_cast<SvxMSDffCalculationData*>(mso_sptCircularArrowCalc), SAL_N_ELEMENTS( mso_sptCircularArrowCalc ),
2119     const_cast<sal_Int32*>(mso_sptCircularArrowDefault),
2120     const_cast<SvxMSDffTextRectangles*>(mso_sptCircularArrowTextRect), SAL_N_ELEMENTS( mso_sptCircularArrowTextRect ),
2121     21600, 21600,
2122     MIN_INT32, MIN_INT32,
2123     nullptr, 0,
2124     const_cast<SvxMSDffHandle*>(mso_sptCircularArrowHandle), SAL_N_ELEMENTS( mso_sptCircularArrowHandle )        // handles
2125 };
2126
2127 const SvxMSDffVertPair mso_sptCubeVert[] =
2128 {
2129     { 0, 12 MSO_I }, { 0, 1 MSO_I }, { 2 MSO_I, 0 }, { 11 MSO_I, 0 }, { 11 MSO_I, 3 MSO_I }, { 4 MSO_I, 12 MSO_I },
2130     { 0, 1 MSO_I }, { 2 MSO_I, 0 }, { 11 MSO_I, 0 }, { 4 MSO_I, 1 MSO_I },
2131     { 4 MSO_I, 12 MSO_I  }, { 4 MSO_I, 1 MSO_I },   { 11 MSO_I, 0 }, { 11 MSO_I, 3 MSO_I }
2132 };
2133 const sal_uInt16 mso_sptCubeSegm[] =
2134 {
2135     0x4000, 0x0005, 0x6001, 0x8000,
2136     0x4000, 0x0003, 0x6001, 0x8000,
2137     0x4000, 0x0003, 0x6001, 0x8000
2138 };
2139 const SvxMSDffCalculationData mso_sptCubeCalc[] =
2140 {
2141     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
2142     { 0x6000, { DFF_Prop_geoTop, 0x400, 0 } },
2143     { 0x6000, { DFF_Prop_geoLeft, 0x400, 0 } },
2144     { 0xa000, { DFF_Prop_geoBottom, 0, 0x400 } },
2145     { 0xa000, { DFF_Prop_geoRight, 0, 0x400 } },
2146     { 0xa000, { DFF_Prop_geoRight, 0, 0x402 } },    // 5
2147     { 0x2001, { 0x405, 1, 2 } },                    // 6
2148     { 0x6000, { 0x402, 0x406, 0 } },                // 7
2149     { 0xa000, { DFF_Prop_geoBottom, 0, 0x401 } },   // 8
2150     { 0x2001, { 0x408, 1, 2 } },                    // 9
2151     { 0x6000, { 0x401, 0x409, 0 } },                // 10
2152     { 0x2000, { DFF_Prop_geoRight, 0, 0 } },        // 11
2153     { 0x2000, { DFF_Prop_geoBottom, 0, 0 } }        // 12
2154 };
2155 const SvxMSDffTextRectangles mso_sptCubeTextRect[] =
2156 {
2157     { { 0, 1 MSO_I }, { 4 MSO_I, 12 MSO_I } }
2158 };
2159 const SvxMSDffHandle mso_sptCubeHandle[] =
2160 {
2161     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::SWITCHED,
2162         0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 21600 }
2163 };
2164 const SvxMSDffVertPair mso_sptCubeGluePoints[] =
2165 {
2166     { 7 MSO_I, 0 }, { 6 MSO_I, 1 MSO_I }, { 0, 10 MSO_I }, { 6 MSO_I, 21600 }, { 4 MSO_I, 10 MSO_I }, { 21600, 9 MSO_I }
2167 };
2168 const mso_CustomShape msoCube =
2169 {
2170     const_cast<SvxMSDffVertPair*>(mso_sptCubeVert), SAL_N_ELEMENTS( mso_sptCubeVert ),
2171     const_cast<sal_uInt16*>(mso_sptCubeSegm), sizeof( mso_sptCubeSegm ) >> 1,
2172     const_cast<SvxMSDffCalculationData*>(mso_sptCubeCalc), SAL_N_ELEMENTS( mso_sptCubeCalc ),
2173     const_cast<sal_Int32*>(mso_sptDefault5400),
2174     const_cast<SvxMSDffTextRectangles*>(mso_sptCubeTextRect), SAL_N_ELEMENTS( mso_sptCubeTextRect ),
2175     21600, 21600,
2176     10800, 10800,
2177     const_cast<SvxMSDffVertPair*>(mso_sptCubeGluePoints), SAL_N_ELEMENTS( mso_sptCubeGluePoints ),
2178     const_cast<SvxMSDffHandle*>(mso_sptCubeHandle), SAL_N_ELEMENTS( mso_sptCubeHandle )
2179 };
2180
2181 const SvxMSDffVertPair mso_sptBevelVert[] =
2182 {
2183     { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
2184     { 0, 0 }, { 21600, 0 }, { 1 MSO_I, 0 MSO_I }, { 0 MSO_I, 0 MSO_I },
2185     { 21600, 0 }, { 21600, 21600 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 0 MSO_I },
2186     { 21600, 21600 }, { 0, 21600 }, { 0 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
2187     { 0, 21600 }, { 0, 0 }, { 0 MSO_I, 0 MSO_I }, { 0 MSO_I, 2 MSO_I }
2188 };
2189 const sal_uInt16 mso_sptBevelSegm[] =
2190 {
2191     0x4000, 0x0003, 0x6001, 0x8000,
2192     0x4000, 0x0003, 0x6001, 0x8000,
2193     0x4000, 0x0003, 0x6001, 0x8000,
2194     0x4000, 0x0003, 0x6001, 0x8000,
2195     0x4000, 0x0003, 0x6001, 0x8000
2196 };
2197 const SvxMSDffCalculationData mso_sptBevelCalc[] =
2198 {
2199     { 0x2001, { DFF_Prop_adjustValue, 21599, 21600 } },
2200     { 0xa000, { DFF_Prop_geoRight, 0, 0x400 } },
2201     { 0xa000, { DFF_Prop_geoBottom, 0, 0x400 } }
2202 };
2203
2204 const SvxMSDffTextRectangles mso_sptBevelTextRect[] =
2205 {
2206     { { 0 MSO_I, 0 MSO_I }, { 1 MSO_I, 2 MSO_I } }
2207 };
2208 const SvxMSDffHandle mso_sptBevelHandle[] =
2209 {
2210     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::SWITCHED,
2211         0x100, 0, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
2212 };
2213 const mso_CustomShape msoBevel =
2214 {
2215     const_cast<SvxMSDffVertPair*>(mso_sptBevelVert), SAL_N_ELEMENTS( mso_sptBevelVert ),
2216     const_cast<sal_uInt16*>(mso_sptBevelSegm), sizeof( mso_sptBevelSegm ) >> 1,
2217     const_cast<SvxMSDffCalculationData*>(mso_sptBevelCalc), SAL_N_ELEMENTS( mso_sptBevelCalc ),
2218     const_cast<sal_Int32*>(mso_sptDefault2700),
2219     const_cast<SvxMSDffTextRectangles*>(mso_sptBevelTextRect), SAL_N_ELEMENTS( mso_sptBevelTextRect ),
2220     21600, 21600,
2221     10800, 10800,
2222     nullptr, 0,
2223     const_cast<SvxMSDffHandle*>(mso_sptBevelHandle), SAL_N_ELEMENTS( mso_sptBevelHandle )
2224 };
2225
2226 const SvxMSDffVertPair mso_sptFoldedCornerVert[] =   // adjustment1 : x 10800 - 21600
2227 {
2228     { 0, 0 }, { 21600, 0 }, { 21600, 0 MSO_I }, { 0 MSO_I, 21600 },
2229     { 0, 21600 }, { 0 MSO_I, 21600 }, { 3 MSO_I, 0 MSO_I }, { 8 MSO_I, 9 MSO_I },
2230     { 10 MSO_I, 11 MSO_I }, { 21600, 0 MSO_I }
2231 };
2232 const sal_uInt16 mso_sptFoldedCornerSegm[] =
2233 {
2234     0x4000, 0x0004, 0x6001, 0x8000,
2235     0x4000, 0x0001, 0x2001, 0x6001, 0x8000
2236 };
2237 const SvxMSDffCalculationData mso_sptFoldedCornerCalc[] =
2238 {
2239     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
2240     { 0x8000, { 21600, 0, 0x400 } },
2241     { 0x2001, { 0x0401, 8000, 10800 } },
2242     { 0x8000, { 21600, 0, 0x0402 } },
2243     { 0x2001, { 0x0401, 1, 2 } },
2244     { 0x2001, { 0x0401, 1, 4 } },
2245     { 0x2001, { 0x0401, 1, 7 } },
2246     { 0x2001, { 0x0401, 1, 16 } },
2247     { 0x6000, { 0x0403, 0x405, 0 } },
2248     { 0x6000, { 0x0400, 0x406, 0 } },
2249     { 0x8000, { 21600, 0, 0x404 } },
2250     { 0x6000, { 0x400, 0x407, 0 } }
2251 };
2252 const sal_Int32 mso_sptFoldedCornerDefault[] =
2253 {
2254     1, 18900
2255 };
2256 const SvxMSDffTextRectangles mso_sptFoldedCornerTextRect[] =
2257 {
2258     { { 0, 0 }, { 21600, 11 MSO_I } }
2259 };
2260 const SvxMSDffHandle mso_sptFoldedCornerHandle[] =
2261 {
2262     {   SvxMSDffHandleFlags::RANGE,
2263         0x100, 1, 10800, 10800, 10800, 21600, MIN_INT32, 0x7fffffff }
2264 };
2265 const mso_CustomShape msoFoldedCorner =
2266 {
2267     const_cast<SvxMSDffVertPair*>(mso_sptFoldedCornerVert), SAL_N_ELEMENTS( mso_sptFoldedCornerVert ),
2268     const_cast<sal_uInt16*>(mso_sptFoldedCornerSegm), sizeof( mso_sptFoldedCornerSegm ) >> 1,
2269     const_cast<SvxMSDffCalculationData*>(mso_sptFoldedCornerCalc), SAL_N_ELEMENTS( mso_sptFoldedCornerCalc ),
2270     const_cast<sal_Int32*>(mso_sptFoldedCornerDefault),
2271     const_cast<SvxMSDffTextRectangles*>(mso_sptFoldedCornerTextRect), SAL_N_ELEMENTS( mso_sptFoldedCornerTextRect ),
2272     21600, 21600,
2273     MIN_INT32, MIN_INT32,
2274     const_cast<SvxMSDffVertPair*>(mso_sptStandardGluePoints), SAL_N_ELEMENTS( mso_sptStandardGluePoints ),
2275     const_cast<SvxMSDffHandle*>(mso_sptFoldedCornerHandle), SAL_N_ELEMENTS( mso_sptFoldedCornerHandle )
2276 };
2277
2278 const SvxMSDffVertPair mso_sptActionButtonBlankVert[] =
2279 {
2280     { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
2281     { 0, 0 }, { 21600, 0 }, { 1 MSO_I, 0 MSO_I }, { 0 MSO_I, 0 MSO_I },
2282     { 21600, 0 }, { 21600, 21600 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 0 MSO_I },
2283     { 21600, 21600 }, { 0, 21600 }, { 0 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
2284     { 0, 21600 }, { 0, 0 }, { 0 MSO_I, 0 MSO_I }, { 0 MSO_I, 2 MSO_I }
2285 };
2286 const sal_uInt16 mso_sptActionButtonBlankSegm[] =
2287 {
2288     0x4000, 0x0003, 0x6001, 0x8000,
2289     0x4000, 0x0003, 0x6001, 0x8000,
2290     0x4000, 0x0003, 0x6001, 0x8000,
2291     0x4000, 0x0003, 0x6001, 0x8000,
2292     0x4000, 0x0003, 0x6001, 0x8000
2293 };
2294 const SvxMSDffCalculationData mso_sptActionButtonBlankCalc[] =
2295 {
2296     { 0x2001, { DFF_Prop_adjustValue, 21599, 21600 } },
2297     { 0xa000, { DFF_Prop_geoRight, 0, 0x400 } },
2298     { 0xa000, { DFF_Prop_geoBottom, 0, 0x400 } }
2299 };
2300 const SvxMSDffTextRectangles mso_sptActionButtonBlankTextRect[] =
2301 {
2302     { { 0 MSO_I, 0 MSO_I }, { 1 MSO_I, 2 MSO_I } }
2303 };
2304 const SvxMSDffHandle mso_sptButtonHandle[] =
2305 {
2306     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::SWITCHED,
2307         0x100, 0, 10800, 10800, 0, 5400, MIN_INT32, 0x7fffffff }
2308 };
2309 const mso_CustomShape msoActionButtonBlank =
2310 {
2311     const_cast<SvxMSDffVertPair*>(mso_sptActionButtonBlankVert), SAL_N_ELEMENTS( mso_sptActionButtonBlankVert ),
2312     const_cast<sal_uInt16*>(mso_sptActionButtonBlankSegm), sizeof( mso_sptActionButtonBlankSegm ) >> 1,
2313     const_cast<SvxMSDffCalculationData*>(mso_sptActionButtonBlankCalc), SAL_N_ELEMENTS( mso_sptActionButtonBlankCalc ),
2314     const_cast<sal_Int32*>(mso_sptDefault1400),
2315     const_cast<SvxMSDffTextRectangles*>(mso_sptActionButtonBlankTextRect), SAL_N_ELEMENTS( mso_sptActionButtonBlankTextRect ),
2316     21600, 21600,
2317     10800, 10800,
2318     nullptr, 0,
2319     const_cast<SvxMSDffHandle*>(mso_sptButtonHandle), SAL_N_ELEMENTS( mso_sptButtonHandle )
2320 };
2321
2322 const SvxMSDffTextRectangles mso_sptActionButtonTextRect[] =
2323 {
2324     { { 1 MSO_I, 2 MSO_I }, { 3 MSO_I, 4 MSO_I } }
2325 };
2326 const SvxMSDffVertPair mso_sptActionButtonHomeVert[] =
2327 {
2328     { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
2329     { 0, 0 }, { 21600, 0 }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
2330     { 21600, 0 }, { 21600, 21600 }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 2 MSO_I },
2331     { 21600, 21600 }, { 0, 21600 }, { 1 MSO_I, 4 MSO_I }, { 3 MSO_I, 4 MSO_I },
2332     { 0, 21600 }, { 0, 0 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 4 MSO_I },
2333
2334     { 7 MSO_I, 0xa MSO_I }, { 0xc MSO_I, 0xe MSO_I }, { 0xc MSO_I, 0x10 MSO_I }, { 0x12 MSO_I, 0x10 MSO_I },
2335     { 0x12 MSO_I, 0x14 MSO_I }, { 0x16 MSO_I, 8 MSO_I }, { 0x18 MSO_I, 8 MSO_I }, { 0x18 MSO_I, 0x1a MSO_I },
2336     { 0x1c MSO_I, 0x1a MSO_I }, { 0x1c MSO_I, 8 MSO_I }, { 0x1e MSO_I, 8 MSO_I },
2337
2338     { 0xc MSO_I, 0xe MSO_I }, { 0xc MSO_I, 0x10 MSO_I }, { 0x12 MSO_I, 0x10 MSO_I },{ 0x12 MSO_I, 0x14 MSO_I },
2339
2340     { 0x20 MSO_I, 0x24 MSO_I }, { 0x22 MSO_I, 0x24 MSO_I }, { 0x22 MSO_I, 0x1a MSO_I }, { 0x18 MSO_I, 0x1a MSO_I },
2341     { 0x18 MSO_I, 8 MSO_I }, { 0x1c MSO_I, 8 MSO_I }, { 0x1c MSO_I, 0x1a MSO_I }, { 0x20 MSO_I, 0x1a MSO_I }
2342
2343 };
2344 const sal_uInt16 mso_sptActionButtonHomeSegm[] =
2345 {
2346     0x4000, 0x0003, 0x6001, 0x8000,
2347     0x4000, 0x0003, 0x6001, 0x8000,
2348     0x4000, 0x0003, 0x6001, 0x8000,
2349     0x4000, 0x0003, 0x6001, 0x8000,
2350     0x4000, 0x0003, 0x6001, 0x8000,
2351     0x4000, 0x000a, 0x6001, 0x8000,
2352     0x4000, 0x0003, 0x6001, 0x8000,
2353     0x4000, 0x0007, 0x6001, 0x8000
2354 };
2355 const SvxMSDffCalculationData mso_sptActionButtonHomeCalc[] =    // adj value 0 - 5400
2356 {
2357     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
2358     { 0x6000, { DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 } },
2359     { 0x6000, { DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 } },
2360     { 0xa000, { DFF_Prop_geoRight, 0, DFF_Prop_adjustValue } },
2361     { 0xa000, { DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue } },
2362     { 0x8000, { 10800, 0, DFF_Prop_adjustValue } },
2363     { 0x2001, { 0x0405, 1, 10800 } },                           // scaling   6
2364     { 0x2001, { DFF_Prop_geoRight, 1, 2 } },    // lr center 7
2365     { 0x2001, { DFF_Prop_geoBottom, 1, 2 } },   // ul center 8
2366
2367     { 0x4001, { -8000, 0x0406, 1 } },   // 9
2368     { 0x6000, { 0x0409, 0x0408, 0 } },  // a
2369     { 0x4001, { 2960, 0x0406, 1 } },    // b
2370     { 0x6000, { 0x040b, 0x0407, 0 } },  // c
2371     { 0x4001, { -5000, 0x0406, 1 } },   // d
2372     { 0x6000, { 0x040d, 0x0408, 0 } },  // e
2373     { 0x4001, { -7000, 0x0406, 1 } },   // f
2374     { 0x6000, { 0x040f, 0x0408, 0 } },  // 10
2375     { 0x4001, { 5000, 0x0406, 1 } },    // 11
2376     { 0x6000, { 0x0411, 0x0407, 0 } },  // 12
2377     { 0x4001, { -2960, 0x0406, 1 } },   // 13
2378     { 0x6000, { 0x0413, 0x0408, 0 } },  // 14
2379     { 0x4001, { 8000, 0x0406, 1 } },    // 15
2380     { 0x6000, { 0x0415,0x0407, 0 } },   // 16
2381     { 0x4001, { 6100, 0x0406, 1 } },    // 17
2382     { 0x6000, { 0x0417,0x0407, 0 } },   // 18
2383     { 0x4001, { 8260, 0x0406, 1 } },    // 19
2384     { 0x6000, { 0x0419, 0x0408, 0 } },  // 1a
2385     { 0x4001, { -6100, 0x0406, 1 } },   // 1b
2386     { 0x6000, { 0x041b, 0x0407, 0 } },  // 1c
2387     { 0x4001, { -8000, 0x0406, 1 } },   // 1d
2388     { 0x6000, { 0x041d, 0x0407, 0 } },  // 1e
2389     { 0x4001, { -1060, 0x0406, 1 } },   // 1f
2390     { 0x6000, { 0x041f, 0x0407, 0 } },  // 20
2391     { 0x4001, { 1060, 0x0406, 1 } },    // 21
2392     { 0x6000, { 0x0421, 0x0407, 0 } },  // 22
2393     { 0x4001, { 4020, 0x0406, 1 } },    // 23
2394     { 0x6000, { 0x0423, 0x0408, 0 } }   // 24
2395
2396 };
2397 const mso_CustomShape msoActionButtonHome =
2398 {
2399     const_cast<SvxMSDffVertPair*>(mso_sptActionButtonHomeVert), SAL_N_ELEMENTS( mso_sptActionButtonHomeVert ),
2400     const_cast<sal_uInt16*>(mso_sptActionButtonHomeSegm), sizeof( mso_sptActionButtonHomeSegm ) >> 1,
2401     const_cast<SvxMSDffCalculationData*>(mso_sptActionButtonHomeCalc), SAL_N_ELEMENTS( mso_sptActionButtonHomeCalc ),
2402     const_cast<sal_Int32*>(mso_sptDefault1400),
2403     const_cast<SvxMSDffTextRectangles*>(mso_sptActionButtonTextRect), SAL_N_ELEMENTS( mso_sptActionButtonTextRect ),
2404     21600, 21600,
2405     10800, 10800,
2406     nullptr, 0,
2407     const_cast<SvxMSDffHandle*>(mso_sptButtonHandle), SAL_N_ELEMENTS( mso_sptButtonHandle )
2408 };
2409
2410 const SvxMSDffVertPair mso_sptActionButtonHelpVert[] =
2411 {
2412     { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
2413     { 0, 0 }, { 21600, 0 }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
2414     { 21600, 0 }, { 21600, 21600 }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 2 MSO_I },
2415     { 21600, 21600 }, { 0, 21600 }, { 1 MSO_I, 4 MSO_I }, { 3 MSO_I, 4 MSO_I },
2416     { 0, 21600 }, { 0, 0 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I,4 MSO_I },
2417     { 7 MSO_I, 0xc MSO_I }, { 0xa MSO_I, 0x3e MSO_I }, { 7 MSO_I, 0x10 MSO_I }, { 0xe MSO_I, 0x3e MSO_I }, { 7 MSO_I, 0xc MSO_I },
2418     { 0x12 MSO_I, 0x14 MSO_I }, { 0x12 MSO_I, 0x16 MSO_I },                             // pp
2419     { 0x12 MSO_I, 0x18 MSO_I }, { 0x1a MSO_I, 8 MSO_I }, { 0x1c MSO_I, 8 MSO_I },       // ccp
2420     { 0x1e MSO_I, 8 MSO_I }, { 0x20 MSO_I, 0x22 MSO_I }, { 0x20 MSO_I, 0x24 MSO_I },    // ccp
2421     { 0x20 MSO_I, 0x26 MSO_I }, { 0x28 MSO_I, 0x2a MSO_I }, { 7 MSO_I, 0x2a MSO_I },    // ccp
2422     { 0x2c MSO_I, 0x2a MSO_I }, { 0x2e MSO_I, 0x26 MSO_I }, { 0x2e MSO_I, 0x24 MSO_I }, // ccp
2423     { 0x30 MSO_I, 0x24 MSO_I }, { 0x30 MSO_I, 0x32 MSO_I }, { 0x34 MSO_I, 0x36 MSO_I }, // ccp
2424     { 7 MSO_I, 0x36 MSO_I },                                                            // p
2425     { 0x12 MSO_I, 0x36 MSO_I }, { 0x1c MSO_I, 0x32 MSO_I }, { 0x1c MSO_I, 0x24 MSO_I }, // ccp
2426     { 0x1c MSO_I, 0x38 MSO_I }, { 0x3a MSO_I, 0x3c MSO_I }, { 0x12 MSO_I, 0x3c MSO_I }, // ccp
2427     { 7 MSO_I, 0x3c MSO_I }, { 0x34 MSO_I, 8 MSO_I }, { 0x34 MSO_I, 0x16 MSO_I },       // ccp
2428     { 0x34 MSO_I, 0x14 MSO_I }
2429 };
2430 const sal_uInt16 mso_sptActionButtonHelpSegm[] =
2431 {
2432     0x4000, 0x0003, 0x6001, 0x8000,
2433     0x4000, 0x0003, 0x6001, 0x8000,
2434     0x4000, 0x0003, 0x6001, 0x8000,
2435     0x4000, 0x0003, 0x6001, 0x8000,
2436     0x4000, 0x0003, 0x6001, 0x8000,
2437     0x4000, 0xa704, 0x6000, 0x8000,
2438     0x4000, 0x0001, 0x2004, 0x0001, 0x2004, 0x0001, 0x6001, 0x8000
2439 };
2440 const SvxMSDffCalculationData mso_sptActionButtonHelpCalc[] =    // 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     { 0x2001, { DFF_Prop_geoRight, 1, 2 } },    // lr center 7
2450     { 0x2001, { DFF_Prop_geoBottom, 1, 2 } },   // ul center 8
2451
2452     { 0x4001, { -1690, 0x0406, 1 } },   // 9
2453     { 0x6000, { 0x0409, 0x0407, 0 } },  // a
2454     { 0x4001, { 4600, 0x0406, 1 } },    // b
2455     { 0x6000, { 0x040b, 0x0408, 0 } },  // c
2456     { 0x4001, { 1690, 0x0406, 1 } },    // d
2457     { 0x6000, { 0x040d, 0x0407, 0 } },  // e
2458     { 0x4001, { 7980, 0x0406, 1 } },    // f
2459     { 0x6000, { 0x040f, 0x0408, 0 } },  // 10
2460     { 0x4001, { 1270, 0x0406, 1 } },    // 11
2461     { 0x6000, { 0x0411, 0x0407, 0 } },  // 12
2462     { 0x4001, { 4000, 0x0406, 1 } },    // 13
2463     { 0x6000, { 0x0413, 0x0408, 0 } },  // 14
2464     { 0x4001, { 1750, 0x0406, 1 } },    // 15
2465     { 0x6000, { 0x0415, 0x0408, 0 } },  // 16
2466     { 0x4001, { 800, 0x0406, 1 } },     // 17
2467     { 0x6000, { 0x0417, 0x0408, 0 } },  // 18
2468     { 0x4001, { 1650, 0x0406, 1 } },    // 19
2469     { 0x6000, { 0x0419, 0x0407, 0 } },  // 1a
2470     { 0x4001, { 2340, 0x0406, 1 } },    // 1b
2471     { 0x6000, { 0x041b, 0x0407, 0 } },  // 1c
2472     { 0x4001, { 3640, 0x0406, 1 } },    // 1d
2473     { 0x6000, { 0x041d, 0x0407, 0 } },  // 1e
2474     { 0x4001, { 4670, 0x0406, 1 } },    // 1f
2475     { 0x6000, { 0x041f, 0x0407, 0 } },  // 20
2476     { 0x4001, { -1570, 0x0406, 1 } },   // 21
2477     { 0x6000, { 0x0421, 0x0408, 0 } },  // 22
2478     { 0x4001, { -3390, 0x0406, 1 } },   // 23
2479     { 0x6000, { 0x0423, 0x0408, 0 } },  // 24
2480     { 0x4001, { -6050, 0x0406, 1 } },   // 25
2481     { 0x6000, { 0x0425, 0x0408, 0 } },  // 26
2482     { 0x4001, { 2540, 0x0406, 1 } },    // 27
2483     { 0x6000, { 0x0427, 0x0407, 0 } },  // 28
2484     { 0x4001, { -8050, 0x0406, 1 } },   // 29
2485     { 0x6000, { 0x0429, 0x0408, 0 } },  // 2a
2486     { 0x4001, { -2540, 0x0406, 1 } },   // 2b
2487     { 0x6000, { 0x042b, 0x0407, 0 } },  // 2c
2488     { 0x4001, { -4460, 0x0406, 1 } },   // 2d
2489     { 0x6000, { 0x042d, 0x0407, 0 } },  // 2e
2490     { 0x4001, { -2330, 0x0406, 1 } },   // 2f
2491     { 0x6000, { 0x042f, 0x0407, 0 } },  // 30
2492     { 0x4001, { -4700, 0x0406, 1 } },   // 31
2493     { 0x6000, { 0x0431, 0x0408, 0 } },  // 32
2494     { 0x4001, { -1270, 0x0406, 1 } },   // 33
2495     { 0x6000, { 0x0433, 0x0407, 0 } },  // 34
2496     { 0x4001, { -5720, 0x0406, 1 } },   // 35
2497     { 0x6000, { 0x0435, 0x0408, 0 } },  // 36
2498     { 0x4001, { -2540, 0x0406, 1 } },   // 37
2499     { 0x6000, { 0x0437, 0x0408, 0 } },  // 38
2500     { 0x4001, { 1800, 0x0406, 1 } },    // 39
2501     { 0x6000, { 0x0439, 0x0407, 0 } },  // 3a
2502     { 0x4001, { -1700, 0x0406, 1 } },   // 3b
2503     { 0x6000, { 0x043b, 0x0408, 0 } },  // 3c
2504     { 0x4001, { 6290, 0x0406, 1 } },    // 3d
2505     { 0x6000, { 0x043d, 0x0408, 0 } }   // 3e
2506 };
2507 const mso_CustomShape msoActionButtonHelp =
2508 {
2509     const_cast<SvxMSDffVertPair*>(mso_sptActionButtonHelpVert), SAL_N_ELEMENTS( mso_sptActionButtonHelpVert ),
2510     const_cast<sal_uInt16*>(mso_sptActionButtonHelpSegm), sizeof( mso_sptActionButtonHelpSegm ) >> 1,
2511     const_cast<SvxMSDffCalculationData*>(mso_sptActionButtonHelpCalc), SAL_N_ELEMENTS( mso_sptActionButtonHelpCalc ),
2512     const_cast<sal_Int32*>(mso_sptDefault1400),
2513     const_cast<SvxMSDffTextRectangles*>(mso_sptActionButtonTextRect), SAL_N_ELEMENTS( mso_sptActionButtonTextRect ),
2514     21600, 21600,
2515     10800, 10800,
2516     nullptr, 0,
2517     const_cast<SvxMSDffHandle*>(mso_sptButtonHandle), SAL_N_ELEMENTS( mso_sptButtonHandle )
2518 };
2519
2520 const SvxMSDffVertPair mso_sptActionButtonInformationVert[] =
2521 {
2522     { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
2523     { 0, 0 }, { 21600, 0 }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
2524     { 21600, 0 }, { 21600, 21600 }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 2 MSO_I },
2525     { 21600, 21600 }, { 0, 21600 }, { 1 MSO_I, 4 MSO_I }, { 3 MSO_I, 4 MSO_I },
2526     { 0, 21600 }, { 0, 0 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 4 MSO_I },
2527     { 0x7 MSO_I, 0xc MSO_I }, { 0xa MSO_I, 0x8 MSO_I }, { 0x7 MSO_I, 0x10 MSO_I }, { 0xe MSO_I, 8 MSO_I }, { 0x7 MSO_I, 0xc MSO_I },
2528     { 0x7 MSO_I, 0x14 MSO_I }, { 0x12 MSO_I, 0x2a MSO_I }, { 0x7 MSO_I, 0x18 MSO_I }, { 0x16 MSO_I, 0x2a MSO_I }, { 0x7 MSO_I, 0x14 MSO_I },
2529     { 0x1a MSO_I, 0x1c MSO_I }, { 0x1e MSO_I, 0x1c MSO_I }, { 0x1e MSO_I, 0x20 MSO_I }, { 0x22 MSO_I, 0x20 MSO_I },
2530     { 0x22 MSO_I, 0x24 MSO_I }, { 0x1a MSO_I, 0x24 MSO_I }, { 0x1a MSO_I, 0x20 MSO_I }, { 0x26 MSO_I, 0x20 MSO_I },
2531     { 0x26 MSO_I, 0x28 MSO_I }, { 0x1a MSO_I, 0x28 MSO_I }
2532 };
2533 const sal_uInt16 mso_sptActionButtonInformationSegm[] =
2534 {
2535     0x4000, 0x0003, 0x6001, 0x8000,
2536     0x4000, 0x0003, 0x6001, 0x8000,
2537     0x4000, 0x0003, 0x6001, 0x8000,
2538     0x4000, 0x0003, 0x6001, 0x8000,
2539     0x4000, 0x0003, 0x6001, 0x8000,
2540     0x4000, 0xa704, 0x6000, 0x8000,
2541     0x4000, 0xa704, 0x6000, 0x8000,
2542     0x4000, 0x0009, 0x6001, 0x8000
2543 };
2544 const SvxMSDffCalculationData mso_sptActionButtonInformationCalc[] = // adj value 0 - 5400
2545 {
2546     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
2547     { 0x6000, { DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 } },
2548     { 0x6000, { DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 } },
2549     { 0xa000, { DFF_Prop_geoRight, 0, DFF_Prop_adjustValue } },
2550     { 0xa000, { DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue } },
2551     { 0x8000, { 10800, 0, DFF_Prop_adjustValue } },
2552     { 0x2001, { 0x0405, 1, 10800 } },           // scaling   6
2553     { 0x2001, { DFF_Prop_geoRight, 1, 2 } },    // lr center 7
2554     { 0x2001, { DFF_Prop_geoBottom, 1, 2 } },   // ul center 8
2555
2556     { 0x4001, { -8050, 0x0406, 1 } },   // 9
2557     { 0x6000, { 0x0409, 0x0407, 0 } },  // a
2558     { 0x4001, { -8050, 0x0406, 1 } },   // b
2559     { 0x6000, { 0x040b, 0x0408, 0 } },  // c
2560     { 0x4001, { 8050, 0x0406, 1 } },    // d
2561     { 0x6000, { 0x040d, 0x0407, 0 } },  // e
2562     { 0x4001, { 8050, 0x0406, 1 } },    // f
2563     { 0x6000, { 0x040f, 0x0408, 0 } },  // 10
2564
2565     { 0x4001, { -2060, 0x0406, 1 } },   // 11
2566     { 0x6000, { 0x0411, 0x0407, 0 } },  // 12
2567     { 0x4001, { -7620, 0x0406, 1 } },   // 13
2568     { 0x6000, { 0x0413, 0x0408, 0 } },  // 14
2569     { 0x4001, { 2060, 0x0406, 1 } },    // 15
2570     { 0x6000, { 0x0415, 0x0407, 0 } },  // 16
2571     { 0x4001, { -3500, 0x0406, 1 } },   // 17
2572     { 0x6000, { 0x0417, 0x0408, 0 } },  // 18
2573
2574     { 0x4001, { -2960, 0x0406, 1 } },   // 19
2575     { 0x6000, { 0x0419, 0x0407, 0 } },  // 1a
2576     { 0x4001, { -2960, 0x0406, 1 } },   // 1b
2577     { 0x6000, { 0x041b, 0x0408, 0 } },  // 1c
2578     { 0x4001, { 1480, 0x0406, 1 } },    // 1d
2579     { 0x6000, { 0x041d, 0x0407, 0 } },  // 1e
2580     { 0x4001, { 5080, 0x0406, 1 } },    // 1f
2581     { 0x6000, { 0x041f, 0x0408, 0 } },  // 20
2582     { 0x4001, { 2960, 0x0406, 1 } },    // 21
2583     { 0x6000, { 0x0421, 0x0407, 0 } },  // 22
2584     { 0x4001, { 6140, 0x0406, 1 } },    // 23
2585     { 0x6000, { 0x0423, 0x0408, 0 } },  // 24
2586     { 0x4001, { -1480, 0x0406, 1 } },   // 25
2587     { 0x6000, { 0x0425, 0x0407, 0 } },  // 26
2588     { 0x4001, { -1920, 0x0406, 1 } },   // 27
2589     { 0x6000, { 0x0427, 0x0408, 0 } },  // 28
2590
2591     { 0x4001, { -5560, 0x0406, 1 } },   // 29
2592     { 0x6000, { 0x0429, 0x0408, 0 } },  // 2a
2593
2594 };
2595 const mso_CustomShape msoActionButtonInformation =
2596 {
2597     const_cast<SvxMSDffVertPair*>(mso_sptActionButtonInformationVert), SAL_N_ELEMENTS( mso_sptActionButtonInformationVert ),
2598     const_cast<sal_uInt16*>(mso_sptActionButtonInformationSegm), sizeof( mso_sptActionButtonInformationSegm ) >> 1,
2599     const_cast<SvxMSDffCalculationData*>(mso_sptActionButtonInformationCalc), SAL_N_ELEMENTS( mso_sptActionButtonInformationCalc ),
2600     const_cast<sal_Int32*>(mso_sptDefault1400),
2601     const_cast<SvxMSDffTextRectangles*>(mso_sptActionButtonTextRect), SAL_N_ELEMENTS( mso_sptActionButtonTextRect ),
2602     21600, 21600,
2603     10800, 10800,
2604     nullptr, 0,
2605     const_cast<SvxMSDffHandle*>(mso_sptButtonHandle), SAL_N_ELEMENTS( mso_sptButtonHandle )
2606 };
2607
2608 const SvxMSDffVertPair mso_sptActionButtonBackPreviousVert[] =
2609 {
2610     { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
2611     { 0, 0 }, { 21600, 0 }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
2612     { 21600, 0 }, { 21600, 21600 }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 2 MSO_I },
2613     { 21600, 21600 }, { 0, 21600 }, { 1 MSO_I, 4 MSO_I }, { 3 MSO_I,4 MSO_I },
2614     { 0, 21600 }, { 0, 0 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 4 MSO_I },
2615
2616     { 0xa MSO_I, 8 MSO_I }, { 0xe MSO_I, 0xc MSO_I }, { 0xe MSO_I, 0x10 MSO_I }
2617 };
2618 const sal_uInt16 mso_sptActionButtonForwardBackSegm[] =
2619 {
2620     0x4000, 0x0003, 0x6001, 0x8000,
2621     0x4000, 0x0003, 0x6001, 0x8000,
2622     0x4000, 0x0003, 0x6001, 0x8000,
2623     0x4000, 0x0003, 0x6001, 0x8000,
2624     0x4000, 0x0003, 0x6001, 0x8000,
2625     0x4000, 0x0002, 0x6001, 0x8000
2626 };
2627 const SvxMSDffCalculationData mso_sptActionButtonForwardBackCalc[] = // adj value 0 - 5400
2628 {
2629     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
2630     { 0x6000, { DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 } },
2631     { 0x6000, { DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 } },
2632     { 0xa000, { DFF_Prop_geoRight, 0, DFF_Prop_adjustValue } },
2633     { 0xa000, { DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue } },
2634     { 0x8000, { 10800, 0, DFF_Prop_adjustValue } },
2635     { 0x2001, { 0x0405, 1, 10800 } },           // scaling   6
2636     { 0x2001, { DFF_Prop_geoRight, 1, 2 } },    // lr center 7
2637     { 0x2001, { DFF_Prop_geoBottom, 1, 2 } },   // ul center 8
2638
2639     { 0x4001, { -8050, 0x0406, 1 } },   // 9
2640     { 0x6000, { 0x0409, 0x0407, 0 } },  // a
2641     { 0x4001, { -8050, 0x0406, 1 } },   // b
2642     { 0x6000, { 0x040b, 0x0408, 0 } },  // c
2643     { 0x4001, { 8050, 0x0406, 1 } },    // d
2644     { 0x6000, { 0x040d, 0x0407, 0 } },  // e
2645     { 0x4001, { 8050, 0x0406, 1 } },    // f
2646     { 0x6000, { 0x040f, 0x0408, 0 } }   // 10
2647 };
2648 const mso_CustomShape msoActionButtonBackPrevious =
2649 {
2650     const_cast<SvxMSDffVertPair*>(mso_sptActionButtonBackPreviousVert), SAL_N_ELEMENTS( mso_sptActionButtonBackPreviousVert ),
2651     const_cast<sal_uInt16*>(mso_sptActionButtonForwardBackSegm), sizeof( mso_sptActionButtonForwardBackSegm ) >> 1,
2652     const_cast<SvxMSDffCalculationData*>(mso_sptActionButtonForwardBackCalc), SAL_N_ELEMENTS( mso_sptActionButtonForwardBackCalc ),
2653     const_cast<sal_Int32*>(mso_sptDefault1400),
2654     const_cast<SvxMSDffTextRectangles*>(mso_sptActionButtonTextRect), SAL_N_ELEMENTS( mso_sptActionButtonTextRect ),
2655     21600, 21600,
2656     10800, 10800,
2657     nullptr, 0,
2658     const_cast<SvxMSDffHandle*>(mso_sptButtonHandle), SAL_N_ELEMENTS( mso_sptButtonHandle )
2659 };
2660
2661 const SvxMSDffVertPair mso_sptActionButtonForwardNextVert[] =
2662 {
2663     { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
2664     { 0, 0 }, { 21600, 0 }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
2665     { 21600, 0 }, { 21600, 21600 }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 2 MSO_I },
2666     { 21600, 21600 }, { 0, 21600 }, { 1 MSO_I, 4 MSO_I }, { 3 MSO_I, 4 MSO_I },
2667     { 0, 21600 }, { 0, 0 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 4 MSO_I },
2668
2669     { 0xa MSO_I, 0xc MSO_I }, { 0xe MSO_I, 8 MSO_I }, { 0xa MSO_I, 0x10 MSO_I }
2670 };
2671 const mso_CustomShape msoActionButtonForwardNext =
2672 {
2673     const_cast<SvxMSDffVertPair*>(mso_sptActionButtonForwardNextVert), SAL_N_ELEMENTS( mso_sptActionButtonForwardNextVert ),
2674     const_cast<sal_uInt16*>(mso_sptActionButtonForwardBackSegm), sizeof( mso_sptActionButtonForwardBackSegm ) >> 1,
2675     const_cast<SvxMSDffCalculationData*>(mso_sptActionButtonForwardBackCalc), SAL_N_ELEMENTS( mso_sptActionButtonForwardBackCalc ),
2676     const_cast<sal_Int32*>(mso_sptDefault1400),
2677     const_cast<SvxMSDffTextRectangles*>(mso_sptActionButtonTextRect), SAL_N_ELEMENTS( mso_sptActionButtonTextRect ),
2678     21600, 21600,
2679     10800, 10800,
2680     nullptr, 0,
2681     const_cast<SvxMSDffHandle*>(mso_sptButtonHandle), SAL_N_ELEMENTS( mso_sptButtonHandle )
2682 };
2683
2684 const SvxMSDffVertPair mso_sptActionButtonBeginningVert[] =
2685 {
2686     { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
2687     { 0, 0 }, { 21600, 0 }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
2688     { 21600, 0 }, { 21600, 21600 }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 2 MSO_I },
2689     { 21600, 21600 }, { 0, 21600 }, { 1 MSO_I, 4 MSO_I }, { 3 MSO_I, 4 MSO_I },
2690     { 0, 21600 }, { 0, 0 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 4 MSO_I },
2691
2692     { 0xa MSO_I, 8 MSO_I }, { 0xe MSO_I, 0xc MSO_I }, { 0xe MSO_I, 0x10 MSO_I }, { 0x12 MSO_I, 0xc MSO_I },
2693     { 0x14 MSO_I, 0xc MSO_I }, { 0x14 MSO_I, 0x10 MSO_I }, { 0x12 MSO_I, 0x10 MSO_I }
2694 };
2695 const sal_uInt16 mso_sptActionButtonBeginningEndSegm[] =
2696 {
2697     0x4000, 0x0003, 0x6001, 0x8000,
2698     0x4000, 0x0003, 0x6001, 0x8000,
2699     0x4000, 0x0003, 0x6001, 0x8000,
2700     0x4000, 0x0003, 0x6001, 0x8000,
2701     0x4000, 0x0003, 0x6001, 0x8000,
2702
2703     0x4000, 0x0002, 0x6001, 0x8000,
2704     0x4000, 0x0003, 0x6001, 0x8000
2705 };
2706 const SvxMSDffCalculationData mso_sptActionButtonBeginningEndCalc[] =    // adj value 0 - 5400
2707 {
2708     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
2709     { 0x6000, { DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 } },
2710     { 0x6000, { DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 } },
2711     { 0xa000, { DFF_Prop_geoRight, 0, DFF_Prop_adjustValue } },
2712     { 0xa000, { DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue } },
2713     { 0x8000, { 10800, 0, DFF_Prop_adjustValue } },
2714     { 0x2001, { 0x0405, 1, 10800 } },           // scaling   6
2715     { 0x2001, { DFF_Prop_geoRight, 1, 2 } },    // lr center 7
2716     { 0x2001, { DFF_Prop_geoBottom, 1, 2 } },   // ul center 8
2717
2718     { 0x4001, { -4020, 0x0406, 1 } },   // 9
2719     { 0x6000, { 0x0409, 0x0407, 0 } },  // a
2720     { 0x4001, { -8050, 0x0406, 1 } },   // b
2721     { 0x6000, { 0x040b, 0x0408, 0 } },  // c
2722     { 0x4001, { 8050, 0x0406, 1 } },    // d
2723     { 0x6000, { 0x040d, 0x0407, 0 } },  // e
2724     { 0x4001, { 8050, 0x0406, 1 } },    // f
2725     { 0x6000, { 0x040f, 0x0408, 0 } },  // 10
2726
2727     { 0x4001, { -8050, 0x0406, 1 } },   // 11
2728     { 0x6000, { 0x0411, 0x0407, 0 } },  // 12
2729     { 0x4001, { -6140, 0x0406, 1 } },   // 13
2730     { 0x6000, { 0x0413, 0x0407, 0 } },  // 14
2731
2732
2733     { 0x4001, { 4020, 0x0406, 1 } },    // 15
2734     { 0x6000, { 0x0415, 0x0407, 0 } },  // 16
2735     { 0x4001, { 6140, 0x0406, 1 } },    // 17
2736     { 0x6000, { 0x0417, 0x0407, 0 } }   // 18
2737 };
2738 const mso_CustomShape msoActionButtonBeginning =
2739 {
2740     const_cast<SvxMSDffVertPair*>(mso_sptActionButtonBeginningVert), SAL_N_ELEMENTS( mso_sptActionButtonBeginningVert ),
2741     const_cast<sal_uInt16*>(mso_sptActionButtonBeginningEndSegm), sizeof( mso_sptActionButtonBeginningEndSegm ) >> 1,
2742     const_cast<SvxMSDffCalculationData*>(mso_sptActionButtonBeginningEndCalc), SAL_N_ELEMENTS( mso_sptActionButtonBeginningEndCalc ),
2743     const_cast<sal_Int32*>(mso_sptDefault1400),
2744     const_cast<SvxMSDffTextRectangles*>(mso_sptActionButtonTextRect), SAL_N_ELEMENTS( mso_sptActionButtonTextRect ),
2745     21600, 21600,
2746     10800, 10800,
2747     nullptr, 0,
2748     const_cast<SvxMSDffHandle*>(mso_sptButtonHandle), SAL_N_ELEMENTS( mso_sptButtonHandle )
2749 };
2750
2751 const SvxMSDffVertPair mso_sptActionButtonEndVert[] =
2752 {
2753     { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
2754     { 0, 0 }, { 21600, 0 }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
2755     { 21600, 0 }, { 21600, 21600 }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 2 MSO_I },
2756     { 21600, 21600 }, { 0, 21600 }, { 1 MSO_I, 4 MSO_I }, { 3 MSO_I, 4 MSO_I },
2757     { 0, 21600 }, { 0, 0 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 4 MSO_I },
2758
2759     { 0x16 MSO_I, 8 MSO_I }, { 0x12 MSO_I, 0x10 MSO_I }, { 0x12 MSO_I, 0xc MSO_I },
2760
2761     { 0x18 MSO_I, 0xc MSO_I }, { 0x18 MSO_I, 0x10 MSO_I }, { 0xe MSO_I, 0x10 MSO_I }, { 0xe MSO_I, 0xc MSO_I }
2762 };
2763 const mso_CustomShape msoActionButtonEnd =
2764 {
2765     const_cast<SvxMSDffVertPair*>(mso_sptActionButtonEndVert), SAL_N_ELEMENTS( mso_sptActionButtonEndVert ),
2766     const_cast<sal_uInt16*>(mso_sptActionButtonBeginningEndSegm), sizeof( mso_sptActionButtonBeginningEndSegm ) >> 1,
2767     const_cast<SvxMSDffCalculationData*>(mso_sptActionButtonBeginningEndCalc), SAL_N_ELEMENTS( mso_sptActionButtonBeginningEndCalc ),
2768     const_cast<sal_Int32*>(mso_sptDefault1400),
2769     const_cast<SvxMSDffTextRectangles*>(mso_sptActionButtonTextRect), SAL_N_ELEMENTS( mso_sptActionButtonTextRect ),
2770     21600, 21600,
2771     10800, 10800,
2772     nullptr, 0,
2773     const_cast<SvxMSDffHandle*>(mso_sptButtonHandle), SAL_N_ELEMENTS( mso_sptButtonHandle )
2774 };
2775
2776 const SvxMSDffVertPair mso_sptActionButtonReturnVert[] =
2777 {
2778     { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
2779     { 0, 0 }, { 21600, 0 }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
2780     { 21600, 0 }, { 21600,  21600 }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 2 MSO_I },
2781     { 21600, 21600 }, { 0, 21600 }, { 1 MSO_I, 4 MSO_I }, { 3 MSO_I, 4 MSO_I },
2782     { 0, 21600 }, { 0, 0 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 4 MSO_I },
2783
2784     { 0xa MSO_I, 0xc MSO_I }, { 0xe MSO_I, 0xc MSO_I }, { 0xe MSO_I, 0x10 MSO_I },                          // ppp
2785     { 0xe MSO_I, 0x12 MSO_I }, { 0x14 MSO_I, 0x16 MSO_I }, { 0x18 MSO_I, 0x16 MSO_I },                      // ccp
2786     { 7 MSO_I, 0x16 MSO_I },                                                                                // p
2787     { 0x1a MSO_I, 0x16 MSO_I }, { 0x1c MSO_I, 0x12 MSO_I }, { 0x1c MSO_I, 0x10 MSO_I },                     // ccp
2788     { 0x1c MSO_I, 0xc MSO_I }, { 7 MSO_I, 0xc MSO_I }, { 0x1e MSO_I, 0x20 MSO_I }, { 0x22 MSO_I, 0xc MSO_I },// pppp
2789     { 0x24 MSO_I, 0xc MSO_I }, { 0x24 MSO_I, 0x10 MSO_I },                                                  // pp
2790     { 0x24 MSO_I, 0x26 MSO_I }, { 0x28 MSO_I, 0x2a MSO_I }, { 7 MSO_I, 0x2a MSO_I },                        // ccp
2791     { 0x18 MSO_I, 0x2a MSO_I },                                                                             // p
2792     { 0x2c MSO_I, 0x2a MSO_I }, { 0xa MSO_I, 0x26 MSO_I }, { 0xa MSO_I, 0x10 MSO_I }                        // ccp
2793 };
2794 const sal_uInt16 mso_sptActionButtonReturnSegm[] =
2795 {
2796     0x4000, 0x0003, 0x6001, 0x8000,
2797     0x4000, 0x0003, 0x6001, 0x8000,
2798     0x4000, 0x0003, 0x6001, 0x8000,
2799     0x4000, 0x0003, 0x6001, 0x8000,
2800     0x4000, 0x0003, 0x6001, 0x8000,
2801     0x4000, 0x0002, 0x2001, 0x0001, 0x2001, 0x0006,0x2001, 0x0001, 0x2001, 0x6001, 0x8000
2802 };
2803 const SvxMSDffCalculationData mso_sptActionButtonReturnCalc[] =  // adj value 0 - 5400
2804 {
2805     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
2806     { 0x6000, { DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 } },
2807     { 0x6000, { DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 } },
2808     { 0xa000, { DFF_Prop_geoRight, 0, DFF_Prop_adjustValue } },
2809     { 0xa000, { DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue } },
2810     { 0x8000, { 10800, 0, DFF_Prop_adjustValue } },
2811     { 0x2001, { 0x0405, 1, 10800 } },           // scaling   6
2812     { 0x2001, { DFF_Prop_geoRight, 1, 2 } },    // lr center 7
2813     { 0x2001, { DFF_Prop_geoBottom, 1, 2 } },   // ul center 8
2814
2815     { 0x4001, { -8050, 0x0406, 1 } },   // 9
2816     { 0x6000, { 0x0409, 0x0407, 0 } },  // a
2817     { 0x4001, { -3800, 0x0406, 1 } },   // b
2818     { 0x6000, { 0x040b, 0x0408, 0 } },  // c
2819     { 0x4001, { -4020, 0x0406, 1 } },   // d
2820     { 0x6000, { 0x040d, 0x0407, 0 } },  // e
2821     { 0x4001, { 2330, 0x0406, 1 } },    // f
2822     { 0x6000, { 0x040f, 0x0408, 0 } },  // 10
2823     { 0x4001, { 3390, 0x0406, 1 } },    // 11
2824     { 0x6000, { 0x0411, 0x0408, 0 } },  // 12
2825     { 0x4001, { -3100, 0x0406, 1 } },   // 13
2826     { 0x6000, { 0x0413, 0x0407, 0 } },  // 14
2827     { 0x4001, { 4230, 0x0406, 1 } },    // 15
2828     { 0x6000, { 0x0415, 0x0408, 0 } },  // 16
2829     { 0x4001, { -1910, 0x0406, 1 } },   // 17
2830     { 0x6000, { 0x0417, 0x0407, 0 } },  // 18
2831     { 0x4001, { 1190, 0x0406, 1 } },    // 19
2832     { 0x6000, { 0x0419, 0x0407, 0 } },  // 1a
2833     { 0x4001, { 2110, 0x0406, 1 } },    // 1b
2834     { 0x6000, { 0x041b, 0x0407, 0 } },  // 1c
2835     { 0x4001, { 4030, 0x0406, 1 } },    // 1d
2836     { 0x6000, { 0x041d, 0x0407, 0 } },  // 1e
2837     { 0x4001, { -7830, 0x0406, 1 } },   // 1f
2838     { 0x6000, { 0x041f, 0x0408, 0 } },  // 20
2839     { 0x4001, { 8250, 0x0406, 1 } },    // 21
2840     { 0x6000, { 0x0421, 0x0407, 0 } },  // 22
2841     { 0x4001, { 6140, 0x0406, 1 } },    // 23
2842     { 0x6000, { 0x0423, 0x0407, 0 } },  // 24
2843     { 0x4001, { 5510, 0x0406, 1 } },    // 25
2844     { 0x6000, { 0x0425, 0x0408, 0 } },  // 26
2845     { 0x4001, { 3180, 0x0406, 1 } },    // 27
2846     { 0x6000, { 0x0427, 0x0407, 0 } },  // 28
2847     { 0x4001, { 8450, 0x0406, 1 } },    // 29
2848     { 0x6000, { 0x0429, 0x0408, 0 } },  // 2a
2849     { 0x4001, { -5090, 0x0406, 1 } },   // 2b
2850     { 0x6000, { 0x042b, 0x0407, 0 } }   // 2c
2851 };
2852 const mso_CustomShape msoActionButtonReturn =
2853 {
2854     const_cast<SvxMSDffVertPair*>(mso_sptActionButtonReturnVert), SAL_N_ELEMENTS( mso_sptActionButtonReturnVert ),
2855     const_cast<sal_uInt16*>(mso_sptActionButtonReturnSegm), sizeof( mso_sptActionButtonReturnSegm ) >> 1,
2856     const_cast<SvxMSDffCalculationData*>(mso_sptActionButtonReturnCalc), SAL_N_ELEMENTS( mso_sptActionButtonReturnCalc ),
2857     const_cast<sal_Int32*>(mso_sptDefault1400),
2858     const_cast<SvxMSDffTextRectangles*>(mso_sptActionButtonTextRect), SAL_N_ELEMENTS( mso_sptActionButtonTextRect ),
2859     21600, 21600,
2860     10800, 10800,
2861     nullptr, 0,
2862     const_cast<SvxMSDffHandle*>(mso_sptButtonHandle), SAL_N_ELEMENTS( mso_sptButtonHandle )
2863 };
2864
2865 const SvxMSDffVertPair mso_sptActionButtonDocumentVert[] =
2866 {
2867     { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
2868     { 0, 0 }, { 21600, 0 }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
2869     { 21600, 0 }, { 21600, 21600 }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 2 MSO_I },
2870     { 21600, 21600 }, { 0, 21600 }, { 1 MSO_I, 4 MSO_I }, { 3 MSO_I, 4 MSO_I },
2871     { 0, 21600 }, { 0, 0 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 4 MSO_I },
2872
2873     { 0xa MSO_I, 0xc MSO_I }, { 0xe MSO_I, 0xc MSO_I }, { 0x10 MSO_I, 0x12 MSO_I }, { 0x10 MSO_I, 0x14 MSO_I },
2874     { 0xa MSO_I, 0x14 MSO_I }, { 0xe MSO_I, 0xc MSO_I }, { 0x10 MSO_I, 0x12 MSO_I }, { 0xe MSO_I, 0x12 MSO_I }
2875 };
2876 const sal_uInt16 mso_sptActionButtonDocumentSegm[] =
2877 {
2878     0x4000, 0x0003, 0x6001, 0x8000,
2879     0x4000, 0x0003, 0x6001, 0x8000,
2880     0x4000, 0x0003, 0x6001, 0x8000,
2881     0x4000, 0x0003, 0x6001, 0x8000,
2882     0x4000, 0x0003, 0x6001, 0x8000,
2883
2884     0x4000, 0x0004, 0x6001, 0x8000,
2885     0x4000, 0x0002, 0x6001, 0x8000
2886 };
2887 const SvxMSDffCalculationData mso_sptActionButtonDocumentCalc[] =    // adj value 0 - 5400
2888 {
2889     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
2890     { 0x6000, { DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 } },
2891     { 0x6000, { DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 } },
2892     { 0xa000, { DFF_Prop_geoRight, 0, DFF_Prop_adjustValue } },
2893     { 0xa000, { DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue } },
2894     { 0x8000, { 10800, 0, DFF_Prop_adjustValue } },
2895     { 0x2001, { 0x0405, 1, 10800 } },           // scaling   6
2896     { 0x2001, { DFF_Prop_geoRight, 1, 2 } },    // lr center 7
2897     { 0x2001, { DFF_Prop_geoBottom, 1, 2 } },   // ul center 8
2898
2899     { 0x4001, { -6350, 0x0406, 1 } },   // 9
2900     { 0x6000, { 0x0409, 0x0407, 0 } },  // a
2901     { 0x4001, { -7830, 0x0406, 1 } },   // b
2902     { 0x6000, { 0x040b, 0x0408, 0 } },  // c
2903     { 0x4001, { 1690, 0x0406, 1 } },    // d
2904     { 0x6000, { 0x040d, 0x0407, 0 } },  // e
2905     { 0x4001, { 6350, 0x0406, 1 } },    // f
2906     { 0x6000, { 0x040f, 0x0407, 0 } },  // 10
2907     { 0x4001, { -3810, 0x0406, 1 } },   // 11
2908     { 0x6000, { 0x0411, 0x0408, 0 } },  // 12
2909     { 0x4001, { 7830, 0x0406, 1 } },    // 13
2910     { 0x6000, { 0x0413, 0x0408, 0 } }   // 14
2911 };
2912 const mso_CustomShape msoActionButtonDocument =
2913 {
2914     const_cast<SvxMSDffVertPair*>(mso_sptActionButtonDocumentVert), SAL_N_ELEMENTS( mso_sptActionButtonDocumentVert ),
2915     const_cast<sal_uInt16*>(mso_sptActionButtonDocumentSegm), sizeof( mso_sptActionButtonDocumentSegm ) >> 1,
2916     const_cast<SvxMSDffCalculationData*>(mso_sptActionButtonDocumentCalc), SAL_N_ELEMENTS( mso_sptActionButtonDocumentCalc ),
2917     const_cast<sal_Int32*>(mso_sptDefault1400),
2918     const_cast<SvxMSDffTextRectangles*>(mso_sptActionButtonTextRect), SAL_N_ELEMENTS( mso_sptActionButtonTextRect ),
2919     21600, 21600,
2920     10800, 10800,
2921     nullptr, 0,
2922     const_cast<SvxMSDffHandle*>(mso_sptButtonHandle), SAL_N_ELEMENTS( mso_sptButtonHandle )
2923 };
2924
2925 const SvxMSDffVertPair mso_sptActionButtonSoundVert[] =
2926 {
2927     { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
2928     { 0, 0 }, { 21600, 0 }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
2929     { 21600, 0 }, { 21600, 21600 }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 2 MSO_I },
2930     { 21600, 21600 }, { 0, 21600 }, { 1 MSO_I, 4 MSO_I }, { 3 MSO_I, 4 MSO_I },
2931     { 0, 21600 }, { 0, 0 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 4 MSO_I },
2932
2933     { 0xa MSO_I, 0xc MSO_I }, { 0xe MSO_I, 0xc MSO_I }, { 0x10 MSO_I, 0x12 MSO_I }, { 0x10 MSO_I, 0x14 MSO_I },
2934     { 0xe MSO_I, 0x16 MSO_I }, { 0xa MSO_I, 0x16 MSO_I }, { 0x18 MSO_I, 8 MSO_I }, { 0x1a MSO_I, 8 MSO_I },
2935
2936     { 0x18 MSO_I, 0xc MSO_I }, { 0x1a MSO_I, 0x1c MSO_I },
2937
2938     { 0x18 MSO_I, 0x16 MSO_I }, { 0x1a MSO_I, 0x1e MSO_I }
2939 };
2940 const sal_uInt16 mso_sptActionButtonSoundSegm[] =
2941 {
2942     0x4000, 0x0003, 0x6001, 0x8000,
2943     0x4000, 0x0003, 0x6001, 0x8000,
2944     0x4000, 0x0003, 0x6001, 0x8000,
2945     0x4000, 0x0003, 0x6001, 0x8000,
2946     0x4000, 0x0003, 0x6001, 0x8000,
2947
2948     0x4000, 0x0005, 0x6001, 0x8000,
2949     0x4000, 0x0001, 0x8000,
2950     0x4000, 0x0001, 0x8000,
2951     0x4000, 0x0001, 0x8000
2952 };
2953 const SvxMSDffCalculationData mso_sptActionButtonSoundCalc[] =   // adj value 0 - 5400
2954 {
2955     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
2956     { 0x6000, { DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 } },
2957     { 0x6000, { DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 } },
2958     { 0xa000, { DFF_Prop_geoRight, 0, DFF_Prop_adjustValue } },
2959     { 0xa000, { DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue } },
2960     { 0x8000, { 10800, 0, DFF_Prop_adjustValue } },
2961     { 0x2001, { 0x0405, 1, 10800 } },           // scaling   6
2962     { 0x2001, { DFF_Prop_geoRight, 1, 2 } },    // lr center 7
2963     { 0x2001, { DFF_Prop_geoBottom, 1, 2 } },   // ul center 8
2964
2965     { 0x4001, { -8050, 0x0406, 1 } },   // 9
2966     { 0x6000, { 0x0409, 0x0407, 0 } },  // a
2967     { 0x4001, { -2750, 0x0406, 1 } },   // b
2968     { 0x6000, { 0x040b, 0x0408, 0 } },  // c
2969     { 0x4001, { -2960, 0x0406, 1 } },   // d
2970     { 0x6000, { 0x040d, 0x0407, 0 } },  // e
2971     { 0x4001, { 2120, 0x0406, 1 } },    // f
2972     { 0x6000, { 0x040f, 0x0407, 0 } },  // 10
2973     { 0x4001, { -8050, 0x0406, 1 } },   // 11
2974     { 0x6000, { 0x0411, 0x0408, 0 } },  // 12
2975     { 0x4001, { 8050, 0x0406, 1 } },    // 13
2976     { 0x6000, { 0x0413, 0x0408, 0 } },  // 14
2977     { 0x4001, { 2750, 0x0406, 1 } },    // 15
2978     { 0x6000, { 0x0415, 0x0408, 0 } },  // 16
2979     { 0x4001, { 4020, 0x0406, 1 } },    // 17
2980     { 0x6000, { 0x0417, 0x0407, 0 } },  // 18
2981     { 0x4001, { 8050, 0x0406, 1 } },    // 19
2982     { 0x6000, { 0x0419, 0x0407, 0 } },  // 1a
2983     { 0x4001, { -5930, 0x0406, 1 } },   // 1b
2984     { 0x6000, { 0x041b, 0x0408, 0 } },  // 1c
2985     { 0x4001, { 5930, 0x0406, 1 } },    // 1d
2986     { 0x6000, { 0x041d, 0x0408, 0 } }   // 1e
2987 };
2988 const mso_CustomShape msoActionButtonSound =
2989 {
2990     const_cast<SvxMSDffVertPair*>(mso_sptActionButtonSoundVert), SAL_N_ELEMENTS( mso_sptActionButtonSoundVert ),
2991     const_cast<sal_uInt16*>(mso_sptActionButtonSoundSegm), sizeof( mso_sptActionButtonSoundSegm ) >> 1,
2992     const_cast<SvxMSDffCalculationData*>(mso_sptActionButtonSoundCalc), SAL_N_ELEMENTS( mso_sptActionButtonSoundCalc ),
2993     const_cast<sal_Int32*>(mso_sptDefault1400),
2994     const_cast<SvxMSDffTextRectangles*>(mso_sptActionButtonTextRect), SAL_N_ELEMENTS( mso_sptActionButtonTextRect ),
2995     21600, 21600,
2996     10800, 10800,
2997     nullptr, 0,
2998     const_cast<SvxMSDffHandle*>(mso_sptButtonHandle), SAL_N_ELEMENTS( mso_sptButtonHandle )
2999 };
3000
3001 const SvxMSDffVertPair mso_sptActionButtonMovieVert[] =
3002 {
3003     { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
3004     { 0, 0 }, { 21600, 0 }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
3005     { 21600, 0 }, { 21600, 21600 }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 2 MSO_I },
3006     { 21600, 21600 }, { 0, 21600 }, { 1 MSO_I, 4 MSO_I }, { 3 MSO_I, 4 MSO_I },
3007     { 0, 21600 }, { 0, 0 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 4 MSO_I },
3008
3009     { 0xa MSO_I, 0xc MSO_I }, { 0xe MSO_I, 0xc MSO_I }, { 0x10 MSO_I, 0x12 MSO_I }, { 0x14 MSO_I, 0x12 MSO_I },
3010     { 0x16 MSO_I, 0x18 MSO_I }, { 0x16 MSO_I, 0x1a MSO_I }, { 0x1c MSO_I, 0x1a MSO_I }, { 0x1e MSO_I, 0x18 MSO_I },
3011     { 0x20 MSO_I, 0x18 MSO_I }, { 0x20 MSO_I, 0x22 MSO_I }, { 0x1e MSO_I, 0x22 MSO_I }, { 0x1c MSO_I, 0x24 MSO_I },
3012     { 0x16 MSO_I, 0x24 MSO_I }, { 0x16 MSO_I, 0x26 MSO_I }, { 0x2a MSO_I, 0x26 MSO_I }, { 0x2a MSO_I, 0x28 MSO_I },
3013     { 0x10 MSO_I, 0x28 MSO_I }, { 0xe MSO_I, 0x2c MSO_I }, { 0xa MSO_I, 0x2c MSO_I }
3014 };
3015 const sal_uInt16 mso_sptActionButtonMovieSegm[] =
3016 {
3017     0x4000, 0x0003, 0x6001, 0x8000,
3018     0x4000, 0x0003, 0x6001, 0x8000,
3019     0x4000, 0x0003, 0x6001, 0x8000,
3020     0x4000, 0x0003, 0x6001, 0x8000,
3021     0x4000, 0x0003, 0x6001, 0x8000,
3022     0x4000, 0x0012, 0x6001, 0x8000
3023 };
3024 const SvxMSDffCalculationData mso_sptActionButtonMovieCalc[] =   // adj value 0 - 5400
3025 {
3026     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
3027     { 0x6000, { DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 } },
3028     { 0x6000, { DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 } },
3029     { 0xa000, { DFF_Prop_geoRight, 0, DFF_Prop_adjustValue } },
3030     { 0xa000, { DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue } },
3031     { 0x8000, { 10800, 0, DFF_Prop_adjustValue } },
3032     { 0x2001, { 0x0405, 1, 10800 } },           // scaling   6
3033     { 0x2001, { DFF_Prop_geoRight, 1, 2 } },    // lr center 7
3034     { 0x2001, { DFF_Prop_geoBottom, 1, 2 } },   // ul center 8
3035
3036     { 0x4001, { -8050, 0x0406, 1 } },   // 9
3037     { 0x6000, { 0x0409, 0x0407, 0 } },  // a
3038     { 0x4001, { -4020, 0x0406, 1 } },   // b
3039     { 0x6000, { 0x040b, 0x0408, 0 } },  // c
3040     { 0x4001, { -7000, 0x0406, 1 } },   // d
3041     { 0x6000, { 0x040d, 0x0407, 0 } },  // e
3042     { 0x4001, { -6560, 0x0406, 1 } },   // f
3043     { 0x6000, { 0x040f, 0x0407, 0 } },  // 10
3044     { 0x4001, { -3600, 0x0406, 1 } },   // 11
3045     { 0x6000, { 0x0411, 0x0408, 0 } },  // 12
3046     { 0x4001, { 4020, 0x0406, 1 } },    // 13
3047     { 0x6000, { 0x0413, 0x0407, 0 } },  // 14
3048     { 0x4001, { 4660, 0x0406, 1 } },    // 15
3049     { 0x6000, { 0x0415, 0x0407, 0 } },  // 16
3050     { 0x4001, { -2960, 0x0406, 1 } },   // 17
3051     { 0x6000, { 0x0417, 0x0408, 0 } },  // 18
3052     { 0x4001, { -2330, 0x0406, 1 } },   // 19
3053     { 0x6000, { 0x0419, 0x0408, 0 } },  // 1a
3054     { 0x4001, { 6780, 0x0406, 1 } },    // 1b
3055     { 0x6000, { 0x041b, 0x0407, 0 } },  // 1c
3056     { 0x4001, { 7200, 0x0406, 1 } },    // 1d
3057     { 0x6000, { 0x041d, 0x0407, 0 } },  // 1e
3058     { 0x4001, { 8050, 0x0406, 1 } },    // 1f
3059     { 0x6000, { 0x041f, 0x0407, 0 } },  // 20
3060     { 0x4001, { 2960, 0x0406, 1 } },    // 21
3061     { 0x6000, { 0x0421, 0x0408, 0 } },  // 22
3062     { 0x4001, { 2330, 0x0406, 1 } },    // 23
3063     { 0x6000, { 0x0423, 0x0408, 0 } },  // 24
3064     { 0x4001, { 3800, 0x0406, 1 } },    // 25
3065     { 0x6000, { 0x0425, 0x0408, 0 } },  // 26
3066     { 0x4001, { -1060, 0x0406, 1 } },   // 27
3067     { 0x6000, { 0x0427, 0x0408, 0 } },  // 28
3068     { 0x4001, { -6350, 0x0406, 1 } },   // 29
3069     { 0x6000, { 0x0429, 0x0407, 0 } },  // 2a
3070     { 0x4001, { -640, 0x0406, 1 } },    // 2b
3071     { 0x6000, { 0x042b, 0x0408, 0 } }   // 2c
3072 };
3073 const mso_CustomShape msoActionButtonMovie =
3074 {
3075     const_cast<SvxMSDffVertPair*>(mso_sptActionButtonMovieVert), SAL_N_ELEMENTS( mso_sptActionButtonMovieVert ),
3076     const_cast<sal_uInt16*>(mso_sptActionButtonMovieSegm), sizeof( mso_sptActionButtonMovieSegm ) >> 1,
3077     const_cast<SvxMSDffCalculationData*>(mso_sptActionButtonMovieCalc), SAL_N_ELEMENTS( mso_sptActionButtonMovieCalc ),
3078     const_cast<sal_Int32*>(mso_sptDefault1400),
3079     const_cast<SvxMSDffTextRectangles*>(mso_sptActionButtonTextRect), SAL_N_ELEMENTS( mso_sptActionButtonTextRect ),
3080     21600, 21600,
3081     10800, 10800,
3082     nullptr, 0,
3083     const_cast<SvxMSDffHandle*>(mso_sptButtonHandle), SAL_N_ELEMENTS( mso_sptButtonHandle )
3084 };
3085
3086 const SvxMSDffVertPair mso_sptSmileyFaceVert[] = // adj value 15510 - 17520
3087 {
3088     { 10800, 10800 }, { 10800, 10800 }, { 0, 360 },
3089     { 7305, 7515 }, { 1000, 1865 }, { 0, 360 },
3090     { 14295, 7515 }, { 1000, 1865 }, { 0, 360 },
3091     { 4870, 1 MSO_I }, { 8680, 2 MSO_I }, { 12920, 2 MSO_I }, { 16730, 1 MSO_I }
3092 };
3093 const sal_uInt16 mso_sptSmileyFaceSegm[] =
3094 {
3095     0xa203, 0x6000, 0x8000,
3096     0xa203, 0x6000, 0x8000,
3097     0xa203, 0x6000, 0x8000,
3098     0x4000, 0x2001, 0xaa00, 0x8000
3099 };
3100 const SvxMSDffCalculationData mso_sptSmileyFaceCalc[] =
3101 {
3102     { 0x2000, { DFF_Prop_adjustValue, 0, 14510 } },
3103     { 0x8000, { 18520, 0, 0x400 } },
3104     { 0x4000, { 14510, 0x400, 0 } }
3105 };
3106
3107 const sal_Int32 mso_sptSmileyFaceDefault[] =
3108 {
3109     1, 18520
3110 };
3111 const SvxMSDffHandle mso_sptSmileyHandle[] =
3112 {
3113     {   SvxMSDffHandleFlags::RANGE,
3114         10800, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 14510, 18520 }
3115 };
3116 const mso_CustomShape msoSmileyFace =
3117 {
3118     const_cast<SvxMSDffVertPair*>(mso_sptSmileyFaceVert), SAL_N_ELEMENTS( mso_sptSmileyFaceVert ),
3119     const_cast<sal_uInt16*>(mso_sptSmileyFaceSegm), sizeof( mso_sptSmileyFaceSegm ) >> 1,
3120     const_cast<SvxMSDffCalculationData*>(mso_sptSmileyFaceCalc), SAL_N_ELEMENTS( mso_sptSmileyFaceCalc ),
3121     const_cast<sal_Int32*>(mso_sptSmileyFaceDefault),
3122     const_cast<SvxMSDffTextRectangles*>(mso_sptEllipseTextRect), SAL_N_ELEMENTS( mso_sptEllipseTextRect ),
3123     21600, 21600,
3124     MIN_INT32, MIN_INT32,
3125     const_cast<SvxMSDffVertPair*>(mso_sptEllipseGluePoints), SAL_N_ELEMENTS( mso_sptEllipseGluePoints ),
3126     const_cast<SvxMSDffHandle*>(mso_sptSmileyHandle), SAL_N_ELEMENTS( mso_sptSmileyHandle )      // handles
3127 };
3128
3129 const SvxMSDffVertPair mso_sptDonutVert[] =  // adj value 0 - 10800
3130 {
3131     { 10800, 10800 }, { 10800, 10800 }, { 0, 360 },
3132     { 10800, 10800 }, { 1 MSO_I, 1 MSO_I }, { 0, 360 }
3133 };
3134 const sal_uInt16 mso_sptDonutSegm[] =
3135 {
3136     0xa203, 0x6000, 0xa203, 0x8000
3137 };
3138 const SvxMSDffCalculationData mso_sptDonutCalc[] =
3139 {
3140     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
3141     { 0x8000, { 10800, 0, DFF_Prop_adjustValue } }
3142 };
3143 const SvxMSDffHandle mso_sptDonutHandle[] =
3144 {
3145     {   SvxMSDffHandleFlags::RANGE,
3146         0x100, 10800, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
3147 };
3148 const mso_CustomShape msoDonut =
3149 {
3150     const_cast<SvxMSDffVertPair*>(mso_sptDonutVert), SAL_N_ELEMENTS( mso_sptDonutVert ),
3151     const_cast<sal_uInt16*>(mso_sptDonutSegm), sizeof( mso_sptDonutSegm ) >> 1,
3152     const_cast<SvxMSDffCalculationData*>(mso_sptDonutCalc), SAL_N_ELEMENTS( mso_sptDonutCalc ),
3153     const_cast<sal_Int32*>(mso_sptDefault5400),
3154     const_cast<SvxMSDffTextRectangles*>(mso_sptEllipseTextRect), SAL_N_ELEMENTS( mso_sptEllipseTextRect ),
3155     21600, 21600,
3156     MIN_INT32, MIN_INT32,
3157     const_cast<SvxMSDffVertPair*>(mso_sptEllipseGluePoints), SAL_N_ELEMENTS( mso_sptEllipseGluePoints ),
3158     const_cast<SvxMSDffHandle*>(mso_sptDonutHandle), SAL_N_ELEMENTS( mso_sptDonutHandle )        // handles
3159 };
3160
3161 const SvxMSDffVertPair mso_sptNoSmokingVert[] =  // adj value 0 - 7200
3162 {
3163     { 10800, 10800 },  { 10800, 10800 }, { 0, 360 },
3164     { 0 MSO_I, 0 MSO_I }, { 1 MSO_I, 1 MSO_I },
3165     { 9 MSO_I, 0xa MSO_I }, { 0xb MSO_I, 0xc MSO_I }, { 0 MSO_I, 0 MSO_I }, { 1 MSO_I, 1 MSO_I },
3166     { 0xd MSO_I, 0xe MSO_I }, { 0xf MSO_I, 0x10 MSO_I }
3167 };
3168 const sal_uInt16 mso_sptNoSmokingSegm[] =
3169 {
3170     0xa203, 0x6000, 0xa404, 0x6000, 0xa404, 0x6000, 0x8000
3171 };
3172 const SvxMSDffCalculationData mso_sptNoSmokingCalc[] =
3173 {
3174     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },         // 0
3175     { 0x8000, { 21600, 0, DFF_Prop_adjustValue } },     // 1
3176     { 0x8000, { 10800, 0, DFF_Prop_adjustValue } },     // 2
3177     { 0x2001, { DFF_Prop_adjustValue, 1, 2 } },         // 3
3178     { 0xa080, { 0x403, 0, 0x402 } },                    // 4
3179     { 0x8000, { 10800, 0, 0x403 } },                    // 5 x1
3180     { 0x4000, { 10800, 0x403, 0 } },                    // 6 x2
3181     { 0x8000, { 10800, 0, 0x404 } },                    // 7 y1
3182     { 0x4000, { 10800, 0x404, 0 } },                    // 8 y2
3183     { 0x6081, { 0x405, 0x407, 45 } },                   // 9
3184     { 0x6082, { 0x405, 0x407, 45 } },                   // a
3185     { 0x6081, { 0x405, 0x408, 45 } },                   // b
3186     { 0x6082, { 0x405, 0x408, 45 } },                   // c
3187     { 0x6081, { 0x406, 0x408, 45 } },                   // d
3188     { 0x6082, { 0x406, 0x408, 45 } },                   // e
3189     { 0x6081, { 0x406, 0x407, 45 } },                   // f
3190     { 0x6082, { 0x406, 0x407, 45 } }                    // 10
3191 };
3192 const SvxMSDffHandle mso_sptNoSmokingHandle[] =
3193 {
3194     {   SvxMSDffHandleFlags::RANGE,
3195         0x100, 10800, 10800, 10800, 0, 7200, MIN_INT32, 0x7fffffff }
3196 };
3197 const mso_CustomShape msoNoSmoking =
3198 {
3199     const_cast<SvxMSDffVertPair*>(mso_sptNoSmokingVert), SAL_N_ELEMENTS( mso_sptNoSmokingVert ),
3200     const_cast<sal_uInt16*>(mso_sptNoSmokingSegm), sizeof( mso_sptNoSmokingSegm ) >> 1,
3201     const_cast<SvxMSDffCalculationData*>(mso_sptNoSmokingCalc), SAL_N_ELEMENTS( mso_sptNoSmokingCalc ),
3202     const_cast<sal_Int32*>(mso_sptDefault2700),
3203     const_cast<SvxMSDffTextRectangles*>(mso_sptEllipseTextRect), SAL_N_ELEMENTS( mso_sptEllipseTextRect ),
3204     21600, 21600,
3205     MIN_INT32, MIN_INT32,
3206     const_cast<SvxMSDffVertPair*>(mso_sptEllipseGluePoints), SAL_N_ELEMENTS( mso_sptEllipseGluePoints ),
3207     const_cast<SvxMSDffHandle*>(mso_sptNoSmokingHandle), SAL_N_ELEMENTS( mso_sptNoSmokingHandle )        // handles
3208 };
3209
3210 const SvxMSDffVertPair mso_sptBlockArcVert[] =   // adj value 0 (degrees)
3211 {                                                       // adj value 1: 0 -> 10800;
3212     { 0, 0 }, { 21600, 21600 }, { 4 MSO_I, 3 MSO_I }, { 2 MSO_I, 3 MSO_I },
3213     { 5 MSO_I, 5 MSO_I }, { 6 MSO_I, 6 MSO_I }, { 2 MSO_I, 3 MSO_I }, { 4 MSO_I, 3 MSO_I }
3214 };
3215 const sal_uInt16 mso_sptBlockArcSegm[] =
3216 {
3217     0xA404, 0xa504, 0x6001, 0x8000
3218 };
3219 const sal_Int32 mso_sptBlockArcDefault[] =
3220 {
3221     2, 180, 5400
3222 };
3223 const SvxMSDffCalculationData mso_sptBlockArcCalc[] =
3224 {
3225     { 0x400a, { 10800, DFF_Prop_adjustValue, 0 } },
3226     { 0x4009, { 10800, DFF_Prop_adjustValue, 0 } },
3227     { 0x2000, { 0x400, 10800, 0 } },
3228     { 0x2000, { 0x401, 10800, 0 } },
3229     { 0x8000, { 21600, 0, 0x402 } },
3230     { 0x8000, { 10800, 0, DFF_Prop_adjust2Value } },
3231     { 0x4000, { 10800, DFF_Prop_adjust2Value, 0 } },
3232     { 0x600a, { 0x405, DFF_Prop_adjustValue, 0 } },
3233     { 0x6009, { 0x405, DFF_Prop_adjustValue, 0 } }
3234 };
3235 const SvxMSDffHandle mso_sptBlockArcHandle[] =
3236 {
3237     {   SvxMSDffHandleFlags::POLAR | SvxMSDffHandleFlags::RADIUS_RANGE,
3238         0x101, 0x100, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
3239 };
3240 const mso_CustomShape msoBlockArc =
3241 {
3242     const_cast<SvxMSDffVertPair*>(mso_sptBlockArcVert), SAL_N_ELEMENTS( mso_sptBlockArcVert ),
3243     const_cast<sal_uInt16*>(mso_sptBlockArcSegm), sizeof( mso_sptBlockArcSegm ) >> 1,
3244     const_cast<SvxMSDffCalculationData*>(mso_sptBlockArcCalc), SAL_N_ELEMENTS( mso_sptBlockArcCalc ),
3245     const_cast<sal_Int32*>(mso_sptBlockArcDefault),
3246     nullptr, 0,
3247     21600, 21600,
3248     MIN_INT32, MIN_INT32,
3249     nullptr, 0,
3250     const_cast<SvxMSDffHandle*>(mso_sptBlockArcHandle), SAL_N_ELEMENTS( mso_sptBlockArcHandle )      // handles
3251 };
3252
3253 // aware : control points are always part of the bounding box
3254 const SvxMSDffVertPair mso_sptHeartVert[] =
3255 {
3256     { 10800, 21599 }, { 321, 6886 }, { 70, 6036 },      // ppp
3257     { -9, 5766 }, { -1, 5474 }, { 2, 5192 },            // ccp
3258     { 6, 4918 }, { 43, 4641 }, { 101, 4370 },           // ccp
3259     { 159, 4103 }, { 245, 3837 }, { 353, 3582 },        // ccp
3260     { 460, 3326 }, { 591, 3077 }, { 741, 2839 },        // ccp
3261     { 892, 2598 }, { 1066, 2369 }, { 1253, 2155 },      // ccp
3262     { 1443, 1938 }, { 1651, 1732 }, { 1874, 1543 },     // ccp
3263     { 2097, 1351 }, { 2337, 1174 }, { 2587, 1014 },     // ccp
3264     { 2839, 854 }, { 3106, 708 }, { 3380, 584 },        // ccp
3265     { 3656, 459 }, { 3945, 350 }, { 4237, 264 },        // ccp
3266     { 4533, 176 }, { 4838, 108 }, { 5144, 66 },         // ccp
3267     { 5454, 22 }, { 5771, 1 }, { 6086, 3 },             // ccp
3268     { 6407, 7 }, { 6731, 35 }, { 7048, 89 },            // ccp
3269     { 7374, 144 }, { 7700, 226 }, { 8015, 335 },        // ccp
3270     { 8344, 447 }, { 8667, 590 }, { 8972, 756 },        // ccp
3271     { 9297, 932 }, { 9613, 1135 }, { 9907, 1363 },      // ccp
3272     { 10224, 1609 }, { 10504, 1900 }, { 10802, 2169 },  // ccp
3273     { 11697, 1363 },                                    // p
3274     { 11971, 1116 }, { 12304, 934 }, { 12630, 756 },    // ccp
3275     { 12935, 590 }, { 13528, 450 }, { 13589, 335 },     // ccp
3276     { 13901, 226 }, { 14227, 144 }, { 14556, 89 },      // ccp
3277     { 14872, 35 }, { 15195, 7 }, { 15517, 3 },          // ccp
3278     { 15830, 0 }, { 16147, 22 }, { 16458, 66 },         // ccp
3279     { 16764, 109 }, { 17068, 177 }, { 17365, 264 },     // ccp
3280     { 17658, 349 }, { 17946, 458 }, { 18222, 584 },     // ccp
3281     { 18496, 708 }, { 18762, 854 }, { 19015, 1014 },    // ccp
3282     { 19264, 1172 }, { 19504, 1349 }, { 19730, 1543 },  // ccp
3283     { 19950, 1731 }, { 20158, 1937 }, { 20350, 2155 },  // ccp
3284     { 20536, 2369 }, { 20710, 2598 }, { 20861, 2839 },  // ccp
3285     { 21010, 3074 }, { 21143, 3323 }, { 21251, 3582 },  // ccp
3286     { 21357, 3835 }, { 21443, 4099 }, { 21502, 4370 },  // ccp
3287     { 21561, 4639 }, { 21595, 4916 }, { 21600, 5192 },  // ccp
3288     { 21606, 5474 }, { 21584, 5760 }, { 21532, 6036 },  // ccp
3289     { 21478, 6326 }, { 21366, 6603 }, { 21282, 6887 },  // ccp
3290     { 10802, 21602 }                                    // p
3291 };
3292 const sal_uInt16 mso_sptHeartSegm[] =
3293 {
3294     0x4000, 0x0002, 0x2010, 0x0001, 0x2010, 0x0001, 0x6001, 0x8000
3295 };
3296 const SvxMSDffTextRectangles mso_sptHeartTextRect[] =
3297 {
3298     { { 5080, 2540 }, { 16520, 13550 } }
3299 };
3300 const SvxMSDffVertPair mso_sptHeartGluePoints[] =
3301 {
3302     { 10800, 2180 }, { 3090, 10800 }, { 10800, 21600 }, { 18490, 10800 }
3303 };
3304 const mso_CustomShape msoHeart =
3305 {
3306     const_cast<SvxMSDffVertPair*>(mso_sptHeartVert), SAL_N_ELEMENTS( mso_sptHeartVert ),
3307     const_cast<sal_uInt16*>(mso_sptHeartSegm), sizeof( mso_sptHeartSegm ) >> 1,
3308     nullptr, 0,
3309     nullptr,
3310     const_cast<SvxMSDffTextRectangles*>(mso_sptHeartTextRect), SAL_N_ELEMENTS( mso_sptHeartTextRect ),
3311     21615, 21602,
3312     MIN_INT32, MIN_INT32,
3313     const_cast<SvxMSDffVertPair*>(mso_sptHeartGluePoints), SAL_N_ELEMENTS( mso_sptHeartGluePoints ),
3314     nullptr, 0     // handles
3315 };
3316
3317 const SvxMSDffVertPair mso_sptLightningBoldVert[] =
3318 {
3319     { 8458, 0 }, { 0, 3923 }, { 7564, 8416 }, { 4993, 9720 },
3320     { 12197, 13904 }, { 9987, 14934 }, { 21600, 21600 }, { 14768, 12911 },
3321     { 16558, 12016 }, { 11030, 6840 }, { 12831, 6120 }, { 8458, 0 }
3322 };
3323 const SvxMSDffTextRectangles mso_sptLightningBoldTextRect[] =
3324 {
3325     { { 8680, 7410 }, { 13970, 14190 } }
3326 };
3327 const SvxMSDffVertPair mso_sptLightningBoldGluePoints[] =
3328 {
3329     { 8458, 0 }, { 0, 3923 }, { 4993, 9720 }, { 9987, 14934 }, { 21600, 21600 },
3330     { 16558, 12016 }, { 12831, 6120 }
3331 };
3332 const mso_CustomShape msoLightningBold =
3333 {
3334     const_cast<SvxMSDffVertPair*>(mso_sptLightningBoldVert), SAL_N_ELEMENTS( mso_sptLightningBoldVert ),
3335     nullptr, 0,
3336     nullptr, 0,
3337     nullptr,
3338     const_cast<SvxMSDffTextRectangles*>(mso_sptLightningBoldTextRect), SAL_N_ELEMENTS( mso_sptLightningBoldTextRect ),
3339     21600, 21600,
3340     MIN_INT32, MIN_INT32,
3341     const_cast<SvxMSDffVertPair*>(mso_sptLightningBoldGluePoints), SAL_N_ELEMENTS( mso_sptLightningBoldGluePoints ),
3342     nullptr, 0     // handles
3343 };
3344
3345 const SvxMSDffVertPair mso_sptSunVert[] =    // adj value 2700 -> 10125
3346 {
3347     { 0, 10800 },               { 4 MSO_I, 8 MSO_I },       { 4 MSO_I, 9 MSO_I },
3348     { 0x0a MSO_I, 0x0b MSO_I }, { 0x0c MSO_I, 0x0d MSO_I }, { 0x0e MSO_I, 0x0f MSO_I },
3349     { 0x10 MSO_I, 0x11 MSO_I }, { 0x12 MSO_I, 0x13 MSO_I }, { 0x14 MSO_I, 0x15 MSO_I },
3350     { 0x16 MSO_I, 0x17 MSO_I }, { 0x18 MSO_I, 0x19 MSO_I }, { 0x1a MSO_I, 0x1b MSO_I },
3351     { 0x1c MSO_I, 0x1d MSO_I }, { 0x1e MSO_I, 0x1f MSO_I }, { 0x20 MSO_I, 0x21 MSO_I },
3352     { 0x22 MSO_I, 0x23 MSO_I }, { 0x24 MSO_I, 0x25 MSO_I }, { 0x26 MSO_I, 0x27 MSO_I },
3353     { 0x28 MSO_I, 0x29 MSO_I }, { 0x2a MSO_I, 0x2b MSO_I }, { 0x2c MSO_I, 0x2d MSO_I },
3354     { 0x2e MSO_I, 0x2f MSO_I }, { 0x30 MSO_I, 0x31 MSO_I }, { 0x32 MSO_I, 0x33 MSO_I },
3355     { 10800, 10800 }, { 0x36 MSO_I, 0x36 MSO_I },   { 0, 360 }
3356 };
3357 const sal_uInt16 mso_sptSunSegm[] =
3358 {
3359     0x4000, 0x0002, 0x6001, 0x8000,
3360     0x4000, 0x0002, 0x6001, 0x8000,
3361     0x4000, 0x0002, 0x6001, 0x8000,
3362     0x4000, 0x0002, 0x6001, 0x8000,
3363     0x4000, 0x0002, 0x6001, 0x8000,
3364     0x4000, 0x0002, 0x6001, 0x8000,
3365     0x4000, 0x0002, 0x6001, 0x8000,
3366     0x4000, 0x0002, 0x6001, 0x8000,
3367     0xa203, 0x6000, 0x8000
3368 };
3369 const SvxMSDffCalculationData mso_sptSunCalc[] =
3370 {
3371     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
3372     { 0x8000, { 21600, 0, DFF_Prop_adjustValue } },
3373     { 0x2000, { DFF_Prop_adjustValue, 0, 2700 } },
3374     { 0x2001, { 0x402, 5080, 7425 } },
3375     { 0x2000, { 0x403, 2540, 0 } },
3376     { 0x8000, { 10125, 0, DFF_Prop_adjustValue } },
3377     { 0x2001, { 0x405, 2120, 7425 } },
3378     { 0x2000, { 0x406, 210, 0 } },
3379     { 0x4000, { 10800, 0x407, 0 } },    // y1 (0x8)
3380     { 0x8000, { 10800, 0, 0x407 } },    // y2 (0x9)
3381     { 0x0081, { 0, 10800, 45 } },       // 0xa
3382     { 0x0082, { 0, 10800, 45 } },       // 0xb
3383     { 0x6081, { 0x404, 0x408, 45 } },   // 0xc
3384     { 0x6082, { 0x404, 0x408, 45 } },   // 0xd
3385     { 0x6081, { 0x404, 0x409, 45 } },   // 0xe
3386     { 0x6082, { 0x404, 0x409, 45 } },   // 0xf
3387     { 0x0081, { 0, 10800, 90 } },       // 0x10
3388     { 0x0082, { 0, 10800, 90 } },       // 0x11
3389     { 0x6081, { 0x404, 0x408, 90 } },   // 0x12
3390     { 0x6082, { 0x404, 0x408, 90 } },   // 0x13
3391     { 0x6081, { 0x404, 0x409, 90 } },   // 0x14
3392     { 0x6082, { 0x404, 0x409, 90 } },   // 0x15
3393     { 0x0081, { 0, 10800, 135 } },      // 0x16
3394     { 0x0082, { 0, 10800, 135 } },      // 0x17
3395     { 0x6081, { 0x404, 0x408, 135 } },  // 0x18
3396     { 0x6082, { 0x404, 0x408, 135 } },  // 0x19
3397     { 0x6081, { 0x404, 0x409, 135 } },  // 0x1a
3398     { 0x6082, { 0x404, 0x409, 135 } },  // 0x1b
3399     { 0x0081, { 0, 10800, 180 } },      // 0x1c
3400     { 0x0082, { 0, 10800, 180 } },      // 0x1d
3401     { 0x6081, { 0x404, 0x408, 180 } },  // 0x1e
3402     { 0x6082, { 0x404, 0x408, 180 } },  // 0x1f
3403     { 0x6081, { 0x404, 0x409, 180 } },  // 0x20
3404     { 0x6082, { 0x404, 0x409, 180 } },  // 0x21
3405     { 0x0081, { 0, 10800, 225 } },      // 0x22
3406     { 0x0082, { 0, 10800, 225 } },      // 0x23
3407     { 0x6081, { 0x404, 0x408, 225 } },  // 0x24
3408     { 0x6082, { 0x404, 0x408, 225 } },  // 0x25
3409     { 0x6081, { 0x404, 0x409, 225 } },  // 0x26
3410     { 0x6082, { 0x404, 0x409, 225 } },  // 0x27
3411     { 0x0081, { 0, 10800, 270 } },      // 0x28
3412     { 0x0082, { 0, 10800, 270 } },      // 0x29
3413     { 0x6081, { 0x404, 0x408, 270 } },  // 0x2a
3414     { 0x6082, { 0x404, 0x408, 270 } },  // 0x2b
3415     { 0x6081, { 0x404, 0x409, 270 } },  // 0x2c
3416     { 0x6082, { 0x404, 0x409, 270 } },  // 0x2d
3417     { 0x0081, { 0, 10800, 315 } },      // 0x2e
3418     { 0x0082, { 0, 10800, 315 } },      // 0x2f
3419     { 0x6081, { 0x404, 0x408, 315 } },  // 0x30
3420     { 0x6082, { 0x404, 0x408, 315 } },  // 0x31
3421     { 0x6081, { 0x404, 0x409, 315 } },  // 0x32
3422     { 0x6082, { 0x404, 0x409, 315 } },  // 0x33
3423     { 0x2081, { DFF_Prop_adjustValue, 10800, 45 } },    // 0x34 ( textbox )
3424     { 0x2081, { DFF_Prop_adjustValue, 10800, 225 } },   // 0x35
3425     { 0x8000, { 10800, 0, DFF_Prop_adjustValue } }
3426 };
3427 const SvxMSDffTextRectangles mso_sptSunTextRect[] =
3428 {
3429     { { 0x34 MSO_I, 0x34 MSO_I }, { 0x35 MSO_I, 0x35 MSO_I } }
3430 };
3431 const SvxMSDffHandle mso_sptSunHandle[] =
3432 {
3433     {   SvxMSDffHandleFlags::RANGE,
3434         0x100, 10800, 10800, 10800, 2700, 10125, MIN_INT32, 0x7fffffff }
3435 };
3436 const mso_CustomShape msoSun =
3437 {
3438     const_cast<SvxMSDffVertPair*>(mso_sptSunVert), SAL_N_ELEMENTS( mso_sptSunVert ),
3439     const_cast<sal_uInt16*>(mso_sptSunSegm), sizeof( mso_sptSunSegm ) >> 1,
3440     const_cast<SvxMSDffCalculationData*>(mso_sptSunCalc), SAL_N_ELEMENTS( mso_sptSunCalc ),
3441     const_cast<sal_Int32*>(mso_sptDefault5400),
3442     const_cast<SvxMSDffTextRectangles*>(mso_sptSunTextRect), SAL_N_ELEMENTS( mso_sptSunTextRect ),
3443     21600, 21600,
3444     MIN_INT32, MIN_INT32,
3445     const_cast<SvxMSDffVertPair*>(mso_sptStandardGluePoints), SAL_N_ELEMENTS( mso_sptStandardGluePoints ),
3446     const_cast<SvxMSDffHandle*>(mso_sptSunHandle), SAL_N_ELEMENTS( mso_sptSunHandle )        // handles
3447 };
3448
3449 const SvxMSDffVertPair mso_sptMoonVert[] =   // adj value 0 -> 18900
3450 {
3451     { 21600, 0 },
3452     { 3 MSO_I, 4 MSO_I },   { 0 MSO_I, 5080 },      { 0 MSO_I, 10800 }, // ccp
3453     { 0 MSO_I, 16520 },     { 3 MSO_I, 5 MSO_I },   { 21600, 21600 },   // ccp
3454     { 9740, 21600 },        { 0, 16730 },           { 0, 10800 },       // ccp
3455     { 0, 4870 },            { 9740, 0 },            { 21600, 0  }       // ccp
3456 };
3457 const sal_uInt16 mso_sptMoonSegm[] =
3458 {
3459     0x4000, 0x2004, 0x6000, 0x8000
3460 };
3461 const SvxMSDffCalculationData mso_sptMoonCalc[] =
3462 {
3463     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
3464     { 0x8000, { 21600, 0, DFF_Prop_adjustValue } },
3465     { 0x2001, { 0x401, 1, 2 } },
3466     { 0x6000, { 0x402, DFF_Prop_adjustValue, 0 } },
3467     { 0x2001, { DFF_Prop_adjustValue, 1794, 10000 } },
3468     { 0x8000, { 21600, 0, 0x0404 } },
3469     { 0x2001, { DFF_Prop_adjustValue, 400, 18900 } },
3470     { 0x8081, { 0, 10800, 0x406 } },
3471     { 0x8082, { 0, 10800, 0x406 } },
3472     { 0x6000, { 0x407, 0x407, 0 } },
3473     { 0x8000, { 21600, 0, 0x408 } }
3474 };
3475 const SvxMSDffTextRectangles mso_sptMoonTextRect[] =
3476 {
3477     { { 9 MSO_I, 8 MSO_I }, { 0 MSO_I, 0xa MSO_I } }
3478 };
3479 const SvxMSDffVertPair mso_sptMoonGluePoints[] =
3480 {
3481     { 21600, 0 }, { 0, 10800 }, { 21600, 21600 }, { 0 MSO_I, 10800 }
3482 };
3483 const SvxMSDffHandle mso_sptMoonHandle[] =
3484 {
3485     {   SvxMSDffHandleFlags::RANGE,
3486         0x100, 10800, 10800, 10800, 0, 18900, MIN_INT32, 0x7fffffff }
3487 };
3488 const mso_CustomShape msoMoon =
3489 {
3490     const_cast<SvxMSDffVertPair*>(mso_sptMoonVert), SAL_N_ELEMENTS( mso_sptMoonVert ),
3491     const_cast<sal_uInt16*>(mso_sptMoonSegm), sizeof( mso_sptMoonSegm ) >> 1,
3492     const_cast<SvxMSDffCalculationData*>(mso_sptMoonCalc), SAL_N_ELEMENTS( mso_sptMoonCalc ),
3493     const_cast<sal_Int32*>(mso_sptDefault10800),
3494     const_cast<SvxMSDffTextRectangles*>(mso_sptMoonTextRect), SAL_N_ELEMENTS( mso_sptMoonTextRect ),
3495     21600, 21600,
3496     MIN_INT32, MIN_INT32,
3497     const_cast<SvxMSDffVertPair*>(mso_sptMoonGluePoints), SAL_N_ELEMENTS( mso_sptMoonGluePoints ),
3498     const_cast<SvxMSDffHandle*>(mso_sptMoonHandle), SAL_N_ELEMENTS( mso_sptMoonHandle )      // handles
3499 };
3500
3501 const SvxMSDffVertPair mso_sptBracketPairVert[] =    // adj value 0 -> 10800
3502 {
3503     { 0 MSO_I, 0 },     { 0, 1 MSO_I },     // left top alignment
3504     { 0, 2 MSO_I },     { 0 MSO_I, 21600 }, // left  bottom "
3505     { 3 MSO_I, 21600 }, { 21600, 2 MSO_I }, // right bottom "
3506     { 21600, 1 MSO_I }, { 3 MSO_I, 0 },     // right top    "
3507     { 0 MSO_I, 0 },     { 0, 1 MSO_I },     // filling area
3508     { 0, 2 MSO_I },     { 0 MSO_I, 21600 },
3509     { 3 MSO_I, 21600 }, { 21600, 2 MSO_I },
3510     { 21600, 1 MSO_I }, { 3 MSO_I, 0 }
3511 };
3512 const sal_uInt16 mso_sptBracketPairSegm[] =
3513 {
3514     0x4000, 0xa701, 0x0001, 0xa801, 0xaa00, 0x8000,
3515     0x4000, 0xa701, 0x0001, 0xa801, 0xaa00, 0x8000,
3516     0x4000, 0xa701, 0x0001, 0xa801, 0x0001,             // filling area
3517     0xa701, 0x0001, 0xa801, 0x6000, 0xab00, 0x8000
3518 };
3519 const SvxMSDffCalculationData mso_sptBracketPairCalc[] =
3520 {
3521     { 0x6000, { DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 } },
3522     { 0x6000, { DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 } },
3523     { 0xa000, { DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue } },
3524     { 0xa000, { DFF_Prop_geoRight, 0, DFF_Prop_adjustValue } },
3525     { 0x2082, { DFF_Prop_adjustValue, 0, 45 } },
3526     { 0x2000, { 0x404, 0, 10800 } },
3527     { 0x8000, { 0, 0, DFF_Prop_adjustValue } },
3528     { 0xa000, { 0x406, 0, 0x405 } },
3529     { 0xa000, { DFF_Prop_geoLeft, 0, 0x407 } },
3530     { 0xa000, { DFF_Prop_geoTop, 0, 0x407 } },
3531     { 0x6000, { DFF_Prop_geoRight, 0x407, 0 } },
3532     { 0x6000, { DFF_Prop_geoBottom, 0x407, 0 } },
3533     { 0xa000, { DFF_Prop_geoLeft, 0, 0x405 } },
3534     { 0xa000, { DFF_Prop_geoTop, 0, 0x405 } },
3535     { 0x6000, { DFF_Prop_geoRight, 0x405, 0 } },
3536     { 0x6000, { DFF_Prop_geoBottom, 0x405, 0 } }
3537 };
3538 const SvxMSDffTextRectangles mso_sptBracketPairTextRect[] =
3539 {
3540     { { 8 MSO_I, 9 MSO_I }, { 0xa MSO_I, 0xb MSO_I } }
3541 };
3542 const SvxMSDffHandle mso_sptBracketPairHandle[] =
3543 {
3544     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::SWITCHED,
3545         0x100, 0, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
3546 };
3547 const mso_CustomShape msoBracketPair =
3548 {
3549     const_cast<SvxMSDffVertPair*>(mso_sptBracketPairVert), SAL_N_ELEMENTS( mso_sptBracketPairVert ),
3550     const_cast<sal_uInt16*>(mso_sptBracketPairSegm), sizeof( mso_sptBracketPairSegm ) >> 1,
3551     const_cast<SvxMSDffCalculationData*>(mso_sptBracketPairCalc), SAL_N_ELEMENTS( mso_sptBracketPairCalc ),
3552     const_cast<sal_Int32*>(mso_sptDefault3700),
3553     const_cast<SvxMSDffTextRectangles*>(mso_sptBracketPairTextRect), SAL_N_ELEMENTS( mso_sptBracketPairTextRect ),
3554     21600, 21600,
3555     10800, MIN_INT32,
3556     const_cast<SvxMSDffVertPair*>(mso_sptStandardGluePoints), SAL_N_ELEMENTS( mso_sptStandardGluePoints ),
3557     const_cast<SvxMSDffHandle*>(mso_sptBracketPairHandle), SAL_N_ELEMENTS( mso_sptBracketPairHandle )        // handles
3558 };
3559
3560 const sal_uInt16 mso_sptPlaqueSegm[] =
3561 {
3562     0x4000, 0xa801, 0x0001, 0xa701, 0x0001, 0xa801, 0x0001, 0xa701, 0x6000, 0x8000
3563 };
3564 const SvxMSDffTextRectangles mso_sptPlaqueTextRect[] =
3565 {
3566     { { 0xc MSO_I, 0xd MSO_I }, { 0xe MSO_I, 0xf MSO_I } }
3567 };
3568 const SvxMSDffHandle mso_sptPlaqueHandle[] =
3569 {
3570     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::SWITCHED,
3571         0x100, 0, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
3572 };
3573 const mso_CustomShape msoPlaque =
3574 {
3575     const_cast<SvxMSDffVertPair*>(mso_sptBracketPairVert), SAL_N_ELEMENTS( mso_sptBracketPairVert ),
3576     const_cast<sal_uInt16*>(mso_sptPlaqueSegm), sizeof( mso_sptPlaqueSegm ) >> 1,
3577     const_cast<SvxMSDffCalculationData*>(mso_sptBracketPairCalc), SAL_N_ELEMENTS( mso_sptBracketPairCalc ),
3578     const_cast<sal_Int32*>(mso_sptDefault3600),
3579     const_cast<SvxMSDffTextRectangles*>(mso_sptPlaqueTextRect), SAL_N_ELEMENTS( mso_sptPlaqueTextRect ),
3580     21600, 21600,
3581     10800, 10800,
3582     const_cast<SvxMSDffVertPair*>(mso_sptStandardGluePoints), SAL_N_ELEMENTS( mso_sptStandardGluePoints ),
3583     const_cast<SvxMSDffHandle*>(mso_sptPlaqueHandle), SAL_N_ELEMENTS( mso_sptPlaqueHandle )      // handles
3584 };
3585
3586 const SvxMSDffVertPair mso_sptBracePairVert[] =  // adj value 0 -> 5400
3587 {
3588     { 4 MSO_I, 0 }, { 0 MSO_I, 1 MSO_I }, { 0 MSO_I, 6 MSO_I }, { 0 ,10800 },           // left bracket
3589     { 0 MSO_I, 7 MSO_I }, { 0 MSO_I, 2 MSO_I }, { 4 MSO_I, 21600 },
3590     { 8 MSO_I, 21600 }, { 3 MSO_I, 2 MSO_I }, { 3 MSO_I, 7 MSO_I }, { 21600, 10800 },   // right bracket
3591     { 3 MSO_I, 6 MSO_I }, { 3 MSO_I, 1 MSO_I }, { 8 MSO_I, 0 },
3592     { 4 MSO_I, 0 }, { 0 MSO_I, 1 MSO_I }, { 0 MSO_I, 6 MSO_I }, { 0 ,10800 },           // filling area
3593     { 0 MSO_I, 7 MSO_I }, { 0 MSO_I, 2 MSO_I }, { 4 MSO_I, 21600 },
3594     { 8 MSO_I, 21600 }, { 3 MSO_I, 2 MSO_I }, { 3 MSO_I, 7 MSO_I }, { 21600, 10800 },
3595     { 3 MSO_I, 6 MSO_I }, { 3 MSO_I, 1 MSO_I }, { 8 MSO_I, 0 }
3596 };
3597 const sal_uInt16 mso_sptBracePairSegm[] =
3598 {
3599     0x4000, 0xa701, 0x0001, 0xa801, 0xa701, 0x0001, 0xa801, 0xaa00, 0x8000,
3600     0x4000, 0xa701, 0x0001, 0xa801, 0xa701, 0x0001, 0xa801, 0xaa00, 0x8000,
3601     0x4000, 0xa701, 0x0001, 0xa801, 0xa701, 0x0001, 0xa801, 0x0001,                     // filling area
3602     0xa701, 0x0001, 0xa801, 0xa701, 0x0001, 0xa801, 0x6000, 0xab00, 0x8000
3603 };
3604 const SvxMSDffCalculationData mso_sptBracePairCalc[] =
3605 {
3606     { 0x6000, { DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 } },
3607     { 0x6000, { DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 } },
3608     { 0xa000, { DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue } },
3609     { 0xa000, { DFF_Prop_geoRight, 0, DFF_Prop_adjustValue } },
3610     { 0x2001, { 0x400, 2, 1 } },                                    //  4
3611     { 0x2001, { DFF_Prop_adjustValue, 2, 1 } },                     //  5
3612     { 0x8000, { 10800, 0, DFF_Prop_adjustValue } },                 //  6
3613     { 0x8000, { 21600, 0, 0x406 } },                                //  7
3614     { 0xa000, { DFF_Prop_geoRight, 0, 0x405 } },                    //  8
3615     { 0x2001, { DFF_Prop_adjustValue, 1, 3 } },                     //  9
3616     { 0x6000, { 0x409, DFF_Prop_adjustValue, 0 } },                 // xa
3617     { 0x6000, { DFF_Prop_geoLeft, 0x40a, 0 } },                     // xb
3618     { 0x6000, { DFF_Prop_geoTop, 0x409, 0 } },                      // xc
3619     { 0xa000, { DFF_Prop_geoRight, 0, 0x40a } },                    // xd
3620     { 0xa000, { DFF_Prop_geoBottom, 0, 0x409 } }                    // xe
3621 };
3622 const SvxMSDffTextRectangles mso_sptBracePairTextRect[] =
3623 {
3624     { { 0xb MSO_I, 0xc MSO_I }, { 0xd MSO_I, 0xe MSO_I } }
3625 };
3626 const SvxMSDffHandle mso_sptBracePairHandle[] =
3627 {
3628     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::SWITCHED,
3629         0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 5400 }
3630 };
3631 const mso_CustomShape msoBracePair =
3632 {
3633     const_cast<SvxMSDffVertPair*>(mso_sptBracePairVert), SAL_N_ELEMENTS( mso_sptBracePairVert ),
3634     const_cast<sal_uInt16*>(mso_sptBracePairSegm), sizeof( mso_sptBracePairSegm ) >> 1,
3635     const_cast<SvxMSDffCalculationData*>(mso_sptBracePairCalc), SAL_N_ELEMENTS( mso_sptBracePairCalc ),
3636     const_cast<sal_Int32*>(mso_sptDefault1800),
3637     const_cast<SvxMSDffTextRectangles*>(mso_sptBracePairTextRect), SAL_N_ELEMENTS( mso_sptBracePairTextRect ),
3638     21600, 21600,
3639     10800, MIN_INT32,
3640     const_cast<SvxMSDffVertPair*>(mso_sptStandardGluePoints), SAL_N_ELEMENTS( mso_sptStandardGluePoints ),
3641     const_cast<SvxMSDffHandle*>(mso_sptBracePairHandle), SAL_N_ELEMENTS( mso_sptBracePairHandle )        // handles
3642 };
3643
3644 const SvxMSDffCalculationData mso_sptBracketCalc[] =
3645 {
3646     { 0x2001, { DFF_Prop_adjustValue, 1, 2 } },
3647     { 0x6000, { DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 } },
3648     { 0xa000, { DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue } },
3649     { 0x6000, { DFF_Prop_geoTop, 0x400, 0 } },
3650     { 0xa000, { DFF_Prop_geoBottom, 0, 0x400 } }
3651 };
3652 const sal_uInt16 mso_sptBracketSegm[] =
3653 {
3654     0x4000, 0x2001, 0x0001, 0x2001, 0x8000
3655 };
3656 const SvxMSDffVertPair mso_sptLeftBracketVert[] =    // adj value 0 -> 10800
3657 {
3658     { 21600, 0 }, { 10800,  0 }, { 0, 3 MSO_I }, { 0, 1 MSO_I },
3659     { 0, 2 MSO_I }, { 0, 4 MSO_I }, { 10800, 21600 }, { 21600, 21600 }
3660 };
3661 const SvxMSDffTextRectangles mso_sptLeftBracketTextRect[] =
3662 {
3663     { { 6350, 3 MSO_I }, { 21600, 4 MSO_I } }
3664 };
3665 const SvxMSDffVertPair mso_sptLeftBracketGluePoints[] =
3666 {
3667     { 21600, 0 }, { 0, 10800 }, { 21600, 21600 }
3668 };
3669 const SvxMSDffHandle mso_sptLeftBracketHandle[] =
3670 {
3671     {   SvxMSDffHandleFlags::RANGE,
3672         0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 10800 }
3673 };
3674 const mso_CustomShape msoLeftBracket =
3675 {
3676     const_cast<SvxMSDffVertPair*>(mso_sptLeftBracketVert), SAL_N_ELEMENTS( mso_sptLeftBracketVert ),
3677     const_cast<sal_uInt16*>(mso_sptBracketSegm), sizeof( mso_sptBracketSegm ) >> 1,
3678     const_cast<SvxMSDffCalculationData*>(mso_sptBracketCalc), SAL_N_ELEMENTS( mso_sptBracketCalc ),
3679     const_cast<sal_Int32*>(mso_sptDefault1800),
3680     const_cast<SvxMSDffTextRectangles*>(mso_sptLeftBracketTextRect), SAL_N_ELEMENTS( mso_sptLeftBracketTextRect ),
3681     21600, 21600,
3682     MIN_INT32, MIN_INT32,
3683     const_cast<SvxMSDffVertPair*>(mso_sptLeftBracketGluePoints), SAL_N_ELEMENTS( mso_sptLeftBracketGluePoints ),
3684     const_cast<SvxMSDffHandle*>(mso_sptLeftBracketHandle), SAL_N_ELEMENTS( mso_sptLeftBracketHandle )        // handles
3685 };
3686 const SvxMSDffVertPair mso_sptRightBracketVert[] =   // adj value 0 -> 10800
3687 {
3688     { 0, 0 }, { 10800, 0 }, { 21600, 3 MSO_I }, { 21600, 1 MSO_I },
3689     { 21600, 2 MSO_I }, { 21600, 4 MSO_I }, { 10800, 21600 }, { 0, 21600 }
3690 };
3691 const SvxMSDffTextRectangles mso_sptRightBracketTextRect[] =
3692 {
3693     { { 0, 3 MSO_I }, { 15150, 4 MSO_I } }
3694 };
3695 const SvxMSDffVertPair mso_sptRightBracketGluePoints[] =
3696 {
3697     { 0, 0 }, { 0, 21600 }, { 21600, 10800 }
3698 };
3699 const SvxMSDffHandle mso_sptRightBracketHandle[] =
3700 {
3701     {   SvxMSDffHandleFlags::RANGE,
3702         1, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 10800 }
3703 };
3704 const mso_CustomShape msoRightBracket =
3705 {
3706     const_cast<SvxMSDffVertPair*>(mso_sptRightBracketVert), SAL_N_ELEMENTS( mso_sptRightBracketVert ),
3707     const_cast<sal_uInt16*>(mso_sptBracketSegm), sizeof( mso_sptBracketSegm ) >> 1,
3708     const_cast<SvxMSDffCalculationData*>(mso_sptBracketCalc), SAL_N_ELEMENTS( mso_sptBracketCalc ),
3709     const_cast<sal_Int32*>(mso_sptDefault1800),
3710     const_cast<SvxMSDffTextRectangles*>(mso_sptRightBracketTextRect), SAL_N_ELEMENTS( mso_sptRightBracketTextRect ),
3711     21600, 21600,
3712     MIN_INT32, MIN_INT32,
3713     const_cast<SvxMSDffVertPair*>(mso_sptRightBracketGluePoints), SAL_N_ELEMENTS( mso_sptRightBracketGluePoints ),
3714     const_cast<SvxMSDffHandle*>(mso_sptRightBracketHandle), SAL_N_ELEMENTS( mso_sptRightBracketHandle )      // handles
3715 };
3716
3717 const SvxMSDffCalculationData mso_sptBraceCalc[] =
3718 {
3719     { 0x2001, { DFF_Prop_adjustValue, 1, 2 } },
3720     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
3721     { 0xa000, { 0x404, 0, DFF_Prop_adjustValue } },
3722     { 0xa000, { 0x404, 0, 0x400 } },
3723     { 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
3724     { 0x6000, { 0x404, 0x400, 0 } },
3725     { 0x6000, { 0x404, DFF_Prop_adjustValue, 0 } },
3726     { 0x8000, { 21600, 0, DFF_Prop_adjustValue } },
3727     { 0x8000, { 21600, 0, 0x400 } },
3728     { 0x2001, { DFF_Prop_adjustValue, 10000, 31953 } },
3729     { 0x8000, { 21600, 0, 0x409 } }
3730 };
3731 const sal_uInt16 mso_sptBraceSegm[] =
3732 {
3733     0x4000, 0x2001, 0x0001, 0x2002, 0x0001, 0x2001, 0x8000
3734 };
3735 const sal_Int32 mso_sptBraceDefault[] =
3736 {
3737     2, 1800, 10800
3738 };
3739 const SvxMSDffVertPair mso_sptLeftBraceVert[] =
3740 {
3741     { 21600, 0 },                                               // p
3742     { 16200, 0 }, { 10800, 0 MSO_I }, { 10800, 1 MSO_I },       // ccp
3743     { 10800, 2 MSO_I },                                         // p
3744     { 10800, 3 MSO_I }, { 5400, 4 MSO_I }, { 0, 4 MSO_I },      // ccp
3745     { 5400, 4 MSO_I },  { 10800, 5 MSO_I }, { 10800, 6 MSO_I }, // ccp
3746     { 10800, 7 MSO_I },                                         // p
3747     { 10800, 8 MSO_I }, { 16200, 21600 }, { 21600, 21600 }      // ccp
3748 };
3749 const SvxMSDffTextRectangles mso_sptLeftBraceTextRect[] =
3750 {
3751     { { 13800, 9 MSO_I }, { 21600, 10 MSO_I } }
3752 };
3753 const SvxMSDffHandle mso_sptLeftBraceHandle[] =
3754 {
3755     {   SvxMSDffHandleFlags::RANGE,
3756         10800, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 5400 },
3757     {   SvxMSDffHandleFlags::RANGE,
3758         0, 0x101, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 21600 }
3759 };
3760 const mso_CustomShape msoLeftBrace =     // adj value0 0 -> 5400
3761 {                                               // adj value1 0 -> 21600
3762     const_cast<SvxMSDffVertPair*>(mso_sptLeftBraceVert), SAL_N_ELEMENTS( mso_sptLeftBraceVert ),
3763     const_cast<sal_uInt16*>(mso_sptBraceSegm), sizeof( mso_sptBraceSegm ) >> 1,
3764     const_cast<SvxMSDffCalculationData*>(mso_sptBraceCalc), SAL_N_ELEMENTS( mso_sptBraceCalc ),
3765     const_cast<sal_Int32*>(mso_sptBraceDefault),
3766     const_cast<SvxMSDffTextRectangles*>(mso_sptLeftBraceTextRect), SAL_N_ELEMENTS( mso_sptLeftBraceTextRect ),
3767     21600, 21600,
3768     MIN_INT32, MIN_INT32,
3769     const_cast<SvxMSDffVertPair*>(mso_sptLeftBracketGluePoints), SAL_N_ELEMENTS( mso_sptLeftBracketGluePoints ),
3770     const_cast<SvxMSDffHandle*>(mso_sptLeftBraceHandle), SAL_N_ELEMENTS( mso_sptLeftBraceHandle )        // handles
3771 };
3772 const SvxMSDffVertPair mso_sptRightBraceVert[] =
3773 {
3774     { 0, 0 },                                                   // p
3775     { 5400, 0 }, { 10800, 0 MSO_I }, { 10800, 1 MSO_I },        // ccp
3776     { 10800, 2 MSO_I },                                         // p
3777     { 10800, 3 MSO_I }, { 16200, 4 MSO_I }, { 21600, 4 MSO_I }, // ccp
3778     { 16200, 4 MSO_I }, { 10800, 5 MSO_I }, { 10800, 6 MSO_I }, // ccp
3779     { 10800, 7 MSO_I },                                         // p
3780     { 10800, 8 MSO_I }, { 5400, 21600 }, { 0, 21600 }           // ccp
3781 };
3782 const SvxMSDffTextRectangles mso_sptRightBraceTextRect[] =
3783 {
3784     { { 0, 9 MSO_I }, { 7800, 10 MSO_I } }
3785 };
3786 const SvxMSDffHandle mso_sptRightBraceHandle[] =
3787 {
3788     {   SvxMSDffHandleFlags::RANGE,
3789         10800, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 5400 },
3790     {   SvxMSDffHandleFlags::RANGE,
3791         1, 0x101, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 21600 }
3792 };
3793 const mso_CustomShape msoRightBrace =        // adj value0 0 -> 5400
3794 {                                               // adj value1 0 -> 21600
3795     const_cast<SvxMSDffVertPair*>(mso_sptRightBraceVert), SAL_N_ELEMENTS( mso_sptRightBraceVert ),
3796     const_cast<sal_uInt16*>(mso_sptBraceSegm), sizeof( mso_sptBraceSegm ) >> 1,
3797     const_cast<SvxMSDffCalculationData*>(mso_sptBraceCalc), SAL_N_ELEMENTS( mso_sptBraceCalc ),
3798     const_cast<sal_Int32*>(mso_sptBraceDefault),
3799     const_cast<SvxMSDffTextRectangles*>(mso_sptRightBraceTextRect), SAL_N_ELEMENTS( mso_sptRightBraceTextRect ),
3800     21600, 21600,
3801     MIN_INT32, MIN_INT32,
3802     const_cast<SvxMSDffVertPair*>(mso_sptRightBracketGluePoints), SAL_N_ELEMENTS( mso_sptRightBracketGluePoints ),
3803     const_cast<SvxMSDffHandle*>(mso_sptRightBraceHandle), SAL_N_ELEMENTS( mso_sptRightBraceHandle )      // handles
3804 };
3805
3806 const SvxMSDffVertPair mso_sptIrregularSeal1Vert[] =
3807 {
3808     { 10901, 5905 }, { 8458, 2399 }, { 7417, 6425 }, { 476, 2399 },
3809     { 4732, 7722 }, { 106, 8718 }, { 3828, 11880 }, { 243, 14689 },
3810     { 5772, 14041 }, { 4868, 17719 }, { 7819, 15730 }, { 8590, 21600 },
3811     { 10637, 15038 }, { 13349, 19840 }, { 14125, 14561 }, { 18248, 18195 },
3812     { 16938, 13044 }, { 21600, 13393 }, { 17710, 10579 }, { 21198, 8242 },
3813     { 16806, 7417 }, { 18482, 4560 }, { 14257, 5429 }, { 14623, 106 }, { 10901, 5905 }
3814 };
3815 const SvxMSDffTextRectangles mso_sptIrregularSeal1TextRect[] =
3816 {
3817     { { 4680, 6570 }, { 16140, 13280 } }
3818 };
3819 const SvxMSDffVertPair mso_sptIrregularSeal1GluePoints[] =
3820 {
3821     { 14623, 106 }, { 106, 8718 }, { 8590, 21600 }, { 21600, 13393 }
3822 };
3823 const mso_CustomShape msoIrregularSeal1 =
3824 {
3825     const_cast<SvxMSDffVertPair*>(mso_sptIrregularSeal1Vert), SAL_N_ELEMENTS( mso_sptIrregularSeal1Vert ),
3826     nullptr, 0,
3827     nullptr, 0,
3828     nullptr,
3829     const_cast<SvxMSDffTextRectangles*>(mso_sptIrregularSeal1TextRect), SAL_N_ELEMENTS( mso_sptIrregularSeal1TextRect ),
3830     21600, 21600,
3831     MIN_INT32, MIN_INT32,
3832     const_cast<SvxMSDffVertPair*>(mso_sptIrregularSeal1GluePoints), SAL_N_ELEMENTS( mso_sptIrregularSeal1GluePoints ),
3833     nullptr, 0     // handles
3834 };
3835
3836 const SvxMSDffVertPair mso_sptIrregularSeal2Vert[] =
3837 {
3838     { 11464, 4340 }, { 9722, 1887 }, { 8548, 6383 }, { 4503, 3626 },
3839     { 5373, 7816 }, { 1174, 8270 }, { 3934, 11592 }, { 0, 12875 },
3840     { 3329, 15372 }, { 1283, 17824 }, { 4804, 18239 }, { 4918, 21600 },
3841     { 7525, 18125 }, { 8698, 19712 }, { 9871, 17371 }, { 11614, 18844 },
3842     { 12178, 15937 }, { 14943, 17371 }, { 14640, 14348 }, { 18878, 15632 },
3843     { 16382, 12311 }, { 18270, 11292 }, { 16986, 9404 }, { 21600, 6646 },
3844     { 16382, 6533 }, { 18005, 3172 }, { 14524, 5778 }, { 14789, 0 },
3845     { 11464, 4340 }
3846 };
3847 const SvxMSDffTextRectangles mso_sptIrregularSeal2TextRect[] =
3848 {
3849     { { 5400, 6570 }, { 14160, 15290 } }
3850 };
3851 const SvxMSDffVertPair mso_sptIrregularSeal2GluePoints[] =
3852 {
3853     { 9722, 1887 }, { 0, 12875 }, { 11614, 18844 }, { 21600, 6646 }
3854 };
3855 const mso_CustomShape msoIrregularSeal2 =
3856 {
3857     const_cast<SvxMSDffVertPair*>(mso_sptIrregularSeal2Vert), SAL_N_ELEMENTS( mso_sptIrregularSeal2Vert ),
3858     nullptr, 0,
3859     nullptr, 0,
3860     nullptr,
3861     const_cast<SvxMSDffTextRectangles*>(mso_sptIrregularSeal2TextRect), SAL_N_ELEMENTS( mso_sptIrregularSeal2TextRect ),
3862     21600, 21600,
3863     MIN_INT32, MIN_INT32,
3864     const_cast<SvxMSDffVertPair*>(mso_sptIrregularSeal2GluePoints), SAL_N_ELEMENTS( mso_sptIrregularSeal2GluePoints ),
3865     nullptr, 0     // handles
3866 };
3867
3868 const SvxMSDffVertPair mso_sptSeal4Vert[] =      // adjustment1 : 0 - 10800
3869 {
3870     { 0, 10800 }, { 4 MSO_I, 4 MSO_I }, { 10800, 0 }, { 3 MSO_I, 4 MSO_I },
3871     { 21600, 10800 }, { 3 MSO_I, 3 MSO_I }, { 10800, 21600 }, { 4 MSO_I, 3 MSO_I },
3872     { 0, 10800 }
3873 };
3874 const SvxMSDffCalculationData mso_sptSeal4Calc[] =
3875 {
3876     { 0x0000, { 7600, 0, 0 } },
3877     { 0x6001, { 0x400, DFF_Prop_adjustValue, 10800 } },
3878     { 0xa000, { 0x400, 0, 0x401 } },
3879     { 0x4000, { 10800, 0x402, 0 } },
3880     { 0x8000, { 10800, 0, 0x402 } }
3881 };
3882 const SvxMSDffTextRectangles mso_sptSeal4TextRect[] =
3883 {
3884     { { 4 MSO_I, 4 MSO_I }, { 3 MSO_I, 3 MSO_I } }
3885 };
3886 const SvxMSDffHandle mso_sptSealHandle[] =
3887 {
3888     {   SvxMSDffHandleFlags::RANGE,
3889         0x100, 10800, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
3890 };
3891 const mso_CustomShape msoSeal4 =
3892 {
3893     const_cast<SvxMSDffVertPair*>(mso_sptSeal4Vert), SAL_N_ELEMENTS( mso_sptSeal4Vert ),
3894     nullptr, 0,
3895     const_cast<SvxMSDffCalculationData*>(mso_sptSeal4Calc), SAL_N_ELEMENTS( mso_sptSeal4Calc ),
3896     const_cast<sal_Int32*>(mso_sptDefault8100),
3897     const_cast<SvxMSDffTextRectangles*>(mso_sptSeal4TextRect), SAL_N_ELEMENTS( mso_sptSeal4TextRect ),
3898     21600, 21600,
3899     MIN_INT32, MIN_INT32,
3900     nullptr, 0,
3901     const_cast<SvxMSDffHandle*>(mso_sptSealHandle), SAL_N_ELEMENTS( mso_sptSealHandle )      // handles
3902 };
3903
3904 const SvxMSDffVertPair mso_sptStarVert[] =
3905 {
3906     { 10797, 0 }, { 8278, 8256 }, { 0, 8256 }, { 6722, 13405 },
3907     { 4198, 21600 }, { 10797, 16580 }, { 17401, 21600 }, { 14878, 13405 },
3908     { 21600, 8256 }, { 13321, 8256 }, { 10797, 0 }
3909 };
3910 const SvxMSDffTextRectangles mso_sptStarTextRect[] =
3911 {
3912     { { 6722, 8256 }, { 14878, 15460 } }
3913 };
3914 const mso_CustomShape msoStar =
3915 {
3916     const_cast<SvxMSDffVertPair*>(mso_sptStarVert), SAL_N_ELEMENTS( mso_sptStarVert ),
3917     nullptr, 0,
3918     nullptr, 0,
3919     nullptr,
3920     const_cast<SvxMSDffTextRectangles*>(mso_sptStarTextRect), SAL_N_ELEMENTS( mso_sptStarTextRect ),
3921     21600, 21600,
3922     MIN_INT32, MIN_INT32,
3923     nullptr, 0,
3924     nullptr, 0     // handles
3925 };
3926
3927 const SvxMSDffCalculationData mso_sptSeal24Calc[] =
3928 {
3929     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },     // 0x00
3930     { 0x2081, { 0x400, 10800, 315 } },              // 0x01 ( textframe )
3931     { 0x2082, { 0x400, 10800, 315 } },              // 0x02
3932     { 0x2081, { 0x400, 10800, 135 } },              // 0x03
3933     { 0x2082, { 0x400, 10800, 135 } },              // 0x04
3934     { 0x0081, { 0,   10800, 0 } },
3935     { 0x0082, { 0,   10800, 0 } },
3936     { 0x2081, { 0x400, 10800, 7 } },
3937     { 0x2082, { 0x400, 10800, 7 } },
3938     { 0x0081, { 0,   10800, 15 } },
3939     { 0x0082, { 0,   10800, 15 } },
3940     { 0x2081, { 0x400, 10800, 22 } },
3941     { 0x2082, { 0x400, 10800, 22 } },
3942     { 0x0081, { 0,   10800, 30 } },
3943     { 0x0082, { 0,   10800, 30 } },
3944     { 0x2081, { 0x400, 10800, 37 } },
3945     { 0x2082, { 0x400, 10800, 37 } },
3946     { 0x0081, { 0,   10800, 45 } },
3947     { 0x0082, { 0,   10800, 45 } },
3948     { 0x2081, { 0x400, 10800, 52 } },
3949     { 0x2082, { 0x400, 10800, 52 } },
3950     { 0x0081, { 0,   10800, 60 } },
3951     { 0x0082, { 0,   10800, 60 } },
3952     { 0x2081, { 0x400, 10800, 67 } },
3953     { 0x2082, { 0x400, 10800, 67 } },
3954     { 0x0081, { 0,   10800, 75 } },
3955     { 0x0082, { 0,   10800, 75 } },
3956     { 0x2081, { 0x400, 10800, 82 } },
3957     { 0x2082, { 0x400, 10800, 82 } },
3958     { 0x0081, { 0,   10800, 90 } },
3959     { 0x0082, { 0,   10800, 90 } },
3960     { 0x2081, { 0x400, 10800, 97 } },
3961     { 0x2082, { 0x400, 10800, 97 } },
3962     { 0x0081, { 0,   10800, 105 } },
3963     { 0x0082, { 0,   10800, 105 } },
3964     { 0x2081, { 0x400, 10800, 112 } },
3965     { 0x2082, { 0x400, 10800, 112 } },
3966     { 0x0081, { 0,   10800, 120 } },
3967     { 0x0082, { 0,   10800, 120 } },
3968     { 0x2081, { 0x400, 10800, 127 } },
3969     { 0x2082, { 0x400, 10800, 127 } },
3970     { 0x0081, { 0,   10800, 135 } },
3971     { 0x0082, { 0,   10800, 135 } },
3972     { 0x2081, { 0x400, 10800, 142 } },
3973     { 0x2082, { 0x400, 10800, 142 } },
3974     { 0x0081, { 0,   10800, 150 } },
3975     { 0x0082, { 0,   10800, 150 } },
3976     { 0x2081, { 0x400, 10800, 157 } },
3977     { 0x2082, { 0x400, 10800, 157 } },
3978     { 0x0081, { 0,   10800, 165 } },
3979     { 0x0082, { 0,   10800, 165 } },
3980     { 0x2081, { 0x400, 10800, 172 } },
3981     { 0x2082, { 0x400, 10800, 172 } },
3982     { 0x0081, { 0,   10800, 180 } },
3983     { 0x0082, { 0,   10800, 180 } },
3984     { 0x2081, { 0x400, 10800, 187 } },
3985     { 0x2082, { 0x400, 10800, 187 } },
3986     { 0x0081, { 0,   10800, 195 } },
3987     { 0x0082, { 0,   10800, 195 } },
3988     { 0x2081, { 0x400, 10800, 202 } },
3989     { 0x2082, { 0x400, 10800, 202 } },
3990     { 0x0081, { 0,   10800, 210 } },
3991     { 0x0082, { 0,   10800, 210 } },
3992     { 0x2081, { 0x400, 10800, 217 } },
3993     { 0x2082, { 0x400, 10800, 217 } },
3994     { 0x0081, { 0,   10800, 225 } },
3995     { 0x0082, { 0,   10800, 225 } },
3996     { 0x2081, { 0x400, 10800, 232 } },
3997     { 0x2082, { 0x400, 10800, 232 } },
3998     { 0x0081, { 0,   10800, 240 } },
3999     { 0x0082, { 0,   10800, 240 } },
4000     { 0x2081, { 0x400, 10800, 247 } },
4001     { 0x2082, { 0x400, 10800, 247 } },
4002     { 0x0081, { 0,   10800, 255 } },
4003     { 0x0082, { 0,   10800, 255 } },
4004     { 0x2081, { 0x400, 10800, 262 } },
4005     { 0x2082, { 0x400, 10800, 262 } },
4006     { 0x0081, { 0,   10800, 270 } },
4007     { 0x0082, { 0,   10800, 270 } },
4008     { 0x2081, { 0x400, 10800, 277 } },
4009     { 0x2082, { 0x400, 10800, 277 } },
4010     { 0x0081, { 0,   10800, 285 } },
4011     { 0x0082, { 0,   10800, 285 } },
4012     { 0x2081, { 0x400, 10800, 292 } },
4013     { 0x2082, { 0x400, 10800, 292 } },
4014     { 0x0081, { 0,   10800, 300 } },
4015     { 0x0082, { 0,   10800, 300 } },
4016     { 0x2081, { 0x400, 10800, 307 } },
4017     { 0x2082, { 0x400, 10800, 307 } },
4018     { 0x0081, { 0,   10800, 315 } },
4019     { 0x0082, { 0,   10800, 315 } },
4020     { 0x2081, { 0x400, 10800, 322 } },
4021     { 0x2082, { 0x400, 10800, 322 } },
4022     { 0x0081, { 0,   10800, 330 } },
4023     { 0x0082, { 0,   10800, 330 } },
4024     { 0x2081, { 0x400, 10800, 337 } },
4025     { 0x2082, { 0x400, 10800, 337 } },
4026     { 0x0081, { 0,   10800, 345 } },
4027     { 0x0082, { 0,   10800, 345 } },
4028     { 0x2081, { 0x400, 10800, 352 } },
4029     { 0x2082, { 0x400, 10800, 352 } }
4030 };
4031 const SvxMSDffVertPair mso_sptSeal8Vert[] =  // adj value 0 -> 10800
4032 {
4033     { 5 MSO_I, 6 MSO_I }, { 11 MSO_I, 12 MSO_I }, { 17 MSO_I, 18 MSO_I }, { 23 MSO_I, 24 MSO_I },
4034     { 29 MSO_I, 30 MSO_I }, { 35 MSO_I, 36 MSO_I }, { 41 MSO_I, 42 MSO_I }, { 47 MSO_I, 48 MSO_I },
4035     { 53 MSO_I, 54 MSO_I }, { 59 MSO_I, 60 MSO_I }, { 65 MSO_I, 66 MSO_I }, { 71 MSO_I, 72 MSO_I },
4036     { 77 MSO_I, 78 MSO_I }, { 83 MSO_I, 84 MSO_I }, { 89 MSO_I, 90 MSO_I }, { 95 MSO_I, 96 MSO_I },
4037     { 5 MSO_I, 6 MSO_I }
4038 };
4039 const SvxMSDffTextRectangles mso_sptSealTextRect[] =
4040 {
4041     { { 1 MSO_I, 2 MSO_I }, { 3 MSO_I, 4 MSO_I } }
4042 };
4043 const mso_CustomShape msoSeal8 =
4044 {
4045     const_cast<SvxMSDffVertPair*>(mso_sptSeal8Vert), SAL_N_ELEMENTS( mso_sptSeal8Vert ),
4046     nullptr, 0,
4047     const_cast<SvxMSDffCalculationData*>(mso_sptSeal24Calc), SAL_N_ELEMENTS( mso_sptSeal24Calc ),
4048     const_cast<sal_Int32*>(mso_sptDefault2500),
4049     const_cast<SvxMSDffTextRectangles*>(mso_sptSealTextRect), SAL_N_ELEMENTS( mso_sptSealTextRect ),
4050     21600, 21600,
4051     MIN_INT32, MIN_INT32,
4052     nullptr, 0,
4053     const_cast<SvxMSDffHandle*>(mso_sptSealHandle), SAL_N_ELEMENTS( mso_sptSealHandle )      // handles
4054 };
4055 const SvxMSDffVertPair mso_sptSeal16Vert[] = // adj value 0 -> 10800
4056 {
4057     { 0x05 MSO_I, 0x06 MSO_I }, { 0x07 MSO_I, 0x08 MSO_I }, { 0x09 MSO_I, 0x0a MSO_I }, { 0x0b MSO_I, 0x0c MSO_I },
4058     { 0x0d MSO_I, 0x0e MSO_I }, { 0x0f MSO_I, 0x10 MSO_I }, { 0x11 MSO_I, 0x12 MSO_I }, { 0x13 MSO_I, 0x14 MSO_I },
4059     { 0x15 MSO_I, 0x16 MSO_I }, { 0x17 MSO_I, 0x18 MSO_I }, { 0x19 MSO_I, 0x1a MSO_I }, { 0x1b MSO_I, 0x1c MSO_I },
4060     { 0x1d MSO_I, 0x1e MSO_I }, { 0x1f MSO_I, 0x20 MSO_I }, { 0x21 MSO_I, 0x22 MSO_I }, { 0x23 MSO_I, 0x24 MSO_I },
4061     { 0x25 MSO_I, 0x26 MSO_I }, { 0x27 MSO_I, 0x28 MSO_I }, { 0x29 MSO_I, 0x2a MSO_I }, { 0x2b MSO_I, 0x2c MSO_I },
4062     { 0x2d MSO_I, 0x2e MSO_I }, { 0x2f MSO_I, 0x30 MSO_I }, { 0x31 MSO_I, 0x32 MSO_I }, { 0x33 MSO_I, 0x34 MSO_I },
4063     { 0x35 MSO_I, 0x36 MSO_I }, { 0x37 MSO_I, 0x38 MSO_I }, { 0x39 MSO_I, 0x3a MSO_I }, { 0x3b MSO_I, 0x3c MSO_I },
4064     { 0x3d MSO_I, 0x3e MSO_I }, { 0x3f MSO_I, 0x40 MSO_I }, { 0x41 MSO_I, 0x42 MSO_I }, { 0x43 MSO_I, 0x44 MSO_I },
4065     { 0x05 MSO_I, 0x06 MSO_I }
4066 };
4067 const SvxMSDffCalculationData mso_sptSeal16Calc[] =
4068 {
4069     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },     // 0x00
4070     { 0x2081, { 0x400, 10800, 315 } },              // 0x01 ( textframe )
4071     { 0x2082, { 0x400, 10800, 315 } },              // 0x02
4072     { 0x2081, { 0x400, 10800, 135 } },              // 0x03
4073     { 0x2082, { 0x400, 10800, 135 } },              // 0x04
4074     { 0x0081, { 0,   10800, 0 } },
4075     { 0x0082, { 0,   10800, 0 } },
4076     { 0x2081, { 0x400, 10800, 11 } },
4077     { 0x2082, { 0x400, 10800, 11 } },
4078     { 0x0081, { 0,   10800, 22 } },
4079     { 0x0082, { 0,   10800, 22 } },
4080     { 0x2081, { 0x400, 10800, 33 } },
4081     { 0x2082, { 0x400, 10800, 33 } },
4082     { 0x0081, { 0,   10800, 45 } },
4083     { 0x0082, { 0,   10800, 45 } },
4084     { 0x2081, { 0x400, 10800, 56 } },
4085     { 0x2082, { 0x400, 10800, 56 } },
4086     { 0x0081, { 0,   10800, 67 } },
4087     { 0x0082, { 0,   10800, 67 } },
4088     { 0x2081, { 0x400, 10800, 78 } },
4089     { 0x2082, { 0x400, 10800, 78 } },
4090     { 0x0081, { 0,   10800, 90 } },
4091     { 0x0082, { 0,   10800, 90 } },
4092     { 0x2081, { 0x400, 10800, 101 } },
4093     { 0x2082, { 0x400, 10800, 101 } },
4094     { 0x0081, { 0,   10800, 112 } },
4095     { 0x0082, { 0,   10800, 112 } },
4096     { 0x2081, { 0x400, 10800, 123 } },
4097     { 0x2082, { 0x400, 10800, 123 } },
4098     { 0x0081, { 0,   10800, 135 } },
4099     { 0x0082, { 0,   10800, 135 } },
4100     { 0x2081, { 0x400, 10800, 146 } },
4101     { 0x2082, { 0x400, 10800, 146 } },
4102     { 0x0081, { 0,   10800, 157 } },
4103     { 0x0082, { 0,   10800, 157 } },
4104     { 0x2081, { 0x400, 10800, 168 } },
4105     { 0x2082, { 0x400, 10800, 168 } },
4106     { 0x0081, { 0,   10800, 180 } },
4107     { 0x0082, { 0,   10800, 180 } },
4108     { 0x2081, { 0x400, 10800, 191 } },
4109     { 0x2082, { 0x400, 10800, 191 } },
4110     { 0x0081, { 0,   10800, 202 } },
4111     { 0x0082, { 0,   10800, 202 } },
4112     { 0x2081, { 0x400, 10800, 213 } },
4113     { 0x2082, { 0x400, 10800, 213 } },
4114     { 0x0081, { 0,   10800, 225 } },
4115     { 0x0082, { 0,   10800, 225 } },
4116     { 0x2081, { 0x400, 10800, 236 } },
4117     { 0x2082, { 0x400, 10800, 236 } },
4118     { 0x0081, { 0,   10800, 247 } },
4119     { 0x0082, { 0,   10800, 247 } },
4120     { 0x2081, { 0x400, 10800, 258 } },
4121     { 0x2082, { 0x400, 10800, 258 } },
4122     { 0x0081, { 0,   10800, 270 } },
4123     { 0x0082, { 0,   10800, 270 } },
4124     { 0x2081, { 0x400, 10800, 281 } },
4125     { 0x2082, { 0x400, 10800, 281 } },
4126     { 0x0081, { 0,   10800, 292 } },
4127     { 0x0082, { 0,   10800, 292 } },
4128     { 0x2081, { 0x400, 10800, 303 } },
4129     { 0x2082, { 0x400, 10800, 303 } },
4130     { 0x0081, { 0,   10800, 315 } },
4131     { 0x0082, { 0,   10800, 315 } },
4132     { 0x2081, { 0x400, 10800, 326 } },
4133     { 0x2082, { 0x400, 10800, 326 } },
4134     { 0x0081, { 0,   10800, 337 } },
4135     { 0x0082, { 0,   10800, 337 } },
4136     { 0x2081, { 0x400, 10800, 348 } },
4137     { 0x2082, { 0x400, 10800, 348 } }
4138 };
4139 const mso_CustomShape msoSeal16 =
4140 {
4141     const_cast<SvxMSDffVertPair*>(mso_sptSeal16Vert), SAL_N_ELEMENTS( mso_sptSeal16Vert ),
4142     nullptr, 0,
4143     const_cast<SvxMSDffCalculationData*>(mso_sptSeal16Calc), SAL_N_ELEMENTS( mso_sptSeal16Calc ),
4144     const_cast<sal_Int32*>(mso_sptDefault2500),
4145     const_cast<SvxMSDffTextRectangles*>(mso_sptSealTextRect), SAL_N_ELEMENTS( mso_sptSealTextRect ),
4146     21600, 21600,
4147     MIN_INT32, MIN_INT32,
4148     nullptr, 0,
4149     const_cast<SvxMSDffHandle*>(mso_sptSealHandle), SAL_N_ELEMENTS( mso_sptSealHandle )      // handles
4150 };
4151 const SvxMSDffVertPair mso_sptSeal24Vert[] =
4152 {
4153     { 0x05 MSO_I, 0x06 MSO_I }, { 0x07 MSO_I, 0x08 MSO_I }, { 0x09 MSO_I, 0x0a MSO_I }, { 0x0b MSO_I, 0x0c MSO_I },
4154     { 0x0d MSO_I, 0x0e MSO_I }, { 0x0f MSO_I, 0x10 MSO_I }, { 0x11 MSO_I, 0x12 MSO_I }, { 0x13 MSO_I, 0x14 MSO_I },
4155     { 0x15 MSO_I, 0x16 MSO_I }, { 0x17 MSO_I, 0x18 MSO_I }, { 0x19 MSO_I, 0x1a MSO_I }, { 0x1b MSO_I, 0x1c MSO_I },
4156     { 0x1d MSO_I, 0x1e MSO_I }, { 0x1f MSO_I, 0x20 MSO_I }, { 0x21 MSO_I, 0x22 MSO_I }, { 0x23 MSO_I, 0x24 MSO_I },
4157     { 0x25 MSO_I, 0x26 MSO_I }, { 0x27 MSO_I, 0x28 MSO_I }, { 0x29 MSO_I, 0x2a MSO_I }, { 0x2b MSO_I, 0x2c MSO_I },
4158     { 0x2d MSO_I, 0x2e MSO_I }, { 0x2f MSO_I, 0x30 MSO_I }, { 0x31 MSO_I, 0x32 MSO_I }, { 0x33 MSO_I, 0x34 MSO_I },
4159     { 0x35 MSO_I, 0x36 MSO_I }, { 0x37 MSO_I, 0x38 MSO_I }, { 0x39 MSO_I, 0x3a MSO_I }, { 0x3b MSO_I, 0x3c MSO_I },
4160     { 0x3d MSO_I, 0x3e MSO_I }, { 0x3f MSO_I, 0x40 MSO_I }, { 0x41 MSO_I, 0x42 MSO_I }, { 0x43 MSO_I, 0x44 MSO_I },
4161     { 0x45 MSO_I, 0x46 MSO_I }, { 0x47 MSO_I, 0x48 MSO_I }, { 0x49 MSO_I, 0x4a MSO_I }, { 0x4b MSO_I, 0x4c MSO_I },
4162     { 0x4d MSO_I, 0x4e MSO_I }, { 0x4f MSO_I, 0x50 MSO_I }, { 0x51 MSO_I, 0x52 MSO_I }, { 0x53 MSO_I, 0x54 MSO_I },
4163     { 0x55 MSO_I, 0x56 MSO_I }, { 0x57 MSO_I, 0x58 MSO_I }, { 0x59 MSO_I, 0x5a MSO_I }, { 0x5b MSO_I, 0x5c MSO_I },
4164     { 0x5d MSO_I, 0x5e MSO_I }, { 0x5f MSO_I, 0x60 MSO_I }, { 0x61 MSO_I, 0x62 MSO_I }, { 0x63 MSO_I, 0x64 MSO_I },
4165     { 0x05 MSO_I, 0x06 MSO_I }
4166 };
4167 const mso_CustomShape msoSeal24 =
4168 {
4169     const_cast<SvxMSDffVertPair*>(mso_sptSeal24Vert), SAL_N_ELEMENTS( mso_sptSeal24Vert ),
4170     nullptr, 0,
4171     const_cast<SvxMSDffCalculationData*>(mso_sptSeal24Calc), SAL_N_ELEMENTS( mso_sptSeal24Calc ),
4172     const_cast<sal_Int32*>(mso_sptDefault2500),
4173     const_cast<SvxMSDffTextRectangles*>(mso_sptSealTextRect), SAL_N_ELEMENTS( mso_sptSealTextRect ),
4174     21600, 21600,
4175     MIN_INT32, MIN_INT32,
4176     nullptr, 0,
4177     const_cast<SvxMSDffHandle*>(mso_sptSealHandle), SAL_N_ELEMENTS( mso_sptSealHandle )      // handles
4178 };
4179 const SvxMSDffCalculationData mso_sptSeal32Calc[] =
4180 {
4181     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },     // 0x00
4182     { 0x2081, { 0x400, 10800, 315 } },              // 0x01 ( textframe )
4183     { 0x2082, { 0x400, 10800, 315 } },              // 0x02
4184     { 0x2081, { 0x400, 10800, 135 } },              // 0x03
4185     { 0x2082, { 0x400, 10800, 135 } },              // 0x04
4186     { 0x0081, { 0,   10800, 0 } },
4187     { 0x0082, { 0,   10800, 0 } },
4188     { 0x2081, { 0x400, 10800, 5 } },
4189     { 0x2082, { 0x400, 10800, 5 } },
4190     { 0x0081, { 0,   10800, 11 } },
4191     { 0x0082, { 0,   10800, 11 } },
4192     { 0x2081, { 0x400, 10800, 16 } },
4193     { 0x2082, { 0x400, 10800, 16 } },
4194     { 0x0081, { 0,   10800, 22 } },
4195     { 0x0082, { 0,   10800, 22 } },
4196     { 0x2081, { 0x400, 10800, 28 } },
4197     { 0x2082, { 0x400, 10800, 28 } },
4198     { 0x0081, { 0,   10800, 33 } },
4199     { 0x0082, { 0,   10800, 33 } },
4200     { 0x2081, { 0x400, 10800, 39 } },
4201     { 0x2082, { 0x400, 10800, 39 } },
4202     { 0x0081, { 0,   10800, 45 } },
4203     { 0x0082, { 0,   10800, 45 } },
4204     { 0x2081, { 0x400, 10800, 50 } },
4205     { 0x2082, { 0x400, 10800, 50 } },
4206     { 0x0081, { 0,   10800, 56 } },
4207     { 0x0082, { 0,   10800, 56 } },
4208     { 0x2081, { 0x400, 10800, 61 } },
4209     { 0x2082, { 0x400, 10800, 61 } },
4210     { 0x0081, { 0,   10800, 67 } },
4211     { 0x0082, { 0,   10800, 67 } },
4212     { 0x2081, { 0x400, 10800, 73 } },
4213     { 0x2082, { 0x400, 10800, 73 } },
4214     { 0x0081, { 0,   10800, 78 } },
4215     { 0x0082, { 0,   10800, 78 } },
4216     { 0x2081, { 0x400, 10800, 84 } },
4217     { 0x2082, { 0x400, 10800, 84 } },
4218     { 0x0081, { 0,   10800, 90 } },
4219     { 0x0082, { 0,   10800, 90 } },
4220     { 0x2081, { 0x400, 10800, 95 } },
4221     { 0x2082, { 0x400, 10800, 95 } },
4222     { 0x0081, { 0,   10800, 101 } },
4223     { 0x0082, { 0,   10800, 101 } },
4224     { 0x2081, { 0x400, 10800, 106 } },
4225     { 0x2082, { 0x400, 10800, 106 } },
4226     { 0x0081, { 0,   10800, 112 } },
4227     { 0x0082, { 0,   10800, 112 } },
4228     { 0x2081, { 0x400, 10800, 118 } },
4229     { 0x2082, { 0x400, 10800, 118 } },
4230     { 0x0081, { 0,   10800, 123 } },
4231     { 0x0082, { 0,   10800, 123 } },
4232     { 0x2081, { 0x400, 10800, 129 } },
4233     { 0x2082, { 0x400, 10800, 129 } },
4234     { 0x0081, { 0,   10800, 135 } },
4235     { 0x0082, { 0,   10800, 135 } },
4236     { 0x2081, { 0x400, 10800, 140 } },
4237     { 0x2082, { 0x400, 10800, 140 } },
4238     { 0x0081, { 0,   10800, 146 } },
4239     { 0x0082, { 0,   10800, 146 } },
4240     { 0x2081, { 0x400, 10800, 151 } },
4241     { 0x2082, { 0x400, 10800, 151 } },
4242     { 0x0081, { 0,   10800, 157 } },
4243     { 0x0082, { 0,   10800, 157 } },
4244     { 0x2081, { 0x400, 10800, 163 } },
4245     { 0x2082, { 0x400, 10800, 163 } },
4246     { 0x0081, { 0,   10800, 168 } },
4247     { 0x0082, { 0,   10800, 168 } },
4248     { 0x2081, { 0x400, 10800, 174 } },
4249     { 0x2082, { 0x400, 10800, 174 } },
4250     { 0x0081, { 0,   10800, 180 } },
4251     { 0x0082, { 0,   10800, 180 } },
4252     { 0x2081, { 0x400, 10800, 185 } },
4253     { 0x2082, { 0x400, 10800, 185 } },
4254     { 0x0081, { 0,   10800, 191 } },
4255     { 0x0082, { 0,   10800, 191 } },
4256     { 0x2081, { 0x400, 10800, 196 } },
4257     { 0x2082, { 0x400, 10800, 196 } },
4258     { 0x0081, { 0,   10800, 202 } },
4259     { 0x0082, { 0,   10800, 202 } },
4260     { 0x2081, { 0x400, 10800, 208 } },
4261     { 0x2082, { 0x400, 10800, 208 } },
4262     { 0x0081, { 0,   10800, 213 } },
4263     { 0x0082, { 0,   10800, 213 } },
4264     { 0x2081, { 0x400, 10800, 219 } },
4265     { 0x2082, { 0x400, 10800, 219 } },
4266     { 0x0081, { 0,   10800, 225 } },
4267     { 0x0082, { 0,   10800, 225 } },
4268     { 0x2081, { 0x400, 10800, 230 } },
4269     { 0x2082, { 0x400, 10800, 230 } },
4270     { 0x0081, { 0,   10800, 236 } },
4271     { 0x0082, { 0,   10800, 236 } },
4272     { 0x2081, { 0x400, 10800, 241 } },
4273     { 0x2082, { 0x400, 10800, 241 } },
4274     { 0x0081, { 0,   10800, 247 } },
4275     { 0x0082, { 0,   10800, 247 } },
4276     { 0x2081, { 0x400, 10800, 253 } },
4277     { 0x2082, { 0x400, 10800, 253 } },
4278     { 0x0081, { 0,   10800, 258 } },
4279     { 0x0082, { 0,   10800, 258 } },
4280     { 0x2081, { 0x400, 10800, 264 } },
4281     { 0x2082, { 0x400, 10800, 264 } },
4282     { 0x0081, { 0,   10800, 270 } },
4283     { 0x0082, { 0,   10800, 270 } },
4284     { 0x2081, { 0x400, 10800, 275 } },
4285     { 0x2082, { 0x400, 10800, 275 } },
4286     { 0x0081, { 0,   10800, 281 } },
4287     { 0x0082, { 0,   10800, 281 } },
4288     { 0x2081, { 0x400, 10800, 286 } },
4289     { 0x2082, { 0x400, 10800, 286 } },
4290     { 0x0081, { 0,   10800, 292 } },
4291     { 0x0082, { 0,   10800, 292 } },
4292     { 0x2081, { 0x400, 10800, 298 } },
4293     { 0x2082, { 0x400, 10800, 298 } },
4294     { 0x0081, { 0,   10800, 303 } },
4295     { 0x0082, { 0,   10800, 303 } },
4296     { 0x2081, { 0x400, 10800, 309 } },
4297     { 0x2082, { 0x400, 10800, 309 } },
4298     { 0x0081, { 0,   10800, 315 } },
4299     { 0x0082, { 0,   10800, 315 } },
4300     { 0x2081, { 0x400, 10800, 320 } },
4301     { 0x2082, { 0x400, 10800, 320 } },
4302     { 0x0081, { 0,   10800, 326 } },
4303     { 0x0082, { 0,   10800, 326 } },
4304     { 0x2081, { 0x400, 10800, 331 } },
4305     { 0x2082, { 0x400, 10800, 331 } },
4306     { 0x0081, { 0,   10800, 337 } },
4307     { 0x0082, { 0,   10800, 337 } },
4308     { 0x2081, { 0x400, 10800, 343 } },
4309     { 0x2082, { 0x400, 10800, 343 } },
4310     { 0x0081, { 0,   10800, 348 } },
4311     { 0x0082, { 0,   10800, 348 } },
4312     { 0x2081, { 0x400, 10800, 354 } },
4313     { 0x2082, { 0x400, 10800, 354 } }
4314 };
4315 const SvxMSDffVertPair mso_sptSeal32Vert[] =
4316 {
4317     { 0x05 MSO_I, 0x06 MSO_I }, { 0x07 MSO_I, 0x08 MSO_I }, { 0x09 MSO_I, 0x0a MSO_I }, { 0x0b MSO_I, 0x0c MSO_I },
4318     { 0x0d MSO_I, 0x0e MSO_I }, { 0x0f MSO_I, 0x10 MSO_I }, { 0x11 MSO_I, 0x12 MSO_I }, { 0x13 MSO_I, 0x14 MSO_I },
4319     { 0x15 MSO_I, 0x16 MSO_I }, { 0x17 MSO_I, 0x18 MSO_I }, { 0x19 MSO_I, 0x1a MSO_I }, { 0x1b MSO_I, 0x1c MSO_I },
4320     { 0x1d MSO_I, 0x1e MSO_I }, { 0x1f MSO_I, 0x20 MSO_I }, { 0x21 MSO_I, 0x22 MSO_I }, { 0x23 MSO_I, 0x24 MSO_I },
4321     { 0x25 MSO_I, 0x26 MSO_I }, { 0x27 MSO_I, 0x28 MSO_I }, { 0x29 MSO_I, 0x2a MSO_I }, { 0x2b MSO_I, 0x2c MSO_I },
4322     { 0x2d MSO_I, 0x2e MSO_I }, { 0x2f MSO_I, 0x30 MSO_I }, { 0x31 MSO_I, 0x32 MSO_I }, { 0x33 MSO_I, 0x34 MSO_I },
4323     { 0x35 MSO_I, 0x36 MSO_I }, { 0x37 MSO_I, 0x38 MSO_I }, { 0x39 MSO_I, 0x3a MSO_I }, { 0x3b MSO_I, 0x3c MSO_I },
4324     { 0x3d MSO_I, 0x3e MSO_I }, { 0x3f MSO_I, 0x40 MSO_I }, { 0x41 MSO_I, 0x42 MSO_I }, { 0x43 MSO_I, 0x44 MSO_I },
4325     { 0x45 MSO_I, 0x46 MSO_I }, { 0x47 MSO_I, 0x48 MSO_I }, { 0x49 MSO_I, 0x4a MSO_I }, { 0x4b MSO_I, 0x4c MSO_I },
4326     { 0x4d MSO_I, 0x4e MSO_I }, { 0x4f MSO_I, 0x50 MSO_I }, { 0x51 MSO_I, 0x52 MSO_I }, { 0x53 MSO_I, 0x54 MSO_I },
4327     { 0x55 MSO_I, 0x56 MSO_I }, { 0x57 MSO_I, 0x58 MSO_I }, { 0x59 MSO_I, 0x5a MSO_I }, { 0x5b MSO_I, 0x5c MSO_I },
4328     { 0x5d MSO_I, 0x5e MSO_I }, { 0x5f MSO_I, 0x60 MSO_I }, { 0x61 MSO_I, 0x62 MSO_I }, { 0x63 MSO_I, 0x64 MSO_I },
4329     { 0x65 MSO_I, 0x66 MSO_I }, { 0x67 MSO_I, 0x68 MSO_I }, { 0x69 MSO_I, 0x6a MSO_I }, { 0x6b MSO_I, 0x6c MSO_I },
4330     { 0x6d MSO_I, 0x6e MSO_I }, { 0x6f MSO_I, 0x70 MSO_I }, { 0x71 MSO_I, 0x72 MSO_I }, { 0x73 MSO_I, 0x74 MSO_I },
4331     { 0x75 MSO_I, 0x76 MSO_I }, { 0x77 MSO_I, 0x78 MSO_I }, { 0x79 MSO_I, 0x7a MSO_I }, { 0x7b MSO_I, 0x7c MSO_I },
4332     { 0x7d MSO_I, 0x7e MSO_I }, { 0x7f MSO_I, 0x80 MSO_I }, { 0x81 MSO_I, 0x82 MSO_I }, { 0x83 MSO_I, 0x84 MSO_I },
4333     { 0x05 MSO_I, 0x06 MSO_I }
4334 };
4335 const mso_CustomShape msoSeal32 =
4336 {
4337     const_cast<SvxMSDffVertPair*>(mso_sptSeal32Vert), SAL_N_ELEMENTS( mso_sptSeal32Vert ),
4338     nullptr, 0,
4339     const_cast<SvxMSDffCalculationData*>(mso_sptSeal32Calc), SAL_N_ELEMENTS( mso_sptSeal32Calc ),
4340     const_cast<sal_Int32*>(mso_sptDefault2500),
4341     const_cast<SvxMSDffTextRectangles*>(mso_sptSealTextRect), SAL_N_ELEMENTS( mso_sptSealTextRect ),
4342     21600, 21600,
4343     MIN_INT32, MIN_INT32,
4344     nullptr, 0,
4345     const_cast<SvxMSDffHandle*>(mso_sptSealHandle), SAL_N_ELEMENTS( mso_sptSealHandle )
4346 };
4347
4348 const SvxMSDffVertPair mso_sptRibbon2Vert[] =    // adjustment1 : x 2700  - 8100     def 5400
4349 {                                                       // adjustment2 : y 14400 - 21600    def 18900
4350     { 12 MSO_I, 1 MSO_I }, { 12 MSO_I, 13 MSO_I },                                      // pp
4351     { 12 MSO_I, 14 MSO_I }, { 15 MSO_I, 21600 }, { 16 MSO_I, 21600 },                   // ccp
4352     { 0, 21600 }, { 2750, 7 MSO_I }, { 0, 2 MSO_I }, { 0 MSO_I, 2 MSO_I },              // pppp
4353     { 0 MSO_I, 4 MSO_I },                                                               // p
4354     { 0 MSO_I, 5 MSO_I }, { 10 MSO_I, 0 }, { 11 MSO_I, 0 },                             // ccp
4355     { 17 MSO_I, 0 },                                                                    // p
4356     { 18 MSO_I, 0 }, { 19 MSO_I, 5 MSO_I }, { 19 MSO_I, 4 MSO_I },                      // ccp
4357     { 19 MSO_I, 2 MSO_I }, { 21600, 2 MSO_I }, { 18850, 7 MSO_I }, { 21600, 21600 },    // pppp
4358     { 20 MSO_I, 21600 },                                                                // p
4359     { 21 MSO_I, 21600 }, { 22 MSO_I, 14 MSO_I }, { 22 MSO_I, 13 MSO_I },                // ccp
4360     { 22 MSO_I, 1 MSO_I }, { 12 MSO_I, 1 MSO_I }, { 12 MSO_I, 13 MSO_I },               // ppp
4361     { 12 MSO_I, 23 MSO_I }, { 15 MSO_I, 24 MSO_I }, { 16 MSO_I, 24 MSO_I },             // ccp
4362     { 11 MSO_I, 24 MSO_I },                                                             // p
4363     { 10 MSO_I, 24 MSO_I }, { 0 MSO_I, 26 MSO_I }, { 0 MSO_I, 25 MSO_I },               // ccp
4364     { 0 MSO_I, 27 MSO_I }, { 10 MSO_I, 1 MSO_I }, { 11 MSO_I, 1 MSO_I },                // ccp
4365
4366     { 22 MSO_I, 1 MSO_I }, { 22 MSO_I, 13 MSO_I },                                      // pp
4367     { 22 MSO_I, 23 MSO_I }, { 21 MSO_I, 24 MSO_I }, { 20 MSO_I, 24 MSO_I },             // ccp
4368     { 17 MSO_I, 24 MSO_I },                                                             // p
4369     { 18 MSO_I, 24 MSO_I }, { 19 MSO_I, 26 MSO_I }, { 19 MSO_I, 25 MSO_I },             // ccp
4370     { 19 MSO_I, 27 MSO_I }, { 18 MSO_I, 1 MSO_I }, { 17 MSO_I, 1 MSO_I },               // ccp
4371
4372     { 0 MSO_I, 25 MSO_I }, { 0 MSO_I, 2 MSO_I },                                        // pp
4373
4374     { 19 MSO_I, 25 MSO_I }, { 19 MSO_I, 2 MSO_I }                                       // pp
4375 };
4376 const sal_uInt16 mso_sptRibbon2Segm[] =
4377 {
4378     0x4000, 0x0001, 0x2001, 0x0005, 0x2001, 0x0001, 0x2001, 0x0005, 0x2001, 0x0001, 0x6001, 0x8000,
4379     0x4000, 0x0001, 0x2001, 0x0001, 0x2002, 0x6001, 0x8000,
4380     0x4000, 0x0001, 0x2001, 0x0001, 0x2002, 0x6001, 0x8000,
4381     0x4000, 0x0001, 0x8000,
4382     0x4000, 0x0001, 0x8000
4383 };
4384 const SvxMSDffCalculationData mso_sptRibbon2Calc[] =
4385 {
4386     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },             // 00
4387     { 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },            // 01
4388     { 0x8000, { 21600, 0, 0x401 } },                        // 02
4389     { 0x2001, { 0x402, 1, 2 } },                            // 03
4390     { 0x2001, { 0x403, 1, 2 } },                            // 04
4391     { 0x2001, { 0x404, 1, 2 } },                            // 05
4392     { 0x2001, { 0x401, 1, 2 } },                            // 06
4393     { 0x8000, { 21600, 0, 0x406 } },                        // 07
4394     { 0x0000, { 420, 0, 0 } },                              // 08
4395     { 0x2001, { 0x408, 2, 1 } },                            // 09
4396     { 0x6000, { 0x400, 0x408, 0 } },                        // 10
4397     { 0x6000, { 0x400, 0x409, 0 } },                        // 11
4398     { 0x2000, { 0x400, 2700, 0 } },                         // 12
4399     { 0x8000, { 21600, 0, 0x404 } },                        // 13
4400     { 0x8000, { 21600, 0, 0x405 } },                        // 14
4401     { 0xa000, { 0x40c, 0, 0x408 } },                        // 15
4402     { 0xa000, { 0x40c, 0, 0x409 } },                        // 16
4403
4404     { 0x8000, { 21600, 0, 0x40b } },                        // 17
4405     { 0x8000, { 21600, 0, 0x40a } },                        // 18
4406     { 0x8000, { 21600, 0, 0x400 } },                        // 19
4407     { 0x8000, { 21600, 0, 0x410 } },                        // 20
4408     { 0x8000, { 21600, 0, 0x40f } },                        // 21
4409     { 0x8000, { 21600, 0, 0x40c } },                        // 22
4410
4411     { 0xa000, { 0x40d, 0, 0x405 } },                        // 23
4412     { 0x6000, { 0x401, 0x403, 0 } },                        // 24
4413     { 0x6000, { 0x401, 0x404, 0 } },                        // 25
4414     { 0x6000, { 0x419, 0x405, 0 } },                        // 26
4415     { 0xa000, { 0x419, 0, 0x405 } }                         // 27
4416 };
4417 const sal_Int32 mso_sptRibbon2Default[] =
4418 {
4419     2, 5400, 18900
4420 };
4421 const SvxMSDffTextRectangles mso_sptRibbon2TextRect[] =
4422 {
4423     { { 0 MSO_I, 0 }, { 19 MSO_I, 1 MSO_I } }
4424 };
4425 const SvxMSDffHandle mso_sptRibbon2Handle[] =
4426 {
4427     {   SvxMSDffHandleFlags::RANGE,
4428         0x100, 0, 10800, 10800, 2700, 8100, MIN_INT32, 0x7fffffff },
4429     {   SvxMSDffHandleFlags::RANGE,
4430         10800, 0x101, 10800, 10800, MIN_INT32, 0x7fffffff, 14400, 21600 }
4431 };
4432 const mso_CustomShape msoRibbon2 =
4433 {
4434     const_cast<SvxMSDffVertPair*>(mso_sptRibbon2Vert), SAL_N_ELEMENTS( mso_sptRibbon2Vert ),
4435     const_cast<sal_uInt16*>(mso_sptRibbon2Segm), sizeof( mso_sptRibbon2Segm ) >> 1,
4436     const_cast<SvxMSDffCalculationData*>(mso_sptRibbon2Calc), SAL_N_ELEMENTS( mso_sptRibbon2Calc ),
4437     const_cast<sal_Int32*>(mso_sptRibbon2Default),
4438     const_cast<SvxMSDffTextRectangles*>(mso_sptRibbon2TextRect), SAL_N_ELEMENTS( mso_sptRibbon2TextRect ),
4439     21600, 21600,
4440     MIN_INT32, MIN_INT32,
4441     nullptr, 0,
4442     const_cast<SvxMSDffHandle*>(mso_sptRibbon2Handle), SAL_N_ELEMENTS( mso_sptRibbon2Handle )
4443 };
4444
4445 const SvxMSDffVertPair mso_sptRibbonVert[] =
4446 {
4447     { 0, 0 }, { 3 MSO_I, 0 },
4448     { 4 MSO_I, 11 MSO_I }, { 4 MSO_I, 10 MSO_I }, { 5 MSO_I, 10 MSO_I }, { 5 MSO_I, 11 MSO_I },
4449     { 6 MSO_I, 0 }, { 21600, 0 }, { 18 MSO_I, 14 MSO_I }, { 21600, 15 MSO_I }, { 9 MSO_I, 15 MSO_I }, { 9 MSO_I, 16 MSO_I }, { 8 MSO_I, 21600 }, { 1 MSO_I, 21600 },
4450     { 0 MSO_I, 16 MSO_I }, { 0 MSO_I, 15 MSO_I }, { 0, 15 MSO_I }, { 2700, 14 MSO_I },
4451
4452     { 4 MSO_I, 11 MSO_I },
4453     { 3 MSO_I, 12 MSO_I }, { 1 MSO_I, 12 MSO_I },
4454     { 0 MSO_I, 13 MSO_I }, { 1 MSO_I, 10 MSO_I }, { 4 MSO_I, 10 MSO_I },
4455     { 5 MSO_I, 11 MSO_I },
4456     { 6 MSO_I, 12 MSO_I }, { 8 MSO_I, 12 MSO_I },
4457     { 9 MSO_I, 13 MSO_I }, { 8 MSO_I, 10 MSO_I }, { 5 MSO_I, 10 MSO_I },
4458     { 0 MSO_I, 13 MSO_I },
4459     { 0 MSO_I, 15 MSO_I },
4460     { 9 MSO_I, 13 MSO_I },
4461     { 9 MSO_I, 15 MSO_I }
4462 };
4463 const sal_uInt16 mso_sptRibbonSegm[] =
4464 {
4465     0x4000, 0x0001, 0xa701, 0x0003, 0xa801, 0x0005, 0xa801, 0x0001, 0xa701, 0x0003, 0x6000, 0x8000,
4466     0x4000, 0xaa00, 0xa801, 0x0001, 0xa702, 0x0001, 0x8000,
4467     0x4000, 0xaa00, 0xa801, 0x0001, 0xa702, 0x0001, 0x8000,
4468     0x4000, 0xaa00, 0x0001, 0x8000,
4469     0x4000, 0xaa00, 0x0001, 0x8000
4470 };
4471 const SvxMSDffCalculationData mso_sptRibbonCalc[] =
4472 {
4473     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },             // 00
4474     { 0x2000, { 0x400, 675, 0 } },                          // 01
4475     { 0x2000, { 0x401, 675, 0 } },                          // 02
4476     { 0x2000, { 0x402, 675, 0 } },                          // 03
4477     { 0x2000, { 0x403, 675, 0 } },                          // 04
4478     { 0x8000, { 21600, 0, 0x404 } },                        // 05
4479     { 0x8000, { 21600, 0, 0x403 } },                        // 06
4480     { 0x8000, { 21600, 0, 0x402 } },                        // 07
4481     { 0x8000, { 21600, 0, 0x401 } },                        // 08
4482     { 0x8000, { 21600, 0, 0x400 } },                        // 09
4483     { 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },            // 10
4484     { 0x2001, { 0x40a, 1, 4 } },                            // 11
4485     { 0x2001, { 0x40b, 2, 1 } },                            // 12
4486     { 0x2001, { 0x40b, 3, 1 } },                            // 13
4487     { 0x8000, { 10800, 0, 0x40c } },                        // 14
4488     { 0x8000, { 21600, 0, 0x40a } },                        // 15
4489     { 0x8000, { 21600, 0, 0x40b } },                        // 16
4490     { 0x0001, { 21600, 1, 2 } },                            // 17
4491     { 0x0000, { 21600, 0, 2700 } },                         // 18
4492     { 0x2000, { 0x411, 0, 2700 } }                          // 19
4493 };
4494 const sal_Int32 mso_sptRibbonDefault[] =
4495 {
4496     2, 5400, 2700
4497 };
4498 const SvxMSDffTextRectangles mso_sptRibbonTextRect[] =
4499 {
4500     { { 0 MSO_I, 10 MSO_I }, { 9 MSO_I, 21600 } }
4501 };
4502 const SvxMSDffVertPair mso_sptRibbonGluePoints[] =
4503 {
4504     { 17 MSO_I, 10 MSO_I }, { 2700, 14 MSO_I }, { 17 MSO_I, 21600 }, { 18 MSO_I, 14 MSO_I }
4505 };
4506 const SvxMSDffHandle mso_sptRibbonHandle[] =
4507 {
4508     {   SvxMSDffHandleFlags::RANGE,
4509         0x100, 0, 10800, 10800, 2700, 8100, MIN_INT32, 0x7fffffff },
4510     {   SvxMSDffHandleFlags::RANGE,
4511         10800, 0x101, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 7200 }
4512 };
4513 const mso_CustomShape msoRibbon =
4514 {
4515     const_cast<SvxMSDffVertPair*>(mso_sptRibbonVert), SAL_N_ELEMENTS( mso_sptRibbonVert ),
4516     const_cast<sal_uInt16*>(mso_sptRibbonSegm), sizeof( mso_sptRibbonSegm ) >> 1,
4517     const_cast<SvxMSDffCalculationData*>(mso_sptRibbonCalc), SAL_N_ELEMENTS( mso_sptRibbonCalc ),
4518     const_cast<sal_Int32*>(mso_sptRibbonDefault),
4519     const_cast<SvxMSDffTextRectangles*>(mso_sptRibbonTextRect), SAL_N_ELEMENTS( mso_sptRibbonTextRect ),
4520     21600, 21600,
4521     MIN_INT32, MIN_INT32,
4522     const_cast<SvxMSDffVertPair*>(mso_sptRibbonGluePoints), SAL_N_ELEMENTS( mso_sptRibbonGluePoints ),
4523     const_cast<SvxMSDffHandle*>(mso_sptRibbonHandle), SAL_N_ELEMENTS( mso_sptRibbonHandle )
4524 };
4525 //msosptEllipseRibbon
4526 //svg path = ar@9@38@8@37,0@27@0@26@9@13@8@4@0@25@22@25@9@38@8@37@22@26@3@27l@7@40@3,wa@9@35@8@10@3,0@21@33@9@36@8@1@21@31@20@31@9@35@8@10@20@33,,l@5@40xewr@9@36@8@1@20@31@0@32nfl@20@33ear@9@36@8@1@21@31@22@32nfl@21@33em@0@26nfl@0@32em@22@26nfl@22@32e
4527 //odp path = A ?f9 ?f38 ?f8 ?f37 0 ?f27 ?f0 ?f26 ?f9 ?f13 ?f8 ?f4 ?f0 ?f25 ?f22 ?f25 ?f9 ?f38 ?f8 ?f37 ?f22 ?f26 ?f3 ?f27 L ?f7 ?f40 ?f3 0 W ?f9 ?f35 ?f8 ?f10 ?f3 0 ?f21 ?f33 ?f9 ?f36 ?f8 ?f1 ?f21 ?f31 ?f20 ?f31 ?f9 ?f35 ?f8 ?f10 ?f20 ?f33 0 0 L ?f5 ?f40 Z N W ?f9 ?f36 ?f8 ?f1 ?f20 ?f31 ?f0 ?f32 F L ?f20 ?f33 N A ?f9 ?f36 ?f8 ?f1 ?f21 ?f31 ?f22 ?f32 F L ?f21 ?f33 N M ?f0 ?f26 F L ?f0 ?f32 N M ?f22 ?f26 F L ?f22 ?f32 N
4528 const SvxMSDffVertPair mso_sptEllipseRibbonVert[] =
4529 {
4530     { 9 MSO_I , 38 MSO_I },
4531     { 8 MSO_I , 37 MSO_I },
4532     { 0 , 27 MSO_I },
4533     { 0 MSO_I , 26 MSO_I },
4534     { 9 MSO_I , 13 MSO_I },
4535     { 8 MSO_I , 4 MSO_I },
4536     { 0 MSO_I , 25 MSO_I },
4537     { 22 MSO_I , 25 MSO_I },
4538     { 9 MSO_I , 38 MSO_I },
4539     { 8 MSO_I , 37 MSO_I },
4540     { 22 MSO_I , 26 MSO_I },
4541     { 3 MSO_I , 27 MSO_I },
4542     { 7 MSO_I , 40 MSO_I },
4543     { 3 MSO_I , 0 },
4544     { 9 MSO_I , 35 MSO_I },
4545     { 8 MSO_I , 10 MSO_I },
4546     { 3 MSO_I , 0 },
4547     { 21 MSO_I , 33 MSO_I },
4548     { 9 MSO_I , 36 MSO_I },
4549     { 8 MSO_I , 1 MSO_I },
4550     { 21 MSO_I , 31 MSO_I },
4551     { 20 MSO_I , 31 MSO_I },
4552     { 9 MSO_I , 35 MSO_I },
4553     { 8 MSO_I , 10 MSO_I },
4554     { 20 MSO_I , 33 MSO_I },
4555     { 0 , 0 },
4556     { 5 MSO_I , 40 MSO_I },
4557     { 9 MSO_I , 36 MSO_I },
4558     { 8 MSO_I , 1 MSO_I },
4559     { 20 MSO_I , 31 MSO_I },
4560     { 0 MSO_I , 32 MSO_I },
4561     { 20 MSO_I , 33 MSO_I },
4562     { 9 MSO_I , 36 MSO_I },
4563     { 8 MSO_I , 1 MSO_I },
4564     { 21 MSO_I , 31 MSO_I },
4565     { 22 MSO_I , 32 MSO_I },
4566     { 21 MSO_I , 33 MSO_I },
4567     { 0 MSO_I , 26 MSO_I },
4568     { 0 MSO_I , 32 MSO_I },
4569     { 22 MSO_I , 26 MSO_I },
4570     { 22 MSO_I , 32 MSO_I }
4571 };
4572
4573 const sal_uInt16 mso_sptEllipseRibbonSegm[] =
4574 {
4575     0xa30c /*ar*/,0x0002/*l*/,0xa50c/*wa*/,0x0001/*l*/,
4576     0x6001/*x*/, 0x8000/*e*/,0xa504/*wr*/,0xaa00/*nf*/,
4577     0x0001/*l*/, 0x8000/*e*/,0xa304/*ar*/,0xaa00/*nf*/,
4578     0x0001/*l*/, 0x8000/*e*/,0x4000/*m*/,0xaa00/*nf*/,
4579     0x0001/*l*/, 0x8000/*e*/,0x4000/*m*/,0xaa00/*nf*/,
4580     0x0001/*l*/, 0x8000/*e*/
4581 };
4582
4583 const SvxMSDffCalculationData mso_sptEllipseRibbonCalc[] =
4584 {
4585     { 0x2000 , { DFF_Prop_adjustValue , 0 , 0 } }, //val #0
4586     { 0x2000 , { DFF_Prop_adjust2Value , 0 , 0 } }, //val #1
4587     { 0x2000 , { DFF_Prop_adjust3Value , 0 , 0 } }, //val #2
4588     { 0x2000 , { DFF_Prop_geoRight , 0 , 0 } }, //val width
4589     { 0x2000 , { DFF_Prop_geoBottom , 0 , 0 } }, //val height
4590     { 0x2001 , { DFF_Prop_geoRight , 1 , 8 } }, //prod width 1 8
4591     { 0x2001 , { DFF_Prop_geoRight , 1 , 2 } }, //prod width 1 2
4592     { 0x2001 , { DFF_Prop_geoRight , 7 , 8 } }, //prod width 7 8
4593     { 0x2001 , { DFF_Prop_geoRight , 3 , 2 } }, //prod width 3 2
4594     { 0x8000 , { 0 , 0 , 0x406 } }, //sum 0 0 @6
4595     { 0xa000 , { DFF_Prop_geoBottom , 0 , DFF_Prop_adjust3Value } }, //sum height 0 #2
4596     { 0x2001 , { 0x40a , 30573 , 4096 } }, //prod @10 30573 4096
4597     { 0x2001 , { 0x40b , 2 , 1 } }, //prod @11 2 1
4598     { 0xa000 , { DFF_Prop_geoBottom , 0 , 0x40c } }, //sum height 0 @12
4599     { 0x6000 , { 0x40b , DFF_Prop_adjust3Value , 0 } }, //sum @11 #2 0
4600     { 0xe000 , { 0x40b , DFF_Prop_geoBottom , DFF_Prop_adjust2Value } }, //sum @11 height #1
4601     { 0xa000 , { DFF_Prop_geoBottom , 0 , DFF_Prop_adjust2Value } }, //sum height 0 #1
4602     { 0x2001 , { 0x410 , 1 , 2 } }, //prod @16 1 2
4603     { 0x6000 , { 0x40b , 0x411 , 0 } }, //sum @11 @17 0
4604     { 0xe000 , { 0x40e , DFF_Prop_adjust2Value , DFF_Prop_geoBottom } }, //sum @14 #1 height
4605     { 0x6000 , { DFF_Prop_adjustValue , 0x405 , 0 } }, //sum #0 @5 0
4606     { 0xa000 , { DFF_Prop_geoRight , 0 , 0x414 } }, //sum width 0 @20
4607     { 0xa000 , { DFF_Prop_geoRight , 0 , DFF_Prop_adjustValue } }, //sum width 0 #0
4608     { 0xa000 , { 0x406 , 0 , DFF_Prop_adjustValue } }, //sum @6 0 #0
4609     { 0xe00f , { 0x417 , DFF_Prop_geoRight , 0x40b } }, //ellipse @23 width @11
4610     { 0xe000 , { 0x418 , DFF_Prop_geoBottom , 0x40b } }, //sum @24 height @11
4611     { 0xe000 , { 0x419 , 0x40b , 0x413 } }, //sum @25 @11 @19
4612     { 0xe000 , { DFF_Prop_adjust3Value , 0x40b , 0x413 } }, //sum #2 @11 @19
4613     { 0x2001 , { 0x40b , 2391 , 32768 } }, //prod @11 2391 32768
4614     { 0xa000 , { 0x406 , 0 , 0x414 } }, //sum @6 0 @20
4615     { 0xe00f , { 0x41d , DFF_Prop_geoRight , 0x40b } }, //ellipse @29 width @11
4616     { 0xe000 , { DFF_Prop_adjust2Value , 0x41e , 0x40b } }, //sum #1 @30 @11
4617     { 0xe000 , { 0x419 , DFF_Prop_adjust2Value , DFF_Prop_geoBottom } }, //sum @25 #1 height
4618     { 0xe000 , { DFF_Prop_geoBottom , 0x41e , 0x40e } }, //sum height @30 @14
4619     { 0x6000 , { 0x40b , 0x40e , 0 } }, //sum @11 @14 0
4620     { 0xa000 , { DFF_Prop_geoBottom , 0 , 0x422 } }, //sum height 0 @34
4621     { 0xe000 , { 0x423 , 0x413 , 0x40b } }, //sum @35 @19 @11
4622     { 0xe000 , { 0x40a , 0x40f , 0x40b } }, //sum @10 @15 @11
4623     { 0xe000 , { 0x423 , 0x40f , 0x40b } }, //sum @35 @15 @11
4624     { 0xe000 , { 0x41c , 0x40e , 0x412 } }, //sum @28 @14 @18
4625     { 0xa000 , { DFF_Prop_geoBottom , 0 , 0x427 } }, //sum height 0 @39
4626     { 0xa000 , { 0x413 , 0 , 0x412 } }, //sum @19 0 @18
4627     { 0x2001 , { 0x429 , 2 , 3 } }, //prod @41 2 3
4628     { 0xa000 , { DFF_Prop_adjust2Value , 0 , 0x42a } }, //sum #1 0 @42
4629     { 0xa000 , { DFF_Prop_adjust3Value , 0 , 0x42a } }, //sum #2 0 @42
4630     { 0x2004 , { 0x42c , 20925 , 0 } }, //min @44 20925
4631     { 0x2001 , { DFF_Prop_geoRight , 3 , 8 } }, //prod width 3 8
4632     { 0x2000 , { 0x42e , 0 , 4 } }, //sum @46 0 4
4633 };
4634
4635 const SvxMSDffTextRectangles mso_sptEllipseRibbonTextRect[] =
4636 {//@0,@1,@22,@25
4637     { { 0 MSO_I, 1 MSO_I }, { 22 MSO_I, 25 MSO_I } }
4638 };
4639
4640 const sal_Int32 mso_sptEllipseRibbonDefault[] =
4641 {
4642     3,5400,5400,18900
4643 };
4644
4645 const SvxMSDffHandle mso_sptEllipseRibbonHandle[] =
4646 {
4647 //position="#0,bottomRight" xrange="@5,@47
4648 //position="center,#1" yrange="@10,@43
4649 //position="topLeft,#2" yrange="@27,@45
4650     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL| SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL,
4651         0x100, 21600, 0, 0, 0x8/*5+3*/, 0x32/*47+3*/, MIN_INT32, 0x7fffffff },
4652     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL,
4653         10800, 0x101, 0, 0, MIN_INT32, 0x7fffffff,0xd/*10+3*/, 0x2e /*43+3*/ },
4654     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL,
4655         0, 0x102, 0, 0, MIN_INT32, 0x7fffffff,0x1e/*27+3*/, 0x30 /*45+3*/ }
4656 };
4657
4658 const mso_CustomShape msosptEllipseRibbon =
4659 {
4660     const_cast<SvxMSDffVertPair*>(mso_sptEllipseRibbonVert), SAL_N_ELEMENTS( mso_sptEllipseRibbonVert ),
4661     const_cast<sal_uInt16*>(mso_sptEllipseRibbonSegm), sizeof( mso_sptEllipseRibbonSegm ) >> 1,
4662     const_cast<SvxMSDffCalculationData*>(mso_sptEllipseRibbonCalc), SAL_N_ELEMENTS( mso_sptEllipseRibbonCalc ),
4663     const_cast<sal_Int32*>(mso_sptEllipseRibbonDefault),
4664     const_cast<SvxMSDffTextRectangles*>(mso_sptEllipseRibbonTextRect), SAL_N_ELEMENTS( mso_sptEllipseRibbonTextRect ),
4665     21600, 21600,
4666     MIN_INT32, MIN_INT32,
4667     nullptr, 0,
4668     const_cast<SvxMSDffHandle*>(mso_sptEllipseRibbonHandle), SAL_N_ELEMENTS( mso_sptEllipseRibbonHandle )
4669 };
4670
4671 //msosptEllipseRibbon2
4672 //svg path = wr@9@34@8@35,0@24@0@23@9,0@8@11@0@22@19@22@9@34@8@35@19@23@3@24l@7@36@3@4at@9@31@8@32@3@4@18@30@9@1@8@33@18@28@17@28@9@31@8@32@17@30,0@4l@5@36xear@9@1@8@33@17@28@0@29nfl@17@30ewr@9@1@8@33@18@28@19@29nfl@18@30em@0@23nfl@0@29em@19@23nfl@19@29e
4673 const SvxMSDffVertPair mso_sptEllipseRibbon2Vert[] =
4674 {
4675     { 9 MSO_I , 34 MSO_I },
4676     { 8 MSO_I , 35 MSO_I },
4677     { 0 , 24 MSO_I },
4678     { 0 MSO_I , 23 MSO_I },
4679     { 9 MSO_I , 0 },
4680     { 8 MSO_I , 11 MSO_I },
4681     { 0 MSO_I , 22 MSO_I },
4682     { 19 MSO_I , 22 MSO_I },
4683     { 9 MSO_I , 34 MSO_I },
4684     { 8 MSO_I , 35 MSO_I },
4685     { 19 MSO_I , 23 MSO_I },
4686     { 3 MSO_I , 24 MSO_I },
4687     { 7 MSO_I , 36 MSO_I },
4688     { 3 MSO_I , 4 MSO_I },
4689     { 9 MSO_I , 31 MSO_I },
4690     { 8 MSO_I , 32 MSO_I },
4691     { 3 MSO_I , 4 MSO_I },
4692     { 18 MSO_I , 30 MSO_I },
4693     { 9 MSO_I , 1 MSO_I },
4694     { 8 MSO_I , 33 MSO_I },
4695     { 18 MSO_I , 28 MSO_I },
4696     { 17 MSO_I , 28 MSO_I },
4697     { 9 MSO_I , 31 MSO_I },
4698     { 8 MSO_I , 32 MSO_I },
4699     { 17 MSO_I , 30 MSO_I },
4700     { 0 , 4l MSO_I },
4701     { 5 MSO_I , 36 MSO_I },
4702     { 9 MSO_I , 1 MSO_I },
4703     { 8 MSO_I , 33 MSO_I },
4704     { 17 MSO_I , 28 MSO_I },
4705     { 0 MSO_I , 29 MSO_I },
4706     { 17 MSO_I , 30 MSO_I },
4707     { 9 MSO_I , 1 MSO_I },
4708     { 8 MSO_I , 33 MSO_I },
4709     { 18 MSO_I , 28 MSO_I },
4710     { 19 MSO_I , 29 MSO_I },
4711     { 18 MSO_I , 30 MSO_I },
4712     { 0 MSO_I , 23 MSO_I },
4713     { 0 MSO_I , 29 MSO_I },
4714     { 19 MSO_I , 23 MSO_I },
4715     { 19 MSO_I , 29 MSO_I }
4716 };
4717 const sal_uInt16 mso_sptEllipseRibbon2Segm[] =
4718 {
4719     0xa50c/*wr*/,0x0002/*l*/,0xa30c/*at*/,0x0001/*l*/,
4720     0x6001/*x*/, 0x8000/*e*/,0xa304/*ar*/,0xaa00/*nf*/,
4721     0x0001/*l*/, 0x8000/*e*/,0xa504/*wr*/,0xaa00/*nf*/,
4722     0x0001/*l*/, 0x8000/*e*/,0x4000/*m*/,0xaa00/*nf*/,
4723     0x0001/*l*/, 0x8000/*e*/,0x4000/*m*/,0xaa00/*nf*/,
4724     0x0001/*l*/, 0x8000/*e*/
4725 };
4726
4727 const SvxMSDffCalculationData mso_sptEllipseRibbon2Calc[] =
4728 {
4729     { 0x2000 , { DFF_Prop_adjustValue , 0 , 0 } }, //val #0
4730     { 0x2000 , { DFF_Prop_adjust2Value , 0 , 0 } }, //val #1
4731     { 0x2000 , { DFF_Prop_adjust3Value , 0 , 0 } }, //val #2
4732     { 0x2000 , { DFF_Prop_geoRight , 0 , 0 } }, //val width
4733     { 0x2000 , { DFF_Prop_geoBottom , 0 , 0 } }, //val height
4734     { 0x2001 , { DFF_Prop_geoRight , 1 , 8 } }, //prod width 1 8
4735     { 0x2001 , { DFF_Prop_geoRight , 1 , 2 } }, //prod width 1 2
4736     { 0x2001 , { DFF_Prop_geoRight , 7 , 8 } }, //prod width 7 8
4737     { 0x2001 , { DFF_Prop_geoRight , 3 , 2 } }, //prod width 3 2
4738     { 0x8000 , { 0 , 0 , 0x406 } }, //sum 0 0 @6
4739     { 0x2001 , { DFF_Prop_adjust3Value , 30573 , 4096 } }, //prod #2 30573 4096
4740     { 0x2001 , { 0x40a , 2 , 1 } }, //prod @10 2 1
4741     { 0xe000 , { 0x40a , DFF_Prop_geoBottom , DFF_Prop_adjust3Value } }, //sum @10 height #2
4742     { 0x6000 , { 0x40a , DFF_Prop_adjust2Value , 0 } }, //sum @10 #1 0
4743     { 0x2001 , { DFF_Prop_adjust2Value , 1 , 2 } }, //prod #1 1 2
4744     { 0x6000 , { 0x40a , 0x40e , 0 } }, //sum @10 @14 0
4745     { 0xa000 , { 0x40c , 0 , DFF_Prop_adjust2Value } }, //sum @12 0 #1
4746     { 0x6000 , { DFF_Prop_adjustValue , 0x405 , 0 } }, //sum #0 @5 0
4747     { 0xa000 , { DFF_Prop_geoRight , 0 , 0x411 } }, //sum width 0 @17
4748     { 0xa000 , { DFF_Prop_geoRight , 0 , DFF_Prop_adjustValue } }, //sum width 0 #0
4749     { 0xa000 , { 0x406 , 0 , DFF_Prop_adjustValue } }, //sum @6 0 #0
4750     { 0xe00f , { 0x414 , DFF_Prop_geoRight , 0x40a } }, //ellipse @20 width @10
4751     { 0xa000 , { 0x40a , 0 , 0x415 } }, //sum @10 0 @21
4752     { 0xe000 , { 0x416 , 0x410 , 0x40a } }, //sum @22 @16 @10
4753     { 0xe000 , { DFF_Prop_adjust3Value , 0x410 , 0x40a } }, //sum #2 @16 @10
4754     { 0x2001 , { 0x40a , 2391 , 32768 } }, //prod @10 2391 32768
4755     { 0xa000 , { 0x406 , 0 , 0x411 } }, //sum @6 0 @17
4756     { 0xe00f , { 0x41a , DFF_Prop_geoRight , 0x40a } }, //ellipse @26 width @10
4757     { 0xe000 , { 0x40a , DFF_Prop_adjust2Value , 0x41b } }, //sum @10 #1 @27
4758     { 0x6000 , { 0x416 , DFF_Prop_adjust2Value , 0 } }, //sum @22 #1 0
4759     { 0xa000 , { 0x40c , 0 , 0x41b } }, //sum @12 0 @27
4760     { 0xa000 , { DFF_Prop_geoBottom , 0 , DFF_Prop_adjust3Value } }, //sum height 0 #2
4761     { 0x6000 , { 0x40a , 0x40c , 0 } }, //sum @10 @12 0
4762     { 0xe000 , { 0x420 , 0x40a , 0x410 } }, //sum @32 @10 @16
4763     { 0xe000 , { 0x41f , 0x40a , 0x40d } }, //sum @31 @10 @13
4764     { 0xe000 , { 0x420 , 0x40a , 0x40d } }, //sum @32 @10 @13
4765     { 0xe000 , { 0x419 , 0x40c , 0x40f } }, //sum @25 @12 @15
4766     { 0xa000 , { 0x410 , 0 , 0x40f } }, //sum @16 0 @15
4767     { 0x2001 , { 0x425 , 2 , 3 } }, //prod @37 2 3
4768     { 0x6000 , { 0x401 , 0x426 , 0 } }, //sum @1 @38 0
4769     { 0x6000 , { DFF_Prop_adjust3Value , 0x426 , 0 } }, //sum #2 @38 0
4770     { 0x2005 , { 0x428 , 675 , 0 } }, //max @40 675
4771     { 0x2001 , { DFF_Prop_geoRight , 3 , 8 } }, //prod width 3 8
4772     { 0x2000 , { 0x42a , 0 , 4 } } //sum @42 0 4
4773 };
4774
4775 const SvxMSDffTextRectangles mso_sptEllipseRibbon2TextRect[] =
4776 {//@0,@22,@19,@1
4777     { { 0 MSO_I, 22 MSO_I }, { 19 MSO_I, 1 MSO_I } }
4778 };
4779
4780 const sal_Int32 mso_sptEllipseRibbon2Default[] =
4781 {
4782     3,5400,16200,2700
4783 };
4784
4785 const SvxMSDffHandle mso_sptEllipseRibbon2Handle[] =
4786 {
4787 //position="#0,topLeft" xrange="@5,@43
4788 //position="center,#1" yrange="@39,@31
4789 //position="topLeft,#2" yrange="@41,@24
4790     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL| SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL,
4791         0x100, 0, 0, 0, 0x8/*5+3*/, 0x2e/*43+3*/, MIN_INT32, 0x7fffffff },
4792     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL,
4793         10800, 0x101, 0, 0, MIN_INT32, 0x7fffffff,0x2a/*39+3*/, 0x22 /*31+3*/ },
4794     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL,
4795         0, 0x102, 0, 0, MIN_INT32, 0x7fffffff,0x2c/*41+3*/, 0x1b /*24+3*/ }
4796 };
4797
4798 const mso_CustomShape msosptEllipseRibbon2 =
4799 {
4800     const_cast<SvxMSDffVertPair*>(mso_sptEllipseRibbon2Vert), SAL_N_ELEMENTS( mso_sptEllipseRibbon2Vert ),
4801     const_cast<sal_uInt16*>(mso_sptEllipseRibbon2Segm), sizeof( mso_sptEllipseRibbon2Segm ) >> 1,
4802     const_cast<SvxMSDffCalculationData*>(mso_sptEllipseRibbon2Calc), SAL_N_ELEMENTS( mso_sptEllipseRibbon2Calc ),
4803     const_cast<sal_Int32*>(mso_sptEllipseRibbon2Default),
4804     const_cast<SvxMSDffTextRectangles*>(mso_sptEllipseRibbon2TextRect), SAL_N_ELEMENTS( mso_sptEllipseRibbon2TextRect ),
4805     21600, 21600,
4806     MIN_INT32, MIN_INT32,
4807     nullptr, 0,
4808     const_cast<SvxMSDffHandle*>(mso_sptEllipseRibbon2Handle), SAL_N_ELEMENTS( mso_sptEllipseRibbon2Handle )
4809 };
4810 // End
4811 const SvxMSDffVertPair mso_sptVerticalScrollVert[] = // adjustment1 : 0 - 5400
4812 {
4813     { 1 MSO_I, 21600 }, { 0, 11 MSO_I }, { 1 MSO_I, 12 MSO_I }, { 0 MSO_I, 12 MSO_I },
4814     { 0 MSO_I, 1 MSO_I }, { 4 MSO_I, 0 }, { 2 MSO_I, 0 }, { 21600, 1 MSO_I },
4815     { 2 MSO_I, 0 MSO_I }, { 3 MSO_I, 0 MSO_I }, { 3 MSO_I, 11 MSO_I }, { 5 MSO_I, 21600 },
4816
4817     { 6 MSO_I, 1 MSO_I }, { 4 MSO_I, 0 MSO_I }, { 8 MSO_I, 9 MSO_I }, { 4 MSO_I, 1 MSO_I },
4818
4819     { 0 MSO_I, 11 MSO_I }, { 1 MSO_I, 21600 }, { 0, 11 MSO_I }, { 1 MSO_I, 12 MSO_I },
4820     { 9 MSO_I, 10 MSO_I }, { 1 MSO_I, 11 MSO_I },
4821
4822     { 4 MSO_I, 0 }, { 6 MSO_I, 1 MSO_I },
4823
4824     { 0 MSO_I, 12 MSO_I }, { 0 MSO_I, 11 MSO_I },
4825
4826     { 4 MSO_I, 0 MSO_I },
4827     { 2 MSO_I, 0 MSO_I }
4828 };
4829 const sal_uInt16 mso_sptVerticalScrollSegm[] =
4830 {
4831     0x4000, 0xa702, 0x0002, 0xa801, 0x0001, 0xa702, 0x0002, 0xa801, 0x6001, 0x8000,
4832     0x4000, 0xa801, 0xa702, 0x6000, 0x8000,
4833     0x4000, 0xa803, 0xa702, 0x6001, 0x8000,
4834     0x4000, 0xa701, 0x8000,
4835     0x4000, 0x0001, 0x8000,
4836     0x4000, 0x0001, 0x8000
4837 };
4838 const SvxMSDffCalculationData mso_sptScrollCalc[] =
4839 {
4840     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
4841     { 0x2001, { 0x400, 1, 2 } },
4842     { 0xa000, { DFF_Prop_geoRight, 0, 0x401 } },
4843     { 0xa000, { DFF_Prop_geoRight, 0, 0x400 } },
4844     { 0x6000, { 0x400, 0x401, 0 } },
4845     { 0xa000, { DFF_Prop_geoRight, 0, 0x404 } },
4846     { 0x2001, { 0x400, 2, 1 } },
4847     { 0x2001, { 0x401, 1, 2 } },
4848     { 0x6000, { 0x400, 0x407, 0 } },
4849     { 0x6000, { 0x401, 0x407, 0 } },
4850     { 0xa000, { DFF_Prop_geoBottom, 0, 0x409 } },
4851     { 0xa000, { DFF_Prop_geoBottom, 0, 0x401 } },
4852     { 0xa000, { DFF_Prop_geoBottom, 0, 0x400 } },
4853     { 0xa000, { DFF_Prop_geoBottom, 0, 0x404 } }
4854 };
4855 const SvxMSDffTextRectangles mso_sptScrollTextRect[] =
4856 {
4857     { { 0 MSO_I, 0 MSO_I }, { 3 MSO_I, 12 MSO_I } }
4858 };
4859 const SvxMSDffHandle mso_sptVerticalScrollHandle[] =
4860 {
4861     {   SvxMSDffHandleFlags::RANGE,
4862         0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 5400 }
4863 };
4864 const mso_CustomShape msoVerticalScroll =
4865 {
4866     const_cast<SvxMSDffVertPair*>(mso_sptVerticalScrollVert), SAL_N_ELEMENTS( mso_sptVerticalScrollVert ),
4867     const_cast<sal_uInt16*>(mso_sptVerticalScrollSegm), sizeof( mso_sptVerticalScrollSegm ) >> 1,
4868     const_cast<SvxMSDffCalculationData*>(mso_sptScrollCalc), SAL_N_ELEMENTS( mso_sptScrollCalc ),
4869     const_cast<sal_Int32*>(mso_sptDefault2700),
4870     const_cast<SvxMSDffTextRectangles*>(mso_sptScrollTextRect), SAL_N_ELEMENTS( mso_sptScrollTextRect ),
4871     21600, 21600,
4872     11000, 10800,
4873     nullptr, 0,
4874     const_cast<SvxMSDffHandle*>(mso_sptVerticalScrollHandle), SAL_N_ELEMENTS( mso_sptVerticalScrollHandle )
4875 };
4876 const SvxMSDffVertPair mso_sptHorizontalScrollVert[] =   // adjustment1 : 0 - 5400
4877 {
4878     { 0, 4 MSO_I }, { 1 MSO_I, 0 MSO_I }, { 3 MSO_I, 0 MSO_I }, { 3 MSO_I, 1 MSO_I },
4879     { 2 MSO_I, 0 }, { 21600, 1 MSO_I }, { 21600, 13 MSO_I }, { 2 MSO_I, 12 MSO_I },
4880     { 0 MSO_I, 12 MSO_I }, { 0 MSO_I, 11 MSO_I }, { 1 MSO_I, 21600 }, { 0, 11 MSO_I },
4881
4882     { 1 MSO_I, 4 MSO_I }, { 9 MSO_I, 8 MSO_I }, { 0 MSO_I, 4 MSO_I }, { 1 MSO_I, 6 MSO_I },
4883
4884     { 2 MSO_I, 1 MSO_I }, { 3 MSO_I, 9 MSO_I }, { 3 MSO_I, 1 MSO_I }, { 2 MSO_I, 0 },
4885     { 21600, 1 MSO_I }, { 2 MSO_I, 0 MSO_I },
4886
4887     { 1 MSO_I, 6 MSO_I },
4888     { 0, 4 MSO_I },
4889
4890     { 2 MSO_I, 0 MSO_I },
4891     { 3 MSO_I, 0 MSO_I },
4892
4893     { 0 MSO_I, 4 MSO_I },
4894     { 0 MSO_I, 11 MSO_I }
4895 };
4896 const sal_uInt16 mso_sptHorizontalScrollSegm[] =
4897 {
4898     0x4000, 0xa801, 0x0002, 0xa802, 0x0001, 0xa801, 0x0002, 0xa802, 0x6001, 0x8000,
4899     0x4000, 0xa803, 0x6000, 0x8000,
4900     0x4000, 0xa803, 0xa702, 0x6000, 0x8000,
4901     0x4000, 0xa701, 0x8000,
4902     0x4000, 0x0001, 0x8000,
4903     0x4000, 0x0001, 0x8000
4904 };
4905 const SvxMSDffHandle mso_sptHorizontalScrollHandle[] =
4906 {
4907     {   SvxMSDffHandleFlags::RANGE,
4908         0x100, 0, 10800, 10800, 0, 5400, MIN_INT32, 0x7fffffff }
4909 };
4910 const mso_CustomShape msoHorizontalScroll =
4911 {
4912     const_cast<SvxMSDffVertPair*>(mso_sptHorizontalScrollVert), SAL_N_ELEMENTS( mso_sptHorizontalScrollVert ),
4913     const_cast<sal_uInt16*>(mso_sptHorizontalScrollSegm), sizeof( mso_sptHorizontalScrollSegm ) >> 1,
4914     const_cast<SvxMSDffCalculationData*>(mso_sptScrollCalc), SAL_N_ELEMENTS( mso_sptScrollCalc ),
4915     const_cast<sal_Int32*>(mso_sptDefault2700),
4916     const_cast<SvxMSDffTextRectangles*>(mso_sptScrollTextRect), SAL_N_ELEMENTS( mso_sptScrollTextRect ),
4917     21600, 21600,
4918     10800, 11000,
4919     nullptr, 0,
4920     const_cast<SvxMSDffHandle*>(mso_sptHorizontalScrollHandle), SAL_N_ELEMENTS( mso_sptHorizontalScrollHandle )
4921 };
4922
4923 const SvxMSDffVertPair mso_sptFlowChartProcessVert[] =
4924 {
4925     { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 }, { 0, 0 }
4926 };
4927 const mso_CustomShape msoFlowChartProcess =
4928 {
4929     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartProcessVert), SAL_N_ELEMENTS( mso_sptFlowChartProcessVert ),
4930     nullptr, 0,
4931     nullptr, 0,
4932     nullptr,
4933     nullptr, 0,
4934     21600, 21600,
4935     MIN_INT32, MIN_INT32,
4936     const_cast<SvxMSDffVertPair*>(mso_sptStandardGluePoints), SAL_N_ELEMENTS( mso_sptStandardGluePoints ),
4937     nullptr, 0     // handles
4938 };
4939
4940 const SvxMSDffVertPair mso_sptFlowChartAlternateProcessVert[] =
4941 {
4942     { 0, 2 MSO_I }, { 0 MSO_I, 0 }, { 1 MSO_I, 0 }, { 21600, 2 MSO_I },
4943     { 21600, 3 MSO_I }, { 1 MSO_I, 21600 }, { 0 MSO_I, 21600 }, { 0, 3 MSO_I }
4944 };
4945 const sal_uInt16 mso_sptFlowChartAlternateProcessSegm[] =
4946 {
4947     0x4000, 0xa801, 0x0001, 0xa701, 0x0001, 0xa801, 0x0001, 0xa701, 0x6000, 0x8000
4948 };
4949 const SvxMSDffCalculationData mso_sptFlowChartAlternateProcessCalc[] =
4950 {
4951     { 0x2000, { DFF_Prop_geoLeft, 2540, 0 } },
4952     { 0x2000, { DFF_Prop_geoRight, 0, 2540 } },
4953     { 0x2000, { DFF_Prop_geoTop, 2540, 0 } },
4954     { 0x2000, { DFF_Prop_geoBottom, 0, 2540 } },
4955     { 0x2000, { DFF_Prop_geoLeft, 800, 0 } },
4956     { 0x2000, { DFF_Prop_geoRight, 0, 800 } },
4957     { 0x2000, { DFF_Prop_geoTop, 800, 0 } },
4958     { 0x2000, { DFF_Prop_geoBottom,0, 800 } }
4959 };
4960 const SvxMSDffTextRectangles mso_sptFlowChartAlternateProcessTextRect[] =
4961 {
4962     { { 4 MSO_I, 6 MSO_I }, { 5 MSO_I, 7 MSO_I } }
4963 };
4964 const mso_CustomShape msoFlowChartAlternateProcess =
4965 {
4966     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartAlternateProcessVert), SAL_N_ELEMENTS( mso_sptFlowChartAlternateProcessVert ),
4967     const_cast<sal_uInt16*>(mso_sptFlowChartAlternateProcessSegm), sizeof( mso_sptFlowChartAlternateProcessSegm ) >> 1,
4968     const_cast<SvxMSDffCalculationData*>(mso_sptFlowChartAlternateProcessCalc), SAL_N_ELEMENTS( mso_sptFlowChartAlternateProcessCalc ),
4969     nullptr,
4970     const_cast<SvxMSDffTextRectangles*>(mso_sptFlowChartAlternateProcessTextRect), SAL_N_ELEMENTS( mso_sptFlowChartAlternateProcessTextRect ),
4971     21600, 21600,
4972     MIN_INT32, MIN_INT32,
4973     const_cast<SvxMSDffVertPair*>(mso_sptStandardGluePoints), SAL_N_ELEMENTS( mso_sptStandardGluePoints ),
4974     nullptr, 0     // handles
4975 };
4976
4977 const SvxMSDffVertPair mso_sptFlowChartDecisionVert[] =
4978 {
4979     { 0, 10800 }, { 10800, 0 }, { 21600, 10800 }, { 10800, 21600 }, { 0, 10800 }
4980 };
4981 const SvxMSDffTextRectangles mso_sptFlowChartDecisionTextRect[] =
4982 {
4983     { { 5400, 5400 }, { 16200, 16200 } }
4984 };
4985 const mso_CustomShape msoFlowChartDecision =
4986 {
4987     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartDecisionVert), SAL_N_ELEMENTS( mso_sptFlowChartDecisionVert ),
4988     nullptr, 0,
4989     nullptr, 0,
4990     nullptr,
4991     const_cast<SvxMSDffTextRectangles*>(mso_sptFlowChartDecisionTextRect), SAL_N_ELEMENTS( mso_sptFlowChartDecisionTextRect ),
4992     21600, 21600,
4993     MIN_INT32, MIN_INT32,
4994     const_cast<SvxMSDffVertPair*>(mso_sptStandardGluePoints), SAL_N_ELEMENTS( mso_sptStandardGluePoints ),
4995     nullptr, 0     // handles
4996 };
4997
4998 const SvxMSDffVertPair mso_sptFlowChartInputOutputVert[] =
4999 {
5000     { 4230, 0 }, { 21600, 0 }, { 17370, 21600 }, { 0, 21600 }, { 4230, 0 }
5001 };
5002 const SvxMSDffTextRectangles mso_sptFlowChartInputOutputTextRect[] =
5003 {
5004     { { 4230, 0 }, { 17370, 21600 } }
5005 };
5006 const SvxMSDffVertPair mso_sptFlowChartInputOutputGluePoints[] =
5007 {
5008     { 12960, 0 }, { 10800, 0 }, { 2160, 10800 }, { 8600, 21600 }, { 10800, 21600 }, { 19400, 10800 }
5009 };
5010 const mso_CustomShape msoFlowChartInputOutput =
5011 {
5012     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartInputOutputVert), SAL_N_ELEMENTS( mso_sptFlowChartInputOutputVert ),
5013     nullptr, 0,
5014     nullptr, 0,
5015     nullptr,
5016     const_cast<SvxMSDffTextRectangles*>(mso_sptFlowChartInputOutputTextRect), SAL_N_ELEMENTS( mso_sptFlowChartInputOutputTextRect ),
5017     21600, 21600,
5018     MIN_INT32, MIN_INT32,
5019     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartInputOutputGluePoints), SAL_N_ELEMENTS( mso_sptFlowChartInputOutputGluePoints ),
5020     nullptr, 0     // handles
5021 };
5022
5023 const SvxMSDffVertPair mso_sptFlowChartPredefinedProcessVert[] =
5024 {
5025     { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
5026
5027     { 2540, 0 }, { 2540, 21600 },
5028
5029     { 21600 - 2540, 0 }, { 21600 - 2540, 21600 }
5030 };
5031 const sal_uInt16 mso_sptFlowChartPredefinedProcessSegm[] =
5032 {
5033     0x4000, 0x0003, 0x6000, 0x8000,
5034     0x4000, 0x0001, 0x8000,
5035     0x4000, 0x0001, 0x8000
5036 };
5037 const SvxMSDffTextRectangles mso_sptFlowChartPredefinedProcessTextRect[] =
5038 {
5039     { { 2540, 0 }, { 21600 - 2540, 21600 } }
5040 };
5041 const mso_CustomShape msoFlowChartPredefinedProcess =
5042 {
5043     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartPredefinedProcessVert), SAL_N_ELEMENTS( mso_sptFlowChartPredefinedProcessVert ),
5044     const_cast<sal_uInt16*>(mso_sptFlowChartPredefinedProcessSegm), sizeof( mso_sptFlowChartPredefinedProcessSegm ) >> 1,
5045     nullptr, 0,
5046     nullptr,
5047     const_cast<SvxMSDffTextRectangles*>(mso_sptFlowChartPredefinedProcessTextRect), SAL_N_ELEMENTS( mso_sptFlowChartPredefinedProcessTextRect ),
5048     21600, 21600,
5049     MIN_INT32, MIN_INT32,
5050     nullptr, 0,
5051     nullptr, 0     // handles
5052 };
5053
5054 const SvxMSDffVertPair mso_sptFlowChartInternalStorageVert[] =
5055 {
5056     { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
5057
5058     { 4230, 0 }, { 4230, 21600 },
5059
5060     { 0, 4230 }, { 21600, 4230 }
5061 };
5062 const sal_uInt16 mso_sptFlowChartInternalStorageSegm[] =
5063 {
5064     0x4000, 0x0003, 0x6000, 0x8000,
5065     0x4000, 0x0001, 0x8000,
5066     0x4000, 0x0001, 0x8000
5067 };
5068 const SvxMSDffTextRectangles mso_sptFlowChartInternalStorageTextRect[] =
5069 {
5070     { { 4230, 4230 }, { 21600, 21600 } }
5071 };
5072 const mso_CustomShape msoFlowChartInternalStorage =
5073 {
5074     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartInternalStorageVert), SAL_N_ELEMENTS( mso_sptFlowChartInternalStorageVert ),
5075     const_cast<sal_uInt16*>(mso_sptFlowChartInternalStorageSegm), sizeof( mso_sptFlowChartInternalStorageSegm ) >> 1,
5076     nullptr, 0,
5077     nullptr,
5078     const_cast<SvxMSDffTextRectangles*>(mso_sptFlowChartInternalStorageTextRect), SAL_N_ELEMENTS( mso_sptFlowChartInternalStorageTextRect ),
5079     21600, 21600,
5080     MIN_INT32, MIN_INT32,
5081     nullptr, 0,
5082     nullptr, 0     // handles
5083 };
5084
5085 const SvxMSDffVertPair mso_sptFlowChartDocumentVert[] =
5086 {
5087     { 0, 0 }, { 21600, 0 }, { 21600, 17360 },
5088     { 13050, 17220 }, { 13340, 20770 }, { 5620, 21600 },    // ccp
5089     { 2860, 21100 }, { 1850, 20700 }, { 0,  20120 }         // ccp
5090 };
5091 const sal_uInt16 mso_sptFlowChartDocumentSegm[] =
5092 {
5093     0x4000, 0x0002, 0x2002, 0x6000, 0x8000
5094 };
5095 const SvxMSDffTextRectangles mso_sptFlowChartDocumentTextRect[] =
5096 {
5097     { { 0, 0 }, { 21600, 17360 } }
5098 };
5099 const SvxMSDffVertPair mso_sptFlowChartDocumentGluePoints[] =
5100 {
5101     { 10800, 0 }, { 0, 10800 }, { 10800, 20320 }, { 21600, 10800 }
5102 };
5103 const mso_CustomShape msoFlowChartDocument =
5104 {
5105     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartDocumentVert), SAL_N_ELEMENTS( mso_sptFlowChartDocumentVert ),
5106     const_cast<sal_uInt16*>(mso_sptFlowChartDocumentSegm), sizeof( mso_sptFlowChartDocumentSegm ) >> 1,
5107     nullptr, 0,
5108     nullptr,
5109     const_cast<SvxMSDffTextRectangles*>(mso_sptFlowChartDocumentTextRect), SAL_N_ELEMENTS( mso_sptFlowChartDocumentTextRect ),
5110     21600, 21600,
5111     MIN_INT32, MIN_INT32,
5112     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartDocumentGluePoints), SAL_N_ELEMENTS( mso_sptFlowChartDocumentGluePoints ),
5113     nullptr, 0     // handles
5114 };
5115
5116 const SvxMSDffVertPair mso_sptFlowChartMultidocumentVert[] =
5117 {
5118     { 0, 3600 }, { 1500, 3600 }, { 1500, 1800 }, { 3000, 1800 },
5119     { 3000, 0 }, { 21600, 0 }, { 21600, 14409 }, { 21600 - 1500, 14409 },
5120     { 21600 - 1500, 14409 + 1800 }, { 21600 - 3000, 14409 + 1800 }, { 21600 - 3000, 14409 + 3600 },
5121     { 11610, 14293 + 3600 }, { 11472, 17239 + 3600 }, { 4833, 17928 + 3600 },                       // ccp
5122     { 2450, 17513 + 3600 }, { 1591, 17181 + 3600 }, { 0, 16700 + 3600 },                            // ccp
5123
5124     { 1500, 3600 }, { 21600 - 3000, 3600 }, { 21600 - 3000, 14409 + 1800 },
5125
5126     { 3000, 1800 }, { 21600 - 1500, 1800 }, { 21600 - 1500, 14409 }
5127 };
5128 const sal_uInt16 mso_sptFlowChartMultidocumentSegm[] =
5129 {
5130     0x4000, 0x000a, 0x2002, 0x6000, 0x8000,
5131     0x4000, 0xaa00, 0x0002, 0x8000,         // NO FILL
5132     0x4000, 0xaa00, 0x0002, 0x8000          // NO FILL
5133 };
5134 const SvxMSDffTextRectangles mso_sptFlowChartMultidocumentTextRect[] =
5135 {
5136     { { 0, 3600 }, { 21600 - 3000, 14409 + 3600 } }
5137 };
5138 const SvxMSDffVertPair mso_sptFlowChartMultidocumentGluePoints[] =
5139 {
5140     { 10800, 0 }, { 0, 10800 }, { 10800, 19890 }, { 21600, 10800 }
5141 };
5142 const mso_CustomShape msoFlowChartMultidocument =
5143 {
5144     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartMultidocumentVert), SAL_N_ELEMENTS( mso_sptFlowChartMultidocumentVert ),
5145     const_cast<sal_uInt16*>(mso_sptFlowChartMultidocumentSegm), sizeof( mso_sptFlowChartMultidocumentSegm ) >> 1,
5146     nullptr, 0,
5147     nullptr,
5148     const_cast<SvxMSDffTextRectangles*>(mso_sptFlowChartMultidocumentTextRect), SAL_N_ELEMENTS( mso_sptFlowChartMultidocumentTextRect ),
5149     21600, 21600,
5150     MIN_INT32, MIN_INT32,
5151     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartMultidocumentGluePoints), SAL_N_ELEMENTS( mso_sptFlowChartMultidocumentGluePoints ),
5152     nullptr, 0     // handles
5153 };
5154
5155 const SvxMSDffVertPair mso_sptFlowChartTerminatorVert[] =
5156 {
5157     { 3470, 21600 }, { 0, 10800 }, { 3470, 0 }, { 18130, 0 },
5158     { 21600, 10800 }, { 18130, 21600 }
5159 };
5160 const sal_uInt16 mso_sptFlowChartTerminatorSegm[] =
5161 {
5162     0x4000, 0xa702, 0x0001, 0xa702, 0x6000, 0x8000
5163 };
5164 const SvxMSDffTextRectangles mso_sptFlowChartTerminatorTextRect[] =
5165 {
5166     { { 1060, 3180 }, { 20540, 18420 } }
5167 };
5168 const mso_CustomShape msoFlowChartTerminator =
5169 {
5170     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartTerminatorVert), SAL_N_ELEMENTS( mso_sptFlowChartTerminatorVert ),
5171     const_cast<sal_uInt16*>(mso_sptFlowChartTerminatorSegm), sizeof( mso_sptFlowChartTerminatorSegm ) >> 1,
5172     nullptr, 0,
5173     nullptr,
5174     const_cast<SvxMSDffTextRectangles*>(mso_sptFlowChartTerminatorTextRect), SAL_N_ELEMENTS( mso_sptFlowChartTerminatorTextRect ),
5175     21600, 21600,
5176     MIN_INT32, MIN_INT32,
5177     const_cast<SvxMSDffVertPair*>(mso_sptStandardGluePoints), SAL_N_ELEMENTS( mso_sptStandardGluePoints ),
5178     nullptr, 0     // handles
5179 };
5180
5181 const SvxMSDffVertPair mso_sptFlowChartPreparationVert[] =
5182 {
5183     { 4350, 0 }, { 17250, 0 }, { 21600, 10800 }, { 17250, 21600 },
5184     { 4350, 21600 }, { 0, 10800 }, { 4350, 0 }
5185 };
5186 const SvxMSDffTextRectangles mso_sptFlowChartPreparationTextRect[] =
5187 {
5188     { { 4350, 0 }, { 17250, 21600 } }
5189 };
5190 const mso_CustomShape msoFlowChartPreparation =
5191 {
5192     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartPreparationVert), SAL_N_ELEMENTS( mso_sptFlowChartPreparationVert ),
5193     nullptr, 0,
5194     nullptr, 0,
5195     nullptr,
5196     const_cast<SvxMSDffTextRectangles*>(mso_sptFlowChartPreparationTextRect), SAL_N_ELEMENTS( mso_sptFlowChartPreparationTextRect ),
5197     21600, 21600,
5198     MIN_INT32, MIN_INT32,
5199     const_cast<SvxMSDffVertPair*>(mso_sptStandardGluePoints), SAL_N_ELEMENTS( mso_sptStandardGluePoints ),
5200     nullptr, 0     // handles
5201 };
5202
5203 const SvxMSDffVertPair mso_sptFlowChartManualInputVert[] =
5204 {
5205     { 0, 4300 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 }, { 0, 4300 }
5206 };
5207 const SvxMSDffTextRectangles mso_sptFlowChartManualInputTextRect[] =
5208 {
5209     { { 0, 4300 }, { 21600, 21600 } }
5210 };
5211 const SvxMSDffVertPair mso_sptFlowChartManualInputGluePoints[] =
5212 {
5213     { 10800, 2150 }, { 0, 10800 }, { 10800, 19890 }, { 21600, 10800 }
5214 };
5215 const mso_CustomShape msoFlowChartManualInput =
5216 {
5217     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartManualInputVert), SAL_N_ELEMENTS( mso_sptFlowChartManualInputVert ),
5218     nullptr, 0,
5219     nullptr, 0,
5220     nullptr,
5221     const_cast<SvxMSDffTextRectangles*>(mso_sptFlowChartManualInputTextRect), SAL_N_ELEMENTS( mso_sptFlowChartManualInputTextRect ),
5222     21600, 21600,
5223     MIN_INT32, MIN_INT32,
5224     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartManualInputGluePoints), SAL_N_ELEMENTS( mso_sptFlowChartManualInputGluePoints ),
5225     nullptr, 0     // handles
5226 };
5227
5228 const SvxMSDffVertPair mso_sptFlowChartManualOperationVert[] =
5229 {
5230     { 0, 0 }, { 21600, 0 }, { 17250, 21600 }, { 4350, 21600 }, { 0, 0 }
5231 };
5232 const SvxMSDffTextRectangles mso_sptFlowChartManualOperationTextRect[] =
5233 {
5234     { { 4350, 0 }, { 17250, 21600 } }
5235 };
5236 const SvxMSDffVertPair mso_sptFlowChartManualOperationGluePoints[] =
5237 {
5238     { 10800, 0 }, { 2160, 10800 }, { 10800, 21600 }, { 19440, 10800 }
5239 };
5240 const mso_CustomShape msoFlowChartManualOperation =
5241 {
5242     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartManualOperationVert), SAL_N_ELEMENTS( mso_sptFlowChartManualOperationVert ),
5243     nullptr, 0,
5244     nullptr, 0,
5245     nullptr,
5246     const_cast<SvxMSDffTextRectangles*>(mso_sptFlowChartManualOperationTextRect), SAL_N_ELEMENTS( mso_sptFlowChartManualOperationTextRect ),
5247     21600, 21600,
5248     MIN_INT32, MIN_INT32,
5249     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartManualOperationGluePoints), SAL_N_ELEMENTS( mso_sptFlowChartManualOperationGluePoints ),
5250     nullptr, 0     // handles
5251 };
5252
5253 const SvxMSDffVertPair mso_sptFlowChartConnectorVert[] =
5254 {
5255     { 10800, 10800 }, { 10800, 10800 },  { 0, 360 }
5256 };
5257 const sal_uInt16 mso_sptFlowChartConnectorSegm[] =
5258 {
5259     0xa203, 0x6000, 0x8000
5260 };
5261 const SvxMSDffTextRectangles mso_sptFlowChartConnectorTextRect[] =
5262 {
5263     { { 3180, 3180 }, { 18420, 18420 } }
5264 };
5265 const mso_CustomShape msoFlowChartConnector =
5266 {
5267     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartConnectorVert), SAL_N_ELEMENTS( mso_sptFlowChartConnectorVert ),
5268     const_cast<sal_uInt16*>(mso_sptFlowChartConnectorSegm), sizeof( mso_sptFlowChartConnectorSegm ) >> 1,
5269     nullptr, 0,
5270     nullptr,
5271     const_cast<SvxMSDffTextRectangles*>(mso_sptFlowChartConnectorTextRect), SAL_N_ELEMENTS( mso_sptFlowChartConnectorTextRect ),
5272     21600, 21600,
5273     MIN_INT32, MIN_INT32,
5274     const_cast<SvxMSDffVertPair*>(mso_sptEllipseGluePoints), SAL_N_ELEMENTS( mso_sptEllipseGluePoints ),
5275     nullptr, 0     // handles
5276 };
5277
5278 const SvxMSDffVertPair mso_sptFlowChartOffpageConnectorVert[] =
5279 {
5280     { 0, 0 }, { 21600, 0 }, { 21600, 17150 }, { 10800, 21600 },
5281     { 0, 17150 }, { 0, 0 }
5282 };
5283 const SvxMSDffTextRectangles mso_sptFlowChartOffpageConnectorTextRect[] =
5284 {
5285     { { 0, 0 }, { 21600, 17150 } }
5286 };
5287 const mso_CustomShape msoFlowChartOffpageConnector =
5288 {
5289     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartOffpageConnectorVert), SAL_N_ELEMENTS( mso_sptFlowChartOffpageConnectorVert ),
5290     nullptr, 0,
5291     nullptr, 0,
5292     nullptr,
5293     const_cast<SvxMSDffTextRectangles*>(mso_sptFlowChartOffpageConnectorTextRect), SAL_N_ELEMENTS( mso_sptFlowChartOffpageConnectorTextRect ),
5294     21600, 21600,
5295     MIN_INT32, MIN_INT32,
5296     const_cast<SvxMSDffVertPair*>(mso_sptStandardGluePoints), SAL_N_ELEMENTS( mso_sptStandardGluePoints ),
5297     nullptr, 0     // handles
5298 };
5299
5300 const SvxMSDffVertPair mso_sptFlowChartPunchedCardVert[] =
5301 {
5302     { 4300, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
5303     { 0, 4300 }, { 4300, 0 }
5304 };
5305 const SvxMSDffTextRectangles mso_sptFlowChartPunchedCardTextRect[] =
5306 {
5307     { { 0, 4300 }, { 21600, 21600 } }
5308 };
5309 const mso_CustomShape msoFlowChartPunchedCard =
5310 {
5311     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartPunchedCardVert), SAL_N_ELEMENTS( mso_sptFlowChartPunchedCardVert ),
5312     nullptr, 0,
5313     nullptr, 0,
5314     nullptr,
5315     const_cast<SvxMSDffTextRectangles*>(mso_sptFlowChartPunchedCardTextRect), SAL_N_ELEMENTS( mso_sptFlowChartPunchedCardTextRect ),
5316     21600, 21600,
5317     MIN_INT32, MIN_INT32,
5318     const_cast<SvxMSDffVertPair*>(mso_sptStandardGluePoints), SAL_N_ELEMENTS( mso_sptStandardGluePoints ),
5319     nullptr, 0     // handles
5320 };
5321
5322 const SvxMSDffVertPair mso_sptFlowChartPunchedTapeVert[] =
5323 {
5324     { 0, 2230 },                                            // p
5325     { 820, 3990 }, { 3410, 3980 }, { 5370, 4360 },          // ccp
5326     { 7430, 4030 }, { 10110, 3890 }, { 10690, 2270 },       // ccp
5327     { 11440, 300 }, { 14200, 160 }, { 16150, 0 },           // ccp
5328     { 18670, 170 }, {  20690, 390 }, { 21600, 2230 },       // ccp
5329     { 21600, 19420 },                                       // p
5330     { 20640, 17510 }, { 18320, 17490 }, { 16140, 17240 },   // ccp
5331     { 14710, 17370 }, { 11310, 17510 }, { 10770, 19430 },   // ccp
5332     { 10150, 21150 }, { 7380, 21290 }, { 5290, 21600 },     // ccp
5333     { 3220, 21250 }, { 610, 21130 }, { 0, 19420 }           // ccp
5334 };
5335 const sal_uInt16 mso_sptFlowChartPunchedTapeSegm[] =
5336 {
5337     0x4000, 0x2004, 0x0001, 0x2004, 0x6000, 0x8000
5338 };
5339 const SvxMSDffTextRectangles mso_sptFlowChartPunchedTapeTextRect[] =
5340 {
5341     { { 0, 4360 }, { 21600, 17240 } }
5342 };
5343 const SvxMSDffVertPair mso_sptFlowChartPunchedTapeGluePoints[] =
5344 {
5345     { 10800, 2020 }, { 0, 10800 }, { 10800, 19320 }, { 21600, 10800 }
5346 };
5347 const mso_CustomShape msoFlowChartPunchedTape =
5348 {
5349     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartPunchedTapeVert), SAL_N_ELEMENTS( mso_sptFlowChartPunchedTapeVert ),
5350     const_cast<sal_uInt16*>(mso_sptFlowChartPunchedTapeSegm), sizeof( mso_sptFlowChartPunchedTapeSegm ) >> 1,
5351     nullptr, 0,
5352     nullptr,
5353     const_cast<SvxMSDffTextRectangles*>(mso_sptFlowChartPunchedTapeTextRect), SAL_N_ELEMENTS( mso_sptFlowChartPunchedTapeTextRect ),
5354     21600, 21600,
5355     MIN_INT32, MIN_INT32,
5356     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartPunchedTapeGluePoints), SAL_N_ELEMENTS( mso_sptFlowChartPunchedTapeGluePoints ),
5357     nullptr, 0     // handles
5358 };
5359
5360 const SvxMSDffVertPair mso_sptFlowChartSummingJunctionVert[] =
5361 {
5362     { 10800, 10800 }, { 10800, 10800 }, { 0, 360 },
5363
5364     { 3100, 3100 },
5365     { 18500, 18500 },
5366
5367     { 3100, 18500 },
5368     { 18500, 3100 }
5369 };
5370 const sal_uInt16 mso_sptFlowChartSummingJunctionSegm[] =
5371 {
5372     0xa203, 0x6000, 0x8000,
5373     0x4000, 0x0001, 0x8000,
5374     0x4000, 0x0001, 0x8000
5375 };
5376 const SvxMSDffTextRectangles mso_sptFlowChartSummingJunctionTextRect[] =
5377 {
5378     { { 3100, 3100 }, { 18500, 18500 } }
5379 };
5380 const mso_CustomShape msoFlowChartSummingJunction =
5381 {
5382     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartSummingJunctionVert), SAL_N_ELEMENTS( mso_sptFlowChartSummingJunctionVert ),
5383     const_cast<sal_uInt16*>(mso_sptFlowChartSummingJunctionSegm), sizeof( mso_sptFlowChartSummingJunctionSegm ) >> 1,
5384     nullptr, 0,
5385     nullptr,
5386     const_cast<SvxMSDffTextRectangles*>(mso_sptFlowChartSummingJunctionTextRect), SAL_N_ELEMENTS( mso_sptFlowChartSummingJunctionTextRect ),
5387     21600, 21600,
5388     MIN_INT32, MIN_INT32,
5389     const_cast<SvxMSDffVertPair*>(mso_sptEllipseGluePoints), SAL_N_ELEMENTS( mso_sptEllipseGluePoints ),
5390     nullptr, 0     // handles
5391 };
5392
5393 const SvxMSDffVertPair mso_sptFlowChartOrVert[] =
5394 {
5395     { 10800, 10800 }, { 10800, 10800 }, { 0, 360 },
5396
5397     { 0, 10800 }, { 21600, 10800 },
5398
5399     { 10800, 0 }, { 10800, 21600 }
5400 };
5401 const sal_uInt16 mso_sptFlowChartOrSegm[] =
5402 {
5403     0xa203, 0x6000, 0x8000,
5404     0x4000, 0x0001, 0x8000,
5405     0x4000, 0x0001, 0x8000
5406 };
5407 const SvxMSDffTextRectangles mso_sptFlowChartOrTextRect[] =
5408 {
5409     { { 3100, 3100 }, { 18500, 18500 } }
5410 };
5411 const mso_CustomShape msoFlowChartOr =
5412 {
5413     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartOrVert), SAL_N_ELEMENTS( mso_sptFlowChartOrVert ),
5414     const_cast<sal_uInt16*>(mso_sptFlowChartOrSegm), sizeof( mso_sptFlowChartOrSegm ) >> 1,
5415     nullptr, 0,
5416     nullptr,
5417     const_cast<SvxMSDffTextRectangles*>(mso_sptFlowChartOrTextRect), SAL_N_ELEMENTS( mso_sptFlowChartOrTextRect ),
5418     21600, 21600,
5419     MIN_INT32, MIN_INT32,
5420     const_cast<SvxMSDffVertPair*>(mso_sptEllipseGluePoints), SAL_N_ELEMENTS( mso_sptEllipseGluePoints ),
5421     nullptr, 0     // handles
5422 };
5423
5424 const SvxMSDffVertPair mso_sptFlowChartCollateVert[] =
5425 {
5426     { 0, 0 }, { 21600, 21600 }, { 0, 21600 }, { 21600, 0 }, { 0, 0 }
5427 };
5428 const SvxMSDffTextRectangles mso_sptFlowChartCollateTextRect[] =
5429 {
5430     { { 5400, 5400 }, { 16200, 16200 } }
5431 };
5432 const SvxMSDffVertPair mso_sptFlowChartCollateGluePoints[] =
5433 {
5434     { 10800, 0 }, { 10800, 10800 }, { 10800, 21600 }
5435 };
5436 const mso_CustomShape msoFlowChartCollate =
5437 {
5438     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartCollateVert), SAL_N_ELEMENTS( mso_sptFlowChartCollateVert ),
5439     nullptr, 0,
5440     nullptr, 0,
5441     nullptr,
5442     const_cast<SvxMSDffTextRectangles*>(mso_sptFlowChartCollateTextRect), SAL_N_ELEMENTS( mso_sptFlowChartCollateTextRect ),
5443     21600, 21600,
5444     MIN_INT32, MIN_INT32,
5445     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartCollateGluePoints), SAL_N_ELEMENTS( mso_sptFlowChartCollateGluePoints ),
5446     nullptr, 0     // handles
5447 };
5448
5449 const SvxMSDffVertPair mso_sptFlowChartSortVert[] =
5450 {
5451     { 0, 10800 }, { 10800, 0 }, { 21600, 10800 }, { 10800, 21600 },
5452
5453     { 0, 10800 }, { 21600, 10800 }
5454 };
5455 const sal_uInt16 mso_sptFlowChartSortSegm[] =
5456 {
5457     0x4000, 0x0003, 0x6000, 0x8000,
5458     0x4000, 0x0001, 0x8000
5459 };
5460 const SvxMSDffTextRectangles mso_sptFlowChartSortTextRect[] =
5461 {
5462     { { 5400, 5400 }, { 16200, 16200 } }
5463 };
5464 const mso_CustomShape msoFlowChartSort =
5465 {
5466     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartSortVert), SAL_N_ELEMENTS( mso_sptFlowChartSortVert ),
5467     const_cast<sal_uInt16*>(mso_sptFlowChartSortSegm), sizeof( mso_sptFlowChartSortSegm ) >> 1,
5468     nullptr, 0,
5469     nullptr,
5470     const_cast<SvxMSDffTextRectangles*>(mso_sptFlowChartSortTextRect), SAL_N_ELEMENTS( mso_sptFlowChartSortTextRect ),
5471     21600, 21600,
5472     MIN_INT32, MIN_INT32,
5473     nullptr, 0,
5474     nullptr, 0     // handles
5475 };
5476
5477 const SvxMSDffVertPair mso_sptFlowChartExtractVert[] =
5478 {
5479     { 10800, 0 }, { 21600, 21600 }, { 0, 21600 }, { 10800, 0 }
5480 };
5481 const SvxMSDffTextRectangles mso_sptFlowChartExtractTextRect[] =
5482 {
5483     { { 5400, 10800 }, { 16200, 21600 } }
5484 };
5485 const SvxMSDffVertPair mso_sptFlowChartExtractGluePoints[] =
5486 {
5487     { 10800, 0 }, { 5400, 10800 }, { 10800, 21600 }, { 16200, 10800 }
5488 };
5489 const mso_CustomShape msoFlowChartExtract =
5490 {
5491     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartExtractVert), SAL_N_ELEMENTS( mso_sptFlowChartExtractVert ),
5492     nullptr, 0,
5493     nullptr, 0,
5494     nullptr,
5495     const_cast<SvxMSDffTextRectangles*>(mso_sptFlowChartExtractTextRect), SAL_N_ELEMENTS( mso_sptFlowChartExtractTextRect ),
5496     21600, 21600,
5497     MIN_INT32, MIN_INT32,
5498     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartExtractGluePoints), SAL_N_ELEMENTS( mso_sptFlowChartExtractGluePoints ),
5499     nullptr, 0     // handles
5500 };
5501
5502 const SvxMSDffVertPair mso_sptFlowChartMergeVert[] =
5503 {
5504     { 0, 0 }, { 21600, 0 }, { 10800, 21600 }, { 0, 0 }
5505 };
5506 const SvxMSDffTextRectangles mso_sptFlowChartMergeTextRect[] =
5507 {
5508     { { 5400, 0 }, { 16200, 10800 } }
5509 };
5510 const mso_CustomShape msoFlowChartMerge =
5511 {
5512     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartMergeVert), SAL_N_ELEMENTS( mso_sptFlowChartMergeVert ),
5513     nullptr, 0,
5514     nullptr, 0,
5515     nullptr,
5516     const_cast<SvxMSDffTextRectangles*>(mso_sptFlowChartMergeTextRect), SAL_N_ELEMENTS( mso_sptFlowChartMergeTextRect ),
5517     21600, 21600,
5518     MIN_INT32, MIN_INT32,
5519     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartExtractGluePoints), SAL_N_ELEMENTS( mso_sptFlowChartExtractGluePoints ),
5520     nullptr, 0     // handles
5521 };
5522
5523 const SvxMSDffVertPair mso_sptFlowChartOnlineStorageVert[] =
5524 {
5525     { 3600, 21600 }, { 0, 10800 }, { 3600, 0 }, { 21600, 0 },
5526     { 18000, 10800 }, { 21600, 21600 }
5527 };
5528 const sal_uInt16 mso_sptFlowChartOnlineStorageSegm[] =
5529 {
5530     0x4000, 0xa702, 0x0001, 0xa702, 0x6000, 0x8000
5531 };
5532 const SvxMSDffTextRectangles mso_sptFlowChartOnlineStorageTextRect[] =
5533 {
5534     { { 3600, 0 }, { 18000, 21600 } }
5535 };
5536 const SvxMSDffVertPair mso_sptFlowChartOnlineStorageGluePoints[] =
5537 {
5538     { 10800, 0 }, { 0, 10800 }, { 10800, 21600 }, { 18000, 10800 }
5539 };
5540 const mso_CustomShape msoFlowChartOnlineStorage =
5541 {
5542     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartOnlineStorageVert), SAL_N_ELEMENTS( mso_sptFlowChartOnlineStorageVert ),
5543     const_cast<sal_uInt16*>(mso_sptFlowChartOnlineStorageSegm), sizeof( mso_sptFlowChartOnlineStorageSegm ) >> 1,
5544     nullptr, 0,
5545     nullptr,
5546     const_cast<SvxMSDffTextRectangles*>(mso_sptFlowChartOnlineStorageTextRect), SAL_N_ELEMENTS( mso_sptFlowChartOnlineStorageTextRect ),
5547     21600, 21600,
5548     MIN_INT32, MIN_INT32,
5549     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartOnlineStorageGluePoints), SAL_N_ELEMENTS( mso_sptFlowChartOnlineStorageGluePoints ),
5550     nullptr, 0     // handles
5551 };
5552
5553 const SvxMSDffVertPair mso_sptFlowChartDelayVert[] =
5554 {
5555     { 10800, 0 }, { 21600, 10800 }, { 10800, 21600 }, { 0, 21600 },
5556     { 0, 0 }
5557 };
5558 const sal_uInt16 mso_sptFlowChartDelaySegm[] =
5559 {
5560     0x4000, 0xa702, 0x0002, 0x6000, 0x8000
5561 };
5562 const SvxMSDffTextRectangles mso_sptFlowChartDelayTextRect[] =
5563 {
5564     { { 0, 3100 }, { 18500, 18500 } }
5565 };
5566 const mso_CustomShape msoFlowChartDelay =
5567 {
5568     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartDelayVert), SAL_N_ELEMENTS( mso_sptFlowChartDelayVert ),
5569     const_cast<sal_uInt16*>(mso_sptFlowChartDelaySegm), sizeof( mso_sptFlowChartDelaySegm ) >> 1,
5570     nullptr, 0,
5571     nullptr,
5572     const_cast<SvxMSDffTextRectangles*>(mso_sptFlowChartDelayTextRect), SAL_N_ELEMENTS( mso_sptFlowChartDelayTextRect ),
5573     21600, 21600,
5574     MIN_INT32, MIN_INT32,
5575     const_cast<SvxMSDffVertPair*>(mso_sptStandardGluePoints), SAL_N_ELEMENTS( mso_sptStandardGluePoints ),
5576     nullptr, 0     // handles
5577 };
5578
5579 const SvxMSDffVertPair mso_sptFlowChartMagneticTapeVert[] =
5580 {
5581     { 20980, 18150 }, { 20980, 21600 }, { 10670, 21600 },
5582     { 4770, 21540 }, { 0, 16720 }, { 0, 10800 },            // ccp
5583     { 0, 4840 }, { 4840, 0 }, { 10800, 0 },                 // ccp
5584     { 16740, 0 }, { 21600, 4840 }, { 21600, 10800 },        // ccp
5585     { 21600, 13520 }, { 20550, 16160 }, { 18670, 18170 }    // ccp
5586 };
5587 const sal_uInt16 mso_sptFlowChartMagneticTapeSegm[] =
5588 {
5589     0x4000, 0x0002, 0x2004, 0x6000, 0x8000
5590 };
5591 const SvxMSDffTextRectangles mso_sptFlowChartMagneticTapeTextRect[] =
5592 {
5593     { { 3100, 3100 }, { 18500, 18500 } }
5594 };
5595 const mso_CustomShape msoFlowChartMagneticTape =
5596 {
5597     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartMagneticTapeVert), SAL_N_ELEMENTS( mso_sptFlowChartMagneticTapeVert ),
5598     const_cast<sal_uInt16*>(mso_sptFlowChartMagneticTapeSegm), sizeof( mso_sptFlowChartMagneticTapeSegm ) >> 1,
5599     nullptr, 0,
5600     nullptr,
5601     const_cast<SvxMSDffTextRectangles*>(mso_sptFlowChartMagneticTapeTextRect), SAL_N_ELEMENTS( mso_sptFlowChartMagneticTapeTextRect ),
5602     21600, 21600,
5603     MIN_INT32, MIN_INT32,
5604     const_cast<SvxMSDffVertPair*>(mso_sptStandardGluePoints), SAL_N_ELEMENTS( mso_sptStandardGluePoints ),
5605     nullptr, 0     // handles
5606 };
5607
5608 const SvxMSDffVertPair mso_sptFlowChartMagneticDiskVert[] =
5609 {
5610     { 0, 3400 }, { 10800, 0 }, { 21600, 3400 }, { 21600, 18200 },
5611     { 10800, 21600 }, { 0, 18200 },
5612
5613     { 0, 3400 }, { 10800, 6800 }, { 21600, 3400 }
5614 };
5615 const sal_uInt16 mso_sptFlowChartMagneticDiskSegm[] =
5616 {
5617     0x4000, 0xa802, 0x0001, 0xa802, 0x6000, 0x8000,
5618     0x4000, 0xa802, 0x8000
5619 };
5620 const SvxMSDffTextRectangles mso_sptFlowChartMagneticDiskTextRect[] =
5621 {
5622     { { 0, 6800 }, { 21600, 18200 } }
5623 };
5624 const SvxMSDffVertPair mso_sptFlowChartMagneticDiskGluePoints[] =
5625 {
5626     { 10800, 6800 }, { 10800, 0 }, { 0, 10800 }, { 10800, 21600 }, { 21600, 10800 }
5627 };
5628 const mso_CustomShape msoFlowChartMagneticDisk =
5629 {
5630     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartMagneticDiskVert), SAL_N_ELEMENTS( mso_sptFlowChartMagneticDiskVert ),
5631     const_cast<sal_uInt16*>(mso_sptFlowChartMagneticDiskSegm), sizeof( mso_sptFlowChartMagneticDiskSegm ) >> 1,
5632     nullptr, 0,
5633     nullptr,
5634     const_cast<SvxMSDffTextRectangles*>(mso_sptFlowChartMagneticDiskTextRect), SAL_N_ELEMENTS( mso_sptFlowChartMagneticDiskTextRect ),
5635     21600, 21600,
5636     MIN_INT32, MIN_INT32,
5637     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartMagneticDiskGluePoints), SAL_N_ELEMENTS( mso_sptFlowChartMagneticDiskGluePoints ),
5638     nullptr, 0     // handles
5639 };
5640
5641 const SvxMSDffVertPair mso_sptFlowChartMagneticDrumVert[] =
5642 {
5643     { 18200, 0 }, { 21600, 10800 }, { 18200, 21600 }, { 3400, 21600 },
5644     { 0, 10800 }, { 3400, 0 },
5645
5646     { 18200, 0 }, { 14800, 10800 }, { 18200, 21600 }
5647 };
5648 const sal_uInt16 mso_sptFlowChartMagneticDrumSegm[] =
5649 {
5650     0x4000, 0xa702, 0x0001, 0xa702, 0x6000, 0x8000,
5651     0x4000, 0xa702, 0x8000
5652 };
5653 const SvxMSDffTextRectangles mso_sptFlowChartMagneticDrumTextRect[] =
5654 {
5655     { { 3400, 0 }, { 14800, 21600 } }
5656 };
5657 const SvxMSDffVertPair mso_sptFlowChartMagneticDrumGluePoints[] =
5658 {
5659     { 10800, 0 }, { 0, 10800 }, { 10800, 21600 }, { 14800, 10800 }, { 21600, 10800 }
5660 };
5661 const mso_CustomShape msoFlowChartMagneticDrum =
5662 {
5663     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartMagneticDrumVert), SAL_N_ELEMENTS( mso_sptFlowChartMagneticDrumVert ),
5664     const_cast<sal_uInt16*>(mso_sptFlowChartMagneticDrumSegm), sizeof( mso_sptFlowChartMagneticDrumSegm ) >> 1,
5665     nullptr, 0,
5666     nullptr,
5667     const_cast<SvxMSDffTextRectangles*>(mso_sptFlowChartMagneticDrumTextRect), SAL_N_ELEMENTS( mso_sptFlowChartMagneticDrumTextRect ),
5668     21600, 21600,
5669     MIN_INT32, MIN_INT32,
5670     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartMagneticDrumGluePoints), SAL_N_ELEMENTS( mso_sptFlowChartMagneticDrumGluePoints ),
5671     nullptr, 0     // handles
5672 };
5673
5674 const SvxMSDffVertPair mso_sptFlowChartDisplayVert[] =
5675 {
5676     { 3600, 0 }, { 17800, 0 }, { 21600, 10800 }, { 17800, 21600 },
5677     { 3600, 21600 }, { 0, 10800 }
5678 };
5679 const sal_uInt16 mso_sptFlowChartDisplaySegm[] =
5680 {
5681     0x4000, 0x0001, 0xa702, 0x0002, 0x6000, 0x8000
5682 };
5683 const SvxMSDffTextRectangles mso_sptFlowChartDisplayTextRect[] =
5684 {
5685     { { 3600, 0 }, { 17800, 21600 } }
5686 };
5687 const mso_CustomShape msoFlowChartDisplay =
5688 {
5689     const_cast<SvxMSDffVertPair*>(mso_sptFlowChartDisplayVert), SAL_N_ELEMENTS( mso_sptFlowChartDisplayVert ),
5690     const_cast<sal_uInt16*>(mso_sptFlowChartDisplaySegm), sizeof( mso_sptFlowChartDisplaySegm ) >> 1,
5691     nullptr, 0,
5692     nullptr,
5693     const_cast<SvxMSDffTextRectangles*>(mso_sptFlowChartDisplayTextRect), SAL_N_ELEMENTS( mso_sptFlowChartDisplayTextRect ),
5694     21600, 21600,
5695     MIN_INT32, MIN_INT32,
5696     const_cast<SvxMSDffVertPair*>(mso_sptStandardGluePoints), SAL_N_ELEMENTS( mso_sptStandardGluePoints ),
5697     nullptr, 0     // handles
5698 };
5699
5700 const SvxMSDffVertPair mso_sptWedgeRectCalloutVert[] =
5701 {
5702     { 0, 0 },
5703     { 0, 3590 }, { 2 MSO_I, 3 MSO_I }, { 0, 8970 },
5704     { 0, 12630 },{ 4 MSO_I, 5 MSO_I }, { 0, 18010 },
5705     { 0, 21600 },
5706     { 3590, 21600 }, { 6 MSO_I, 7 MSO_I }, { 8970, 21600 },
5707     { 12630, 21600 }, { 8 MSO_I, 9 MSO_I }, { 18010, 21600 },
5708     { 21600, 21600 },
5709     { 21600, 18010 }, { 10 MSO_I, 11 MSO_I }, { 21600, 12630 },
5710     { 21600, 8970 }, { 12 MSO_I, 13 MSO_I }, { 21600, 3590 },
5711     { 21600, 0 },
5712     { 18010, 0 }, { 14 MSO_I, 15 MSO_I }, { 12630, 0 },
5713     { 8970, 0 }, { 16 MSO_I, 17 MSO_I }, { 3590, 0 },
5714     { 0, 0 }
5715 };
5716 const SvxMSDffCalculationData mso_sptWedgeRectCalloutCalc[] =
5717 {
5718     { 0x2000, { DFF_Prop_adjustValue, 0, 10800 } },     //0x400
5719     { 0x2000, { DFF_Prop_adjust2Value, 0,10800 } },
5720     { 0x6006, { 0x412, DFF_Prop_adjustValue, 0 } },     //0x402
5721     { 0x6006, { 0x412, DFF_Prop_adjust2Value, 6280 } },
5722     { 0x6006, { 0x417, DFF_Prop_adjustValue, 0 } },     //0x404
5723     { 0x6006, { 0x417, DFF_Prop_adjust2Value, 15320 } },
5724     { 0x6006, { 0x41a, DFF_Prop_adjustValue, 6280 } },  //0x406
5725     { 0x6006, { 0x41a, DFF_Prop_adjust2Value, 21600 } },
5726     { 0x6006, { 0x41d, DFF_Prop_adjustValue, 15320 } }, //0x408
5727     { 0x6006, { 0x41d, DFF_Prop_adjust2Value, 21600 } },
5728     { 0x6006, { 0x420, DFF_Prop_adjustValue, 21600 } }, //0x40a
5729     { 0x6006, { 0x420, DFF_Prop_adjust2Value, 15320 } },
5730     { 0x6006, { 0x422, DFF_Prop_adjustValue, 21600 } }, //0x40c
5731     { 0x6006, { 0x422, DFF_Prop_adjust2Value, 6280 } },
5732     { 0x6006, { 0x424, DFF_Prop_adjustValue, 15320 } }, //0x40e
5733     { 0x6006, { 0x424, DFF_Prop_adjust2Value, 0 } },
5734     { 0x6006, { 0x426, DFF_Prop_adjustValue, 6280 } },  //0x410
5735     { 0x6006, { 0x426, DFF_Prop_adjust2Value, 0 } },
5736     { 0xa006, { DFF_Prop_adjustValue, -1, 0x413 } },    //0x412
5737     { 0xa006, { 0x401, -1, 0x416 } },
5738     { 0x2003, { 0x400, 0, 0 } },                        //0x414
5739     { 0x2003, { 0x401, 0, 0 } },
5740     { 0xa000, { 0x414, 0, 0x415 } },                    //0x416
5741     { 0xa006, { DFF_Prop_adjustValue, -1, 0x418 } },
5742     { 0x6006, { 0x401, 0x416, -1 } },                   //0x418
5743     { 0x2000, { DFF_Prop_adjust2Value, 0, 21600 } },
5744     { 0x6006, { 0x419, 0x41b, -1 } },                   //0x41a
5745     { 0xa006, { 0x400, -1, 0x41c } },
5746     { 0xa000, { 0x415, 0, 0x414 } },                    //0x41c
5747     { 0x6006, { 0x419, 0x41e, -1 } },
5748     { 0x6006, { 0x400, 0x41c, -1 } },                   //0x41e
5749     { 0x2000, { DFF_Prop_adjustValue, 0, 21600 } },
5750     { 0x6006, { 0x41f, 0x421, -1 } },                   //0x420
5751     { 0x6006, { 0x401, 0x416, -1 } },
5752     { 0x6006, { 0x41f, 0x423, -1 } },                   //0x422
5753     { 0xa006, { 0x401, -1, 0x416 } },
5754     { 0xa006, { DFF_Prop_adjust2Value, -1, 0x425 } },   //0x424
5755     { 0x6006, { 0x400, 0x41c, -1 } },
5756     { 0xa006, { DFF_Prop_adjust2Value, -1, 0x427 } },   //0x426
5757     { 0xa006, { 0x400, -1, 0x41c } },
5758     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },         //0x428
5759     { 0x2000, { DFF_Prop_adjust2Value, 0, 0 } }
5760 };
5761 const sal_Int32 mso_sptWedgeRectCalloutDefault[] =
5762 {
5763     2, 1400, 25920
5764 };
5765 const SvxMSDffTextRectangles mso_sptWedgeRectCalloutTextRect[] =
5766 {
5767     { { 0, 0 }, { 21600, 21600 } }
5768 };
5769 const SvxMSDffVertPair mso_sptWedgeRectCalloutGluePoints[] =
5770 {
5771     { 10800, 0 }, { 0, 10800 },  { 10800, 21600 }, { 21600, 10800 }, { 40 MSO_I, 41 MSO_I }
5772 };
5773 const SvxMSDffHandle mso_sptCalloutHandle[] =
5774 {
5775     {
5776         SvxMSDffHandleFlags::NONE,
5777         0x100, 0x101, 10800, 10800, MIN_INT32, 0x7fffffff, MIN_INT32, 0x7fffffff
5778     }
5779 };
5780 const mso_CustomShape msoWedgeRectCallout =
5781 {
5782     const_cast<SvxMSDffVertPair*>(mso_sptWedgeRectCalloutVert), SAL_N_ELEMENTS( mso_sptWedgeRectCalloutVert ),
5783     nullptr, 0,
5784     const_cast<SvxMSDffCalculationData*>(mso_sptWedgeRectCalloutCalc), SAL_N_ELEMENTS( mso_sptWedgeRectCalloutCalc ),
5785     const_cast<sal_Int32*>(mso_sptWedgeRectCalloutDefault),
5786     const_cast<SvxMSDffTextRectangles*>(mso_sptWedgeRectCalloutTextRect), SAL_N_ELEMENTS( mso_sptWedgeRectCalloutTextRect ),
5787     21600, 21600,
5788     MIN_INT32, MIN_INT32,
5789     const_cast<SvxMSDffVertPair*>(mso_sptWedgeRectCalloutGluePoints), SAL_N_ELEMENTS( mso_sptWedgeRectCalloutGluePoints ),
5790     const_cast<SvxMSDffHandle*>(mso_sptCalloutHandle), SAL_N_ELEMENTS( mso_sptCalloutHandle )        // handles
5791 };
5792 const SvxMSDffVertPair mso_sptWedgeRRectCalloutVert[] =
5793 {
5794     { 3590, 0 },
5795     { 0, 3590 },
5796     { 2 MSO_I, 3 MSO_I }, { 0, 8970 },
5797     { 0, 12630 },{ 4 MSO_I, 5 MSO_I }, { 0, 18010 },
5798     { 3590, 21600 },
5799     { 6 MSO_I, 7 MSO_I }, { 8970, 21600 },
5800     { 12630, 21600 }, { 8 MSO_I, 9 MSO_I }, { 18010, 21600 },
5801     { 21600, 18010 },
5802     { 10 MSO_I, 11 MSO_I }, { 21600, 12630 },
5803     { 21600, 8970 }, { 12 MSO_I, 13 MSO_I }, { 21600, 3590 },
5804     { 18010, 0 },
5805     { 14 MSO_I, 15 MSO_I }, { 12630, 0 },
5806     { 8970, 0 }, { 16 MSO_I, 17 MSO_I }
5807 };
5808 const sal_uInt16 mso_sptWedgeRRectCalloutSegm[] =
5809 {
5810     0x4000, 0xa701, 0x0005, 0xa801, 0x0005, 0xa701, 0x0005, 0xa801, 0x0004, 0x6001, 0x8000
5811 };
5812 const SvxMSDffTextRectangles mso_sptWedgeRRectCalloutTextRect[] =
5813 {
5814     { { 800, 800 }, { 20800, 20800 } }
5815 };
5816 const mso_CustomShape msoWedgeRRectCallout =
5817 {
5818     const_cast<SvxMSDffVertPair*>(mso_sptWedgeRRectCalloutVert), SAL_N_ELEMENTS( mso_sptWedgeRRectCalloutVert ),
5819     const_cast<sal_uInt16*>(mso_sptWedgeRRectCalloutSegm), sizeof( mso_sptWedgeRRectCalloutSegm ) >> 1,
5820     const_cast<SvxMSDffCalculationData*>(mso_sptWedgeRectCalloutCalc), SAL_N_ELEMENTS( mso_sptWedgeRectCalloutCalc ),
5821     const_cast<sal_Int32*>(mso_sptWedgeRectCalloutDefault),
5822     const_cast<SvxMSDffTextRectangles*>(mso_sptWedgeRRectCalloutTextRect), SAL_N_ELEMENTS( mso_sptWedgeRRectCalloutTextRect ),
5823     21600, 21600,
5824     MIN_INT32, MIN_INT32,
5825     nullptr, 0,
5826     const_cast<SvxMSDffHandle*>(mso_sptCalloutHandle), SAL_N_ELEMENTS( mso_sptCalloutHandle )        // handles
5827 };
5828 const SvxMSDffVertPair mso_sptBalloonVert[] =
5829 {
5830     { 3590, 0 },
5831     { 0, 3590 },
5832     { 0, 14460 },
5833     { 3590, 18050 },
5834     { 40 MSO_I, 21600 }, { 5420, 18050 },
5835     { 18010, 18050 },
5836     { 21600, 14460 },
5837     { 21600, 3590 },
5838     { 18010, 0 }
5839 };
5840 const sal_uInt16 mso_sptBalloonSegm[] =
5841 {
5842     0x4000, 0xa701, 0x0001, 0xa801, 0x0003, 0xa701, 0x0001, 0xa801, 0x6001, 0x8000
5843 };
5844 const SvxMSDffHandle mso_sptBalloonHandle[] =
5845 {
5846     {
5847         SvxMSDffHandleFlags::RANGE,
5848         0x100, 1, 10800, 10800, 0, 8990, MIN_INT32, 0x7fffffff
5849     }
5850 };
5851 const SvxMSDffTextRectangles mso_sptBalloonTextRect[] =
5852 {
5853     { { 800, 800 }, { 20800, 17250 } }
5854 };
5855 const mso_CustomShape msoBalloon =
5856 {
5857     const_cast<SvxMSDffVertPair*>(mso_sptBalloonVert), SAL_N_ELEMENTS( mso_sptBalloonVert ),
5858     const_cast<sal_uInt16*>(mso_sptBalloonSegm), sizeof( mso_sptBalloonSegm ) >> 1,
5859     const_cast<SvxMSDffCalculationData*>(mso_sptWedgeRectCalloutCalc), SAL_N_ELEMENTS( mso_sptWedgeRectCalloutCalc ),
5860     const_cast<sal_Int32*>(mso_sptWedgeRectCalloutDefault),
5861     const_cast<SvxMSDffTextRectangles*>(mso_sptBalloonTextRect), SAL_N_ELEMENTS( mso_sptBalloonTextRect ),
5862     21600, 21600,
5863     MIN_INT32, MIN_INT32,
5864     nullptr, 0,
5865     const_cast<SvxMSDffHandle*>(mso_sptBalloonHandle), SAL_N_ELEMENTS( mso_sptBalloonHandle )        // handles
5866 };
5867 const SvxMSDffVertPair mso_sptWedgeEllipseCalloutVert[] =
5868 {
5869     { 0, 0 }, { 21600, 21600 }, { 0x16 MSO_I, 0x17 MSO_I }, { 0x12 MSO_I, 0x13 MSO_I }, { 0xe MSO_I, 0xf MSO_I }
5870 };
5871 const sal_uInt16 mso_sptWedgeEllipseCalloutSegm[] =
5872 {
5873     0xa504, 0x0001, 0x6001, 0x8000
5874 };
5875 const SvxMSDffCalculationData mso_sptWedgeEllipseCalloutCalc[] =
5876 {
5877     { 0x2000, { DFF_Prop_adjustValue, 0, 10800 } },     // 00 rad x
5878     { 0x2000, { DFF_Prop_adjust2Value, 0, 10800 } },    // 01 rad y
5879     { 0x6001, { 0x400, 0x400, 1 } },                    // 02 rad x^2
5880     { 0x6001, { 0x401, 0x401, 1 } },                    // 03 rad y^2
5881     { 0x6000, { 0x402, 0x403, 0 } },                    // 04
5882     { 0x200d, { 0x404, 0, 0 } },                        // 05
5883     { 0x2000, { 0x405, 0, 10800 } },                    // 06 > 0 ? spur needs to be drawn : 10800
5884     { 0x6008, { 0x400, 0x401, 0 } },                    // 07 atan2 -> angle
5885     { 0x2000, { 0x407, 0, 10 } },                       // 08
5886     { 0x2000, { 0x407, 10, 0 } },                       // 09
5887     { 0x400a, { 10800, 0x407, 0 } },                    // 0a
5888     { 0x4009, { 10800, 0x407, 0 } },                    // 0b
5889     { 0x2000, { 0x40a, 10800, 0 } },                    // 0c
5890     { 0x2000, { 0x40b, 10800, 0 } },                    // 0d
5891     { 0xe006, { 0x406, DFF_Prop_adjustValue, 0x40c } }, // 0e
5892     { 0xe006, { 0x406, DFF_Prop_adjust2Value, 0x40d } },// 0f
5893     { 0x400a, { 10800, 0x408, 0 } },                    // 10
5894     { 0x4009, { 10800, 0x408, 0 } },                    // 11
5895     { 0x2000, { 0x410, 10800, 0 } },                    // 12
5896     { 0x2000, { 0x411, 10800, 0 } },                    // 13
5897     { 0x400a, { 10800, 0x409, 0 } },                    // 14
5898     { 0x4009, { 10800, 0x409, 0 } },                    // 15
5899     { 0x2000, { 0x414, 10800, 0 } },                    // 16
5900     { 0x2000, { 0x415, 10800, 0 } }                     // 17
5901 };
5902 const sal_Int32 mso_sptWedgeEllipseCalloutDefault[] =
5903 {
5904     2, 1350, 25920
5905 };
5906 const SvxMSDffVertPair mso_sptWedgeEllipseCalloutGluePoints[] =
5907 {
5908     { 10800, 0 }, { 3160, 3160 }, { 0, 10800 }, { 3160, 18440 }, { 10800, 21600 }, { 18440, 18440 }, { 21600, 10800 }, { 18440, 3160 }, { 0xe MSO_I, 0xf MSO_I }
5909 };
5910 const SvxMSDffTextRectangles mso_sptWedgeEllipseCalloutTextRect[] =
5911 {
5912     { { 3200, 3200 }, { 18400, 18400 } }
5913 };
5914 const mso_CustomShape msoWedgeEllipseCallout =
5915 {
5916     const_cast<SvxMSDffVertPair*>(mso_sptWedgeEllipseCalloutVert), SAL_N_ELEMENTS( mso_sptWedgeEllipseCalloutVert ),
5917     const_cast<sal_uInt16*>(mso_sptWedgeEllipseCalloutSegm), sizeof( mso_sptWedgeEllipseCalloutSegm ) >> 1,
5918     const_cast<SvxMSDffCalculationData*>(mso_sptWedgeEllipseCalloutCalc), SAL_N_ELEMENTS( mso_sptWedgeEllipseCalloutCalc ),
5919     const_cast<sal_Int32*>(mso_sptWedgeEllipseCalloutDefault),
5920     const_cast<SvxMSDffTextRectangles*>(mso_sptWedgeEllipseCalloutTextRect), SAL_N_ELEMENTS( mso_sptWedgeEllipseCalloutTextRect ),
5921     21600, 21600,
5922     MIN_INT32, MIN_INT32,
5923     const_cast<SvxMSDffVertPair*>(mso_sptWedgeEllipseCalloutGluePoints), SAL_N_ELEMENTS( mso_sptWedgeEllipseCalloutGluePoints ),
5924     const_cast<SvxMSDffHandle*>(mso_sptCalloutHandle), SAL_N_ELEMENTS( mso_sptCalloutHandle )        // handles
5925 };
5926
5927 const SvxMSDffVertPair mso_sptCloudCalloutVert[] =
5928 {
5929     { 1930,7160 },                                      // p
5930     { 1530,4490 }, { 3400,1970 }, { 5270,1970 },        // ccp
5931     { 5860,1950 }, { 6470,2210 }, { 6970,2600 },        // ccp
5932     { 7450,1390 }, { 8340,650 }, { 9340,650 },          // ccp
5933     { 10004,690 }, { 10710,1050 }, { 11210,1700 },      // ccp
5934     { 11570,630 }, { 12330,0 }, { 13150,0 },            // ccp
5935     { 13840,0 }, { 14470,460 }, { 14870,1160 },         // ccp
5936     { 15330,440 }, { 16020,0 }, { 16740,0 },            // ccp
5937     { 17910,0 }, { 18900,1130 }, { 19110,2710 },        // ccp
5938     { 20240,3150 }, { 21060,4580 }, { 21060,6220 },     // ccp
5939     { 21060,6720 }, { 21000,7200 }, { 20830,7660 },     // ccp
5940     { 21310,8460 }, { 21600,9450 }, { 21600,10460 },    // ccp
5941     { 21600,12750 }, { 20310,14680 }, { 18650,15010 },  // ccp
5942     { 18650,17200 }, { 17370,18920 }, { 15770,18920 },  // ccp
5943     { 15220,18920 }, { 14700,18710 }, { 14240,18310 },  // ccp
5944     { 13820,20240 }, { 12490,21600 }, { 11000,21600 },  // ccp
5945     { 9890,21600 }, { 8840,20790 }, { 8210,19510 },     // ccp
5946     { 7620,20000 }, { 7930,20290 }, { 6240,20290 },     // ccp
5947     { 4850,20290 }, { 3570,19280 }, { 2900,17640 },     // ccp
5948     { 1300,17600 }, { 480,16300 }, { 480,14660 },       // ccp
5949     { 480,13900 }, { 690,13210 }, { 1070,12640 },       // ccp
5950     { 380,12160 }, { 0,11210 }, { 0,10120 },            // ccp
5951     { 0,8590 }, { 840,7330 }, { 1930,7160 },            // ccp
5952
5953     { 1930, 7160 }, { 1950, 7410 }, { 2040, 7690 }, { 2090, 7920 },         // pccp
5954     { 6970, 2600 }, { 7200, 2790 }, { 7480, 3050 }, { 7670, 3310 },         // pccp
5955     { 11210, 1700 }, { 11130, 1910 }, { 11080, 2160 }, { 11030, 2400 },     // pccp
5956     { 14870, 1160 }, { 14720, 1400 }, { 14640, 1720 }, { 14540, 2010 },     // pccp
5957     { 19110, 2710 }, { 19130, 2890 }, { 19230, 3290 }, { 19190, 3380 },     // pccp
5958     { 20830, 7660 }, { 20660, 8170 }, { 20430, 8620 }, { 20110, 8990 },     // pccp
5959     { 18660, 15010 }, { 18740, 14200 }, { 18280, 12200 }, { 17000, 11450 }, // pccp
5960     { 14240, 18310 }, { 14320, 17980 }, { 14350, 17680 }, { 14370, 17360 }, // pccp
5961     { 8220, 19510 }, { 8060, 19250 }, { 7960, 18950 }, { 7860, 18640 },     // pccp
5962     { 2900, 17640 }, { 3090, 17600 }, { 3280, 17540 }, { 3460, 17450 },     // pccp
5963     { 1070, 12640 }, { 1400, 12900 }, { 1780, 13130 }, { 2330, 13040 },     // pccp
5964
5965     { 0x11 MSO_I, 0x12 MSO_I }, { 1800, 1800 }, { 0, 360 },                 // circ1
5966     { 0x13 MSO_I, 0x14 MSO_I }, { 1200, 1200 }, { 0, 360 },                 // circ2
5967     { 0xd MSO_I, 0xe MSO_I }, { 700, 700 }, { 0, 360 }                      // circ3
5968 };
5969 const sal_uInt16 mso_sptCloudCalloutSegm[] =
5970 {
5971     0x4000, 0x2016, 0x6001, 0x8000,
5972     0x4000, 0x2001, 0xaa00, 0x8000,
5973     0x4000, 0x2001, 0xaa00, 0x8000,
5974     0x4000, 0x2001, 0xaa00, 0x8000,
5975     0x4000, 0x2001, 0xaa00, 0x8000,
5976     0x4000, 0x2001, 0xaa00, 0x8000,
5977     0x4000, 0x2001, 0xaa00, 0x8000,
5978     0x4000, 0x2001, 0xaa00, 0x8000,
5979     0x4000, 0x2001, 0xaa00, 0x8000,
5980     0x4000, 0x2001, 0xaa00, 0x8000,
5981     0x4000, 0x2001, 0xaa00, 0x8000,
5982     0x4000, 0x2001, 0xaa00, 0x8000,
5983     0xa203, 0x6001, 0x8000,
5984     0xa203, 0x6001, 0x8000,
5985     0xa203, 0x6001, 0x8000
5986 };
5987 const SvxMSDffCalculationData mso_sptCloudCalloutCalc[] =
5988 {
5989     { 0x2000, { DFF_Prop_adjustValue, 0, 10800 } },
5990     { 0x2000, { DFF_Prop_adjust2Value, 0, 10800 } },
5991     { 0x6008, { 0x400, 0x401, 0 } },
5992     { 0x400a, { 10800, 0x402, 0 } },                    // 3
5993     { 0x4009, { 10800, 0x402, 0 } },                    // 4
5994     { 0x2000, { 0x403, 10800, 0 } },                    // 5
5995     { 0x2000, { 0x404, 10800, 0 } },                    // 6
5996     { 0xa000, { DFF_Prop_adjustValue, 0, 0x405 } },     // 7
5997     { 0xa000, { DFF_Prop_adjust2Value,0, 0x406 } },     // 8
5998     { 0x2001, { 0x407, 1, 3 } },                        // 9
5999     { 0x2001, { 0x408, 1, 3 } },                        // 0xa
6000     { 0x2001, { 0x407, 2, 3 } },                        // 0xb
6001     { 0x2001, { 0x408, 2, 3 } },                        // 0xc
6002     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },         // 0xd
6003     { 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },        // 0xe
6004     { 0x2001, { 0x403, 1, 10800 / 900 } },              // 0xf  taking half x distance of the radius from the first bobble
6005     { 0x2001, { 0x404, 1, 10800 / 900 } },              // 0x10
6006     { 0xe000, { 0x409, 0x405, 0x40f } },                // 0x11
6007     { 0xe000, { 0x40a, 0x406, 0x410 } },                // 0x12
6008     { 0x6000, { 0x40b, 0x405, 0 } },                    // 0x13
6009     { 0x6000, { 0x40c, 0x406, 0 } }                     // 0x14
6010 };
6011 const sal_Int32 mso_sptCloudCalloutDefault[] =
6012 {
6013     2, 1350, 25920
6014 };
6015 const SvxMSDffTextRectangles mso_sptCloudCalloutTextRect[] =
6016 {
6017     { { 3000, 3320 }, { 17110, 17330 } }
6018 };
6019 const mso_CustomShape msoCloudCallout =
6020 {
6021     const_cast<SvxMSDffVertPair*>(mso_sptCloudCalloutVert), SAL_N_ELEMENTS( mso_sptCloudCalloutVert ),
6022     const_cast<sal_uInt16*>(mso_sptCloudCalloutSegm), sizeof( mso_sptCloudCalloutSegm ) >> 1,
6023     const_cast<SvxMSDffCalculationData*>(mso_sptCloudCalloutCalc), SAL_N_ELEMENTS( mso_sptCloudCalloutCalc ),
6024     const_cast<sal_Int32*>(mso_sptCloudCalloutDefault),
6025     const_cast<SvxMSDffTextRectangles*>(mso_sptCloudCalloutTextRect), SAL_N_ELEMENTS( mso_sptCloudCalloutTextRect ),
6026     21600, 21600,
6027     MIN_INT32, MIN_INT32,
6028     nullptr, 0,
6029     const_cast<SvxMSDffHandle*>(mso_sptCalloutHandle), SAL_N_ELEMENTS( mso_sptCalloutHandle )        // handles
6030 };
6031
6032 const SvxMSDffVertPair mso_sptWaveVert[] =   // adjustment1 : 0 - 4460
6033 {                                                   // adjustment2 : 8640 - 12960
6034     { 7 MSO_I, 0 MSO_I }, { 15 MSO_I, 9 MSO_I }, { 16 MSO_I, 10 MSO_I }, { 12 MSO_I, 0 MSO_I },
6035     { 24 MSO_I, 1 MSO_I }, { 25 MSO_I, 26 MSO_I }, { 27 MSO_I, 28 MSO_I }, { 29 MSO_I, 1 MSO_I }
6036 };
6037 const SvxMSDffCalculationData mso_sptWaveCalc[] =
6038 {
6039     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, //400 (vert.adj)
6040     { 0x8000, { 21600, 0, 0x400 } },            //401
6041     { 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },//402 (horz.adj)
6042     { 0x2000, { 0x402, 0, 10800 } },            //403 -2160 -> 2160 (horz.adj)
6043     { 0x2001, { 0x403, 2, 1 } },                //404 -4320 -> 4320 (horz.adj)
6044     { 0x2003, { 0x404, 0, 0 } },                //405 abs( 0x404 )  (horz.adj)
6045     { 0x8000, { 4320, 0, 0x405 } },             //406
6046     { 0xa006, { 0x403, 0, 0x405 } },            //407
6047     { 0x4001, { 15800, 0x400, 4460 } },         //408 0 -> 15800    (vert.adj)
6048     { 0xa000, { 0x400, 0, 0x408 } },            //409
6049     { 0x6000, { 0x400, 0x408, 0 } },            //40a
6050     { 0x8000, { 21600, 0, 0x404 } },            //40b
6051     { 0x6006, { 0x403, 0x40b, 21600 } },        //40c
6052     { 0xa000, { 0x40c, 0, 0x407 } },            //40d width between p0 and p1
6053     { 0x2001, { 0x405, 1, 2 } },                //40e
6054     { 0xa000, { 0x407, 7200, 0x40e } },         //40f
6055     { 0x6000, { 0x40c, 0x40e, 7200 } },         //410
6056     { 0x2001, { 0x40d, 1, 2 } },                //411 1/2 width
6057     { 0x6000, { 0x407, 0x411, 0 } },            //412 top center glue xpos
6058     { 0x8000, { 21600, 0, 0x412 } },            //413 bottom center glue xpos
6059     { 0x2001, { 0x405, 1, 2 } },                //414 left glue x pos
6060     { 0x8000, { 21600, 0, 0x414 } },            //415 right glue x pos
6061     { 0x2001, { 0x400, 2, 1 } },                //416 y1 (textbox)
6062     { 0x8000, { 21600, 0, 0x416 } },            //417 y2 (textbox)
6063
6064     { 0x8000, { 21600, 0, 0x407 } },            //418 p2
6065
6066     { 0x8000, { 21600, 0, 0x40f } },            //419 c
6067     { 0x6000, { 0x401, 0x408, 0 } },            //41a
6068
6069     { 0x8000, { 21600, 0, 0x410 } },            //41b c
6070     { 0xa000, { 0x401, 0, 0x408 } },            //41c
6071
6072     { 0x8000, { 21600, 0, 0x40c } }             //41d p3
6073 };
6074 const SvxMSDffVertPair mso_sptWaveGluePoints[] =
6075 {
6076     { 0x12 MSO_I, 0 MSO_I }, { 0x14 MSO_I, 10800 }, { 0x13 MSO_I, 1 MSO_I }, { 0x15 MSO_I, 10800 }
6077 };
6078 const sal_uInt16 mso_sptWaveSegm[] =
6079 {
6080     0x4000, 0x2001, 0x0001, 0x2001, 0x6000, 0x8000
6081 };
6082 const SvxMSDffHandle mso_sptWaveHandle[] =
6083 {
6084     {   SvxMSDffHandleFlags::RANGE,
6085         0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 4460 },
6086     {   SvxMSDffHandleFlags::RANGE,
6087         0x101, 21600, 10800, 10800, 8640, 12960, MIN_INT32, 0x7fffffff }
6088 };
6089 const sal_Int32 mso_sptWaveDefault[] =
6090 {
6091     2, 1400, 10800
6092 };
6093 const SvxMSDffTextRectangles mso_sptWaveTextRect[] =
6094 {
6095     { { 5 MSO_I, 22 MSO_I }, { 11 MSO_I, 23 MSO_I } }
6096 };
6097 const mso_CustomShape msoWave =
6098 {
6099     const_cast<SvxMSDffVertPair*>(mso_sptWaveVert), SAL_N_ELEMENTS( mso_sptWaveVert ),
6100     const_cast<sal_uInt16*>(mso_sptWaveSegm), sizeof( mso_sptWaveSegm ) >> 1,
6101     const_cast<SvxMSDffCalculationData*>(mso_sptWaveCalc), SAL_N_ELEMENTS( mso_sptWaveCalc ),
6102     const_cast<sal_Int32*>(mso_sptWaveDefault),
6103     const_cast<SvxMSDffTextRectangles*>(mso_sptWaveTextRect), SAL_N_ELEMENTS( mso_sptWaveTextRect ),
6104     21600, 21600,
6105     MIN_INT32, MIN_INT32,
6106     const_cast<SvxMSDffVertPair*>(mso_sptWaveGluePoints), SAL_N_ELEMENTS( mso_sptWaveGluePoints ),
6107     const_cast<SvxMSDffHandle*>(mso_sptWaveHandle), SAL_N_ELEMENTS( mso_sptWaveHandle )
6108 };
6109
6110 const SvxMSDffVertPair mso_sptDoubleWaveVert[] = // adjustment1 : 0 - 2230
6111 {                                                       // adjustment2 : 8640 - 12960
6112     { 7 MSO_I, 0 MSO_I }, { 15 MSO_I, 9 MSO_I }, { 0x1f MSO_I, 10 MSO_I }, { 0x12 MSO_I, 0 MSO_I }, { 0x1e MSO_I, 9 MSO_I }, { 16 MSO_I, 10 MSO_I }, { 12 MSO_I, 0 MSO_I },
6113     { 24 MSO_I, 1 MSO_I }, { 25 MSO_I, 26 MSO_I }, { 0x20 MSO_I, 28 MSO_I }, { 0x13 MSO_I, 1 MSO_I }, { 0x21 MSO_I, 26 MSO_I }, { 27 MSO_I, 28 MSO_I }, { 29 MSO_I, 1 MSO_I }
6114 };
6115 const SvxMSDffCalculationData mso_sptDoubleWaveCalc[] =
6116 {
6117     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, //400 (vert.adj)
6118     { 0x8000, { 21600, 0, 0x400 } },            //401
6119     { 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },//402 (horz.adj)
6120     { 0x2000, { 0x402, 0, 10800 } },            //403 -2160 -> 2160 (horz.adj)
6121     { 0x2001, { 0x403, 2, 1 } },                //404 -4320 -> 4320 (horz.adj)
6122     { 0x2003, { 0x404, 0, 0 } },                //405 abs( 0x404 )  (horz.adj)
6123     { 0x8000, { 4320, 0, 0x405 } },             //406 -> not used
6124     { 0xa006, { 0x403, 0, 0x405 } },            //407
6125     { 0x4001, { 7900, 0x400, 2230 } },          //408 0 -> 7900 (vert.adj)
6126     { 0xa000, { 0x400, 0, 0x408 } },            //409
6127     { 0x6000, { 0x400, 0x408, 0 } },            //40a
6128     { 0x8000, { 21600, 0, 0x404 } },            //40b
6129     { 0x6006, { 0x403, 0x40b, 21600 } },        //40c
6130     { 0xa000, { 0x40c, 0, 0x407 } },            //40d width between p0 and p1
6131     { 0x2001, { 0x405, 1, 2 } },                //40e
6132     { 0xa000, { 0x407, 3600, 0x40e } },         //40f
6133     { 0x6000, { 0x40c, 0x40e, 3600 } },         //410
6134     { 0x2001, { 0x40d, 1, 2 } },                //411 1/2 width
6135     { 0x6000, { 0x407, 0x411, 0 } },            //412 top center glue xpos
6136     { 0x8000, { 21600, 0, 0x412 } },            //413 bottom center glue xpos
6137     { 0x2001, { 0x405, 1, 2 } },                //414 left glue x pos
6138     { 0x8000, { 21600, 0, 0x414 } },            //415 right glue x pos
6139     { 0x2001, { 0x400, 2, 1 } },                //416 y1 (textbox)
6140     { 0x8000, { 21600, 0, 0x416 } },            //417 y2 (textbox)
6141
6142     { 0x8000, { 21600, 0, 0x407 } },            //418 p2
6143
6144     { 0x8000, { 21600, 0, 0x40f } },            //419 c
6145     { 0x6000, { 0x401, 0x408, 0 } },            //41a
6146
6147     { 0x8000, { 21600, 0, 0x410 } },            //41b c
6148     { 0xa000, { 0x401, 0, 0x408 } },            //41c
6149
6150     { 0x8000, { 21600, 0, 0x40c } },            //41d p3
6151     { 0xa000, { 0x412, 3600, 0x40e } },         //41e
6152     { 0x6000, { 0x412, 0x40e, 3600 } },         //41f
6153     { 0xa000, { 0x413, 3600, 0x40e } },         //420
6154     { 0x6000, { 0x413, 0x40e, 3600 } }          //421
6155 };
6156 const SvxMSDffVertPair mso_sptDoubleWaveGluePoints[] =
6157 {
6158     { 0x12 MSO_I, 0 MSO_I }, { 0x14 MSO_I, 10800 }, { 0x13 MSO_I, 1 MSO_I }, { 0x15 MSO_I, 10800 }
6159 };
6160 const sal_uInt16 mso_sptDoubleWaveSegm[] =
6161 {
6162     0x4000, 0x2002, 0x0001, 0x2002, 0x6000, 0x8000
6163 };
6164 const SvxMSDffHandle mso_sptDoubleWaveHandle[] =
6165 {
6166     {   SvxMSDffHandleFlags::RANGE,
6167         0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 2230 },
6168     {   SvxMSDffHandleFlags::RANGE,
6169         0x101, 21600, 10800, 10800, 8640, 12960, MIN_INT32, 0x7fffffff }
6170 };
6171 const sal_Int32 mso_sptDoubleWaveDefault[] =
6172 {
6173     2, 1400, 10800
6174 };
6175 const SvxMSDffTextRectangles mso_sptDoubleWaveTextRect[] =
6176 {
6177     { { 5 MSO_I, 22 MSO_I }, { 11 MSO_I, 23 MSO_I } }
6178 };
6179 const mso_CustomShape msoDoubleWave =
6180 {
6181     const_cast<SvxMSDffVertPair*>(mso_sptDoubleWaveVert), SAL_N_ELEMENTS( mso_sptDoubleWaveVert ),
6182     const_cast<sal_uInt16*>(mso_sptDoubleWaveSegm), sizeof( mso_sptDoubleWaveSegm ) >> 1,
6183     const_cast<SvxMSDffCalculationData*>(mso_sptDoubleWaveCalc), SAL_N_ELEMENTS( mso_sptDoubleWaveCalc ),
6184     const_cast<sal_Int32*>(mso_sptDoubleWaveDefault),
6185     const_cast<SvxMSDffTextRectangles*>(mso_sptDoubleWaveTextRect), SAL_N_ELEMENTS( mso_sptDoubleWaveTextRect ),
6186     21600, 21600,
6187     MIN_INT32, MIN_INT32,
6188     const_cast<SvxMSDffVertPair*>(mso_sptDoubleWaveGluePoints), SAL_N_ELEMENTS( mso_sptDoubleWaveGluePoints ),
6189     const_cast<SvxMSDffHandle*>(mso_sptDoubleWaveHandle), SAL_N_ELEMENTS( mso_sptDoubleWaveHandle )
6190 };
6191
6192 // for each shapetype a bit of 1 is indicating that the shape is NOT filled by default
6193 const sal_uInt16 mso_DefaultFillingTable[] =
6194 {
6195     0x0000, 0x0018, 0x01ff, 0x0000, 0x0c00, 0x01e0, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0600, 0x0000, 0x0000, 0x0000, 0x0000
6196 };
6197 bool IsCustomShapeFilledByDefault( MSO_SPT eSpType )
6198 {
6199     bool bIsFilledByDefault = true;
6200     sal_uInt32 i = static_cast<sal_uInt32>(eSpType);
6201     if ( i < 0x100 )
6202         bIsFilledByDefault = ( mso_DefaultFillingTable[ i >> 4 ] & ( 1 << ( i & 0xf ) ) ) == 0;
6203     return bIsFilledByDefault;
6204 }
6205 sal_Int16 GetCustomShapeConnectionTypeDefault( MSO_SPT eSpType )
6206 {
6207     sal_Int16 nGluePointType = css::drawing::EnhancedCustomShapeGluePointType::SEGMENTS;
6208     const mso_CustomShape* pDefCustomShape = GetCustomShapeContent( eSpType );
6209     if ( pDefCustomShape && pDefCustomShape->nGluePoints )
6210         nGluePointType = css::drawing::EnhancedCustomShapeGluePointType::CUSTOM;
6211     else
6212     {
6213         switch( eSpType )
6214         {
6215             case mso_sptRectangle :
6216             case mso_sptRoundRectangle :
6217             case mso_sptPictureFrame :
6218             case mso_sptFlowChartProcess :
6219             case mso_sptFlowChartPredefinedProcess :
6220             case mso_sptFlowChartInternalStorage :
6221             case mso_sptTextPlainText :
6222             case mso_sptTextBox :
6223             case mso_sptVerticalScroll :
6224             case mso_sptHorizontalScroll :
6225                 nGluePointType = css::drawing::EnhancedCustomShapeGluePointType::RECT;
6226                 break;
6227             default: break;
6228         }
6229     }
6230     return nGluePointType;
6231 }
6232
6233 // for each shapetype a bit of 1 is indicating that the shape is NOT stroked by default
6234 // #i28269#
6235 const sal_uInt16 mso_DefaultStrokingTable[] =
6236 {
6237     0x0000, 0x0000, 0x0000, 0x0000,
6238     0x0800, 0x0000, 0x0000, 0x0000, // #i28269# Added shape 75 (mso_sptPictureFrame)
6239     0x0000, 0x0000, 0x0000, 0x0000,
6240     0x0000, 0x0000, 0x0000, 0x0000
6241 };
6242 // #i28269#
6243 bool IsCustomShapeStrokedByDefault( MSO_SPT eSpType )
6244 {
6245     bool bIsStrokedByDefault = true;
6246     sal_uInt32 i = static_cast<sal_uInt32>(eSpType);
6247     if ( i < 0x100 )
6248         bIsStrokedByDefault = ( mso_DefaultStrokingTable[ i >> 4 ] & ( 1 << ( i & 0xf ) ) ) == 0;
6249     return bIsStrokedByDefault;
6250 }
6251
6252 const sal_uInt16 msoSortFilledObjectsToBackTable[] =
6253 {
6254     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0010, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000
6255 };
6256 bool SortFilledObjectsToBackByDefault( MSO_SPT eSpType )
6257 {
6258     bool bSortFilledObjectsToBackByDefault = true;
6259     sal_uInt32 i = static_cast<sal_uInt32>(eSpType);
6260     if ( i < 0x100 )
6261         bSortFilledObjectsToBackByDefault = ( msoSortFilledObjectsToBackTable[ i >> 4 ] & ( 1 << ( i & 0xf ) ) ) != 0;
6262     return bSortFilledObjectsToBackByDefault;
6263 }
6264
6265 const SvxMSDffTextRectangles mso_sptFontWorkTextRect[] =
6266 {
6267     { { 0, 0 }, { 21600, 21600 } }
6268 };
6269
6270 const SvxMSDffVertPair mso_sptTextPlainTextVert[] =
6271 {
6272     { 3 MSO_I, 0 }, { 5 MSO_I, 0 }, { 6 MSO_I, 21600 }, { 7 MSO_I, 21600 }
6273 };
6274 const SvxMSDffCalculationData mso_sptTextPlainTextCalc[] =   // adjustment1 : 6629 - 14971
6275 {
6276     { 0x2000, { DFF_Prop_adjustValue, 0, 10800 } },
6277     { 0x2001, { 0x400, 2, 1 } },
6278     { 0x2003, { 0x401, 0, 0 } },
6279     { 0xa006, { 0x401, 0, 0x402 } },        // x1(3)
6280     { 0x8000, { 21600, 0, 0x402 } },
6281     { 0x6006, { 0x401, 0x404, 21600 } },    // x2(5)
6282     { 0x6006, { 0x401, 0x402, 0 } },        // x2
6283     { 0xa006, { 0x401, 21600, 0x404 } }     // x3(7)
6284 };
6285 const sal_uInt16 mso_sptTextPlainTextSegm[] =
6286 {
6287     0x4000, 0x0001, 0x8000,
6288     0x4000, 0x0001, 0x8000
6289 };
6290 const SvxMSDffHandle mso_sptTextPlainTextHandle[] =
6291 {
6292     {   SvxMSDffHandleFlags::RANGE,
6293         0x100, 21600, 10800, 10800, 6629, 14971, MIN_INT32, 0x7fffffff }
6294 };
6295 const mso_CustomShape msoTextPlainText =
6296 {
6297     const_cast<SvxMSDffVertPair*>(mso_sptTextPlainTextVert), SAL_N_ELEMENTS( mso_sptTextPlainTextVert ),
6298     const_cast<sal_uInt16*>(mso_sptTextPlainTextSegm), sizeof( mso_sptTextPlainTextSegm ) >> 1,
6299     const_cast<SvxMSDffCalculationData*>(mso_sptTextPlainTextCalc), SAL_N_ELEMENTS( mso_sptTextPlainTextCalc ),
6300     const_cast<sal_Int32*>(mso_sptDefault10800),
6301     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
6302     21600, 21600,
6303     MIN_INT32, MIN_INT32,
6304     nullptr, 0,
6305     const_cast<SvxMSDffHandle*>(mso_sptTextPlainTextHandle), SAL_N_ELEMENTS( mso_sptTextPlainTextHandle )
6306 };
6307
6308 const SvxMSDffVertPair mso_sptTextStopVert[] =
6309 {
6310     { 0, 0 MSO_I }, { 7200, 0 }, { 14400, 0 }, { 21600, 0 MSO_I },
6311     { 0, 1 MSO_I }, { 7200, 21600 }, { 14400, 21600 }, { 21600, 1 MSO_I }
6312 };
6313 const SvxMSDffCalculationData mso_sptTextStopCalc[] =    // adjustment1 : 3080 - 10800
6314 {
6315     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
6316     { 0x8000, { 21600, 0, DFF_Prop_adjustValue } }
6317 };
6318 const sal_uInt16 mso_sptTextStopSegm[] =
6319 {
6320     0x4000, 0x0003, 0x8000,
6321     0x4000, 0x0003, 0x8000
6322 };
6323 const sal_Int32 mso_sptTextStopDefault[] =
6324 {
6325     1, 2700
6326 };
6327 const SvxMSDffHandle mso_sptTextStopHandle[] =
6328 {
6329     {   SvxMSDffHandleFlags::RANGE,
6330         0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 3080, 10800 }
6331 };
6332 const mso_CustomShape msoTextStop =
6333 {
6334     const_cast<SvxMSDffVertPair*>(mso_sptTextStopVert), SAL_N_ELEMENTS( mso_sptTextStopVert ),
6335     const_cast<sal_uInt16*>(mso_sptTextStopSegm), sizeof( mso_sptTextStopSegm ) >> 1,
6336     const_cast<SvxMSDffCalculationData*>(mso_sptTextStopCalc), SAL_N_ELEMENTS( mso_sptTextStopCalc ),
6337     const_cast<sal_Int32*>(mso_sptTextStopDefault),
6338     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
6339     21600, 21600,
6340     MIN_INT32, MIN_INT32,
6341     nullptr, 0,
6342     const_cast<SvxMSDffHandle*>(mso_sptTextStopHandle), SAL_N_ELEMENTS( mso_sptTextStopHandle )
6343 };
6344
6345 const SvxMSDffVertPair mso_sptTextTriangleVert[] =
6346 {
6347     { 0, 0 MSO_I }, { 10800, 0 }, { 21600, 0 MSO_I }, { 0, 21600 }, { 21600, 21600 }
6348 };
6349 const SvxMSDffCalculationData mso_sptTextTriangleCalc[] =    // adjustment1 : 6629 - 14971
6350 {
6351     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } }
6352 };
6353 const sal_uInt16 mso_sptTextTriangleSegm[] =
6354 {
6355     0x4000, 0x0002, 0x8000,
6356     0x4000, 0x0001, 0x8000
6357 };
6358 const SvxMSDffHandle mso_sptTextTriangleHandle[] =
6359 {
6360     {   SvxMSDffHandleFlags::RANGE,
6361         0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 21600 }
6362 };
6363 const mso_CustomShape msoTextTriangle =
6364 {
6365     const_cast<SvxMSDffVertPair*>(mso_sptTextTriangleVert), SAL_N_ELEMENTS( mso_sptTextTriangleVert ),
6366     const_cast<sal_uInt16*>(mso_sptTextTriangleSegm), sizeof( mso_sptTextTriangleSegm ) >> 1,
6367     const_cast<SvxMSDffCalculationData*>(mso_sptTextTriangleCalc), SAL_N_ELEMENTS( mso_sptTextTriangleCalc ),
6368     const_cast<sal_Int32*>(mso_sptDefault10800),
6369     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
6370     21600, 21600,
6371     MIN_INT32, MIN_INT32,
6372     nullptr, 0,
6373     const_cast<SvxMSDffHandle*>(mso_sptTextTriangleHandle), SAL_N_ELEMENTS( mso_sptTextTriangleHandle )
6374 };
6375 const SvxMSDffVertPair mso_sptTextTriangleInvertedVert[] =
6376 {
6377     { 0, 0 }, { 21600, 0 }, { 0, 0 MSO_I }, { 10800, 21600 }, { 21600, 0 MSO_I }
6378 };
6379 const sal_uInt16 mso_sptTextTriangleInvertedSegm[] =
6380 {
6381     0x4000, 0x0001, 0x8000,
6382     0x4000, 0x0002, 0x8000
6383 };
6384 const mso_CustomShape msoTextTriangleInverted =
6385 {
6386     const_cast<SvxMSDffVertPair*>(mso_sptTextTriangleInvertedVert), SAL_N_ELEMENTS( mso_sptTextTriangleInvertedVert ),
6387     const_cast<sal_uInt16*>(mso_sptTextTriangleInvertedSegm), sizeof( mso_sptTextTriangleInvertedSegm ) >> 1,
6388     const_cast<SvxMSDffCalculationData*>(mso_sptTextTriangleCalc), SAL_N_ELEMENTS( mso_sptTextTriangleCalc ),
6389     const_cast<sal_Int32*>(mso_sptDefault10800),
6390     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
6391     21600, 21600,
6392     MIN_INT32, MIN_INT32,
6393     nullptr, 0,
6394     const_cast<SvxMSDffHandle*>(mso_sptTextTriangleHandle), SAL_N_ELEMENTS( mso_sptTextTriangleHandle )
6395 };
6396
6397 const SvxMSDffVertPair mso_sptTextChevronVert[] =
6398 {
6399     { 0, 0 MSO_I }, { 10800, 0 }, { 21600, 0 MSO_I }, { 0, 21600 }, { 10800, 1 MSO_I }, { 21600, 21600 }
6400 };
6401 const SvxMSDffCalculationData mso_sptTextChevronCalc[] = // adjustment1 : 6629 - 14971
6402 {
6403     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
6404     { 0x8000, { 21600, 0, DFF_Prop_adjustValue } }
6405 };
6406 const sal_uInt16 mso_sptTextChevronSegm[] =
6407 {
6408     0x4000, 0x0002, 0x8000,
6409     0x4000, 0x0002, 0x8000
6410 };
6411 const SvxMSDffHandle mso_sptTextChevronHandle[] =
6412 {
6413     {   SvxMSDffHandleFlags::RANGE,
6414         0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 10800 }
6415 };
6416 const mso_CustomShape msoTextChevron =
6417 {
6418     const_cast<SvxMSDffVertPair*>(mso_sptTextChevronVert), SAL_N_ELEMENTS( mso_sptTextChevronVert ),
6419     const_cast<sal_uInt16*>(mso_sptTextChevronSegm), sizeof( mso_sptTextChevronSegm ) >> 1,
6420     const_cast<SvxMSDffCalculationData*>(mso_sptTextChevronCalc), SAL_N_ELEMENTS( mso_sptTextChevronCalc ),
6421     const_cast<sal_Int32*>(mso_sptDefault5400),
6422     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
6423     21600, 21600,
6424     MIN_INT32, MIN_INT32,
6425     nullptr, 0,
6426     const_cast<SvxMSDffHandle*>(mso_sptTextChevronHandle), SAL_N_ELEMENTS( mso_sptTextChevronHandle )
6427 };
6428
6429 const SvxMSDffVertPair mso_sptTextChevronInvertedVert[] =
6430 {
6431     { 0, 0 }, { 10800, 1 MSO_I }, { 21600, 0 }, { 0, 0 MSO_I }, { 10800, 21600 }, { 21600, 0 MSO_I }
6432 };
6433 const SvxMSDffCalculationData mso_sptTextChevronInvertedCalc[] = // adjustment1 : 6629 - 14971
6434 {
6435     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
6436     { 0x8000, { 21600, 0, DFF_Prop_adjustValue } }
6437 };
6438 const sal_uInt16 mso_sptTextChevronInvertedSegm[] =
6439 {
6440     0x4000, 0x0002, 0x8000,
6441     0x4000, 0x0002, 0x8000
6442 };
6443 const SvxMSDffHandle mso_sptTextChevronInvertedHandle[] =
6444 {
6445     {   SvxMSDffHandleFlags::RANGE,
6446         0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 10800, 21600 }
6447 };
6448 const mso_CustomShape msoTextChevronInverted =
6449 {
6450     const_cast<SvxMSDffVertPair*>(mso_sptTextChevronInvertedVert), SAL_N_ELEMENTS( mso_sptTextChevronInvertedVert ),
6451     const_cast<sal_uInt16*>(mso_sptTextChevronInvertedSegm), sizeof( mso_sptTextChevronInvertedSegm ) >> 1,
6452     const_cast<SvxMSDffCalculationData*>(mso_sptTextChevronInvertedCalc), SAL_N_ELEMENTS( mso_sptTextChevronInvertedCalc ),
6453     const_cast<sal_Int32*>(mso_sptDefault16200),
6454     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
6455     21600, 21600,
6456     MIN_INT32, MIN_INT32,
6457     nullptr, 0,
6458     const_cast<SvxMSDffHandle*>(mso_sptTextChevronInvertedHandle), SAL_N_ELEMENTS( mso_sptTextChevronInvertedHandle )
6459 };
6460 //V 0 0 21600 ?f2 0 ?f0 21600 ?f0
6461 //W 0 0 21600 ?f2 21600 ?f0 0 ?f0 N
6462 //V 0 ?f3 21600 21600 0 ?f1 21600 ?f1
6463 //W 0 ?f3 21600 21600 21600 ?f1 0 ?f1 N
6464 //mso_sptTextRingInside
6465 const SvxMSDffVertPair mso_sptTextRingInsideVert[] =
6466 {
6467     { 0, 0 }, { 21600, 2 MSO_I }, { 0, 0 MSO_I },{ 21600, 0 MSO_I },//V
6468     { 0, 0 }, { 21600, 2 MSO_I }, { 21600, 0 MSO_I },{ 0, 0 MSO_I },//W
6469     { 0, 3 MSO_I }, { 21600, 21600 }, { 0, 1 MSO_I },{ 21600, 1 MSO_I },//V
6470     { 0, 3 MSO_I }, { 21600, 21600 }, { 21600, 1 MSO_I },{ 0, 1 MSO_I }//W
6471 };
6472 const SvxMSDffCalculationData mso_sptTextRingInsideCalc[] =  // adjustment1 : 6629 - 14971
6473 {
6474     { 0x2001, { DFF_Prop_adjustValue, 1, 2 } },
6475     { 0x8000, { 21600, 0, 0x400 } },
6476     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, //$0
6477     { 0x8000, { 21600, 0, DFF_Prop_adjustValue } }//21600-$0
6478 };
6479 const sal_uInt16 mso_sptTextRingInsideSegm[] =
6480 {
6481     0xa604, 0xa504,0x8000,
6482     0xa604, 0xa504,0x8000
6483 };
6484 const SvxMSDffHandle mso_sptTextRingInsideHandle[] =
6485 {
6486     {   SvxMSDffHandleFlags::RANGE| SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL,
6487         10800, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 10800, 21600 }
6488 };
6489 const mso_CustomShape msoTextRingInside =
6490 {
6491     const_cast<SvxMSDffVertPair*>(mso_sptTextRingInsideVert), SAL_N_ELEMENTS( mso_sptTextRingInsideVert ),
6492     const_cast<sal_uInt16*>(mso_sptTextRingInsideSegm), sizeof( mso_sptTextRingInsideSegm ) >> 1,
6493     const_cast<SvxMSDffCalculationData*>(mso_sptTextRingInsideCalc), SAL_N_ELEMENTS( mso_sptTextRingInsideCalc ),
6494     const_cast<sal_Int32*>(mso_sptDefault13500),
6495     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
6496     21600, 21600,
6497     MIN_INT32, MIN_INT32,
6498     nullptr, 0,
6499     const_cast<SvxMSDffHandle*>(mso_sptTextRingInsideHandle), SAL_N_ELEMENTS( mso_sptTextRingInsideHandle )
6500 };
6501 //mso_sptTextRingOutside
6502 //path = U 10800 ?f0 10800 ?f2 180 539 N U 10800 ?f1 10800 ?f2 180 539 N
6503 // MSO binary format has swing angle, not end angle, therefore 359 instead of 539.
6504 const SvxMSDffVertPair mso_sptTextRingOutsideVert[] =
6505 {
6506     { 10800, 0 MSO_I }, { 10800, 0 MSO_I }, { 180, 359 },
6507     { 10800, 1 MSO_I }, { 10800, 0 MSO_I }, { 180, 359 }
6508 };
6509 const SvxMSDffCalculationData mso_sptTextRingOutsideCalc[] = // adjustment1 : 6629 - 14971
6510 {
6511     { 0x2001, { DFF_Prop_adjustValue, 1, 2 } },
6512     { 0x8000, { 21600, 0, 0x400 } }
6513 };
6514 const sal_uInt16 mso_sptTextRingOutsideSegm[] =
6515 {
6516     0xA203, 0x8000,
6517     0xA203, 0x8000
6518 };
6519 const SvxMSDffHandle mso_sptTextRingOutsideHandle[] =
6520 {
6521     {   SvxMSDffHandleFlags::RANGE,
6522         10800, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 10800, 21600 }
6523 };
6524 const mso_CustomShape msoTextRingOutside =
6525 {
6526     const_cast<SvxMSDffVertPair*>(mso_sptTextRingOutsideVert), SAL_N_ELEMENTS( mso_sptTextRingOutsideVert ),
6527     const_cast<sal_uInt16*>(mso_sptTextRingOutsideSegm), sizeof( mso_sptTextRingOutsideSegm ) >> 1,
6528     const_cast<SvxMSDffCalculationData*>(mso_sptTextRingOutsideCalc), SAL_N_ELEMENTS( mso_sptTextRingOutsideCalc ),
6529     const_cast<sal_Int32*>(mso_sptDefault13500),
6530     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
6531     21600, 21600,
6532     MIN_INT32, MIN_INT32,
6533     nullptr, 0,
6534     const_cast<SvxMSDffHandle*>(mso_sptTextRingOutsideHandle), SAL_N_ELEMENTS( mso_sptTextRingOutsideHandle )
6535 };
6536
6537 const SvxMSDffVertPair mso_sptTextFadeRightVert[] =
6538 {
6539     { 0, 0 }, { 21600, 0 MSO_I }, { 0, 21600 }, { 21600, 1 MSO_I }
6540 };
6541 const SvxMSDffCalculationData mso_sptTextFadeCalc[] =
6542 {
6543     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
6544     { 0x8000, { 21600, 0, DFF_Prop_adjustValue } }
6545 };
6546 const sal_uInt16 mso_sptTextFadeSegm[] =
6547 {
6548     0x4000, 0x0001, 0x8000,
6549     0x4000, 0x0001, 0x8000
6550 };
6551 const SvxMSDffHandle mso_sptTextFadeRightHandle[] =
6552 {
6553     {   SvxMSDffHandleFlags::RANGE,
6554         21600, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 10800 }
6555 };
6556 const mso_CustomShape msoTextFadeRight =
6557 {
6558     const_cast<SvxMSDffVertPair*>(mso_sptTextFadeRightVert), SAL_N_ELEMENTS( mso_sptTextFadeRightVert ),
6559     const_cast<sal_uInt16*>(mso_sptTextFadeSegm), sizeof( mso_sptTextFadeSegm ) >> 1,
6560     const_cast<SvxMSDffCalculationData*>(mso_sptTextFadeCalc), SAL_N_ELEMENTS( mso_sptTextFadeCalc ),
6561     const_cast<sal_Int32*>(mso_sptDefault7200),
6562     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
6563     21600, 21600,
6564     MIN_INT32, MIN_INT32,
6565     nullptr, 0,
6566     const_cast<SvxMSDffHandle*>(mso_sptTextFadeRightHandle), SAL_N_ELEMENTS( mso_sptTextFadeRightHandle )
6567 };
6568
6569 const SvxMSDffVertPair mso_sptTextFadeLeftVert[] =
6570 {
6571     { 0, 0 MSO_I }, { 21600, 0 }, { 0, 1 MSO_I }, { 21600, 21600 }
6572 };
6573 const SvxMSDffHandle mso_sptTextFadeLeftHandle[] =
6574 {
6575     {   SvxMSDffHandleFlags::RANGE,
6576         0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 10800 }
6577 };
6578 const mso_CustomShape msoTextFadeLeft =
6579 {
6580     const_cast<SvxMSDffVertPair*>(mso_sptTextFadeLeftVert), SAL_N_ELEMENTS( mso_sptTextFadeLeftVert ),
6581     const_cast<sal_uInt16*>(mso_sptTextFadeSegm), sizeof( mso_sptTextFadeSegm ) >> 1,
6582     const_cast<SvxMSDffCalculationData*>(mso_sptTextFadeCalc), SAL_N_ELEMENTS( mso_sptTextFadeCalc ),
6583     const_cast<sal_Int32*>(mso_sptDefault7200),
6584     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
6585     21600, 21600,
6586     MIN_INT32, MIN_INT32,
6587     nullptr, 0,
6588     const_cast<SvxMSDffHandle*>(mso_sptTextFadeLeftHandle), SAL_N_ELEMENTS( mso_sptTextFadeLeftHandle )
6589 };
6590
6591 const SvxMSDffVertPair mso_sptTextFadeUpVert[] =
6592 {
6593     { 0 MSO_I, 0 }, { 1 MSO_I, 0 }, { 0, 21600 }, { 21600, 21600 }
6594 };
6595 const SvxMSDffHandle mso_sptTextFadeUpHandle[] =
6596 {
6597     {   SvxMSDffHandleFlags::RANGE,
6598         0x100, 0, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
6599 };
6600 const mso_CustomShape msoTextFadeUp =
6601 {
6602     const_cast<SvxMSDffVertPair*>(mso_sptTextFadeUpVert), SAL_N_ELEMENTS( mso_sptTextFadeUpVert ),
6603     const_cast<sal_uInt16*>(mso_sptTextFadeSegm), sizeof( mso_sptTextFadeSegm ) >> 1,
6604     const_cast<SvxMSDffCalculationData*>(mso_sptTextFadeCalc), SAL_N_ELEMENTS( mso_sptTextFadeCalc ),
6605     const_cast<sal_Int32*>(mso_sptDefault7200),
6606     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
6607     21600, 21600,
6608     MIN_INT32, MIN_INT32,
6609     nullptr, 0,
6610     const_cast<SvxMSDffHandle*>(mso_sptTextFadeUpHandle), SAL_N_ELEMENTS( mso_sptTextFadeUpHandle )
6611 };
6612
6613 const SvxMSDffVertPair mso_sptTextFadeDownVert[] =
6614 {
6615     { 0, 0 }, { 21600, 0 }, { 0 MSO_I, 21600 }, { 1 MSO_I, 21600 }
6616 };
6617 const SvxMSDffHandle mso_sptTextFadeDownHandle[] =
6618 {
6619     {   SvxMSDffHandleFlags::RANGE,
6620         0x100, 21600, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
6621 };
6622 const mso_CustomShape msoTextFadeDown =
6623 {
6624     const_cast<SvxMSDffVertPair*>(mso_sptTextFadeDownVert), SAL_N_ELEMENTS( mso_sptTextFadeDownVert ),
6625     const_cast<sal_uInt16*>(mso_sptTextFadeSegm), sizeof( mso_sptTextFadeSegm ) >> 1,
6626     const_cast<SvxMSDffCalculationData*>(mso_sptTextFadeCalc), SAL_N_ELEMENTS( mso_sptTextFadeCalc ),
6627     const_cast<sal_Int32*>(mso_sptDefault7200),
6628     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
6629     21600, 21600,
6630     MIN_INT32, MIN_INT32,
6631     nullptr, 0,
6632     const_cast<SvxMSDffHandle*>(mso_sptTextFadeDownHandle), SAL_N_ELEMENTS( mso_sptTextFadeDownHandle )
6633 };
6634
6635 const SvxMSDffVertPair mso_sptTextSlantUpVert[] =
6636 {
6637     { 0, 0 MSO_I }, { 21600, 0 }, { 0, 21600 }, { 21600, 1 MSO_I }
6638 };
6639 const SvxMSDffHandle mso_sptTextSlantUpHandle[] =
6640 {
6641     {   SvxMSDffHandleFlags::RANGE,
6642         0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 15400 }
6643 };
6644 const mso_CustomShape msoTextSlantUp =
6645 {
6646     const_cast<SvxMSDffVertPair*>(mso_sptTextSlantUpVert), SAL_N_ELEMENTS( mso_sptTextSlantUpVert ),
6647     const_cast<sal_uInt16*>(mso_sptTextFadeSegm), sizeof( mso_sptTextFadeSegm ) >> 1,
6648     const_cast<SvxMSDffCalculationData*>(mso_sptTextFadeCalc), SAL_N_ELEMENTS( mso_sptTextFadeCalc ),
6649     const_cast<sal_Int32*>(mso_sptDefault12000),
6650     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
6651     21600, 21600,
6652     MIN_INT32, MIN_INT32,
6653     nullptr, 0,
6654     const_cast<SvxMSDffHandle*>(mso_sptTextSlantUpHandle), SAL_N_ELEMENTS( mso_sptTextSlantUpHandle )
6655 };
6656
6657 const SvxMSDffVertPair mso_sptTextSlantDownVert[] =
6658 {
6659     { 0, 0 }, { 21600, 1 MSO_I }, { 0, 0 MSO_I }, { 21600, 21600 }
6660 };
6661 const SvxMSDffHandle mso_sptTextSlantDownHandle[] =
6662 {
6663     {   SvxMSDffHandleFlags::RANGE,
6664         0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 6200, 21600 }
6665 };
6666 const mso_CustomShape msoTextSlantDown =
6667 {
6668     const_cast<SvxMSDffVertPair*>(mso_sptTextSlantDownVert), SAL_N_ELEMENTS( mso_sptTextSlantDownVert ),
6669     const_cast<sal_uInt16*>(mso_sptTextFadeSegm), sizeof( mso_sptTextFadeSegm ) >> 1,
6670     const_cast<SvxMSDffCalculationData*>(mso_sptTextFadeCalc), SAL_N_ELEMENTS( mso_sptTextFadeCalc ),
6671     const_cast<sal_Int32*>(mso_sptDefault12000),
6672     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
6673     21600, 21600,
6674     MIN_INT32, MIN_INT32,
6675     nullptr, 0,
6676     const_cast<SvxMSDffHandle*>(mso_sptTextSlantDownHandle), SAL_N_ELEMENTS( mso_sptTextSlantDownHandle )
6677 };
6678
6679 const SvxMSDffVertPair mso_sptTextCascadeUpVert[] =
6680 {
6681     { 0, 2 MSO_I }, { 21600, 0 }, { 0, 21600 }, { 21600, 0 MSO_I }
6682 };
6683 const SvxMSDffCalculationData mso_sptTextCascadeCalc[] =
6684 {
6685     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
6686     { 0x8000, { 21600, 0, DFF_Prop_adjustValue } },
6687     { 0x2001, { 0x401, 1, 4 } }
6688 };
6689 const SvxMSDffHandle mso_sptTextCascadeUpHandle[] =
6690 {
6691     {   SvxMSDffHandleFlags::RANGE,
6692         21600, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 6200, 21600 }
6693 };
6694 const mso_CustomShape msoTextCascadeUp =
6695 {
6696     const_cast<SvxMSDffVertPair*>(mso_sptTextCascadeUpVert), SAL_N_ELEMENTS( mso_sptTextCascadeUpVert ),
6697     const_cast<sal_uInt16*>(mso_sptTextFadeSegm), sizeof( mso_sptTextFadeSegm ) >> 1,
6698     const_cast<SvxMSDffCalculationData*>(mso_sptTextCascadeCalc), SAL_N_ELEMENTS( mso_sptTextCascadeCalc ),
6699     const_cast<sal_Int32*>(mso_sptDefault9600),
6700     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
6701     21600, 21600,
6702     MIN_INT32, MIN_INT32,
6703     nullptr, 0,
6704     const_cast<SvxMSDffHandle*>(mso_sptTextCascadeUpHandle), SAL_N_ELEMENTS( mso_sptTextCascadeUpHandle )
6705 };
6706
6707 const SvxMSDffVertPair mso_sptTextCascadeDownVert[] =
6708 {
6709     { 0, 0 }, { 21600, 2 MSO_I }, { 0, 0 MSO_I }, { 21600, 21600 }
6710 };
6711 const SvxMSDffHandle mso_sptTextCascadeDownHandle[] =
6712 {
6713     {   SvxMSDffHandleFlags::RANGE,
6714         0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 6200, 21600 }
6715 };
6716 const mso_CustomShape msoTextCascadeDown =
6717 {
6718     const_cast<SvxMSDffVertPair*>(mso_sptTextCascadeDownVert), SAL_N_ELEMENTS( mso_sptTextCascadeDownVert ),
6719     const_cast<sal_uInt16*>(mso_sptTextFadeSegm), sizeof( mso_sptTextFadeSegm ) >> 1,
6720     const_cast<SvxMSDffCalculationData*>(mso_sptTextCascadeCalc), SAL_N_ELEMENTS( mso_sptTextCascadeCalc ),
6721     const_cast<sal_Int32*>(mso_sptDefault9600),
6722     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
6723     21600, 21600,
6724     MIN_INT32, MIN_INT32,
6725     nullptr, 0,
6726     const_cast<SvxMSDffHandle*>(mso_sptTextCascadeDownHandle), SAL_N_ELEMENTS( mso_sptTextCascadeDownHandle )
6727 };
6728
6729 const SvxMSDffVertPair mso_sptTextArchUpCurveVert[] =
6730 {
6731     { 0, 0 }, { 21600, 21600 }, { 2 MSO_I, 3 MSO_I }, { 4 MSO_I, 3 MSO_I }
6732 };
6733 const SvxMSDffCalculationData mso_sptTextArchCurveCalc[] =
6734 {
6735     { 0x400a, { 10800, DFF_Prop_adjustValue, 0 } },
6736     { 0x4009, { 10800, DFF_Prop_adjustValue, 0 } },
6737     { 0x2000, { 0x400, 10800, 0 } },
6738     { 0x2000, { 0x401, 10800, 0 } },
6739     { 0x8000, { 21600, 0, 0x402 } }
6740 };
6741 const sal_uInt16 mso_sptTextArchUpCurveSegm[] =
6742 {
6743     0xA504, 0x8000      // clockwise arc
6744 };
6745 const SvxMSDffHandle mso_sptTextArchUpCurveHandle[] =
6746 {
6747     {   SvxMSDffHandleFlags::POLAR,
6748         10800, 0x100, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
6749 };
6750 const sal_Int32 mso_sptTextArchUpCurveDefault[] =
6751 {
6752     1, 180
6753 };
6754 const mso_CustomShape msoTextArchUpCurve =
6755 {
6756     const_cast<SvxMSDffVertPair*>(mso_sptTextArchUpCurveVert), SAL_N_ELEMENTS( mso_sptTextArchUpCurveVert ),
6757     const_cast<sal_uInt16*>(mso_sptTextArchUpCurveSegm), sizeof( mso_sptTextArchUpCurveSegm ) >> 1,
6758     const_cast<SvxMSDffCalculationData*>(mso_sptTextArchCurveCalc), SAL_N_ELEMENTS( mso_sptTextArchCurveCalc ),
6759     const_cast<sal_Int32*>(mso_sptTextArchUpCurveDefault),
6760     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
6761     21600, 21600,
6762     MIN_INT32, MIN_INT32,
6763     nullptr, 0,
6764     const_cast<SvxMSDffHandle*>(mso_sptTextArchUpCurveHandle), SAL_N_ELEMENTS( mso_sptTextArchUpCurveHandle )
6765 };
6766
6767 const SvxMSDffVertPair mso_sptTextArchDownCurveVert[] =
6768 {
6769     { 0, 0 }, { 21600, 21600 }, { 4 MSO_I, 3 MSO_I }, { 2 MSO_I, 3 MSO_I }
6770 };
6771 const sal_uInt16 mso_sptTextArchDownCurveSegm[] =
6772 {
6773     0xA304, 0x8000      // counter clockwise arc to
6774 };
6775 const SvxMSDffHandle mso_sptTextArchDownCurveHandle[] =
6776 {
6777     {   SvxMSDffHandleFlags::POLAR,
6778         10800, 0x100, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
6779 };
6780 const sal_Int32 mso_sptTextArchDownCurveDefault[] =
6781 {
6782     1, 0
6783 };
6784 const mso_CustomShape msoTextArchDownCurve =
6785 {
6786     const_cast<SvxMSDffVertPair*>(mso_sptTextArchDownCurveVert), SAL_N_ELEMENTS( mso_sptTextArchDownCurveVert ),
6787     const_cast<sal_uInt16*>(mso_sptTextArchDownCurveSegm), sizeof( mso_sptTextArchDownCurveSegm ) >> 1,
6788     const_cast<SvxMSDffCalculationData*>(mso_sptTextArchCurveCalc), SAL_N_ELEMENTS( mso_sptTextArchCurveCalc ),
6789     const_cast<sal_Int32*>(mso_sptTextArchDownCurveDefault),
6790     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
6791     21600, 21600,
6792     MIN_INT32, MIN_INT32,
6793     nullptr, 0,
6794     const_cast<SvxMSDffHandle*>(mso_sptTextArchDownCurveHandle), SAL_N_ELEMENTS( mso_sptTextArchDownCurveHandle )
6795 };
6796
6797 const SvxMSDffVertPair mso_sptTextCircleCurveVert[] =
6798 {
6799     { 0, 0 }, { 21600, 21600 }, { 2 MSO_I, 3 MSO_I }, { 2 MSO_I, 4 MSO_I }
6800 };
6801 const SvxMSDffCalculationData mso_sptTextCircleCurveCalc[] =
6802 {
6803     { 0x400a, { 10800, DFF_Prop_adjustValue, 0 } },
6804     { 0x4009, { 10800, DFF_Prop_adjustValue, 0 } },
6805     { 0x2000, { 0x400, 10800, 0 } },
6806     { 0x2000, { 0x401, 10800, 0 } },
6807     { 0x8000, { 21600, 0, 0x403 } }
6808 };
6809 const sal_uInt16 mso_sptTextCircleCurveSegm[] =
6810 {
6811     0xA504, 0x8000      // clockwise arc to
6812 };
6813 const SvxMSDffHandle mso_sptTextCircleCurveHandle[] =
6814 {
6815     {   SvxMSDffHandleFlags::POLAR,
6816         10800, 0x100, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
6817 };
6818 const sal_Int32 mso_sptTextCircleCurveDefault[] =
6819 {
6820     1, -179
6821 };
6822 const mso_CustomShape msoTextCircleCurve =
6823 {
6824     const_cast<SvxMSDffVertPair*>(mso_sptTextCircleCurveVert), SAL_N_ELEMENTS( mso_sptTextCircleCurveVert ),
6825     const_cast<sal_uInt16*>(mso_sptTextCircleCurveSegm), sizeof( mso_sptTextCircleCurveSegm ) >> 1,
6826     const_cast<SvxMSDffCalculationData*>(mso_sptTextCircleCurveCalc), SAL_N_ELEMENTS( mso_sptTextCircleCurveCalc ),
6827     const_cast<sal_Int32*>(mso_sptTextCircleCurveDefault),
6828     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
6829     21600, 21600,
6830     MIN_INT32, MIN_INT32,
6831     nullptr, 0,
6832     const_cast<SvxMSDffHandle*>(mso_sptTextCircleCurveHandle), SAL_N_ELEMENTS( mso_sptTextCircleCurveHandle )
6833 };
6834
6835 const SvxMSDffVertPair mso_sptTextButtonCurveVert[] =
6836 {
6837     { 0, 0 }, { 21600, 21600 }, { 2 MSO_I, 3 MSO_I }, { 4 MSO_I, 3 MSO_I },
6838     { 0, 10800 }, { 21600, 10800 },
6839     { 0, 0 }, { 21600, 21600 }, { 2 MSO_I, 5 MSO_I }, { 4 MSO_I, 5 MSO_I }
6840 };
6841 const SvxMSDffCalculationData mso_sptTextButtonCurveCalc[] =
6842 {
6843     { 0x400a, { 10800, DFF_Prop_adjustValue, 0 } },
6844     { 0x4009, { 10800, DFF_Prop_adjustValue, 0 } },
6845     { 0x2000, { 0x400, 10800, 0 } },
6846     { 0x2000, { 0x401, 10800, 0 } },
6847     { 0x8000, { 21600, 0, 0x402 } },
6848     { 0x8000, { 21600, 0, 0x403 } }
6849 };
6850 const sal_uInt16 mso_sptTextButtonCurveSegm[] =
6851 {
6852     0xA504, 0x8000,     // clockwise arc
6853     0x4000, 0x0001, 0x8000,
6854     0xA304, 0x8000      // counter clockwise
6855 };
6856 const SvxMSDffHandle mso_sptTextButtonCurveHandle[] =
6857 {
6858     {   SvxMSDffHandleFlags::POLAR,
6859         10800, 0x100, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
6860 };
6861 const sal_Int32 mso_sptTextButtonCurveDefault[] =
6862 {
6863     1, 180
6864 };
6865 const mso_CustomShape msoTextButtonCurve =
6866 {
6867     const_cast<SvxMSDffVertPair*>(mso_sptTextButtonCurveVert), SAL_N_ELEMENTS( mso_sptTextButtonCurveVert ),
6868     const_cast<sal_uInt16*>(mso_sptTextButtonCurveSegm), sizeof( mso_sptTextButtonCurveSegm ) >> 1,
6869     const_cast<SvxMSDffCalculationData*>(mso_sptTextButtonCurveCalc), SAL_N_ELEMENTS( mso_sptTextButtonCurveCalc ),
6870     const_cast<sal_Int32*>(mso_sptTextButtonCurveDefault),
6871     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
6872     21600, 21600,
6873     MIN_INT32, MIN_INT32,
6874     nullptr, 0,
6875     const_cast<SvxMSDffHandle*>(mso_sptTextButtonCurveHandle), SAL_N_ELEMENTS( mso_sptTextButtonCurveHandle )
6876 };
6877
6878 const SvxMSDffVertPair mso_sptTextArchUpPourVert[] =
6879 {
6880     { 0, 0 }, { 21600, 21600 }, { 2 MSO_I, 3 MSO_I }, { 4 MSO_I, 3 MSO_I },
6881     { 5 MSO_I, 5 MSO_I }, { 11 MSO_I, 11 MSO_I }, { 8 MSO_I, 9 MSO_I }, { 0xa MSO_I, 9 MSO_I }
6882 };
6883 const SvxMSDffCalculationData mso_sptTextArchPourCalc[] =
6884 {
6885     { 0x400a, { 10800, DFF_Prop_adjustValue, 0 } },
6886     { 0x4009, { 10800, DFF_Prop_adjustValue, 0 } },
6887     { 0x2000, { 0x400, 10800, 0 } },
6888     { 0x2000, { 0x401, 10800, 0 } },
6889     { 0x8000, { 21600, 0, 0x402 } },
6890     { 0x8000, { 10800, 0, DFF_Prop_adjust2Value } },
6891     { 0x600a, { 0x405, DFF_Prop_adjustValue, 0 } }, // 6
6892     { 0x6009, { 0x405, DFF_Prop_adjustValue, 0 } },
6893     { 0x2000, { 0x406, 10800, 0 } },                // 8
6894     { 0x2000, { 0x407, 10800, 0 } },
6895     { 0x8000, { 21600, 0, 0x408 } },                // 10
6896     { 0x8000, { 21600, 0, 0x405 } }
6897 };
6898 const sal_uInt16 mso_sptTextArchUpPourSegm[] =
6899 {
6900     0xA504, 0x8000, 0xA504, 0x8000
6901 };
6902 const SvxMSDffHandle mso_sptTextArchPourHandle[] =
6903 {
6904     {   SvxMSDffHandleFlags::POLAR | SvxMSDffHandleFlags::RADIUS_RANGE,
6905         0x101, 0x100, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
6906 };
6907 const sal_Int32 mso_sptTextArchUpPourDefault[] =
6908 {
6909     2, 180, 5400
6910 };
6911 const mso_CustomShape msoTextArchUpPour =
6912 {
6913     const_cast<SvxMSDffVertPair*>(mso_sptTextArchUpPourVert), SAL_N_ELEMENTS( mso_sptTextArchUpPourVert ),
6914     const_cast<sal_uInt16*>(mso_sptTextArchUpPourSegm), sizeof( mso_sptTextArchUpPourSegm ) >> 1,
6915     const_cast<SvxMSDffCalculationData*>(mso_sptTextArchPourCalc), SAL_N_ELEMENTS( mso_sptTextArchPourCalc ),
6916     const_cast<sal_Int32*>(mso_sptTextArchUpPourDefault),
6917     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
6918     21600, 21600,
6919     MIN_INT32, MIN_INT32,
6920     nullptr, 0,
6921     const_cast<SvxMSDffHandle*>(mso_sptTextArchPourHandle), SAL_N_ELEMENTS( mso_sptTextArchPourHandle )
6922 };
6923
6924 const SvxMSDffVertPair mso_sptTextArchDownPourVert[] =
6925 {
6926     { 5 MSO_I, 5 MSO_I }, { 11 MSO_I, 11 MSO_I }, { 0xa MSO_I, 9 MSO_I }, { 8 MSO_I, 9 MSO_I },
6927     { 0, 0 }, { 21600, 21600 }, { 4 MSO_I, 3 MSO_I }, { 2 MSO_I, 3 MSO_I }
6928 };
6929 const sal_uInt16 mso_sptTextArchDownPourSegm[] =
6930 {
6931     0xA304, 0x8000, 0xA304, 0x8000
6932 };
6933 const sal_Int32 mso_sptTextArchDownPourDefault[] =
6934 {
6935     2, 0, 5400
6936 };
6937 const mso_CustomShape msoTextArchDownPour =
6938 {
6939     const_cast<SvxMSDffVertPair*>(mso_sptTextArchDownPourVert), SAL_N_ELEMENTS( mso_sptTextArchDownPourVert ),
6940     const_cast<sal_uInt16*>(mso_sptTextArchDownPourSegm), sizeof( mso_sptTextArchDownPourSegm ) >> 1,
6941     const_cast<SvxMSDffCalculationData*>(mso_sptTextArchPourCalc), SAL_N_ELEMENTS( mso_sptTextArchPourCalc ),
6942     const_cast<sal_Int32*>(mso_sptTextArchDownPourDefault),
6943     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
6944     21600, 21600,
6945     MIN_INT32, MIN_INT32,
6946     nullptr, 0,
6947     const_cast<SvxMSDffHandle*>(mso_sptTextArchPourHandle), SAL_N_ELEMENTS( mso_sptTextArchPourHandle )
6948 };
6949
6950 const SvxMSDffVertPair mso_sptTextCirclePourVert[] =
6951 {
6952     { 0, 0 }, { 21600, 21600 }, { 2 MSO_I, 3 MSO_I }, { 2 MSO_I, 4 MSO_I },
6953     { 5 MSO_I, 5 MSO_I }, { 11 MSO_I, 11 MSO_I }, { 8 MSO_I, 9 MSO_I }, { 8 MSO_I, 0xa MSO_I }
6954 };
6955 const SvxMSDffCalculationData mso_sptTextCirclePourCalc[] =
6956 {
6957     { 0x400a, { 10800, DFF_Prop_adjustValue, 0 } },
6958     { 0x4009, { 10800, DFF_Prop_adjustValue, 0 } },
6959     { 0x2000, { 0x400, 10800, 0 } },
6960     { 0x2000, { 0x401, 10800, 0 } },
6961     { 0x8000, { 21600, 0, 0x403 } },
6962     { 0x8000, { 10800, 0, DFF_Prop_adjust2Value } },
6963     { 0x600a, { 0x405, DFF_Prop_adjustValue, 0 } }, // 6
6964     { 0x6009, { 0x405, DFF_Prop_adjustValue, 0 } },
6965     { 0x2000, { 0x406, 10800, 0 } },                // 8
6966     { 0x2000, { 0x407, 10800, 0 } },
6967     { 0x8000, { 21600, 0, 0x409 } },                // 10
6968     { 0x8000, { 21600, 0, 0x405 } },
6969     { 0x000, { 21600, 0, 0 } }
6970 };
6971 const sal_uInt16 mso_sptTextCirclePourSegm[] =
6972 {
6973     0xA504, 0x8000, 0xA504, 0x8000
6974 };
6975 const SvxMSDffHandle mso_sptTextCirclePourHandle[] =
6976 {
6977     {   SvxMSDffHandleFlags::POLAR | SvxMSDffHandleFlags::RADIUS_RANGE,
6978         0x101, 0x100, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
6979 };
6980 const sal_Int32 mso_sptTextCirclePourDefault[] =
6981 {
6982     2,  -179, 5400
6983 };
6984 const mso_CustomShape msoTextCirclePour =
6985 {
6986     const_cast<SvxMSDffVertPair*>(mso_sptTextCirclePourVert), SAL_N_ELEMENTS( mso_sptTextCirclePourVert ),
6987     const_cast<sal_uInt16*>(mso_sptTextCirclePourSegm), sizeof( mso_sptTextCirclePourSegm ) >> 1,
6988     const_cast<SvxMSDffCalculationData*>(mso_sptTextCirclePourCalc), SAL_N_ELEMENTS( mso_sptTextCirclePourCalc ),
6989     const_cast<sal_Int32*>(mso_sptTextCirclePourDefault),
6990     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
6991     21600, 21600,
6992     MIN_INT32, MIN_INT32,
6993     nullptr, 0,
6994     const_cast<SvxMSDffHandle*>(mso_sptTextCirclePourHandle), SAL_N_ELEMENTS( mso_sptTextCirclePourHandle )
6995 };
6996
6997 const SvxMSDffVertPair mso_sptTextButtonPourVert[] =
6998 {
6999     { 0, 0 }, { 21600, 21600 }, { 2 MSO_I, 3 MSO_I }, { 4 MSO_I, 3 MSO_I },
7000     { 6 MSO_I, 6 MSO_I }, { 7 MSO_I, 7 MSO_I }, { 10 MSO_I, 11 MSO_I }, { 12 MSO_I, 11 MSO_I },
7001     { 0x16 MSO_I, 16 MSO_I }, { 0x15 MSO_I, 16 MSO_I },
7002     { 0x16 MSO_I, 15 MSO_I }, { 0x15 MSO_I, 15 MSO_I },
7003     { 6 MSO_I, 6 MSO_I }, { 7 MSO_I, 7 MSO_I }, { 10 MSO_I, 13 MSO_I }, { 12 MSO_I, 13 MSO_I },
7004     { 0, 0 }, { 21600, 21600 }, { 2 MSO_I, 5 MSO_I }, { 4 MSO_I, 5 MSO_I }
7005 };
7006 const SvxMSDffCalculationData mso_sptTextButtonPourCalc[] =
7007 {
7008     { 0x400a, { 10800, DFF_Prop_adjustValue, 0 } },                 // 0x00
7009     { 0x4009, { 10800, DFF_Prop_adjustValue, 0 } },                 // 0x01
7010     { 0x2000, { 0x400, 10800, 0 } },                                // 0x02
7011     { 0x2000, { 0x401, 10800, 0 } },                                // 0x03
7012     { 0x8000, { 21600, 0, 0x402 } },                                // 0x04
7013     { 0x8000, { 21600, 0, 0x403 } },                                // 0x05
7014
7015     { 0x8000, { 10800, 0, DFF_Prop_adjust2Value } },                // 0x06
7016     { 0x8000, { 21600, 0, 0x406 } },                                // 0x07
7017
7018     { 0x600a, { DFF_Prop_adjust2Value, DFF_Prop_adjustValue, 0 } }, // 0x08
7019     { 0x6009, { DFF_Prop_adjust2Value, DFF_Prop_adjustValue, 0 } }, // 0x09
7020     { 0x2000, { 0x408, 10800, 0 } },    // 0x0a
7021     { 0x2000, { 0x409, 10800, 0 } },    // 0x0b
7022     { 0x8000, { 21600, 0, 0x40a } },    // 0x0c
7023     { 0x8000, { 21600, 0, 0x40b } },    // 0x0d
7024     { 0x2001, { 0x406, 1, 2 } },        // 0x0e
7025     { 0x4000, { 10800, 0x40e, 0 } },    // 0x0f
7026     { 0x8000, { 10800, 0, 0x40e } },    // 0x10
7027     { 0x6001, { 0x40e, 0x40e, 1 } },    // 0x11
7028     { 0x6001, { DFF_Prop_adjust2Value, DFF_Prop_adjust2Value, 1 } },    // 0x12
7029     { 0xA000, { 0x412, 0, 0x411 } },    // 0x13
7030     { 0x200d, { 0x413, 0, 0 } },        // 0x14
7031     { 0x4000, { 10800, 0x414, 0 } },    // 0x15
7032     { 0x8000, { 10800, 0, 0x414 } }     // 0x16
7033 };
7034 const sal_uInt16 mso_sptTextButtonPourSegm[] =
7035 {
7036     0xA504, 0x8000,     // clockwise arc
7037     0xA504, 0x8000,     // clockwise arc
7038     0x4000, 0x0001, 0x8000,
7039     0x4000, 0x0001, 0x8000,
7040     0xA304, 0x8000,     // counter clockwise
7041     0xA304, 0x8000      // counter clockwise
7042 };
7043 const SvxMSDffHandle mso_sptTextButtonPourHandle[] =
7044 {
7045     {   SvxMSDffHandleFlags::POLAR | SvxMSDffHandleFlags::RADIUS_RANGE,
7046         0x101, 0x100, 10800, 10800, 4320, 10800, MIN_INT32, 0x7fffffff }
7047 };
7048 const sal_Int32 mso_sptTextButtonPourDefault[] =
7049 {
7050     2, 180, 5400
7051 };
7052 const mso_CustomShape msoTextButtonPour =
7053 {
7054     const_cast<SvxMSDffVertPair*>(mso_sptTextButtonPourVert), SAL_N_ELEMENTS( mso_sptTextButtonPourVert ),
7055     const_cast<sal_uInt16*>(mso_sptTextButtonPourSegm), sizeof( mso_sptTextButtonPourSegm ) >> 1,
7056     const_cast<SvxMSDffCalculationData*>(mso_sptTextButtonPourCalc), SAL_N_ELEMENTS( mso_sptTextButtonPourCalc ),
7057     const_cast<sal_Int32*>(mso_sptTextButtonPourDefault),
7058     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
7059     21600, 21600,
7060     MIN_INT32, MIN_INT32,
7061     nullptr, 0,
7062     const_cast<SvxMSDffHandle*>(mso_sptTextButtonPourHandle), SAL_N_ELEMENTS( mso_sptTextButtonPourHandle )
7063 };
7064
7065 const SvxMSDffVertPair mso_sptTextCurveUpVert[] =
7066 {
7067     { 0, 0 MSO_I }, { 4900, 1 MSO_I /*12170->0 14250 ->0*/ }, { 11640, 2 MSO_I /*12170->0 12800 ->0*/ }, { 21600, 0 },
7068     { 0, 4 MSO_I /*12170->0 17220 ->21600*/ }, { 3700, 21600 }, { 8500, 21600 }, { 10100, 21600 }, { 14110, 21600 }, { 15910, 21600 }, { 21600, 4 MSO_I /*12170->0 17220 ->21600*/ }
7069 };
7070 const SvxMSDffCalculationData mso_sptTextCurveUpCalc[] =
7071 {
7072     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, // 400
7073     { 0x4001, { 14250, 0x400, 12170 } },        // 401
7074     { 0x4001, { 12800, 0x400, 12170 } },        // 402
7075     { 0x4001, { 6380, 0x400, 12170 } },         // 403
7076     { 0x8000, { 21600, 0, 0x403 } }             // 404
7077 };
7078 const sal_uInt16 mso_sptTextCurveUpSegm[] =
7079 {
7080     0x4000, 0x2001, 0x8000,
7081     0x4000, 0x2002, 0x8000
7082 };
7083 const SvxMSDffHandle mso_sptTextCurveUpHandle[] =
7084 {
7085     {   SvxMSDffHandleFlags::RANGE,
7086         0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 12170 }
7087 };
7088 const sal_Int32 mso_sptTextCurveUpDefault[] =
7089 {
7090     1, 9900
7091 };
7092 const mso_CustomShape msoTextCurveUp =
7093 {
7094     const_cast<SvxMSDffVertPair*>(mso_sptTextCurveUpVert), SAL_N_ELEMENTS( mso_sptTextCurveUpVert ),
7095     const_cast<sal_uInt16*>(mso_sptTextCurveUpSegm), sizeof( mso_sptTextCurveUpSegm ) >> 1,
7096     const_cast<SvxMSDffCalculationData*>(mso_sptTextCurveUpCalc), SAL_N_ELEMENTS( mso_sptTextCurveUpCalc ),
7097     const_cast<sal_Int32*>(mso_sptTextCurveUpDefault),
7098     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
7099     21600, 21600,
7100     MIN_INT32, MIN_INT32,
7101     nullptr, 0,
7102     const_cast<SvxMSDffHandle*>(mso_sptTextCurveUpHandle), SAL_N_ELEMENTS( mso_sptTextCurveUpHandle )
7103 };
7104
7105 const SvxMSDffVertPair mso_sptTextCurveDownVert[] =
7106 {
7107 //  { 0, 0 MSO_I }, { 4900, 1 MSO_I /*12170->0 14250 ->0*/ }, { 11640, 2 MSO_I /*12170->0 12800 ->0*/ }, { 21600, 0 },
7108     { 0, 0 }, { 9960, 2 MSO_I }, { 16700, 1 MSO_I }, { 21600, 0 MSO_I },
7109
7110 //  { 0, 4 MSO_I /*12170->0 17220 ->21600*/ }, { 3700, 21600 }, { 8500, 21600 }, { 10100, 21600 }, { 14110, 21600 }, { 15910, 21600 }, { 21600, 4 MSO_I /*12170->0 17220 ->21600*/ }
7111     { 0, 4 MSO_I }, { 5690, 21600 }, { 7490, 21600 }, { 11500, 21600 }, { 13100, 21600 }, { 17900, 21600 }, { 21600, 4 MSO_I }
7112 };
7113 const SvxMSDffHandle mso_sptTextCurveDownHandle[] =
7114 {
7115     {   SvxMSDffHandleFlags::RANGE,
7116         21600, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 12170 }
7117 };
7118 const mso_CustomShape msoTextCurveDown =
7119 {
7120     const_cast<SvxMSDffVertPair*>(mso_sptTextCurveDownVert), SAL_N_ELEMENTS( mso_sptTextCurveDownVert ),
7121     const_cast<sal_uInt16*>(mso_sptTextCurveUpSegm), sizeof( mso_sptTextCurveUpSegm ) >> 1,
7122     const_cast<SvxMSDffCalculationData*>(mso_sptTextCurveUpCalc), SAL_N_ELEMENTS( mso_sptTextCurveUpCalc ),
7123     const_cast<sal_Int32*>(mso_sptTextCurveUpDefault),
7124     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
7125     21600, 21600,
7126     MIN_INT32, MIN_INT32,
7127     nullptr, 0,
7128     const_cast<SvxMSDffHandle*>(mso_sptTextCurveDownHandle), SAL_N_ELEMENTS( mso_sptTextCurveDownHandle )
7129 };
7130
7131 const SvxMSDffVertPair mso_sptTextCanUpVert[] =
7132 {
7133     { 0, 1 MSO_I }, { 900, 0 }, { 7100, 0 }, { 10800, 0 }, { 14500, 0 }, { 20700, 0 }, { 21600, 1 MSO_I },
7134     { 0, 21600 }, { 900, 4 MSO_I }, { 7100, 0 MSO_I }, { 10800, 0 MSO_I }, { 14500, 0 MSO_I }, { 20700, 4 MSO_I }, { 21600, 21600 }
7135 };
7136 const SvxMSDffCalculationData mso_sptTextCanUpCalc[] =
7137 {
7138     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },     // 400
7139     { 0x8000, { 21600, 0, DFF_Prop_adjustValue } }, // 401
7140     { 0x2000, { DFF_Prop_adjustValue, 0, 14400 } }, // 402
7141     { 0x4001, { 5470, 0x402, 7200 } },              // 403
7142     { 0x4000, { 16130, 0x403, 0 } }                 // 404
7143 };
7144 const sal_uInt16 mso_sptTextCanUpSegm[] =
7145 {
7146     0x4000, 0x2002, 0x8000,
7147     0x4000, 0x2002, 0x8000
7148 };
7149 const SvxMSDffHandle mso_sptTextCanUpHandle[] =
7150 {
7151     {   SvxMSDffHandleFlags::RANGE,
7152         10800, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 14400, 21600 }
7153 };
7154 const sal_Int32 mso_sptTextCanUpDefault[] =
7155 {
7156     1, 18500
7157 };
7158 const mso_CustomShape msoTextCanUp =
7159 {
7160     const_cast<SvxMSDffVertPair*>(mso_sptTextCanUpVert), SAL_N_ELEMENTS( mso_sptTextCanUpVert ),
7161     const_cast<sal_uInt16*>(mso_sptTextCanUpSegm), sizeof( mso_sptTextCanUpSegm ) >> 1,
7162     const_cast<SvxMSDffCalculationData*>(mso_sptTextCanUpCalc), SAL_N_ELEMENTS( mso_sptTextCanUpCalc ),
7163     const_cast<sal_Int32*>(mso_sptTextCanUpDefault),
7164     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
7165     21600, 21600,
7166     MIN_INT32, MIN_INT32,
7167     nullptr, 0,
7168     const_cast<SvxMSDffHandle*>(mso_sptTextCanUpHandle), SAL_N_ELEMENTS( mso_sptTextCanUpHandle )
7169 };
7170
7171 const SvxMSDffVertPair mso_sptTextCanDownVert[] =
7172 {
7173     { 0, 0 }, { 900, 2 MSO_I }, { 7100, 0 MSO_I }, { 10800, 0 MSO_I }, { 14500, 0 MSO_I }, { 20700, 2 MSO_I }, { 21600, 0 },
7174     { 0, 1 MSO_I }, { 900, 21600 }, { 7100, 21600 }, { 10800, 21600 }, { 14500, 21600 }, { 20700, 21600 }, { 21600, 1 MSO_I }
7175 };
7176 const SvxMSDffCalculationData mso_sptTextCanDownCalc[] =
7177 {
7178     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },     // 400
7179     { 0x8000, { 21600, 0, DFF_Prop_adjustValue } }, // 401
7180     { 0x4001, { 5470, 0x400, 7200 } }               // 402
7181 };
7182 const SvxMSDffHandle mso_sptTextCanDownHandle[] =
7183 {
7184     {   SvxMSDffHandleFlags::RANGE,
7185         10800, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 7200 }
7186 };
7187 const sal_Int32 mso_sptTextCanDownDefault[] =
7188 {
7189     1, 3100
7190 };
7191 const mso_CustomShape msoTextCanDown =
7192 {
7193     const_cast<SvxMSDffVertPair*>(mso_sptTextCanDownVert), SAL_N_ELEMENTS( mso_sptTextCanDownVert ),
7194     const_cast<sal_uInt16*>(mso_sptTextCanUpSegm), sizeof( mso_sptTextCanUpSegm ) >> 1,
7195     const_cast<SvxMSDffCalculationData*>(mso_sptTextCanDownCalc), SAL_N_ELEMENTS( mso_sptTextCanDownCalc ),
7196     const_cast<sal_Int32*>(mso_sptTextCanDownDefault),
7197     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
7198     21600, 21600,
7199     MIN_INT32, MIN_INT32,
7200     nullptr, 0,
7201     const_cast<SvxMSDffHandle*>(mso_sptTextCanDownHandle), SAL_N_ELEMENTS( mso_sptTextCanDownHandle )
7202 };
7203
7204 const SvxMSDffVertPair mso_sptTextInflateVert[] =
7205 {
7206     { 0, 0 MSO_I }, { 4100, 1 MSO_I }, { 7300, 0 }, { 10800, 0 }, { 14300, 0 }, { 17500, 1 MSO_I }, { 21600, 0 MSO_I },
7207     { 0, 2 MSO_I }, { 4100, 3 MSO_I }, { 7300, 21600 }, { 10800, 21600 }, { 14300, 21600 }, { 17500, 3 MSO_I }, { 21600, 2 MSO_I }
7208 };
7209 const SvxMSDffCalculationData mso_sptTextInflateCalc[] =
7210 {
7211     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, // 400
7212     { 0x4001, { 1530, 0x400, 4650 } },          // 401
7213     { 0x8000, { 21600, 0, 0x400 } },            // 402
7214     { 0x8000, { 21600, 0, 0x401 } }             // 403
7215 };
7216 const SvxMSDffHandle mso_sptTextInflateHandle[] =
7217 {
7218     {   SvxMSDffHandleFlags::RANGE,
7219         0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 4650 }
7220 };
7221 const sal_Int32 mso_sptTextInflateDefault[] =
7222 {
7223     1, 2950
7224 };
7225 const mso_CustomShape msoTextInflate =
7226 {
7227     const_cast<SvxMSDffVertPair*>(mso_sptTextInflateVert), SAL_N_ELEMENTS( mso_sptTextInflateVert ),
7228     const_cast<sal_uInt16*>(mso_sptTextCanUpSegm), sizeof( mso_sptTextCanUpSegm ) >> 1,
7229     const_cast<SvxMSDffCalculationData*>(mso_sptTextInflateCalc), SAL_N_ELEMENTS( mso_sptTextInflateCalc ),
7230     const_cast<sal_Int32*>(mso_sptTextInflateDefault),
7231     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
7232     21600, 21600,
7233     MIN_INT32, MIN_INT32,
7234     nullptr, 0,
7235     const_cast<SvxMSDffHandle*>(mso_sptTextInflateHandle), SAL_N_ELEMENTS( mso_sptTextInflateHandle )
7236 };
7237
7238 const SvxMSDffVertPair mso_sptTextDeflateVert[] =
7239 {
7240     { 0, 0 }, { 3500, 1 MSO_I }, { 7100, 0 MSO_I }, { 10800, 0 MSO_I }, { 14500, 0 MSO_I }, { 18100, 1 MSO_I }, { 21600, 0 },
7241     { 0, 21600 }, { 3500, 3 MSO_I }, { 7100, 2 MSO_I }, { 10800, 2 MSO_I }, { 14500, 2 MSO_I }, { 18100, 3 MSO_I }, { 21600, 21600 }
7242 };
7243 const SvxMSDffCalculationData mso_sptTextDeflateCalc[] =
7244 {
7245     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, // 400
7246     { 0x2001, { 0x400, 5320, 7100 } },          // 401
7247     { 0x8000, { 21600, 0, 0x400 } },            // 402
7248     { 0x8000, { 21600, 0, 0x401 } }             // 403
7249 };
7250 const SvxMSDffHandle mso_sptTextDeflateHandle[] =
7251 {
7252     {   SvxMSDffHandleFlags::RANGE,
7253         10800, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 8100 }
7254 };
7255 const mso_CustomShape msoTextDeflate =
7256 {
7257     const_cast<SvxMSDffVertPair*>(mso_sptTextDeflateVert), SAL_N_ELEMENTS( mso_sptTextDeflateVert ),
7258     const_cast<sal_uInt16*>(mso_sptTextCanUpSegm), sizeof( mso_sptTextCanUpSegm ) >> 1,
7259     const_cast<SvxMSDffCalculationData*>(mso_sptTextDeflateCalc), SAL_N_ELEMENTS( mso_sptTextDeflateCalc ),
7260     const_cast<sal_Int32*>(mso_sptDefault8100),
7261     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
7262     21600, 21600,
7263     MIN_INT32, MIN_INT32,
7264     nullptr, 0,
7265     const_cast<SvxMSDffHandle*>(mso_sptTextDeflateHandle), SAL_N_ELEMENTS( mso_sptTextDeflateHandle )
7266 };
7267
7268 const SvxMSDffVertPair mso_sptTextInflateBottomVert[] =
7269 {
7270     { 0, 0 }, { 21600, 0 },
7271     { 0, 0 MSO_I }, { 3500, 3 MSO_I }, { 7300, 21600 }, { 10800, 21600 }, { 14300, 21600 }, { 18100, 3 MSO_I }, { 21600, 0 MSO_I }
7272 };
7273 const SvxMSDffCalculationData mso_sptTextInflateBottomCalc[] =
7274 {
7275     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, // 400
7276     { 0x2000, { 0x400, 0, 11150 } },            // 401 0->10450
7277     { 0x2001, { 0x401, 3900, 10450 } },         // 402
7278     { 0x2000, { 0x402, 17700, 0 } }             // 403
7279 };
7280 const sal_uInt16 mso_sptTextInflateBottomSegm[] =
7281 {
7282     0x4000, 0x0001, 0x8000,
7283     0x4000, 0x2002, 0x8000
7284 };
7285 const SvxMSDffHandle mso_sptTextInflateBottomHandle[] =
7286 {
7287     {   SvxMSDffHandleFlags::RANGE,
7288         0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 11150, 21600 }
7289 };
7290 const sal_Int32 mso_sptTextInflateBottomDefault[] =
7291 {
7292     1, 14700
7293 };
7294 const mso_CustomShape msoTextInflateBottom =
7295 {
7296     const_cast<SvxMSDffVertPair*>(mso_sptTextInflateBottomVert), SAL_N_ELEMENTS( mso_sptTextInflateBottomVert ),
7297     const_cast<sal_uInt16*>(mso_sptTextInflateBottomSegm), sizeof( mso_sptTextInflateBottomSegm ) >> 1,
7298     const_cast<SvxMSDffCalculationData*>(mso_sptTextInflateBottomCalc), SAL_N_ELEMENTS( mso_sptTextInflateBottomCalc ),
7299     const_cast<sal_Int32*>(mso_sptTextInflateBottomDefault),
7300     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
7301     21600, 21600,
7302     MIN_INT32, MIN_INT32,
7303     nullptr, 0,
7304     const_cast<SvxMSDffHandle*>(mso_sptTextInflateBottomHandle), SAL_N_ELEMENTS( mso_sptTextInflateBottomHandle )
7305 };
7306
7307 const SvxMSDffVertPair mso_sptTextDeflateBottomVert[] =
7308 {
7309     { 0, 0 }, { 21600, 0 },
7310     { 0, 21600 }, { 2900, 3 MSO_I }, { 7200, 0 MSO_I }, { 10800, 0 MSO_I }, { 14400, 0 MSO_I }, { 18700, 3 MSO_I }, { 21600, 21600 }
7311 };
7312 const SvxMSDffCalculationData mso_sptTextDeflateBottomCalc[] =
7313 {
7314     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, // 400
7315     { 0x2000, { 0x400, 0, 1350 } },             // 401 0->20250
7316     { 0x2001, { 0x401, 12070, 20250 } },        // 402
7317     { 0x2000, { 0x402, 9530, 0 } }              // 403
7318 };
7319 const sal_uInt16 mso_sptTextDeflateBottomSegm[] =
7320 {
7321     0x4000, 0x0001, 0x8000,
7322     0x4000, 0x2002, 0x8000
7323 };
7324 const SvxMSDffHandle mso_sptTextDeflateBottomHandle[] =
7325 {
7326     {   SvxMSDffHandleFlags::RANGE,
7327         10800, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 1350, 21600 }
7328 };
7329 const sal_Int32 mso_sptTextDeflateBottomDefault[] =
7330 {
7331     1, 11500
7332 };
7333 const mso_CustomShape msoTextDeflateBottom =
7334 {
7335     const_cast<SvxMSDffVertPair*>(mso_sptTextDeflateBottomVert), SAL_N_ELEMENTS( mso_sptTextDeflateBottomVert ),
7336     const_cast<sal_uInt16*>(mso_sptTextDeflateBottomSegm), sizeof( mso_sptTextDeflateBottomSegm ) >> 1,
7337     const_cast<SvxMSDffCalculationData*>(mso_sptTextDeflateBottomCalc), SAL_N_ELEMENTS( mso_sptTextDeflateBottomCalc ),
7338     const_cast<sal_Int32*>(mso_sptTextDeflateBottomDefault),
7339     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
7340     21600, 21600,
7341     MIN_INT32, MIN_INT32,
7342     nullptr, 0,
7343     const_cast<SvxMSDffHandle*>(mso_sptTextDeflateBottomHandle), SAL_N_ELEMENTS( mso_sptTextDeflateBottomHandle )
7344 };
7345
7346 const SvxMSDffVertPair mso_sptTextInflateTopVert[] =
7347 {
7348     { 0, 0 MSO_I }, { 3500, 1 MSO_I }, { 7300, 0 }, { 10800, 0 }, { 14300, 0 }, { 18100, 1 MSO_I }, { 21600, 0 MSO_I },
7349     { 0, 21600 }, { 21600, 21600 }
7350 };
7351 const SvxMSDffCalculationData mso_sptTextInflateTopCalc[] =
7352 {
7353     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, // 400
7354     { 0x2001, { 0x400, 3900, 10450 } }          // 401
7355 };
7356 const sal_uInt16 mso_sptTextInflateTopSegm[] =
7357 {
7358     0x4000, 0x2002, 0x8000,
7359     0x4000, 0x0001, 0x8000
7360 };
7361 const SvxMSDffHandle mso_sptTextInflateTopHandle[] =
7362 {
7363     {   SvxMSDffHandleFlags::RANGE,
7364         0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 10450 }
7365 };
7366 const sal_Int32 mso_sptTextInflateTopDefault[] =
7367 {
7368     1, 6900
7369 };
7370 const mso_CustomShape msoTextInflateTop =
7371 {
7372     const_cast<SvxMSDffVertPair*>(mso_sptTextInflateTopVert), SAL_N_ELEMENTS( mso_sptTextInflateTopVert ),
7373     const_cast<sal_uInt16*>(mso_sptTextInflateTopSegm), sizeof( mso_sptTextInflateTopSegm ) >> 1,
7374     const_cast<SvxMSDffCalculationData*>(mso_sptTextInflateTopCalc), SAL_N_ELEMENTS( mso_sptTextInflateTopCalc ),
7375     const_cast<sal_Int32*>(mso_sptTextInflateTopDefault),
7376     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
7377     21600, 21600,
7378     MIN_INT32, MIN_INT32,
7379     nullptr, 0,
7380     const_cast<SvxMSDffHandle*>(mso_sptTextInflateTopHandle), SAL_N_ELEMENTS( mso_sptTextInflateTopHandle )
7381 };
7382
7383 const SvxMSDffVertPair mso_sptTextDeflateTopVert[] =
7384 {
7385     { 0, 0 }, { 2900, 1 MSO_I }, { 7200, 0 MSO_I }, { 10800, 0 MSO_I }, { 14400, 0 MSO_I }, { 18700, 1 MSO_I }, { 21600, 0 },
7386     { 0, 21600 }, { 21600, 21600 }
7387 };
7388 const SvxMSDffCalculationData mso_sptTextDeflateTopCalc[] =
7389 {
7390     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, // 400
7391     { 0x2001, { 0x400, 12070, 20250 } }         // 402
7392 };
7393 const sal_uInt16 mso_sptTextDeflateTopSegm[] =
7394 {
7395     0x4000, 0x2002, 0x8000,
7396     0x4000, 0x0001, 0x8000
7397 };
7398 const SvxMSDffHandle mso_sptTextDeflateTopHandle[] =
7399 {
7400     {   SvxMSDffHandleFlags::RANGE,
7401         10800, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 20250 }
7402 };
7403 const sal_Int32 mso_sptTextDeflateTopDefault[] =
7404 {
7405     1, 10100
7406 };
7407 const mso_CustomShape msoTextDeflateTop =
7408 {
7409     const_cast<SvxMSDffVertPair*>(mso_sptTextDeflateTopVert), SAL_N_ELEMENTS( mso_sptTextDeflateTopVert ),
7410     const_cast<sal_uInt16*>(mso_sptTextDeflateTopSegm), sizeof( mso_sptTextDeflateTopSegm ) >> 1,
7411     const_cast<SvxMSDffCalculationData*>(mso_sptTextDeflateTopCalc), SAL_N_ELEMENTS( mso_sptTextDeflateTopCalc ),
7412     const_cast<sal_Int32*>(mso_sptTextDeflateTopDefault),
7413     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
7414     21600, 21600,
7415     MIN_INT32, MIN_INT32,
7416     nullptr, 0,
7417     const_cast<SvxMSDffHandle*>(mso_sptTextDeflateTopHandle), SAL_N_ELEMENTS( mso_sptTextDeflateTopHandle )
7418 };
7419
7420 const SvxMSDffVertPair mso_sptTextDeflateInflateVert[] =
7421 {
7422     { 0, 0 }, { 21600, 0 },
7423     { 0, 10100 }, { 3300, 3 MSO_I }, { 7100, 5 MSO_I }, { 10800, 5 MSO_I }, { 14500, 5 MSO_I }, { 18300, 3 MSO_I }, { 21600, 10100 },
7424     { 0, 11500 }, { 3300, 4 MSO_I }, { 7100, 6 MSO_I }, { 10800, 6 MSO_I }, { 14500, 6 MSO_I }, { 18300, 4 MSO_I }, { 21600, 11500 },
7425     { 0, 21600 }, { 21600, 21600 }
7426 };
7427 const SvxMSDffCalculationData mso_sptTextDeflateInflateCalc[] =
7428 {
7429     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, // 400
7430     { 0x8000, { 10800, 0, 0x400 } },            // 401
7431     { 0x2001, { 0x401, 5770, 9500 } },          // 402
7432     { 0x8000, { 10100, 0, 0x402 } },            // 403
7433     { 0x8000, { 11500, 0, 0x402 } },            // 404
7434     { 0x2000, { 0x400, 0, 700 } },              // 405
7435     { 0x2000, { 0x400, 700, 0 } }               // 406
7436 };
7437 const sal_uInt16 mso_sptTextDeflateInflateSegm[] =
7438 {
7439     0x4000, 0x0001, 0x8000,
7440     0x4000, 0x2002, 0x8000,
7441     0x4000, 0x2002, 0x8000,
7442     0x4000, 0x0001, 0x8000
7443 };
7444 const SvxMSDffHandle mso_sptTextDeflateInflateHandle[] =
7445 {
7446     {   SvxMSDffHandleFlags::RANGE,
7447         10800, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 1300, 20300 }
7448 };
7449 const sal_Int32 mso_sptTextDeflateInflateDefault[] =
7450 {
7451     1, 6500
7452 };
7453 const mso_CustomShape msoTextDeflateInflate =
7454 {
7455     const_cast<SvxMSDffVertPair*>(mso_sptTextDeflateInflateVert), SAL_N_ELEMENTS( mso_sptTextDeflateInflateVert ),
7456     const_cast<sal_uInt16*>(mso_sptTextDeflateInflateSegm), sizeof( mso_sptTextDeflateInflateSegm ) >> 1,
7457     const_cast<SvxMSDffCalculationData*>(mso_sptTextDeflateInflateCalc), SAL_N_ELEMENTS( mso_sptTextDeflateInflateCalc ),
7458     const_cast<sal_Int32*>(mso_sptTextDeflateInflateDefault),
7459     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
7460     21600, 21600,
7461     MIN_INT32, MIN_INT32,
7462     nullptr, 0,
7463     const_cast<SvxMSDffHandle*>(mso_sptTextDeflateInflateHandle), SAL_N_ELEMENTS( mso_sptTextDeflateInflateHandle )
7464 };
7465
7466 const SvxMSDffVertPair mso_sptTextDeflateInflateDeflateVert[] =
7467 {
7468     { 0, 0 }, { 21600, 0 },
7469     { 0, 6600 }, { 3600, 3 MSO_I }, { 7250, 4 MSO_I }, { 10800, 4 MSO_I }, { 14350, 4 MSO_I }, { 18000, 3 MSO_I }, { 21600, 6600 },
7470     { 0, 7500 }, { 3600, 5 MSO_I }, { 7250, 6 MSO_I }, { 10800, 6 MSO_I }, { 14350, 6 MSO_I }, { 18000, 5 MSO_I }, { 21600, 7500 },
7471     { 0, 14100 }, { 3600, 9 MSO_I }, { 7250, 10 MSO_I }, { 10800, 10 MSO_I }, { 14350, 10 MSO_I }, { 18000, 9 MSO_I }, { 21600, 14100 },
7472     { 0, 15000 }, { 3600, 7 MSO_I }, { 7250, 8 MSO_I }, { 10800, 8 MSO_I }, { 14350, 8 MSO_I }, { 18000, 7 MSO_I }, { 21600, 15000 },
7473     { 0, 21600 }, { 21600, 21600 }
7474 };
7475 const SvxMSDffCalculationData mso_sptTextDeflateInflateDeflateCalc[] =
7476 {
7477     { 0x2000, { DFF_Prop_adjustValue, 0, 850 } },       // 400
7478     { 0x2001, { 0x400, 6120, 8700 } },
7479     { 0x2000, { 0x401, 0, 4280 } },
7480     { 0x4000, { 6600, 0x402, 0 } },
7481     { 0x2000, { DFF_Prop_adjustValue, 0, 450 } },       // 404
7482     { 0x2000, { 0x403, 900, 0 } },                      // 405
7483     { 0x2000, { 0x404, 900, 0 } },                      // 406
7484     { 0x8000, { 21600, 0, 0x403 } },                    // 407
7485     { 0x8000, { 21600, 0, 0x404 } },                    // 408
7486     { 0x8000, { 21600, 0, 0x405 } },                    // 409
7487     { 0x8000, { 21600, 0, 0x406 } }                     // 410
7488 };
7489 const sal_uInt16 mso_sptTextDeflateInflateDeflateSegm[] =
7490 {
7491     0x4000, 0x0001, 0x8000,
7492     0x4000, 0x2002, 0x8000,
7493     0x4000, 0x2002, 0x8000,
7494     0x4000, 0x2002, 0x8000,
7495     0x4000, 0x2002, 0x8000,
7496     0x4000, 0x0001, 0x8000
7497 };
7498 const SvxMSDffHandle mso_sptTextDeflateInflateDeflateHandle[] =
7499 {
7500     {   SvxMSDffHandleFlags::RANGE,
7501         10800, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 850, 9550 }
7502 };
7503 const sal_Int32 mso_sptTextDeflateInflateDeflateDefault[] =
7504 {
7505     1, 6050
7506 };
7507 const mso_CustomShape msoTextDeflateInflateDeflate =
7508 {
7509     const_cast<SvxMSDffVertPair*>(mso_sptTextDeflateInflateDeflateVert), SAL_N_ELEMENTS( mso_sptTextDeflateInflateDeflateVert ),
7510     const_cast<sal_uInt16*>(mso_sptTextDeflateInflateDeflateSegm), sizeof( mso_sptTextDeflateInflateDeflateSegm ) >> 1,
7511     const_cast<SvxMSDffCalculationData*>(mso_sptTextDeflateInflateDeflateCalc), SAL_N_ELEMENTS( mso_sptTextDeflateInflateDeflateCalc ),
7512     const_cast<sal_Int32*>(mso_sptTextDeflateInflateDeflateDefault),
7513     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
7514     21600, 21600,
7515     MIN_INT32, MIN_INT32,
7516     nullptr, 0,
7517     const_cast<SvxMSDffHandle*>(mso_sptTextDeflateInflateDeflateHandle), SAL_N_ELEMENTS( mso_sptTextDeflateInflateDeflateHandle )
7518 };
7519
7520 const SvxMSDffVertPair mso_sptTextWave1Vert[] =  // adjustment1 : 0 - 4459
7521 {                                                   // adjustment2 : 8640 - 12960
7522     { 7 MSO_I, 0 MSO_I }, { 15 MSO_I, 9 MSO_I }, { 16 MSO_I, 10 MSO_I }, { 12 MSO_I, 0 MSO_I },
7523     { 29 MSO_I, 1 MSO_I }, { 27 MSO_I, 28 MSO_I }, { 25 MSO_I, 26 MSO_I }, { 24 MSO_I, 1 MSO_I }
7524 };
7525 const sal_uInt16 mso_sptTextWave1Segm[] =
7526 {
7527     0x4000, 0x2001, 0x8000,
7528     0x4000, 0x2001, 0x8000
7529 };
7530 const mso_CustomShape msoTextWave1 =
7531 {
7532     const_cast<SvxMSDffVertPair*>(mso_sptTextWave1Vert), SAL_N_ELEMENTS( mso_sptTextWave1Vert ),
7533     const_cast<sal_uInt16*>(mso_sptTextWave1Segm), sizeof( mso_sptTextWave1Segm ) >> 1,
7534     const_cast<SvxMSDffCalculationData*>(mso_sptWaveCalc), SAL_N_ELEMENTS( mso_sptWaveCalc ),
7535     const_cast<sal_Int32*>(mso_sptWaveDefault),
7536     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
7537     21600, 21600,
7538     MIN_INT32, MIN_INT32,
7539     const_cast<SvxMSDffVertPair*>(mso_sptWaveGluePoints), SAL_N_ELEMENTS( mso_sptWaveGluePoints ),
7540     const_cast<SvxMSDffHandle*>(mso_sptWaveHandle), SAL_N_ELEMENTS( mso_sptWaveHandle )
7541 };
7542
7543 const SvxMSDffVertPair mso_sptTextWave2Vert[] =  // adjustment1 : 0 - 4459
7544 {                                                   // adjustment2 : 8640 - 12960
7545     { 7 MSO_I, 0 MSO_I }, { 15 MSO_I, 10 MSO_I }, { 16 MSO_I, 9 MSO_I }, { 12 MSO_I, 0 MSO_I },
7546     { 29 MSO_I, 1 MSO_I }, { 27 MSO_I, 26 MSO_I }, { 25 MSO_I, 28 MSO_I }, { 24 MSO_I, 1 MSO_I }
7547 };
7548 const mso_CustomShape msoTextWave2 =
7549 {
7550     const_cast<SvxMSDffVertPair*>(mso_sptTextWave2Vert), SAL_N_ELEMENTS( mso_sptTextWave2Vert ),
7551     const_cast<sal_uInt16*>(mso_sptTextWave1Segm), sizeof( mso_sptTextWave1Segm ) >> 1,
7552     const_cast<SvxMSDffCalculationData*>(mso_sptWaveCalc), SAL_N_ELEMENTS( mso_sptWaveCalc ),
7553     const_cast<sal_Int32*>(mso_sptWaveDefault),
7554     const_cast<SvxMSDffTextRectangles*>(mso_sptFontWorkTextRect), SAL_N_ELEMENTS( mso_sptFontWorkTextRect ),
7555     21600, 21600,
7556     MIN_INT32, MIN_INT32,
7557     const_cast<SvxMSDffVertPair*>(mso_sptWaveGluePoints), SAL_N_ELEMENTS( mso_sptWaveGluePoints ),
7558     const_cast<SvxMSDffHandle*>(mso_sptWaveHandle), SAL_N_ELEMENTS( mso_sptWaveHandle )
7559 };
7560
7561 const SvxMSDffVertPair mso_sptTextWave3Vert[] =  // adjustment1 : 0 - 2230
7562 {                                                       // adjustment2 : 8640 - 12960
7563     { 7 MSO_I, 0 MSO_I }, { 15 MSO_I, 9 MSO_I }, { 0x1f MSO_I, 10 MSO_I }, { 0x12 MSO_I, 0 MSO_I }, { 0x1e MSO_I, 9 MSO_I }, { 16 MSO_I, 10 MSO_I }, { 12 MSO_I, 0 MSO_I },
7564     { 29 MSO_I, 1 MSO_I }, { 27 MSO_I, 28 MSO_I }, { 0x21 MSO_I, 26 MSO_I }, { 0x13 MSO_I, 1 MSO_I }, { 0x20 MSO_I, 28 MSO_I }, { 25 MSO_I, 26 MSO_I }, { 24 MSO_I, 1 MSO_I }
7565 };
7566 const sal_uInt16 mso_sptTextWave3Segm[] =
7567 {
7568     0x4000, 0x2002, 0x8000,
7569     0x4000, 0x2002, 0x8000
7570 };
7571 const mso_CustomShape msoTextWave3 =
7572 {
7573     const_cast<SvxMSDffVertPair*>(mso_sptTextWave3Vert), SAL_N_ELEMENTS( mso_sptTextWave3Vert ),
7574     const_cast<sal_uInt16*>(mso_sptTextWave3Segm), sizeof( mso_sptTextWave3Segm ) >> 1,
7575     const_cast<SvxMSDffCalculationData*>(mso_sptDoubleWaveCalc), SAL_N_ELEMENTS( mso_sptDoubleWaveCalc ),
7576     const_cast<sal_Int32*>(mso_sptDoubleWaveDefault),
7577     const_cast<SvxMSDffTextRectangles*>(mso_sptDoubleWaveTextRect), SAL_N_ELEMENTS( mso_sptDoubleWaveTextRect ),
7578     21600, 21600,
7579     MIN_INT32, MIN_INT32,
7580     const_cast<SvxMSDffVertPair*>(mso_sptDoubleWaveGluePoints), SAL_N_ELEMENTS( mso_sptDoubleWaveGluePoints ),
7581     const_cast<SvxMSDffHandle*>(mso_sptDoubleWaveHandle), SAL_N_ELEMENTS( mso_sptDoubleWaveHandle )
7582 };
7583
7584 const SvxMSDffVertPair mso_sptTextWave4Vert[] =  // adjustment1 : 0 - 2230
7585 {                                                       // adjustment2 : 8640 - 12960
7586     { 7 MSO_I, 0 MSO_I }, { 15 MSO_I, 10 MSO_I }, { 0x1f MSO_I, 9 MSO_I }, { 0x12 MSO_I, 0 MSO_I }, { 0x1e MSO_I, 10 MSO_I }, { 16 MSO_I, 9 MSO_I }, { 12 MSO_I, 0 MSO_I },
7587     { 29 MSO_I, 1 MSO_I }, { 27 MSO_I, 26 MSO_I }, { 0x21 MSO_I, 28 MSO_I }, { 0x13 MSO_I, 1 MSO_I }, { 0x20 MSO_I, 26 MSO_I }, { 25 MSO_I, 28 MSO_I }, { 24 MSO_I, 1 MSO_I }
7588 };
7589 const mso_CustomShape msoTextWave4 =
7590 {
7591     const_cast<SvxMSDffVertPair*>(mso_sptTextWave4Vert), SAL_N_ELEMENTS( mso_sptTextWave4Vert ),
7592     const_cast<sal_uInt16*>(mso_sptTextWave3Segm), sizeof( mso_sptTextWave3Segm ) >> 1,
7593     const_cast<SvxMSDffCalculationData*>(mso_sptDoubleWaveCalc), SAL_N_ELEMENTS( mso_sptDoubleWaveCalc ),
7594     const_cast<sal_Int32*>(mso_sptDoubleWaveDefault),
7595     const_cast<SvxMSDffTextRectangles*>(mso_sptDoubleWaveTextRect), SAL_N_ELEMENTS( mso_sptDoubleWaveTextRect ),
7596     21600, 21600,
7597     MIN_INT32, MIN_INT32,
7598     const_cast<SvxMSDffVertPair*>(mso_sptDoubleWaveGluePoints), SAL_N_ELEMENTS( mso_sptDoubleWaveGluePoints ),
7599     const_cast<SvxMSDffHandle*>(mso_sptDoubleWaveHandle), SAL_N_ELEMENTS( mso_sptDoubleWaveHandle )
7600 };
7601
7602 const sal_Int32 mso_sptCalloutDefault1[] =
7603 {
7604     4, -1800, 24500, -1800, 4000
7605 };
7606 const sal_Int32 mso_sptCalloutDefault2[] =
7607 {
7608     4, -8300, 24500, -1800, 4000
7609 };
7610 const sal_Int32 mso_sptCalloutDefault3[] =
7611 {
7612     6, -10000, 24500, -3600, 4000, -1800, 4000
7613 };
7614 const sal_Int32 mso_sptCalloutDefault4[] =
7615 {
7616     8, 23400, 24500, 25200, 21600, 25200, 4000, 23400, 4000
7617 };
7618 const SvxMSDffVertPair mso_sptCalloutVert1[] =
7619 {
7620     { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 }, { 0 MSO_I, 1 MSO_I }, { 2 MSO_I, 3 MSO_I }
7621 };
7622 const SvxMSDffHandle mso_sptCalloutHandle1[] =
7623 {
7624     {   SvxMSDffHandleFlags::NONE,
7625         0x100, 0x101, 10800, 10800, MIN_INT32, 0x7fffffff, MIN_INT32, 0x7fffffff },
7626     {   SvxMSDffHandleFlags::NONE,
7627         0x102, 0x103, 10800, 10800, MIN_INT32, 0x7fffffff, MIN_INT32, 0x7fffffff }
7628 };
7629 const sal_uInt16 mso_sptCalloutSegm1a[] =
7630 {
7631     0x4000, 0x0003, 0x6000, 0x8000,
7632     0x4000, 0x0001, 0x8000
7633 };
7634 const sal_uInt16 mso_sptCalloutSegm1b[] =
7635 {
7636     0x4000, 0xab00, 0x0003, 0x6000, 0x8000, // NO STROKE
7637     0x4000, 0x0001, 0x8000
7638 };
7639 const SvxMSDffVertPair mso_sptCallout1Vert[] =
7640 {
7641     { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 }, { 0 MSO_I, 1 MSO_I }, { 2 MSO_I, 3 MSO_I }, { 2 MSO_I, 0 }, { 2 MSO_I, 21600 }
7642 };
7643 const sal_uInt16 mso_sptCallout1Segm1a[] =
7644 {
7645     0x4000, 0x0003, 0x6000, 0x8000,
7646     0x4000, 0x0001, 0x8000,
7647     0x4000, 0x0001, 0x8000
7648 };
7649 const sal_uInt16 mso_sptCallout1Segm1b[] =
7650 {
7651     0x4000, 0xab00, 0x0003, 0x6000, 0x8000, // NO STROKE
7652     0x4000, 0x0001, 0x8000,
7653     0x4000, 0x0001, 0x8000
7654 };
7655 const SvxMSDffVertPair mso_sptCallout2Verta[] =
7656 {
7657     { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 }, { 0 MSO_I, 1 MSO_I }, { 2 MSO_I, 3 MSO_I }, { 2 MSO_I, 3 MSO_I }, { 4 MSO_I, 5 MSO_I }
7658 };
7659 const SvxMSDffVertPair mso_sptCallout2Vertb[] =
7660 {
7661     { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 }, { 0 MSO_I, 1 MSO_I }, { 2 MSO_I, 3 MSO_I }, { 2 MSO_I, 3 MSO_I }, { 4 MSO_I, 5 MSO_I }, { 4 MSO_I, 0 }, { 4 MSO_I, 21600 }
7662 };
7663 const SvxMSDffHandle mso_sptCalloutHandle2[] =
7664 {
7665     {   SvxMSDffHandleFlags::NONE,
7666         0x100, 0x101, 10800, 10800, MIN_INT32, 0x7fffffff, MIN_INT32, 0x7fffffff },
7667     {   SvxMSDffHandleFlags::NONE,
7668         0x102, 0x103, 10800, 10800, MIN_INT32, 0x7fffffff, MIN_INT32, 0x7fffffff },
7669     {   SvxMSDffHandleFlags::NONE,
7670         0x104, 0x105, 10800, 10800, MIN_INT32, 0x7fffffff, MIN_INT32, 0x7fffffff }
7671 };
7672 const sal_uInt16 mso_sptCallout2Segm1a[] =
7673 {
7674     0x4000, 0x0003, 0x6000, 0x8000,
7675     0x4000, 0x0001, 0x8000,
7676     0x4000, 0x0001, 0x8000,
7677     0x4000, 0x0001, 0x8000
7678 };
7679 const sal_uInt16 mso_sptCallout2Segm1b[] =
7680 {
7681     0x4000, 0xab00, 0x0003, 0x6000, 0x8000, // NO STROKE
7682     0x4000, 0x0001, 0x8000,
7683     0x4000, 0x0001, 0x8000,
7684     0x4000, 0x0001, 0x8000
7685 };
7686 const sal_uInt16 mso_sptCallout2Segm1c[] =
7687 {
7688     0x4000, 0x0003, 0x6000, 0x8000,
7689     0x4000, 0x0001, 0x8000,
7690     0x4000, 0x0001, 0x8000,
7691     0x4000, 0x0001, 0x8000,
7692     0x4000, 0x0001, 0x8000
7693 };
7694 const sal_uInt16 mso_sptCallout2Segm1d[] =
7695 {
7696     0x4000, 0xab00, 0x0003, 0x6000, 0x8000, // NO STROKE
7697     0x4000, 0x0001, 0x8000,
7698     0x4000, 0x0001, 0x8000,
7699     0x4000, 0x0001, 0x8000,
7700     0x4000, 0x0001, 0x8000
7701 };
7702 const SvxMSDffVertPair mso_sptCallout3Verta[] =
7703 {
7704     { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 }, { 6 MSO_I, 7 MSO_I }, { 4 MSO_I, 5 MSO_I }, { 2 MSO_I, 3 MSO_I }, { 0 MSO_I, 1 MSO_I }
7705 };
7706 const SvxMSDffVertPair mso_sptCallout3Vertb[] =
7707 {
7708     { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 }, { 6 MSO_I, 7 MSO_I }, { 4 MSO_I, 5 MSO_I }, { 2 MSO_I, 3 MSO_I }, { 0 MSO_I, 1 MSO_I }, { 6 MSO_I, 0 }, { 6 MSO_I, 21600 }
7709 };
7710 const SvxMSDffHandle mso_sptCalloutHandle3[] =
7711 {
7712     {   SvxMSDffHandleFlags::NONE,
7713         0x100, 0x101, 10800, 10800, MIN_INT32, 0x7fffffff, MIN_INT32, 0x7fffffff },
7714     {   SvxMSDffHandleFlags::NONE,
7715         0x102, 0x103, 10800, 10800, MIN_INT32, 0x7fffffff, MIN_INT32, 0x7fffffff },
7716     {   SvxMSDffHandleFlags::NONE,
7717         0x104, 0x105, 10800, 10800, MIN_INT32, 0x7fffffff, MIN_INT32, 0x7fffffff },
7718     {   SvxMSDffHandleFlags::NONE,
7719         0x106, 0x107, 10800, 10800, MIN_INT32, 0x7fffffff, MIN_INT32, 0x7fffffff }
7720 };
7721 const sal_uInt16 mso_sptCallout3Segm1a[] =
7722 {
7723     0x4000, 0x0003, 0x6000, 0x8000,
7724     0x4000, 0xaa00, 0x0003, 0x8000          // NO_FILL
7725 };
7726 const sal_uInt16 mso_sptCallout3Segm1b[] =
7727 {
7728     0x4000, 0xab00, 0x0003, 0x6000, 0x8000, // NO STROKE
7729     0x4000, 0xaa00, 0x0003, 0x8000          // NO FILL
7730 };
7731 const sal_uInt16 mso_sptCallout3Segm1c[] =
7732 {
7733     0x4000, 0x0003, 0x6000, 0x8000,
7734     0x4000, 0xaa00, 0x0003, 0x8000,         // NO FILL
7735     0x4000, 0x0001, 0x8000
7736 };
7737 const sal_uInt16 mso_sptCallout3Segm1d[] =
7738 {
7739     0x4000, 0xab00, 0x0003, 0x6000, 0x8000, // NO STROKE
7740     0x4000, 0xaa00, 0x0003, 0x8000,         // NO FILL
7741     0x4000, 0x0001, 0x8000
7742 };
7743
7744 const SvxMSDffCalculationData mso_sptCalloutCalc[] =
7745 {
7746     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
7747     { 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
7748     { 0x2000, { DFF_Prop_adjust3Value, 0, 0 } },
7749     { 0x2000, { DFF_Prop_adjust4Value, 0, 0 } },
7750     { 0x2000, { DFF_Prop_adjust5Value, 0, 0 } },
7751     { 0x2000, { DFF_Prop_adjust6Value, 0, 0 } },
7752     { 0x2000, { DFF_Prop_adjust7Value, 0, 0 } },
7753     { 0x2000, { DFF_Prop_adjust8Value, 0, 0 } }
7754 };
7755
7756 const mso_CustomShape msoCallout90 =
7757 {
7758     const_cast<SvxMSDffVertPair*>(mso_sptCalloutVert1), SAL_N_ELEMENTS( mso_sptCalloutVert1 ),
7759     const_cast<sal_uInt16*>(mso_sptCalloutSegm1b), sizeof( mso_sptCalloutSegm1b ) >> 1,
7760     const_cast<SvxMSDffCalculationData*>(mso_sptCalloutCalc), SAL_N_ELEMENTS( mso_sptCalloutCalc ),
7761     const_cast<sal_Int32*>(mso_sptCalloutDefault1),
7762     nullptr, 0,
7763     21600, 21600,
7764     MIN_INT32, MIN_INT32,
7765     nullptr, 0,
7766     const_cast<SvxMSDffHandle*>(mso_sptCalloutHandle1), SAL_N_ELEMENTS( mso_sptCalloutHandle1 )
7767 };
7768 const mso_CustomShape msoCallout1 =
7769 {
7770     const_cast<SvxMSDffVertPair*>(mso_sptCalloutVert1), SAL_N_ELEMENTS( mso_sptCalloutVert1 ),
7771     const_cast<sal_uInt16*>(mso_sptCalloutSegm1b), sizeof( mso_sptCalloutSegm1b ) >> 1,
7772     const_cast<SvxMSDffCalculationData*>(mso_sptCalloutCalc), SAL_N_ELEMENTS( mso_sptCalloutCalc ),
7773     const_cast<sal_Int32*>(mso_sptCalloutDefault2),
7774     nullptr, 0,
7775     21600, 21600,
7776     MIN_INT32, MIN_INT32,
7777     nullptr, 0,
7778     const_cast<SvxMSDffHandle*>(mso_sptCalloutHandle1), SAL_N_ELEMENTS( mso_sptCalloutHandle1 )
7779 };
7780 const mso_CustomShape msoCallout2 =
7781 {
7782     const_cast<SvxMSDffVertPair*>(mso_sptCallout2Verta), SAL_N_ELEMENTS( mso_sptCallout2Verta ),
7783     const_cast<sal_uInt16*>(mso_sptCallout2Segm1b), sizeof( mso_sptCallout2Segm1b ) >> 1,
7784     const_cast<SvxMSDffCalculationData*>(mso_sptCalloutCalc), SAL_N_ELEMENTS( mso_sptCalloutCalc ),
7785     const_cast<sal_Int32*>(mso_sptCalloutDefault3),
7786     nullptr, 0,
7787     21600, 21600,
7788     MIN_INT32, MIN_INT32,
7789     nullptr, 0,
7790     const_cast<SvxMSDffHandle*>(mso_sptCalloutHandle2), SAL_N_ELEMENTS( mso_sptCalloutHandle2 )
7791 };
7792 const mso_CustomShape msoCallout3 =
7793 {
7794     const_cast<SvxMSDffVertPair*>(mso_sptCallout3Verta), SAL_N_ELEMENTS( mso_sptCallout3Verta ),
7795     const_cast<sal_uInt16*>(mso_sptCallout3Segm1b), sizeof( mso_sptCallout3Segm1b ) >> 1,
7796     const_cast<SvxMSDffCalculationData*>(mso_sptCalloutCalc), SAL_N_ELEMENTS( mso_sptCalloutCalc ),
7797     const_cast<sal_Int32*>(mso_sptCalloutDefault4),
7798     nullptr, 0,
7799     21600, 21600,
7800     MIN_INT32, MIN_INT32,
7801     nullptr, 0,
7802     const_cast<SvxMSDffHandle*>(mso_sptCalloutHandle3), SAL_N_ELEMENTS( mso_sptCalloutHandle3 )
7803 };
7804 const mso_CustomShape msoAccentCallout90 =
7805 {
7806     const_cast<SvxMSDffVertPair*>(mso_sptCalloutVert1), SAL_N_ELEMENTS( mso_sptCalloutVert1 ),
7807     const_cast<sal_uInt16*>(mso_sptCalloutSegm1b), sizeof( mso_sptCalloutSegm1b ) >> 1,
7808     const_cast<SvxMSDffCalculationData*>(mso_sptCalloutCalc), SAL_N_ELEMENTS( mso_sptCalloutCalc ),
7809     const_cast<sal_Int32*>(mso_sptCalloutDefault1),
7810     nullptr, 0,
7811     21600, 21600,
7812     MIN_INT32, MIN_INT32,
7813     nullptr, 0,
7814     const_cast<SvxMSDffHandle*>(mso_sptCalloutHandle1), SAL_N_ELEMENTS( mso_sptCalloutHandle1 )
7815 };
7816 const mso_CustomShape msoAccentCallout1 =
7817 {
7818     const_cast<SvxMSDffVertPair*>(mso_sptCallout1Vert), SAL_N_ELEMENTS( mso_sptCallout1Vert ),
7819     const_cast<sal_uInt16*>(mso_sptCallout1Segm1b), sizeof( mso_sptCallout1Segm1b ) >> 1,
7820     const_cast<SvxMSDffCalculationData*>(mso_sptCalloutCalc), SAL_N_ELEMENTS( mso_sptCalloutCalc ),
7821     const_cast<sal_Int32*>(mso_sptCalloutDefault2),
7822     nullptr, 0,
7823     21600, 21600,
7824     MIN_INT32, MIN_INT32,
7825     nullptr, 0,
7826     const_cast<SvxMSDffHandle*>(mso_sptCalloutHandle1), SAL_N_ELEMENTS( mso_sptCalloutHandle1 )
7827 };
7828 const mso_CustomShape msoAccentCallout2 =
7829 {
7830     const_cast<SvxMSDffVertPair*>(mso_sptCallout2Vertb), SAL_N_ELEMENTS( mso_sptCallout2Vertb ),
7831     const_cast<sal_uInt16*>(mso_sptCallout2Segm1d), sizeof( mso_sptCallout2Segm1d ) >> 1,
7832     const_cast<SvxMSDffCalculationData*>(mso_sptCalloutCalc), SAL_N_ELEMENTS( mso_sptCalloutCalc ),
7833     const_cast<sal_Int32*>(mso_sptCalloutDefault3),
7834     nullptr, 0,
7835     21600, 21600,
7836     MIN_INT32, MIN_INT32,
7837     nullptr, 0,
7838     const_cast<SvxMSDffHandle*>(mso_sptCalloutHandle2), SAL_N_ELEMENTS( mso_sptCalloutHandle2 )
7839 };
7840 const mso_CustomShape msoAccentCallout3 =
7841 {
7842     const_cast<SvxMSDffVertPair*>(mso_sptCallout3Vertb), SAL_N_ELEMENTS( mso_sptCallout3Vertb ),
7843     const_cast<sal_uInt16*>(mso_sptCallout3Segm1d), sizeof( mso_sptCallout3Segm1d ) >> 1,
7844     const_cast<SvxMSDffCalculationData*>(mso_sptCalloutCalc), SAL_N_ELEMENTS( mso_sptCalloutCalc ),
7845     const_cast<sal_Int32*>(mso_sptCalloutDefault4),
7846     nullptr, 0,
7847     21600, 21600,
7848     MIN_INT32, MIN_INT32,
7849     nullptr, 0,
7850     const_cast<SvxMSDffHandle*>(mso_sptCalloutHandle3), SAL_N_ELEMENTS( mso_sptCalloutHandle3 )
7851 };
7852 const mso_CustomShape msoBorderCallout90 =
7853 {
7854     const_cast<SvxMSDffVertPair*>(mso_sptCalloutVert1), SAL_N_ELEMENTS( mso_sptCalloutVert1 ),
7855     const_cast<sal_uInt16*>(mso_sptCalloutSegm1a), sizeof( mso_sptCalloutSegm1a ) >> 1,
7856     const_cast<SvxMSDffCalculationData*>(mso_sptCalloutCalc), SAL_N_ELEMENTS( mso_sptCalloutCalc ),
7857     const_cast<sal_Int32*>(mso_sptCalloutDefault1),
7858     nullptr, 0,
7859     21600, 21600,
7860     MIN_INT32, MIN_INT32,
7861     nullptr, 0,
7862     const_cast<SvxMSDffHandle*>(mso_sptCalloutHandle1), SAL_N_ELEMENTS( mso_sptCalloutHandle1 )
7863 };
7864 const mso_CustomShape msoBorderCallout1 =
7865 {
7866     const_cast<SvxMSDffVertPair*>(mso_sptCalloutVert1), SAL_N_ELEMENTS( mso_sptCalloutVert1 ),
7867     const_cast<sal_uInt16*>(mso_sptCalloutSegm1a), sizeof( mso_sptCalloutSegm1a ) >> 1,
7868     const_cast<SvxMSDffCalculationData*>(mso_sptCalloutCalc), SAL_N_ELEMENTS( mso_sptCalloutCalc ),
7869     const_cast<sal_Int32*>(mso_sptCalloutDefault2),
7870     nullptr, 0,
7871     21600, 21600,
7872     MIN_INT32, MIN_INT32,
7873     nullptr, 0,
7874     const_cast<SvxMSDffHandle*>(mso_sptCalloutHandle1), SAL_N_ELEMENTS( mso_sptCalloutHandle1 )
7875 };
7876 const mso_CustomShape msoBorderCallout2 =
7877 {
7878     const_cast<SvxMSDffVertPair*>(mso_sptCallout2Verta), SAL_N_ELEMENTS( mso_sptCallout2Verta ),
7879     const_cast<sal_uInt16*>(mso_sptCallout2Segm1a), sizeof( mso_sptCallout2Segm1a ) >> 1,
7880     const_cast<SvxMSDffCalculationData*>(mso_sptCalloutCalc), SAL_N_ELEMENTS( mso_sptCalloutCalc ),
7881     const_cast<sal_Int32*>(mso_sptCalloutDefault3),
7882     nullptr, 0,
7883     21600, 21600,
7884     MIN_INT32, MIN_INT32,
7885     nullptr, 0,
7886     const_cast<SvxMSDffHandle*>(mso_sptCalloutHandle2), SAL_N_ELEMENTS( mso_sptCalloutHandle2 )
7887 };
7888 const mso_CustomShape msoBorderCallout3 =
7889 {
7890     const_cast<SvxMSDffVertPair*>(mso_sptCallout3Verta), SAL_N_ELEMENTS( mso_sptCallout3Verta ),
7891     const_cast<sal_uInt16*>(mso_sptCallout3Segm1a), sizeof( mso_sptCallout3Segm1a ) >> 1,
7892     const_cast<SvxMSDffCalculationData*>(mso_sptCalloutCalc), SAL_N_ELEMENTS( mso_sptCalloutCalc ),
7893     const_cast<sal_Int32*>(mso_sptCalloutDefault4),
7894     nullptr, 0,
7895     21600, 21600,
7896     MIN_INT32, MIN_INT32,
7897     nullptr, 0,
7898     const_cast<SvxMSDffHandle*>(mso_sptCalloutHandle3), SAL_N_ELEMENTS( mso_sptCalloutHandle3 )
7899 };
7900 const mso_CustomShape msoAccentBorderCallout90 =
7901 {
7902     const_cast<SvxMSDffVertPair*>(mso_sptCalloutVert1), SAL_N_ELEMENTS( mso_sptCalloutVert1 ),
7903     const_cast<sal_uInt16*>(mso_sptCalloutSegm1a), sizeof( mso_sptCalloutSegm1a ) >> 1,
7904     const_cast<SvxMSDffCalculationData*>(mso_sptCalloutCalc), SAL_N_ELEMENTS( mso_sptCalloutCalc ),
7905     const_cast<sal_Int32*>(mso_sptCalloutDefault1),
7906     nullptr, 0,
7907     21600, 21600,
7908     MIN_INT32, MIN_INT32,
7909     nullptr, 0,
7910     const_cast<SvxMSDffHandle*>(mso_sptCalloutHandle1), SAL_N_ELEMENTS( mso_sptCalloutHandle1 )
7911 };
7912 const mso_CustomShape msoAccentBorderCallout1 =
7913 {
7914     const_cast<SvxMSDffVertPair*>(mso_sptCallout1Vert), SAL_N_ELEMENTS( mso_sptCallout1Vert ),
7915     const_cast<sal_uInt16*>(mso_sptCallout1Segm1a), sizeof( mso_sptCallout1Segm1a ) >> 1,
7916     const_cast<SvxMSDffCalculationData*>(mso_sptCalloutCalc), SAL_N_ELEMENTS( mso_sptCalloutCalc ),
7917     const_cast<sal_Int32*>(mso_sptCalloutDefault2),
7918     nullptr, 0,
7919     21600, 21600,
7920     MIN_INT32, MIN_INT32,
7921     nullptr, 0,
7922     const_cast<SvxMSDffHandle*>(mso_sptCalloutHandle1), SAL_N_ELEMENTS( mso_sptCalloutHandle1 )
7923 };
7924 const mso_CustomShape msoAccentBorderCallout2 =
7925 {
7926     const_cast<SvxMSDffVertPair*>(mso_sptCallout2Vertb), SAL_N_ELEMENTS( mso_sptCallout2Vertb ),
7927     const_cast<sal_uInt16*>(mso_sptCallout2Segm1c), sizeof( mso_sptCallout2Segm1c ) >> 1,
7928     const_cast<SvxMSDffCalculationData*>(mso_sptCalloutCalc), SAL_N_ELEMENTS( mso_sptCalloutCalc ),
7929     const_cast<sal_Int32*>(mso_sptCalloutDefault3),
7930     nullptr, 0,
7931     21600, 21600,
7932     MIN_INT32, MIN_INT32,
7933     nullptr, 0,
7934     const_cast<SvxMSDffHandle*>(mso_sptCalloutHandle2), SAL_N_ELEMENTS( mso_sptCalloutHandle2 )
7935 };
7936 const mso_CustomShape msoAccentBorderCallout3 =
7937 {
7938     const_cast<SvxMSDffVertPair*>(mso_sptCallout3Vertb), SAL_N_ELEMENTS( mso_sptCallout3Vertb ),
7939     const_cast<sal_uInt16*>(mso_sptCallout3Segm1c), sizeof( mso_sptCallout3Segm1c ) >> 1,
7940     const_cast<SvxMSDffCalculationData*>(mso_sptCalloutCalc), SAL_N_ELEMENTS( mso_sptCalloutCalc ),
7941     const_cast<sal_Int32*>(mso_sptCalloutDefault4),
7942     nullptr, 0,
7943     21600, 21600,
7944     MIN_INT32, MIN_INT32,
7945     nullptr, 0,
7946     const_cast<SvxMSDffHandle*>(mso_sptCalloutHandle3), SAL_N_ELEMENTS( mso_sptCalloutHandle3 )
7947 };
7948
7949 const SvxMSDffVertPair mso_sptStraightConnector1Vert[] =
7950 {
7951     { 0, 0 }, { 21600, 21600 }
7952 };
7953 const sal_uInt16 mso_sptStraightConnector1Segm[] =
7954 {
7955     0x4000, 0x0001, 0x8000
7956 };
7957 const mso_CustomShape msoStraightConnector1 =
7958 {
7959     const_cast<SvxMSDffVertPair*>(mso_sptStraightConnector1Vert), SAL_N_ELEMENTS( mso_sptStraightConnector1Vert ),
7960     const_cast<sal_uInt16*>(mso_sptStraightConnector1Segm), sizeof( mso_sptStraightConnector1Segm ) >> 1,
7961     nullptr, 0,
7962     nullptr,
7963     nullptr, 0,
7964     21600, 21600,
7965     MIN_INT32, MIN_INT32,
7966     nullptr, 0,
7967     nullptr, 0
7968 };
7969
7970 const SvxMSDffVertPair mso_sptBentConnector2Vert[] =
7971 {
7972     { 0, 0 }, { 21600, 0 }, { 21600, 21600 }
7973 };
7974 const sal_uInt16 mso_sptBentConnector2Segm[] =
7975 {
7976     0x4000, 0x0002, 0x8000
7977 };
7978 const mso_CustomShape msoBentConnector2 =
7979 {
7980     const_cast<SvxMSDffVertPair*>(mso_sptBentConnector2Vert), SAL_N_ELEMENTS( mso_sptBentConnector2Vert ),
7981     const_cast<sal_uInt16*>(mso_sptBentConnector2Segm), sizeof( mso_sptBentConnector2Segm ) >> 1,
7982     nullptr, 0,
7983     nullptr,
7984     nullptr, 0,
7985     21600, 21600,
7986     MIN_INT32, MIN_INT32,
7987     nullptr, 0,
7988     nullptr, 0
7989 };
7990
7991 const SvxMSDffVertPair mso_sptBentConnector3Vert[] =
7992 {
7993     { 0, 0 }, { 0 MSO_I, 0 }, { 0 MSO_I, 21600 }, { 21600, 21600 }
7994 };
7995 const sal_uInt16 mso_sptBentConnector3Segm[] =
7996 {
7997     0x4000, 0x0003, 0x8000
7998 };
7999 const SvxMSDffCalculationData mso_sptBentConnector3Calc[] =
8000 {
8001     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } }
8002 };
8003 const sal_Int32 mso_sptBentConnector3Default[] =
8004 {
8005     1, 10800
8006 };
8007 const SvxMSDffHandle mso_sptBentConnector3Handle[] =
8008 {
8009     {   SvxMSDffHandleFlags::RANGE,
8010         0x100, 10800, 10800, 10800, MIN_INT32, 0x7fffffff, MIN_INT32, 0x7fffffff }
8011 };
8012 const mso_CustomShape msoBentConnector3 =
8013 {
8014     const_cast<SvxMSDffVertPair*>(mso_sptBentConnector3Vert), SAL_N_ELEMENTS( mso_sptBentConnector3Vert ),
8015     const_cast<sal_uInt16*>(mso_sptBentConnector3Segm), sizeof( mso_sptBentConnector3Segm ) >> 1,
8016     const_cast<SvxMSDffCalculationData*>(mso_sptBentConnector3Calc), SAL_N_ELEMENTS( mso_sptBentConnector3Calc ),
8017     const_cast<sal_Int32*>(mso_sptBentConnector3Default),
8018     nullptr, 0,
8019     21600, 21600,
8020     MIN_INT32, MIN_INT32,
8021     nullptr, 0,
8022     const_cast<SvxMSDffHandle*>(mso_sptBentConnector3Handle), SAL_N_ELEMENTS( mso_sptBentConnector3Handle )
8023 };
8024
8025 const SvxMSDffVertPair mso_sptBentConnector4Vert[] =
8026 {
8027     { 0, 0 }, { 0 MSO_I, 0 }, { 0 MSO_I, 1 MSO_I }, { 21600, 1 MSO_I }, { 21600, 21600 }
8028 };
8029 const sal_uInt16 mso_sptBentConnector4Segm[] =
8030 {
8031     0x4000, 0x0004, 0x8000
8032 };
8033 const SvxMSDffCalculationData mso_sptBentConnector4Calc[] =
8034 {
8035     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
8036     { 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
8037     { 0x2000, { 0x400, 21600, 0 } },
8038     { 0x2001, { 0x402, 1, 2 } },
8039     { 0x2001, { 0x401, 1, 2 } }
8040 };
8041 const sal_Int32 mso_sptBentConnector4Default[] =
8042 {
8043     2, 10800, 10800
8044 };
8045 const SvxMSDffHandle mso_sptBentConnector4Handle[] =
8046 {
8047     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
8048         0x100, 4 + 3, 10800, 10800, MIN_INT32, 0x7fffffff, 4 + 3, 4 + 3 },
8049     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
8050         3 + 3, 0x101, 10800, 10800, 3 + 3, 3 + 3, MIN_INT32, 0x7fffffff }
8051 };
8052 const mso_CustomShape msoBentConnector4 =
8053 {
8054     const_cast<SvxMSDffVertPair*>(mso_sptBentConnector4Vert), SAL_N_ELEMENTS( mso_sptBentConnector4Vert ),
8055     const_cast<sal_uInt16*>(mso_sptBentConnector4Segm), sizeof( mso_sptBentConnector4Segm ) >> 1,
8056     const_cast<SvxMSDffCalculationData*>(mso_sptBentConnector4Calc), SAL_N_ELEMENTS( mso_sptBentConnector4Calc ),
8057     const_cast<sal_Int32*>(mso_sptBentConnector4Default),
8058     nullptr, 0,
8059     21600, 21600,
8060     MIN_INT32, MIN_INT32,
8061     nullptr, 0,
8062     const_cast<SvxMSDffHandle*>(mso_sptBentConnector4Handle), SAL_N_ELEMENTS( mso_sptBentConnector4Handle )
8063 };
8064
8065 const SvxMSDffVertPair mso_sptBentConnector5Vert[] =
8066 {
8067     { 0, 0 }, { 0 MSO_I, 0 }, { 0 MSO_I, 4 MSO_I }, { 1 MSO_I, 4 MSO_I }, { 1 MSO_I, 21600 }, { 21600, 21600 }
8068 };
8069 const sal_uInt16 mso_sptBentConnector5Segm[] =
8070 {
8071     0x4000, 0x0005, 0x8000
8072 };
8073 const SvxMSDffCalculationData mso_sptBentConnector5Calc[] =
8074 {
8075     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
8076     { 0x2000, { DFF_Prop_adjust3Value, 0, 0 } },
8077     { 0x6000, { 0x400, 0x401, 0 } },
8078     { 0x2001, { 0x402, 1, 2 } },
8079     { 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
8080     { 0x2001, { 0x404, 1, 2 } },
8081     { 0x4000, { 21600, 0x404, 0 } },
8082     { 0x2001, { 0x406, 1, 2 } }
8083 };
8084 const sal_Int32 mso_sptBentConnector5Default[] =
8085 {
8086     3, 10800, 10800, 10800
8087 };
8088 const SvxMSDffHandle mso_sptBentConnector5Handle[] =
8089 {
8090     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
8091         0x100, 5 + 3, 10800, 10800, MIN_INT32, 0x7fffffff, 5 + 3, 5 + 3 },
8092     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
8093         3 + 3, 0x101, 10800, 10800, 3 + 3, 3 + 3, MIN_INT32, 0x7fffffff },
8094     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
8095         0x102, 7 + 3, 10800, 10800, MIN_INT32, 0x7fffffff, 7 + 3, 7 + 3 }
8096 };
8097 const mso_CustomShape msoBentConnector5 =
8098 {
8099     const_cast<SvxMSDffVertPair*>(mso_sptBentConnector5Vert), SAL_N_ELEMENTS( mso_sptBentConnector5Vert ),
8100     const_cast<sal_uInt16*>(mso_sptBentConnector5Segm), sizeof( mso_sptBentConnector5Segm ) >> 1,
8101     const_cast<SvxMSDffCalculationData*>(mso_sptBentConnector5Calc), SAL_N_ELEMENTS( mso_sptBentConnector5Calc ),
8102     const_cast<sal_Int32*>(mso_sptBentConnector5Default),
8103     nullptr, 0,
8104     21600, 21600,
8105     MIN_INT32, MIN_INT32,
8106     nullptr, 0,
8107     const_cast<SvxMSDffHandle*>(mso_sptBentConnector5Handle), SAL_N_ELEMENTS( mso_sptBentConnector5Handle )
8108 };
8109
8110 const SvxMSDffVertPair mso_sptCurvedConnector2Vert[] =
8111 {
8112     { 0, 0 }, { 10800, 0 }, { 21600, 10800 }, { 21600, 21600 }
8113 };
8114 const sal_uInt16 mso_sptCurvedConnector2Segm[] =
8115 {
8116     0x4000, 0x2001, 0x8000
8117 };
8118 const mso_CustomShape msoCurvedConnector2 =
8119 {
8120     const_cast<SvxMSDffVertPair*>(mso_sptCurvedConnector2Vert), SAL_N_ELEMENTS( mso_sptCurvedConnector2Vert ),
8121     const_cast<sal_uInt16*>(mso_sptCurvedConnector2Segm), sizeof( mso_sptCurvedConnector2Segm ) >> 1,
8122     nullptr, 0,
8123     nullptr,
8124     nullptr, 0,
8125     21600, 21600,
8126     MIN_INT32, MIN_INT32,
8127     nullptr, 0,
8128     nullptr, 0
8129 };
8130
8131 const SvxMSDffVertPair mso_sptCurvedConnector3Vert[] =
8132 {
8133     { 0, 0 }, { 1 MSO_I, 0 }, { 0 MSO_I, 5400 }, { 0 MSO_I, 10800 }, { 0 MSO_I, 16200 }, { 3 MSO_I, 21600 }, { 21600, 21600 }
8134 };
8135 const sal_uInt16 mso_sptCurvedConnector3Segm[] =
8136 {
8137     0x4000, 0x2002, 0x8000
8138 };
8139 const SvxMSDffCalculationData mso_sptCurvedConnector3Calc[] =
8140 {
8141     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
8142     { 0x2001, { 0x400, 1, 2 } },
8143     { 0x2000, { 0x400, 21600, 0 } },
8144     { 0x2001, { 0x402, 1, 2 } }
8145 };
8146 const sal_Int32 mso_sptCurvedConnector3Default[] =
8147 {
8148     1, 10800
8149 };
8150 const SvxMSDffHandle mso_sptCurvedConnector3Handle[] =
8151 {
8152     {   SvxMSDffHandleFlags::RANGE,
8153         0x100, 10800, 10800, 10800, MIN_INT32, 0x7fffffff, MIN_INT32, 0x7fffffff }
8154 };
8155 const mso_CustomShape msoCurvedConnector3 =
8156 {
8157     const_cast<SvxMSDffVertPair*>(mso_sptCurvedConnector3Vert), SAL_N_ELEMENTS( mso_sptCurvedConnector3Vert ),
8158     const_cast<sal_uInt16*>(mso_sptCurvedConnector3Segm), sizeof( mso_sptCurvedConnector3Segm ) >> 1,
8159     const_cast<SvxMSDffCalculationData*>(mso_sptCurvedConnector3Calc), SAL_N_ELEMENTS( mso_sptCurvedConnector3Calc ),
8160     const_cast<sal_Int32*>(mso_sptCurvedConnector3Default),
8161     nullptr, 0,
8162     21600, 21600,
8163     MIN_INT32, MIN_INT32,
8164     nullptr, 0,
8165     const_cast<SvxMSDffHandle*>(mso_sptCurvedConnector3Handle), SAL_N_ELEMENTS( mso_sptCurvedConnector3Handle )
8166 };
8167
8168 const SvxMSDffVertPair mso_sptCurvedConnector4Vert[] =
8169 {
8170     { 0, 0 }, { 1 MSO_I, 0 }, { 0 MSO_I, 10 MSO_I }, { 0 MSO_I, 9 MSO_I },
8171     { 0 MSO_I, 12 MSO_I }, { 5 MSO_I, 8 MSO_I }, { 3 MSO_I, 8 MSO_I },
8172     { 7 MSO_I, 8 MSO_I }, { 21600, 14 MSO_I }, { 21600, 21600 }
8173
8174 };
8175 const sal_uInt16 mso_sptCurvedConnector4Segm[] =
8176 {
8177     0x4000, 0x2003, 0x8000
8178 };
8179 const SvxMSDffCalculationData mso_sptCurvedConnector4Calc[] =
8180 {
8181     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
8182     { 0x2001, { 0x400, 1, 2 } },
8183     { 0x4000, { 21600, 0x400, 0 } },
8184     { 0x2001, { 0x402, 1, 2 } },
8185     { 0x6000, { 0x400, 0x403, 0 } },
8186     { 0x2001, { 0x404, 1, 2 } },
8187     { 0x2000, { 0x403, 21600, 0 } },
8188     { 0x2001, { 0x406, 1, 2 } },
8189     { 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
8190     { 0x2001, { DFF_Prop_adjust2Value, 1, 2 } },
8191     { 0x2001, { DFF_Prop_adjust2Value, 1, 4 } },
8192     { 0x6000, { 0x408, 0x409, 0 } },
8193     { 0x2001, { 0x40b, 1, 2 } },
8194     { 0x2000, { 0x408, 21600, 0 } },
8195     { 0x2001, { 0x40d, 1, 2 } }
8196 };
8197 const sal_Int32 mso_sptCurvedConnector4Default[] =
8198 {
8199     2, 10800, 10800
8200 };
8201 const SvxMSDffHandle mso_sptCurvedConnector4Handle[] =
8202 {
8203     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
8204         0x100, 9 + 3, 10800, 10800, MIN_INT32, 0x7fffffff, 9 + 3, 9 + 3 },
8205     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
8206         3 + 3, 0x101, 10800, 10800, 3 + 3, 3 + 3, MIN_INT32, 0x7fffffff }
8207 };
8208 const mso_CustomShape msoCurvedConnector4 =
8209 {
8210     const_cast<SvxMSDffVertPair*>(mso_sptCurvedConnector4Vert), SAL_N_ELEMENTS( mso_sptCurvedConnector4Vert ),
8211     const_cast<sal_uInt16*>(mso_sptCurvedConnector4Segm), sizeof( mso_sptCurvedConnector4Segm ) >> 1,
8212     const_cast<SvxMSDffCalculationData*>(mso_sptCurvedConnector4Calc), SAL_N_ELEMENTS( mso_sptCurvedConnector4Calc ),
8213     const_cast<sal_Int32*>(mso_sptCurvedConnector4Default),
8214     nullptr, 0,
8215     21600, 21600,
8216     MIN_INT32, MIN_INT32,
8217     nullptr, 0,
8218     const_cast<SvxMSDffHandle*>(mso_sptCurvedConnector4Handle), SAL_N_ELEMENTS( mso_sptCurvedConnector4Handle )
8219 };
8220
8221 const SvxMSDffVertPair mso_sptCurvedConnector5Vert[] =
8222 {
8223     { 0, 0 },
8224     { 21 MSO_I, 0 }, { 0 MSO_I, 12 MSO_I }, { 0 MSO_I, 11 MSO_I },
8225     { 0 MSO_I, 14 MSO_I }, { 6 MSO_I, 4 MSO_I }, { 3 MSO_I, 4 MSO_I },
8226     { 8 MSO_I, 4 MSO_I }, { 1 MSO_I, 18 MSO_I }, { 1 MSO_I, 16 MSO_I },
8227     { 1 MSO_I, 20 MSO_I }, { 10 MSO_I, 21600 }, { 21600, 21600 }
8228 };
8229 const sal_uInt16 mso_sptCurvedConnector5Segm[] =
8230 {
8231     0x4000, 0x2004, 0x8000
8232 };
8233 const SvxMSDffCalculationData mso_sptCurvedConnector5Calc[] =
8234 {
8235     { 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
8236     { 0x2000, { DFF_Prop_adjust3Value, 0, 0 } },
8237     { 0x6000, { 0x400, 0x401, 0 } },
8238     { 0x2001, { 0x402, 1, 2 } },
8239     { 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
8240     { 0x6000, { 0x400, 0x403, 0 } },
8241     { 0x2001, { 0x405, 1, 2 } },
8242     { 0x6000, { 0x401, 0x403, 0 } },
8243     { 0x2001, { 0x407, 1, 2 } },
8244     { 0x2000, { 0x401, 21600, 0 } },
8245     { 0x2001, { 0x409, 1, 2 } },
8246     { 0x2001, { 0x404, 1, 2 } },
8247     { 0x2001, { 0x40b, 1, 2 } },
8248     { 0x6000, { 0x404, 0x40b, 0 } },
8249     { 0x2001, { 0x40d, 1, 2 } },
8250     { 0x2000, { 0x404, 21600, 0 } },
8251     { 0x2001, { 0x40f, 1, 2 } },
8252     { 0x6000, { 0x404, 0x410, 0 } },
8253     { 0x2001, { 0x411, 1, 2 } },
8254     { 0x2000, { 0x410, 21600, 0 } },
8255     { 0x2001, { 0x413, 1, 2 } },
8256     { 0x2001, { 0x400, 1, 2 } }
8257 };
8258 const sal_Int32 mso_sptCurvedConnector5Default[] =
8259 {
8260     3, 10800, 10800, 10800
8261 };
8262 const SvxMSDffHandle mso_sptCurvedConnector5Handle[] =
8263 {
8264     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
8265         0x100, 11 + 3, 10800, 10800, MIN_INT32, 0x7fffffff, 11 + 3, 11 + 3 },
8266     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
8267         3 + 3, 0x101, 10800, 10800, 3 + 3, 3 + 3, MIN_INT32, 0x7fffffff },
8268     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
8269         0x102, 16 + 3, 10800, 10800, MIN_INT32, 0x7fffffff, 16 + 3, 16 + 3 }
8270 };
8271 const mso_CustomShape msoCurvedConnector5 =
8272 {
8273     const_cast<SvxMSDffVertPair*>(mso_sptCurvedConnector5Vert), SAL_N_ELEMENTS( mso_sptCurvedConnector5Vert ),
8274     const_cast<sal_uInt16*>(mso_sptCurvedConnector5Segm), sizeof( mso_sptCurvedConnector5Segm ) >> 1,
8275     const_cast<SvxMSDffCalculationData*>(mso_sptCurvedConnector5Calc), SAL_N_ELEMENTS( mso_sptCurvedConnector5Calc ),
8276     const_cast<sal_Int32*>(mso_sptCurvedConnector5Default),
8277     nullptr, 0,
8278     21600, 21600,
8279     MIN_INT32, MIN_INT32,
8280     nullptr, 0,
8281     const_cast<SvxMSDffHandle*>(mso_sptCurvedConnector5Handle), SAL_N_ELEMENTS( mso_sptCurvedConnector5Handle )
8282 };
8283
8284 /////////////////////////////teardrop
8285 const SvxMSDffVertPair mso_sptTearDropVert[] =
8286 {
8287     { 10800, 0 },
8288     { 0, 10800 },                                                   // X
8289     { 10800, 21600 },                                               // Y
8290     { 21600, 10800 },                                               // X
8291     { 21600, 10800 }, { 21600, 3 MSO_I }, { 0 MSO_I, 1 MSO_I },             // C
8292     { 0 MSO_I, 1 MSO_I }, { 4 MSO_I, 0 }, { 10800, 0 }
8293 };
8294
8295 //  the last number (0x***n)  :  0 = sum, 1 = prod, 2 = mid, 3 = abs, 4 = min, 5 = max, 6 = if, 13 = sqrt, 15 = eclipse ...
8296 //    the first number(0xn***)  :  2/4/8 the first/second/third value is not directly value
8297 const SvxMSDffCalculationData mso_sptTearDropCalc[] =
8298 {
8299     { 0x2000 , { DFF_Prop_adjustValue , 0 , 0 } },  // 0  adjust value #0
8300     { 0x8000 , { 21600 , 0 , 0x0400 } },            // 1  21600 - @0                     y0
8301     { 0x8000 , { 32400 , 0 , 0x0400 } },            // 2   (32400 - @0)
8302     { 0x2001 , { 0x0402 , 1 , 2 } },                // 3   (32400 - @0)/2               y1
8303     { 0x2002 , { 0x0400 , 10800 , 0 } },            // 4  (@0+10800)/2                  x2
8304 };
8305
8306 //m, qx, qy, qx,C,C
8307 //the last number(0x***n) : repeat number of this current Segm
8308 const sal_uInt16 mso_sptTearDropSegm[] =
8309 {
8310     0x4000, 0xa701, 0xa801, 0xa701, 0x2002, 0x6000, 0x8000
8311 };
8312
8313 const SvxMSDffTextRectangles mso_sptTearDropTextRect[] =
8314 {
8315     { { 2863, 2863 }, { 18737, 18737 } }
8316 };
8317
8318 //the range of adjust values
8319 const SvxMSDffHandle mso_sptTearDropHandle[] =
8320 {
8321     //position="$0,0" xrange="10800,32400"
8322     {   SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL| SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL,
8323         0x100, 0, 10800, 10800, 10800, 32400, MIN_INT32, 0x7fffffff }
8324 };
8325
8326 //the number of adjust values, the default values
8327 const sal_Int32 mso_sptTearDropDefault[] =
8328 {
8329     1, 21600
8330 };
8331
8332 const mso_CustomShape msoTearDrop =
8333 {
8334     const_cast<SvxMSDffVertPair*>(mso_sptTearDropVert), SAL_N_ELEMENTS( mso_sptTearDropVert ),
8335     const_cast<sal_uInt16*>(mso_sptTearDropSegm), sizeof( mso_sptTearDropSegm ) >> 1,
8336     const_cast<SvxMSDffCalculationData*>(mso_sptTearDropCalc), SAL_N_ELEMENTS(mso_sptTearDropCalc),
8337     const_cast<sal_Int32*>(mso_sptTearDropDefault),
8338     const_cast<SvxMSDffTextRectangles*>(mso_sptTearDropTextRect), SAL_N_ELEMENTS( mso_sptTearDropTextRect ),
8339     21600, 21600,
8340     MIN_INT32, MIN_INT32,
8341     nullptr, 0,
8342     const_cast<SvxMSDffHandle*>(mso_sptTearDropHandle), SAL_N_ELEMENTS(mso_sptTearDropHandle)        // handles
8343 };
8344
8345
8346 const mso_CustomShape* GetCustomShapeContent( MSO_SPT eSpType )
8347 {
8348     const mso_CustomShape* pCustomShape = nullptr;
8349     switch( eSpType )
8350     {
8351         case mso_sptArc :                       pCustomShape = &msoArc; break;
8352         case mso_sptLine:                       pCustomShape = &msoStraightConnector1; break;
8353         case mso_sptRectangle :                 pCustomShape = &msoRectangle; break;
8354         case mso_sptParallelogram :             pCustomShape = &msoParallelogram; break;
8355         case mso_sptTrapezoid :                 pCustomShape = &msoTrapezoid; break;
8356         case mso_sptDiamond :                   pCustomShape = &msoDiamond; break;
8357         case mso_sptRoundRectangle :            pCustomShape = &msoRoundRectangle; break;
8358         case mso_sptOctagon :                   pCustomShape = &msoOctagon; break;
8359         case mso_sptIsocelesTriangle :          pCustomShape = &msoIsocelesTriangle; break;
8360         case mso_sptRightTriangle :             pCustomShape = &msoRightTriangle; break;
8361         case mso_sptEllipse :                   pCustomShape = &msoEllipse; break;
8362         case mso_sptHexagon :                   pCustomShape = &msoHexagon; break;
8363         case mso_sptPlus :                      pCustomShape = &msoPlus; break;
8364         case mso_sptPentagon :                  pCustomShape = &msoPentagon; break;
8365         case mso_sptCan :                       pCustomShape = &msoCan; break;
8366         case mso_sptCube :                      pCustomShape = &msoCube; break;
8367         case mso_sptBalloon :                   pCustomShape = &msoBalloon; break;
8368         case mso_sptActionButtonBlank :         pCustomShape = &msoActionButtonBlank; break;
8369         case mso_sptActionButtonHome :          pCustomShape = &msoActionButtonHome; break;
8370         case mso_sptActionButtonHelp :          pCustomShape = &msoActionButtonHelp; break;
8371         case mso_sptActionButtonInformation :   pCustomShape = &msoActionButtonInformation; break;
8372         case mso_sptActionButtonBackPrevious :  pCustomShape = &msoActionButtonBackPrevious; break;
8373         case mso_sptActionButtonForwardNext :   pCustomShape = &msoActionButtonForwardNext; break;
8374         case mso_sptActionButtonBeginning :     pCustomShape = &msoActionButtonBeginning; break;
8375         case mso_sptActionButtonEnd :           pCustomShape = &msoActionButtonEnd; break;
8376         case mso_sptActionButtonReturn :        pCustomShape = &msoActionButtonReturn;  break;
8377         case mso_sptActionButtonDocument :      pCustomShape = &msoActionButtonDocument; break;
8378         case mso_sptActionButtonSound :         pCustomShape = &msoActionButtonSound; break;
8379         case mso_sptActionButtonMovie :         pCustomShape = &msoActionButtonMovie; break;
8380         case mso_sptBevel :                     pCustomShape = &msoBevel; break;
8381         case mso_sptFoldedCorner :              pCustomShape = &msoFoldedCorner; break;
8382         case mso_sptSmileyFace :                pCustomShape = &msoSmileyFace;  break;
8383         case mso_sptDonut :                     pCustomShape = &msoDonut; break;
8384         case mso_sptNoSmoking :                 pCustomShape = &msoNoSmoking; break;
8385         case mso_sptBlockArc :                  pCustomShape = &msoBlockArc; break;
8386         case mso_sptHeart :                     pCustomShape = &msoHeart; break;
8387         case mso_sptLightningBolt :             pCustomShape = &msoLightningBold; break;
8388         case mso_sptSun :                       pCustomShape = &msoSun; break;
8389         case mso_sptMoon :                      pCustomShape = &msoMoon; break;
8390         case mso_sptBracketPair :               pCustomShape = &msoBracketPair; break;
8391         case mso_sptBracePair :                 pCustomShape = &msoBracePair; break;
8392         case mso_sptPlaque :                    pCustomShape = &msoPlaque; break;
8393         case mso_sptLeftBracket :               pCustomShape = &msoLeftBracket; break;
8394         case mso_sptRightBracket :              pCustomShape = &msoRightBracket; break;
8395         case mso_sptLeftBrace :                 pCustomShape = &msoLeftBrace; break;
8396         case mso_sptRightBrace :                pCustomShape = &msoRightBrace; break;
8397         case mso_sptArrow :                     pCustomShape = &msoArrow; break;
8398         case mso_sptUpArrow :                   pCustomShape = &msoUpArrow; break;
8399         case mso_sptDownArrow :                 pCustomShape = &msoDownArrow; break;
8400         case mso_sptLeftArrow :                 pCustomShape = &msoLeftArrow; break;
8401         case mso_sptLeftRightArrow :            pCustomShape = &msoLeftRightArrow; break;
8402         case mso_sptUpDownArrow :               pCustomShape = &msoUpDownArrow; break;
8403         case mso_sptQuadArrow :                 pCustomShape = &msoQuadArrow; break;
8404         case mso_sptLeftRightUpArrow :          pCustomShape = &msoLeftRightUpArrow; break;
8405         case mso_sptBentArrow :                 pCustomShape = &msoBentArrow; break;
8406         case mso_sptUturnArrow :                pCustomShape = &msoUturnArrow; break;
8407         case mso_sptLeftUpArrow :               pCustomShape = &msoLeftUpArrow; break;
8408         case mso_sptBentUpArrow :               pCustomShape = &msoBentUpArrow; break;
8409         case mso_sptCurvedRightArrow :          pCustomShape = &msoCurvedRightArrow; break;
8410         case mso_sptCurvedLeftArrow :           pCustomShape = &msoCurvedLeftArrow; break;
8411         case mso_sptCurvedUpArrow :             pCustomShape = &msoCurvedUpArrow; break;
8412         case mso_sptCurvedDownArrow :           pCustomShape = &msoCurvedDownArrow; break;
8413         case mso_sptStripedRightArrow :         pCustomShape = &msoStripedRightArrow; break;
8414         case mso_sptNotchedRightArrow :         pCustomShape = &msoNotchedRightArrow; break;
8415         case mso_sptHomePlate :                 pCustomShape = &msoHomePlate; break;
8416         case mso_sptChevron :                   pCustomShape = &msoChevron; break;
8417         case mso_sptRightArrowCallout :         pCustomShape = &msoRightArrowCallout; break;
8418         case mso_sptLeftArrowCallout :          pCustomShape = &msoLeftArrowCallout; break;
8419         case mso_sptUpArrowCallout :            pCustomShape = &msoUpArrowCallout; break;
8420         case mso_sptDownArrowCallout :          pCustomShape = &msoDownArrowCallout; break;
8421         case mso_sptLeftRightArrowCallout :     pCustomShape = &msoLeftRightArrowCallout; break;
8422         case mso_sptUpDownArrowCallout :        pCustomShape = &msoUpDownArrowCallout; break;
8423         case mso_sptQuadArrowCallout :          pCustomShape = &msoQuadArrowCallout; break;
8424         case mso_sptCircularArrow :             pCustomShape = &msoCircularArrow; break;
8425         case mso_sptIrregularSeal1 :            pCustomShape = &msoIrregularSeal1; break;
8426         case mso_sptIrregularSeal2 :            pCustomShape = &msoIrregularSeal2; break;
8427         case mso_sptSeal4 :                     pCustomShape = &msoSeal4; break;
8428         case mso_sptStar :                      pCustomShape = &msoStar; break;
8429         case mso_sptSeal8 :                     pCustomShape = &msoSeal8; break;
8430         case mso_sptSeal :
8431         case mso_sptSeal16 :                    pCustomShape = &msoSeal16; break;
8432         case mso_sptSeal24 :                    pCustomShape = &msoSeal24; break;
8433         case mso_sptSeal32 :                    pCustomShape = &msoSeal32; break;
8434         case mso_sptRibbon2 :                   pCustomShape = &msoRibbon2; break;
8435         case mso_sptRibbon :                    pCustomShape = &msoRibbon; break;
8436         case mso_sptEllipseRibbon2 :            pCustomShape = &msosptEllipseRibbon2; break;    // SJ: TODO
8437         case mso_sptEllipseRibbon :             pCustomShape = &msosptEllipseRibbon; break; // SJ: TODO
8438         case mso_sptVerticalScroll :            pCustomShape = &msoVerticalScroll;  break;
8439         case mso_sptHorizontalScroll :          pCustomShape = &msoHorizontalScroll; break;
8440         case mso_sptFlowChartProcess :          pCustomShape = &msoFlowChartProcess; break;
8441         case mso_sptFlowChartAlternateProcess : pCustomShape = &msoFlowChartAlternateProcess; break;
8442         case mso_sptFlowChartDecision :         pCustomShape = &msoFlowChartDecision; break;
8443         case mso_sptFlowChartInputOutput :      pCustomShape = &msoFlowChartInputOutput; break;
8444         case mso_sptFlowChartPredefinedProcess :pCustomShape = &msoFlowChartPredefinedProcess; break;
8445         case mso_sptFlowChartInternalStorage :  pCustomShape = &msoFlowChartInternalStorage; break;
8446         case mso_sptFlowChartDocument :         pCustomShape = &msoFlowChartDocument; break;
8447         case mso_sptFlowChartMultidocument :    pCustomShape = &msoFlowChartMultidocument; break;
8448         case mso_sptFlowChartTerminator :       pCustomShape = &msoFlowChartTerminator; break;
8449         case mso_sptFlowChartPreparation :      pCustomShape = &msoFlowChartPreparation; break;
8450         case mso_sptFlowChartManualInput :      pCustomShape = &msoFlowChartManualInput; break;
8451         case mso_sptFlowChartManualOperation :  pCustomShape = &msoFlowChartManualOperation; break;
8452         case mso_sptFlowChartConnector :        pCustomShape = &msoFlowChartConnector; break;
8453         case mso_sptFlowChartOffpageConnector : pCustomShape = &msoFlowChartOffpageConnector; break;
8454         case mso_sptFlowChartPunchedCard :      pCustomShape = &msoFlowChartPunchedCard; break;
8455         case mso_sptFlowChartPunchedTape :      pCustomShape = &msoFlowChartPunchedTape; break;
8456         case mso_sptFlowChartSummingJunction :  pCustomShape = &msoFlowChartSummingJunction; break;
8457         case mso_sptFlowChartOr :               pCustomShape = &msoFlowChartOr; break;
8458         case mso_sptFlowChartCollate :          pCustomShape = &msoFlowChartCollate; break;
8459         case mso_sptFlowChartSort :             pCustomShape = &msoFlowChartSort; break;
8460         case mso_sptFlowChartExtract :          pCustomShape = &msoFlowChartExtract; break;
8461         case mso_sptFlowChartMerge :            pCustomShape = &msoFlowChartMerge; break;
8462         case mso_sptFlowChartOnlineStorage :    pCustomShape = &msoFlowChartOnlineStorage; break;
8463         case mso_sptFlowChartDelay :            pCustomShape = &msoFlowChartDelay; break;
8464         case mso_sptFlowChartMagneticTape :     pCustomShape = &msoFlowChartMagneticTape; break;
8465         case mso_sptFlowChartMagneticDisk :     pCustomShape = &msoFlowChartMagneticDisk; break;
8466         case mso_sptFlowChartMagneticDrum :     pCustomShape = &msoFlowChartMagneticDrum; break;
8467         case mso_sptFlowChartDisplay :          pCustomShape = &msoFlowChartDisplay; break;
8468         case mso_sptWedgeRectCallout :          pCustomShape = &msoWedgeRectCallout; break;
8469         case mso_sptWedgeRRectCallout :         pCustomShape = &msoWedgeRRectCallout; break;
8470         case mso_sptWedgeEllipseCallout :       pCustomShape = &msoWedgeEllipseCallout; break;
8471         case mso_sptCloudCallout :              pCustomShape = &msoCloudCallout; break;
8472         case mso_sptWave :                      pCustomShape = &msoWave; break;
8473         case mso_sptDoubleWave :                pCustomShape = &msoDoubleWave; break;
8474
8475         // callout
8476         case mso_sptCallout1 :                  pCustomShape = &msoCallout1; break;
8477         case mso_sptCallout2 :                  pCustomShape = &msoCallout2; break;
8478         case mso_sptCallout3 :                  pCustomShape = &msoCallout3; break;
8479         case mso_sptAccentCallout1 :            pCustomShape = &msoAccentCallout1; break;
8480         case mso_sptAccentCallout2 :            pCustomShape = &msoAccentCallout2; break;
8481         case mso_sptAccentCallout3 :            pCustomShape = &msoAccentCallout3; break;
8482         case mso_sptBorderCallout1 :            pCustomShape = &msoBorderCallout1; break;
8483         case mso_sptBorderCallout2 :            pCustomShape = &msoBorderCallout2; break;
8484         case mso_sptBorderCallout3 :            pCustomShape = &msoBorderCallout3; break;
8485         case mso_sptAccentBorderCallout1 :      pCustomShape = &msoAccentBorderCallout1; break;
8486         case mso_sptAccentBorderCallout2 :      pCustomShape = &msoAccentBorderCallout2; break;
8487         case mso_sptAccentBorderCallout3 :      pCustomShape = &msoAccentBorderCallout3; break;
8488         case mso_sptCallout90 :                 pCustomShape = &msoCallout90; break;
8489         case mso_sptAccentCallout90 :           pCustomShape = &msoAccentCallout90; break;
8490         case mso_sptBorderCallout90 :           pCustomShape = &msoBorderCallout90; break;
8491         case mso_sptAccentBorderCallout90 :     pCustomShape = &msoAccentBorderCallout90; break;
8492
8493         // connectors
8494         case mso_sptStraightConnector1 :        pCustomShape = &msoStraightConnector1; break;
8495         case mso_sptBentConnector2 :            pCustomShape = &msoBentConnector2; break;
8496         case mso_sptBentConnector3 :            pCustomShape = &msoBentConnector3; break;
8497         case mso_sptBentConnector4 :            pCustomShape = &msoBentConnector4; break;
8498         case mso_sptBentConnector5 :            pCustomShape = &msoBentConnector5; break;
8499         case mso_sptCurvedConnector2 :          pCustomShape = &msoCurvedConnector2; break;
8500         case mso_sptCurvedConnector3 :          pCustomShape = &msoCurvedConnector3; break;
8501         case mso_sptCurvedConnector4 :          pCustomShape = &msoCurvedConnector4; break;
8502         case mso_sptCurvedConnector5 :          pCustomShape = &msoCurvedConnector5; break;
8503
8504         // Don't know, simply mapping to TextSimple
8505         case mso_sptTextOnRing :
8506         case mso_sptTextOnCurve :
8507         case mso_sptTextRing :
8508         case mso_sptTextWave :
8509         case mso_sptTextCurve :
8510         case mso_sptTextHexagon :
8511         case mso_sptTextOctagon :
8512         case mso_sptTextBox :                   pCustomShape = &msoTextSimple; break;
8513
8514         // FontWork
8515         case mso_sptTextSimple :
8516         case mso_sptTextPlainText :             pCustomShape = &msoTextPlainText; break;
8517         case mso_sptTextStop :                  pCustomShape = &msoTextStop; break;
8518         case mso_sptTextTriangle :              pCustomShape = &msoTextTriangle; break;
8519         case mso_sptTextTriangleInverted :      pCustomShape = &msoTextTriangleInverted; break;
8520         case mso_sptTextChevron :               pCustomShape = &msoTextChevron; break;
8521         case mso_sptTextChevronInverted :       pCustomShape = &msoTextChevronInverted; break;
8522         case mso_sptTextRingInside :            pCustomShape = &msoTextRingInside; break;   // SJ: TODO->the orientation of the ellipse needs to be changed
8523         case mso_sptTextRingOutside :           pCustomShape = &msoTextRingOutside; break;
8524         case mso_sptTextFadeRight :             pCustomShape = &msoTextFadeRight; break;
8525         case mso_sptTextFadeLeft :              pCustomShape = &msoTextFadeLeft; break;
8526         case mso_sptTextFadeUp :                pCustomShape = &msoTextFadeUp; break;
8527         case mso_sptTextFadeDown :              pCustomShape = &msoTextFadeDown; break;
8528         case mso_sptTextSlantUp :               pCustomShape = &msoTextSlantUp; break;
8529         case mso_sptTextSlantDown :             pCustomShape = &msoTextSlantDown; break;
8530         case mso_sptTextCascadeUp :             pCustomShape = &msoTextCascadeUp; break;
8531         case mso_sptTextCascadeDown :           pCustomShape = &msoTextCascadeDown; break;
8532         case mso_sptTextArchUpCurve :           pCustomShape = &msoTextArchUpCurve; break;
8533         case mso_sptTextArchDownCurve :         pCustomShape = &msoTextArchDownCurve; break;
8534         case mso_sptTextCircleCurve :           pCustomShape = &msoTextCircleCurve; break;
8535         case mso_sptTextButtonCurve :           pCustomShape = &msoTextButtonCurve; break;
8536         case mso_sptTextArchUpPour :            pCustomShape = &msoTextArchUpPour; break;
8537         case mso_sptTextArchDownPour :          pCustomShape = &msoTextArchDownPour; break;
8538         case mso_sptTextCirclePour :            pCustomShape = &msoTextCirclePour; break;
8539         case mso_sptTextButtonPour :            pCustomShape = &msoTextButtonPour; break;
8540         case mso_sptTextCurveUp :               pCustomShape = &msoTextCurveUp; break;
8541         case mso_sptTextCurveDown :             pCustomShape = &msoTextCurveDown; break;
8542         case mso_sptTextCanUp :                 pCustomShape = &msoTextCanUp; break;
8543         case mso_sptTextCanDown :               pCustomShape = &msoTextCanDown; break;
8544         case mso_sptTextInflate :               pCustomShape = &msoTextInflate; break;
8545         case mso_sptTextDeflate :               pCustomShape = &msoTextDeflate; break;
8546         case mso_sptTextInflateBottom :         pCustomShape = &msoTextInflateBottom; break;
8547         case mso_sptTextDeflateBottom :         pCustomShape = &msoTextDeflateBottom; break;
8548         case mso_sptTextInflateTop :            pCustomShape = &msoTextInflateTop; break;
8549         case mso_sptTextDeflateTop :            pCustomShape = &msoTextDeflateTop; break;
8550         case mso_sptTextDeflateInflate :        pCustomShape = &msoTextDeflateInflate; break;
8551         case mso_sptTextDeflateInflateDeflate : pCustomShape = &msoTextDeflateInflateDeflate; break;
8552         case mso_sptTextWave1 :                 pCustomShape = &msoTextWave1; break;
8553         case mso_sptTextWave2 :                 pCustomShape = &msoTextWave2; break;
8554         case mso_sptTextWave3 :                 pCustomShape = &msoTextWave3; break;
8555         case mso_sptTextWave4 :                 pCustomShape = &msoTextWave4; break;
8556         case mso_sptTearDrop :                  pCustomShape = &msoTearDrop; break;
8557         default :
8558         break;
8559     }
8560     return pCustomShape;
8561 }
8562
8563 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */