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