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