8630 lines
351 KiB
C++
8630 lines
351 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*
|
|
* This file is part of the LibreOffice project.
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*
|
|
* This file incorporates work covered by the following license notice:
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed
|
|
* with this work for additional information regarding copyright
|
|
* ownership. The ASF licenses this file to you under the Apache
|
|
* License, Version 2.0 (the "License"); you may not use this file
|
|
* except in compliance with the License. You may obtain a copy of
|
|
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
|
|
*/
|
|
|
|
#include <sal/config.h>
|
|
|
|
#include <cmath>
|
|
#include <limits>
|
|
#include <span>
|
|
|
|
#include <svx/EnhancedCustomShapeGeometry.hxx>
|
|
#include <com/sun/star/drawing/EnhancedCustomShapeGluePointType.hpp>
|
|
|
|
const sal_Int32 MIN_INT32 = std::numeric_limits<sal_Int32>::min();
|
|
|
|
const sal_Int32 mso_sptDefault1400[] =
|
|
{
|
|
1, 1400
|
|
};
|
|
const sal_Int32 mso_sptDefault1800[] =
|
|
{
|
|
1, 1800
|
|
};
|
|
const sal_Int32 mso_sptDefault2500[] =
|
|
{
|
|
1, 2500
|
|
};
|
|
const sal_Int32 mso_sptDefault2700[] =
|
|
{
|
|
1, 2700
|
|
};
|
|
const sal_Int32 mso_sptDefault3600[] =
|
|
{
|
|
1, 3600
|
|
};
|
|
const sal_Int32 mso_sptDefault3700[] =
|
|
{
|
|
1, 3700
|
|
};
|
|
const sal_Int32 mso_sptDefault5400[] =
|
|
{
|
|
1, 5400
|
|
};
|
|
const sal_Int32 mso_sptDefault7200[] =
|
|
{
|
|
1, 7200
|
|
};
|
|
const sal_Int32 mso_sptDefault8100[] =
|
|
{
|
|
1, 8100
|
|
};
|
|
const sal_Int32 mso_sptDefault9600[] =
|
|
{
|
|
1, 9600
|
|
};
|
|
const sal_Int32 mso_sptDefault10800[] =
|
|
{
|
|
1, 10800
|
|
};
|
|
const sal_Int32 mso_sptDefault12000[] =
|
|
{
|
|
1, 12000
|
|
};
|
|
const sal_Int32 mso_sptDefault13500[] =
|
|
{
|
|
1, 13500
|
|
};
|
|
const sal_Int32 mso_sptDefault16200[] =
|
|
{
|
|
1, 16200
|
|
};
|
|
const sal_Int32 mso_sptDefault16200and5400[] =
|
|
{
|
|
2, 16200, 5400
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptArcVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 21600 }, { 3 MSO_I, 1 MSO_I }, { 7 MSO_I, 5 MSO_I }, { 10800, 10800 },
|
|
{ 0, 0 }, { 21600, 21600 }, { 3 MSO_I, 1 MSO_I }, { 7 MSO_I, 5 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptArcSegm[] =
|
|
{
|
|
0xa604, 0xab00, 0x0001, 0x6001, 0x8000,
|
|
0xa604, 0xaa00, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptArcCalc[] =
|
|
{
|
|
{ 0x4009, { 10800, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x2000, { 0x400, 10800, 0 } },
|
|
{ 0x400a, { 10800, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x2000, { 0x402, 10800, 0 } },
|
|
{ 0x4009, { 10800, DFF_Prop_adjust2Value, 0 } },
|
|
{ 0x2000, { 0x404, 10800, 0 } },
|
|
{ 0x400a, { 10800, DFF_Prop_adjust2Value, 0 } },
|
|
{ 0x2000, { 0x406, 10800, 0 } }
|
|
};
|
|
const sal_Int32 mso_sptArcDefault[] =
|
|
{
|
|
2, 270, 0
|
|
};
|
|
const SvxMSDffVertPair mso_sptStandardGluePoints[] =
|
|
{
|
|
{ 10800, 0 }, { 0, 10800 }, { 10800, 21600 }, { 21600, 10800 }
|
|
};
|
|
const SvxMSDffHandle mso_sptArcHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::POLAR | SvxMSDffHandleFlags::RADIUS_RANGE,
|
|
10800, 0x100, 10800, 10800, 10800, 10800, MIN_INT32, 0x7fffffff },
|
|
{ SvxMSDffHandleFlags::POLAR | SvxMSDffHandleFlags::RADIUS_RANGE,
|
|
10800, 0x101, 10800, 10800, 10800, 10800, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoArc =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptArcVert),
|
|
const_cast<sal_uInt16*>(mso_sptArcSegm), sizeof( mso_sptArcSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptArcCalc),
|
|
const_cast<sal_Int32*>(mso_sptArcDefault),
|
|
std::span<const SvxMSDffTextRectangles>(),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptArcHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextSimpleVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 }, { 0, 0 }
|
|
};
|
|
const mso_CustomShape msoTextSimple =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextSimpleVert),
|
|
nullptr, 0,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptRectangleVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 }, { 0, 0 }
|
|
};
|
|
const mso_CustomShape msoRectangle =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptRectangleVert),
|
|
nullptr, 0,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptRoundRectangleVert[] = // adj value 0 -> 10800
|
|
{
|
|
{ 7 MSO_I, 0 }, { 0, 8 MSO_I }, { 0, 9 MSO_I }, { 7 MSO_I, 21600 },
|
|
{ 10 MSO_I, 21600 }, { 21600, 9 MSO_I }, { 21600, 8 MSO_I }, { 10 MSO_I, 0 }
|
|
};
|
|
const sal_uInt16 mso_sptRoundRectangleSegm[] =
|
|
{
|
|
0x4000, 0xa701, 0x0001, 0xa801, 0x0001, 0xa701, 0x0001, 0xa801, 0x6000, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptRoundRectangleCalc[] =
|
|
{
|
|
{ 0x000e, { 0, 45, 0 } },
|
|
{ 0x6009, { DFF_Prop_adjustValue, 0x400, 0 } },
|
|
{ 0x2001, { 0x401, 3163, 7636 } },
|
|
{ 0x6000, { DFF_Prop_geoLeft, 0x402, 0 } },
|
|
{ 0x6000, { DFF_Prop_geoTop, 0x402, 0 } },
|
|
{ 0xa000, { DFF_Prop_geoRight, 0, 0x402 } },
|
|
{ 0xa000, { DFF_Prop_geoBottom, 0, 0x402 } },
|
|
{ 0x6000, { DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x6000, { DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 } },
|
|
{ 0xa000, { DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue } },
|
|
{ 0xa000, { DFF_Prop_geoRight, 0, DFF_Prop_adjustValue } }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptRoundRectangleTextRect[] =
|
|
{
|
|
{ { 3 MSO_I, 4 MSO_I }, { 5 MSO_I, 6 MSO_I } }
|
|
};
|
|
const SvxMSDffHandle mso_sptRoundRectangleHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::SWITCHED,
|
|
0x100, 0, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoRoundRectangle =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptRoundRectangleVert),
|
|
const_cast<sal_uInt16*>(mso_sptRoundRectangleSegm), sizeof( mso_sptRoundRectangleSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptRoundRectangleCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault3600),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptRoundRectangleTextRect),
|
|
21600, 21600,
|
|
10800, 10800,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptRoundRectangleHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptRightTriangleVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 21600 }, { 0, 21600 }, { 0, 0 }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptRightTriangleTextRect[] =
|
|
{
|
|
{ { 1900, 12700 }, { 12700, 19700 } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptRightTriangleGluePoints[] =
|
|
{
|
|
{ 0, 0 }, { 0, 10800 }, { 0, 21600 }, { 10800, 21600 }, { 21600, 21600 }, { 10800, 10800 }
|
|
};
|
|
const mso_CustomShape msoRightTriangle =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptRightTriangleVert),
|
|
nullptr, 0,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptRightTriangleTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptRightTriangleGluePoints),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptEllipseVert[] =
|
|
{
|
|
{ 10800, 10800 }, { 10800, 10800 }, { 0, 360 }
|
|
};
|
|
const sal_uInt16 mso_sptEllipseSegm[] =
|
|
{
|
|
0xa203, 0x6000, 0x8000
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptEllipseTextRect[] =
|
|
{
|
|
{ { 3163, 3163 }, { 18437, 18437 } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptEllipseGluePoints[] =
|
|
{
|
|
{ 10800, 0 }, { 3163, 3163 }, { 0, 10800 }, { 3163, 18437 }, { 10800, 21600 }, { 18437, 18437 }, { 21600, 10800 }, { 18437, 3163 }
|
|
};
|
|
const mso_CustomShape msoEllipse =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptEllipseVert),
|
|
const_cast<sal_uInt16*>(mso_sptEllipseSegm), sizeof( mso_sptEllipseSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptEllipseTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptEllipseGluePoints),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptParallelogramVert[] = // adjustment1 : 0 - 21600
|
|
{
|
|
{ 0 MSO_I, 0 }, { 21600, 0 }, { 1 MSO_I, 21600 }, { 0, 21600 }
|
|
};
|
|
const sal_uInt16 mso_sptParallelogramSegm[] =
|
|
{
|
|
0x4000, 0x0003, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptParallelogramCalc[] =
|
|
{
|
|
{ 0x4000, { 0, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x8000, { 0, 21600, DFF_Prop_adjustValue } },
|
|
{ 0x2001, { DFF_Prop_adjustValue, 10, 24 } },
|
|
{ 0x2000, { 0x0402, 1750, 0 } },
|
|
{ 0x8000, { 21600, 0, 0x0403 } },
|
|
{ 0x2001, { 0x400, 1, 2 } },
|
|
{ 0x4000, { 10800, 0x405, 0 } },
|
|
{ 0x2000, { 0x400, 0, 10800 } },
|
|
{ 0x6006, { 0x407, 0x40d, 0 } },
|
|
{ 0x8000, { 10800, 0, 0x405 } },
|
|
{ 0x6006, { 0x407, 0x40c, 21600 } },
|
|
{ 0x8000, { 21600, 0, 0x405 } },
|
|
{ 0x8001, { 21600, 10800, 0x400 } },
|
|
{ 0x8000, { 21600, 0, 0x40c } }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptParallelogramTextRect[] =
|
|
{
|
|
{ { 3 MSO_I, 3 MSO_I }, { 4 MSO_I, 4 MSO_I } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptParallelogramGluePoints[] =
|
|
{
|
|
{ 6 MSO_I, 0 }, { 10800, 8 MSO_I }, { 11 MSO_I, 10800 }, { 9 MSO_I, 21600 }, { 10800, 10 MSO_I }, { 5 MSO_I, 10800 }
|
|
};
|
|
const SvxMSDffHandle mso_sptParallelogramHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0x100, 0, 10800, 10800, 0, 21600, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoParallelogram =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptParallelogramVert),
|
|
const_cast<sal_uInt16*>(mso_sptParallelogramSegm), sizeof( mso_sptParallelogramSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptParallelogramCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault5400),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptParallelogramTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptParallelogramGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptParallelogramHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptDiamondVert[] =
|
|
{
|
|
{ 10800, 0 }, { 21600, 10800 }, { 10800, 21600 }, { 0, 10800 }, { 10800, 0 }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptDiamondTextRect[] =
|
|
{
|
|
{ { 5400, 5400 }, { 16200, 16200 } }
|
|
};
|
|
const mso_CustomShape msoDiamond =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptDiamondVert),
|
|
nullptr, 0,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptDiamondTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptStandardGluePoints),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTrapezoidVert[] = // adjustment1 : 0 - 10800
|
|
{
|
|
{ 0, 0 }, { 21600, 0 }, {0 MSO_I, 21600 }, { 1 MSO_I, 21600 }
|
|
};
|
|
const sal_uInt16 mso_sptTrapezoidSegm[] =
|
|
{
|
|
0x4000, 0x0003, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptTrapezoidCalc[] =
|
|
{
|
|
{ 0x8000, { 21600, 0, DFF_Prop_adjustValue } },
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x2001, { DFF_Prop_adjustValue, 10, 18 } },
|
|
{ 0x2000, { 0x0402, 1750, 0 } },
|
|
{ 0x8000, { 21600, 0, 0x403 } },
|
|
{ 0x2001, { DFF_Prop_adjustValue, 1, 2 } },
|
|
{ 0x8000, { 21600, 0, 0x405 } }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptTrapezoidTextRect[] =
|
|
{
|
|
{ { 3 MSO_I, 3 MSO_I }, { 4 MSO_I, 4 MSO_I } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptTrapezoidGluePoints[] =
|
|
{
|
|
{ 6 MSO_I, 10800 }, { 10800, 21600 }, { 5 MSO_I, 10800 }, { 10800, 0 }
|
|
};
|
|
const SvxMSDffHandle mso_sptTrapezoidHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0x100, 1, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoTrapezoid =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTrapezoidVert),
|
|
const_cast<sal_uInt16*>(mso_sptTrapezoidSegm), sizeof( mso_sptTrapezoidSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTrapezoidCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault5400),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptTrapezoidTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptTrapezoidGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptTrapezoidHandle),
|
|
};
|
|
|
|
/*
|
|
|
|
The side of the enclosing square for the regular (all sides the
|
|
same, all angles the same) octagon described below is 21600. Let's
|
|
call that 'a'.
|
|
|
|
The "adjustment1" is the horizontal (or vertical) distance from a
|
|
side of the square to the nearest vertex. Let's call that 'd'.
|
|
|
|
Let's call the side of the regular octagon 'b'.
|
|
|
|
We know a. We want d. d=(a-b)/2
|
|
|
|
Pythagoras says that b^2 = 2d^2
|
|
|
|
Solving for b, we get b = (sqrt(2)-1)a
|
|
|
|
|
|
!------------a=21600-------!
|
|
|
|
!--d--!
|
|
x--------------x
|
|
/ \
|
|
/ \
|
|
/ \
|
|
/ \
|
|
/ \
|
|
x x
|
|
! !
|
|
! !
|
|
! !
|
|
! !
|
|
! !
|
|
! !
|
|
x x
|
|
\ /
|
|
\ /
|
|
\ /
|
|
\ /
|
|
\ /
|
|
x--------------x
|
|
|
|
*/
|
|
|
|
const SvxMSDffVertPair mso_sptOctagonVert[] = // adjustment1 : 0 - 10800
|
|
{
|
|
{ 0 MSO_I, 0 }, { 2 MSO_I, 0 }, { 21600, 1 MSO_I }, { 21600, 3 MSO_I },
|
|
{ 2 MSO_I, 21600 }, { 0 MSO_I, 21600 }, { 0, 3 MSO_I }, { 0, 1 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptOctagonSegm[] =
|
|
{
|
|
0x4000, 0x0007, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptOctagonCalc[] =
|
|
{
|
|
{ 0x6000, { DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x6000, { DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 } },
|
|
{ 0xa000, { DFF_Prop_geoRight, 0, DFF_Prop_adjustValue } },
|
|
{ 0xa000, { DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue } },
|
|
{ 0x2001, { DFF_Prop_adjustValue, 1, 2 } },
|
|
{ 0x6000, { DFF_Prop_geoLeft, 0x404, 0 } },
|
|
{ 0x6000, { DFF_Prop_geoTop, 0x404, 0 } },
|
|
{ 0xa000, { DFF_Prop_geoRight, 0, 0x404 } },
|
|
{ 0xa000, { DFF_Prop_geoBottom, 0, 0x404 } }
|
|
};
|
|
const sal_Int32 mso_sptOctagonDefault[] =
|
|
{
|
|
1, static_cast<sal_Int32>((21600 - ((M_SQRT2-1)*21600)) / 2)
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptOctagonTextRect[] =
|
|
{
|
|
{ { 5 MSO_I, 6 MSO_I }, { 7 MSO_I, 8 MSO_I } }
|
|
};
|
|
const SvxMSDffHandle mso_sptOctagonHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0x100, 0, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoOctagon =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptOctagonVert),
|
|
const_cast<sal_uInt16*>(mso_sptOctagonSegm), sizeof( mso_sptOctagonSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptOctagonCalc),
|
|
const_cast<sal_Int32*>(mso_sptOctagonDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptOctagonTextRect),
|
|
21600, 21600,
|
|
10800, 10800,
|
|
std::span<const SvxMSDffVertPair>(mso_sptStandardGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptOctagonHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptIsocelesTriangleVert[] = // adjustment1 : 0 - 21600
|
|
{
|
|
{ 0 MSO_I, 0 }, { 21600, 21600 }, { 0, 21600 }
|
|
};
|
|
const sal_uInt16 mso_sptIsocelesTriangleSegm[] =
|
|
{
|
|
0x4000, 0x0002, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptIsocelesTriangleCalc[] =
|
|
{
|
|
{ 0x4000, { 0, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x2001, { DFF_Prop_adjustValue, 1, 2 } },
|
|
{ 0x2000, { 0x401, 10800, 0 } },
|
|
{ 0x2001, { DFF_Prop_adjustValue, 2, 3 } },
|
|
{ 0x2000, { 0x403, 7200, 0 } },
|
|
{ 0x8000, { 21600, 0, 0x400 } },
|
|
{ 0x2001, { 0x405, 1, 2 } },
|
|
{ 0x8000, { 21600, 0, 0x406 } }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptIsocelesTriangleTextRect[] =
|
|
{
|
|
{ { 1 MSO_I, 10800 }, { 2 MSO_I, 18000 } },
|
|
{ { 3 MSO_I, 7200 }, { 4 MSO_I, 21600 } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptIsocelesTriangleGluePoints[] =
|
|
{
|
|
{ 0 MSO_I, 0 }, { 1 MSO_I, 10800 }, { 0, 21600 }, { 10800, 21600 }, { 21600, 21600 }, { 7 MSO_I, 10800 }
|
|
};
|
|
const SvxMSDffHandle mso_sptIsocelesTriangleHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0x100, 0, 10800, 10800, 0, 21600, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoIsocelesTriangle =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptIsocelesTriangleVert),
|
|
const_cast<sal_uInt16*>(mso_sptIsocelesTriangleSegm), sizeof( mso_sptIsocelesTriangleSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptIsocelesTriangleCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault10800),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptIsocelesTriangleTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptIsocelesTriangleGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptIsocelesTriangleHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptHexagonVert[] = // adjustment1 : 0 - 10800
|
|
{
|
|
{ 0 MSO_I, 0 }, { 1 MSO_I, 0 }, { 21600, 10800 }, { 1 MSO_I, 21600 },
|
|
{ 0 MSO_I, 21600 }, { 0, 10800 }
|
|
};
|
|
const sal_uInt16 mso_sptHexagonSegm[] =
|
|
{
|
|
0x4000, 0x0005, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptHexagonCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x8000, { 21600, 0, DFF_Prop_adjustValue } },
|
|
{ 0x2001, { DFF_Prop_adjustValue, 100, 234 } },
|
|
{ 0x2000, { 0x402, 1700, 0 } },
|
|
{ 0x8000, { 21600, 0, 0x403 } }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptHexagonTextRect[] =
|
|
{
|
|
{ { 3 MSO_I, 3 MSO_I }, { 4 MSO_I, 4 MSO_I } }
|
|
};
|
|
const SvxMSDffHandle mso_sptHexagonHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0x100, 0, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoHexagon =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptHexagonVert),
|
|
const_cast<sal_uInt16*>(mso_sptHexagonSegm), sizeof( mso_sptHexagonSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptHexagonCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault5400),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptHexagonTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptStandardGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptHexagonHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptPentagonVert[] =
|
|
{
|
|
{ 10800, 0 }, { 0, 8260 }, { 4230, 21600 }, { 17370, 21600 },
|
|
{ 21600, 8260 }, { 10800, 0 }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptPentagonTextRect[] =
|
|
{
|
|
{ { 4230, 5080 }, { 17370, 21600 } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptPentagonGluePoints[] =
|
|
{
|
|
{ 10800, 0 }, { 0, 8260 }, { 4230, 21600 }, { 10800, 21600 },
|
|
{ 17370, 21600 }, { 21600, 8260 }
|
|
};
|
|
const mso_CustomShape msoPentagon =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptPentagonVert),
|
|
nullptr, 0,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptPentagonTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptPentagonGluePoints),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptPlusVert[] = // adjustment1 : 0 - 10800
|
|
{
|
|
{ 1 MSO_I, 0 }, { 2 MSO_I, 0 }, { 2 MSO_I, 1 MSO_I }, { 21600, 1 MSO_I },
|
|
{ 21600, 3 MSO_I }, { 2 MSO_I, 3 MSO_I }, { 2 MSO_I, 21600 }, { 1 MSO_I, 21600 },
|
|
{ 1 MSO_I, 3 MSO_I }, { 0, 3 MSO_I }, { 0, 1 MSO_I }, { 1 MSO_I, 1 MSO_I }, { 1 MSO_I, 0 }
|
|
};
|
|
const SvxMSDffCalculationData mso_sptPlusCalc[] =
|
|
{
|
|
{ 0x2001, { DFF_Prop_adjustValue, 10799, 10800 } },
|
|
{ 0x2000, { 0x400, 0, 0 } },
|
|
{ 0xa000, { DFF_Prop_geoRight, 0, 0x400 } },
|
|
{ 0xa000, { DFF_Prop_geoBottom, 0, 0x400 } }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptPlusTextRect[] =
|
|
{
|
|
{ { 1 MSO_I, 1 MSO_I }, { 2 MSO_I, 3 MSO_I } }
|
|
};
|
|
const SvxMSDffHandle mso_sptPlusHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::SWITCHED,
|
|
0x100, 0, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoPlus =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptPlusVert),
|
|
nullptr, 0,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptPlusCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault5400),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptPlusTextRect),
|
|
21600, 21600,
|
|
10800, 10800,
|
|
std::span<const SvxMSDffVertPair>(mso_sptStandardGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptPlusHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptCanVert[] = // adjustment1 : 0 - 10800
|
|
{
|
|
{ 44, 0 },
|
|
{ 20, 0 }, { 0, 2 MSO_I }, { 0, 0 MSO_I }, // ccp
|
|
{ 0, 3 MSO_I }, // p
|
|
{ 0, 4 MSO_I }, { 20, 21600 }, { 44, 21600 }, // ccp
|
|
{ 68, 21600 }, { 88, 4 MSO_I }, { 88, 3 MSO_I }, // ccp
|
|
{ 88, 0 MSO_I }, // p
|
|
{ 88, 2 MSO_I }, { 68, 0 }, { 44, 0 }, // ccp
|
|
{ 44, 0 }, // p
|
|
{ 20, 0 }, { 0, 2 MSO_I }, { 0, 0 MSO_I }, // ccp
|
|
{ 0, 5 MSO_I }, { 20, 6 MSO_I }, { 44, 6 MSO_I }, // ccp
|
|
{ 68, 6 MSO_I },{ 88, 5 MSO_I }, { 88, 0 MSO_I }, // ccp
|
|
{ 88, 2 MSO_I },{ 68, 0 }, { 44, 0 } // ccp
|
|
};
|
|
const sal_uInt16 mso_sptCanSegm[] =
|
|
{
|
|
0x4000, 0x2001, 0x0001, 0x2002, 0x0001, 0x2001, 0x6001, 0x8000,
|
|
0x4000, 0x2004, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptCanCalc[] =
|
|
{
|
|
{ 0x2001, { DFF_Prop_adjustValue, 2, 4 } }, // 1/4
|
|
{ 0x2001, { 0x0400, 6, 11 } },
|
|
{ 0xa000, { 0x0400, 0, 0x0401 } },
|
|
{ 0x8000, { 21600, 0, 0x0400 } },
|
|
{ 0x6000, { 0x0403, 0x0401, 0 } },
|
|
{ 0x6000, { 0x0400, 0x0401, 0 } },
|
|
{ 0x2001, { DFF_Prop_adjustValue, 2, 2 } },
|
|
{ 0x0000, { 44, 0, 0 } }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptCanTextRect[] =
|
|
{
|
|
{ { 0, 6 MSO_I }, { 88, 3 MSO_I } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptCanGluePoints[] =
|
|
{
|
|
{ 44, 6 MSO_I }, { 44, 0 }, { 0, 10800 }, { 44, 21600 }, { 88, 10800 }
|
|
};
|
|
const SvxMSDffHandle mso_sptCanHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
7 + 3, 0x100, 44, 10800, MIN_INT32, 0x7fffffff, 0, 10800 }
|
|
};
|
|
const mso_CustomShape msoCan =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptCanVert),
|
|
const_cast<sal_uInt16*>(mso_sptCanSegm), sizeof( mso_sptCanSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptCanCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault5400),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptCanTextRect),
|
|
88, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptCanGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptCanHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptArrowVert[] = // adjustment1: x 0 - 21600
|
|
{ // adjustment2: y 0 - 10800
|
|
{ 0, 0 MSO_I }, { 1 MSO_I, 0 MSO_I }, { 1 MSO_I, 0 }, { 21600, 10800 },
|
|
{ 1 MSO_I, 21600 }, { 1 MSO_I, 2 MSO_I }, { 0, 2 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptArrowSegm[] =
|
|
{
|
|
0x4000, 0x0006, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptArrowCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x8000, { 21600, 0, DFF_Prop_adjust2Value } },
|
|
{ 0x8000, { 21600, 0, 0x401 } },
|
|
{ 0x6001, { 0x403, 0x400, 10800 } },
|
|
{ 0x6000, { 0x401, 0x404, 0 } },
|
|
{ 0x6001, { 0x401, 0x400, 10800 } },
|
|
{ 0xa000, { 0x401, 0, 0x406 } }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptArrowTextRect[] =
|
|
{
|
|
{ { 0, 0 MSO_I }, { 5 MSO_I, 2 MSO_I } }
|
|
};
|
|
const SvxMSDffHandle mso_sptArrowHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0x100, 0x101, 10800, 10800, 0, 21600, 0, 10800 }
|
|
};
|
|
const mso_CustomShape msoArrow =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptArrowVert),
|
|
const_cast<sal_uInt16*>(mso_sptArrowSegm), sizeof( mso_sptArrowSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptArrowCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault16200and5400),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptArrowTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptArrowHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptLeftArrowVert[] = // adjustment1: x 0 - 21600
|
|
{ // adjustment2: y 0 - 10800
|
|
{ 21600, 0 MSO_I }, { 1 MSO_I, 0 MSO_I }, { 1 MSO_I, 0 }, { 0, 10800 },
|
|
{ 1 MSO_I, 21600 }, { 1 MSO_I, 2 MSO_I }, { 21600, 2 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptLeftArrowSegm[] =
|
|
{
|
|
0x4000, 0x0006, 0x6001, 0x8000
|
|
};
|
|
const sal_Int32 mso_sptLeftArrowDefault[] =
|
|
{
|
|
2, 5400, 5400
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptLeftArrowTextRect[] =
|
|
{
|
|
{ { 7 MSO_I, 0 MSO_I }, { 21600, 2 MSO_I } }
|
|
};
|
|
const SvxMSDffHandle mso_sptLeftArrowHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0x100, 0x101, 10800, 10800, 0, 21600, 0, 10800 }
|
|
};
|
|
const mso_CustomShape msoLeftArrow =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptLeftArrowVert),
|
|
const_cast<sal_uInt16*>(mso_sptLeftArrowSegm), sizeof( mso_sptLeftArrowSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptArrowCalc),
|
|
const_cast<sal_Int32*>(mso_sptLeftArrowDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptLeftArrowTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptLeftArrowHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptDownArrowVert[] = // adjustment1: x 0 - 21600
|
|
{ // adjustment2: y 0 - 10800
|
|
{ 0 MSO_I, 0 }, { 0 MSO_I, 1 MSO_I }, { 0, 1 MSO_I }, { 10800, 21600 },
|
|
{ 21600, 1 MSO_I }, { 2 MSO_I, 1 MSO_I }, { 2 MSO_I, 0 }
|
|
};
|
|
const sal_uInt16 mso_sptDownArrowSegm[] =
|
|
{
|
|
0x4000, 0x0006, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptDownArrowTextRect[] =
|
|
{
|
|
{ { 0 MSO_I, 0 }, { 2 MSO_I, 5 MSO_I } }
|
|
};
|
|
const SvxMSDffHandle mso_sptDownArrowHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0x101, 0x100, 10800, 10800, 0, 10800, 0, 21600 }
|
|
};
|
|
const mso_CustomShape msoDownArrow =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptDownArrowVert),
|
|
const_cast<sal_uInt16*>(mso_sptDownArrowSegm), sizeof( mso_sptDownArrowSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptArrowCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault16200and5400),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptDownArrowTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptDownArrowHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptUpArrowVert[] = // adjustment1: x 0 - 21600
|
|
{ // adjustment2: y 0 - 10800
|
|
{ 0 MSO_I, 21600 }, { 0 MSO_I, 1 MSO_I }, { 0, 1 MSO_I }, { 10800, 0 },
|
|
{ 21600, 1 MSO_I }, { 2 MSO_I, 1 MSO_I }, { 2 MSO_I, 21600 }
|
|
};
|
|
const sal_uInt16 mso_sptUpArrowSegm[] =
|
|
{
|
|
0x4000, 0x0006, 0x6001, 0x8000
|
|
};
|
|
const sal_Int32 mso_sptUpArrowDefault[] =
|
|
{
|
|
2, 5400, 5400
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptUpArrowTextRect[] =
|
|
{
|
|
{ { 0 MSO_I, 7 MSO_I }, { 2 MSO_I, 21600 } }
|
|
};
|
|
const SvxMSDffHandle mso_sptUpArrowHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0x101, 0x100, 10800, 10800, 0, 10800, 0, 21600 }
|
|
};
|
|
const mso_CustomShape msoUpArrow =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptUpArrowVert),
|
|
const_cast<sal_uInt16*>(mso_sptUpArrowSegm), sizeof( mso_sptUpArrowSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptArrowCalc),
|
|
const_cast<sal_Int32*>(mso_sptUpArrowDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptUpArrowTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptUpArrowHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptLeftRightArrowVert[] = // adjustment1: x 0 - 10800
|
|
{ // adjustment2: y 0 - 10800
|
|
{ 0, 10800 }, { 0 MSO_I, 0 }, { 0 MSO_I, 1 MSO_I }, { 2 MSO_I, 1 MSO_I },
|
|
{ 2 MSO_I, 0 }, { 21600, 10800 }, { 2 MSO_I, 21600 }, { 2 MSO_I, 3 MSO_I },
|
|
{ 0 MSO_I, 3 MSO_I }, { 0 MSO_I, 21600 }
|
|
};
|
|
const sal_uInt16 mso_sptLeftRightArrowSegm[] =
|
|
{
|
|
0x4000, 0x0009, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptDoubleArrowCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
|
|
{ 0x8000, { 21600, 0, DFF_Prop_adjustValue } },
|
|
{ 0x8000, { 21600, 0, DFF_Prop_adjust2Value } },
|
|
{ 0x8000, { 10800, 0, DFF_Prop_adjust2Value } },
|
|
{ 0x6001, { DFF_Prop_adjustValue, 0x404, 10800 } },
|
|
{ 0x8000, { 21600, 0, 0x405 } },
|
|
{ 0x8000, { 10800, 0, DFF_Prop_adjustValue } },
|
|
{ 0x6001, { DFF_Prop_adjust2Value, 0x407, 10800 } },
|
|
{ 0x8000, { 21600, 0, 0x408 } }
|
|
};
|
|
const sal_Int32 mso_sptLeftRightArrowDefault[] =
|
|
{
|
|
2, 4300, 5400
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptLeftRightArrowTextRect[] =
|
|
{
|
|
{ { 5 MSO_I, 1 MSO_I }, { 6 MSO_I, 3 MSO_I } }
|
|
};
|
|
const SvxMSDffHandle mso_sptLeftRightArrowHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0x100, 0x101, 10800, 10800, 0, 10800, 0, 10800 }
|
|
};
|
|
const mso_CustomShape msoLeftRightArrow =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptLeftRightArrowVert),
|
|
const_cast<sal_uInt16*>(mso_sptLeftRightArrowSegm), sizeof( mso_sptLeftRightArrowSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptDoubleArrowCalc),
|
|
const_cast<sal_Int32*>(mso_sptLeftRightArrowDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptLeftRightArrowTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptLeftRightArrowHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptUpDownArrowVert[] = // adjustment1: x 0 - 10800
|
|
{ // adjustment2: y 0 - 10800
|
|
{ 0, 1 MSO_I }, { 10800, 0 }, { 21600, 1 MSO_I }, { 2 MSO_I, 1 MSO_I },
|
|
{ 2 MSO_I, 3 MSO_I }, { 21600, 3 MSO_I }, { 10800, 21600 }, { 0, 3 MSO_I },
|
|
{ 0 MSO_I, 3 MSO_I }, { 0 MSO_I, 1 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptUpDownArrowSegm[] =
|
|
{
|
|
0x4000, 0x0009, 0x6001, 0x8000
|
|
};
|
|
const sal_Int32 mso_sptUpDownArrowDefault[] =
|
|
{
|
|
2, 5400, 4300
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptUpDownArrowTextRect[] =
|
|
{
|
|
{ { 0 MSO_I, 8 MSO_I }, { 2 MSO_I, 9 MSO_I } }
|
|
};
|
|
const SvxMSDffHandle mso_sptUpDownArrowHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0x100, 0x101, 10800, 10800, 0, 10800, 0, 10800 }
|
|
};
|
|
const mso_CustomShape msoUpDownArrow =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptUpDownArrowVert),
|
|
const_cast<sal_uInt16*>(mso_sptUpDownArrowSegm), sizeof( mso_sptUpDownArrowSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptDoubleArrowCalc),
|
|
const_cast<sal_Int32*>(mso_sptUpDownArrowDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptUpDownArrowTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptUpDownArrowHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptQuadArrowVert[] = // adjustment1: x 0 - 10800, adjustment2: x 0 - 10800
|
|
{ // adjustment3: y 0 - 10800
|
|
{ 0, 10800 }, { 0 MSO_I, 1 MSO_I }, { 0 MSO_I, 2 MSO_I }, { 2 MSO_I, 2 MSO_I },
|
|
{ 2 MSO_I, 0 MSO_I }, { 1 MSO_I, 0 MSO_I }, { 10800, 0 }, { 3 MSO_I, 0 MSO_I },
|
|
{ 4 MSO_I, 0 MSO_I }, { 4 MSO_I, 2 MSO_I }, { 5 MSO_I, 2 MSO_I }, { 5 MSO_I, 1 MSO_I },
|
|
{ 21600, 10800 }, { 5 MSO_I, 3 MSO_I }, { 5 MSO_I, 4 MSO_I }, { 4 MSO_I, 4 MSO_I },
|
|
{ 4 MSO_I, 5 MSO_I }, { 3 MSO_I, 5 MSO_I }, { 10800, 21600 }, { 1 MSO_I, 5 MSO_I },
|
|
{ 2 MSO_I, 5 MSO_I }, { 2 MSO_I, 4 MSO_I }, { 0 MSO_I, 4 MSO_I }, { 0 MSO_I, 3 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptQuadArrowSegm[] =
|
|
{
|
|
0x4000, 0x0017, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptQuadArrowCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjust3Value, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
|
|
{ 0x8000, { 21600, 0, DFF_Prop_adjustValue } },
|
|
{ 0x8000, { 21600, 0, DFF_Prop_adjust2Value } },
|
|
{ 0x8000, { 21600, 0, DFF_Prop_adjust3Value } }
|
|
};
|
|
const sal_Int32 mso_sptQuadArrowDefault[] =
|
|
{
|
|
3, 6500, 8600, 4300
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptQuadArrowTextRect[] = // todo
|
|
{
|
|
{ { 0, 0 }, { 21600, 21600 } }
|
|
};
|
|
const SvxMSDffHandle mso_sptQuadArrowHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL,
|
|
0x101, 0x102, 10800, 10800, 0x100, 10800, 0, 0x100 },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
|
|
0x100, 0, 10800, 10800, 0x102, 0x101, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoQuadArrow =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptQuadArrowVert),
|
|
const_cast<sal_uInt16*>(mso_sptQuadArrowSegm), sizeof( mso_sptQuadArrowSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptQuadArrowCalc),
|
|
const_cast<sal_Int32*>(mso_sptQuadArrowDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptQuadArrowTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptQuadArrowHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptLeftRightUpArrowVert[] = // adjustment1: x 0 - 10800, adjustment2: x 0 - 10800
|
|
{ // adjustment3: y 0 - 21600
|
|
{ 10800, 0 }, { 3 MSO_I, 2 MSO_I }, { 4 MSO_I, 2 MSO_I }, { 4 MSO_I, 1 MSO_I },
|
|
{ 5 MSO_I, 1 MSO_I }, { 5 MSO_I, 0 MSO_I }, { 21600, 10800 }, { 5 MSO_I, 3 MSO_I },
|
|
{ 5 MSO_I, 4 MSO_I }, { 2 MSO_I, 4 MSO_I }, { 2 MSO_I, 3 MSO_I }, { 0, 10800 },
|
|
{ 2 MSO_I, 0 MSO_I }, { 2 MSO_I, 1 MSO_I }, { 1 MSO_I, 1 MSO_I }, { 1 MSO_I, 2 MSO_I },
|
|
{ 0 MSO_I, 2 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptLeftRightUpArrowSegm[] =
|
|
{
|
|
0x4000, 0x0010, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptLeftRightUpArrowCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, // 0
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0, 0 } }, // 1
|
|
{ 0x6001, { 0x0403, DFF_Prop_adjust3Value, 21600 } }, // 2
|
|
{ 0x8000, { 21600, 0, DFF_Prop_adjustValue } }, // 3
|
|
{ 0x8000, { 21600, 0, DFF_Prop_adjust2Value } }, // 4
|
|
{ 0x8000, { 21600, 0, 0x0402 } } // 5
|
|
};
|
|
const sal_Int32 mso_sptLeftRightUpArrowDefault[] =
|
|
{
|
|
3, 6500, 8600, 6200
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptLeftRightUpArrowTextRect[] = // todo
|
|
{
|
|
{ { 0, 0 }, { 21600, 21600 } }
|
|
};
|
|
const SvxMSDffHandle mso_sptLeftRightUpArrowHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL,
|
|
0x101, 0x102, 10800, 10800, 0x100, 10800, 0, 0x100 },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
|
|
0x100, 0, 10800, 10800, 0x102, 0x101, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoLeftRightUpArrow =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptLeftRightUpArrowVert),
|
|
const_cast<sal_uInt16*>(mso_sptLeftRightUpArrowSegm), sizeof( mso_sptLeftRightUpArrowSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptLeftRightUpArrowCalc),
|
|
const_cast<sal_Int32*>(mso_sptLeftRightUpArrowDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptLeftRightUpArrowTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptLeftRightUpArrowHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptBentArrowVert[] = // adjustment1 : x 12427 - 21600
|
|
{ // adjustment2 : y 0 - 6079
|
|
{ 0, 21600 }, { 0, 12160 }, { 12427, 1 MSO_I }, { 0 MSO_I, 1 MSO_I },
|
|
{ 0 MSO_I, 0 }, { 21600, 6079 }, { 0 MSO_I, 12158 }, { 0 MSO_I, 2 MSO_I },
|
|
{ 12427, 2 MSO_I }, { 4 MSO_I, 12160 }, { 4 MSO_I, 21600 }
|
|
};
|
|
const sal_uInt16 mso_sptBentArrowSegm[] =
|
|
{
|
|
0x4000, 0x0001, 0xa801, 0x0006, 0xa701, 0x0001, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptBentArrowCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
|
|
{ 0x8000, { 12158, 0, DFF_Prop_adjust2Value } },
|
|
{ 0x8000, { 6079, 0, DFF_Prop_adjust2Value } },
|
|
{ 0x2001, { 0x0403, 2, 1 } }
|
|
};
|
|
const sal_Int32 mso_sptBentArrowDefault[] =
|
|
{
|
|
2, 15100, 2900
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptBentArrowTextRect[] = // todo
|
|
{
|
|
{ { 0, 0 }, { 21600, 21600 } }
|
|
};
|
|
const SvxMSDffHandle mso_sptBentArrowHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0x100, 0x101, 10800, 10800, 12427, 21600, 0, 6079 }
|
|
};
|
|
const mso_CustomShape msoBentArrow =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptBentArrowVert),
|
|
const_cast<sal_uInt16*>(mso_sptBentArrowSegm), sizeof( mso_sptBentArrowSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptBentArrowCalc),
|
|
const_cast<sal_Int32*>(mso_sptBentArrowDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptBentArrowTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptBentArrowHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptUturnArrowVert[] =
|
|
{
|
|
{ 0, 21600 }, { 0, 8550 }, // pp
|
|
{ 0, 3540 }, { 4370, 0 }, { 9270, 0 }, // ccp
|
|
{ 13890, 0 }, { 18570, 3230 }, { 18600, 8300 }, // ccp
|
|
{ 21600, 8300 }, { 15680, 14260 }, { 9700, 8300 }, { 12500, 8300 }, // pppp
|
|
{ 12320, 6380 }, { 10870, 5850 }, { 9320, 5850 }, // ccp
|
|
{ 7770, 5850 }, { 6040, 6410 }, { 6110, 8520 }, // ccp
|
|
{ 6110, 21600 }
|
|
};
|
|
const sal_uInt16 mso_sptUturnArrowSegm[] =
|
|
{
|
|
0x4000, 0x0001, 0x2002, 0x0004, 0x2002, 0x0001, 0x6000, 0x8000
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptUturnArrowTextRect[] =
|
|
{
|
|
{ { 0, 8280 }, { 6110, 21600 } }
|
|
};
|
|
const mso_CustomShape msoUturnArrow =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptUturnArrowVert),
|
|
const_cast<sal_uInt16*>(mso_sptUturnArrowSegm), sizeof( mso_sptUturnArrowSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptUturnArrowTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptLeftUpArrowVert[] = // adjustment1 : x 0 - 21600, adjustment2 : x 0 - 21600
|
|
{ // adjustment3 : y 0 - 21600
|
|
{ 0, 5 MSO_I }, { 2 MSO_I, 0 MSO_I }, { 2 MSO_I, 7 MSO_I }, { 7 MSO_I, 7 MSO_I },
|
|
{ 7 MSO_I, 2 MSO_I }, { 0 MSO_I, 2 MSO_I }, { 5 MSO_I, 0 }, { 21600, 2 MSO_I },
|
|
{ 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 1 MSO_I }, { 2 MSO_I, 1 MSO_I }, { 2 MSO_I, 21600 }
|
|
};
|
|
const sal_uInt16 mso_sptLeftUpArrowSegm[] =
|
|
{
|
|
0x4000, 0x000b, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptLeftUpArrowCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, // 0
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0, 0 } }, // 1
|
|
{ 0x2000, { DFF_Prop_adjust3Value, 0, 0 } }, // 2
|
|
{ 0x8000, { 21600, 0, DFF_Prop_adjustValue } }, // 3
|
|
{ 0x2001, { 0x0403, 1, 2 } }, // 4
|
|
{ 0x6000, { DFF_Prop_adjustValue, 0x0404, 0 } }, // 5
|
|
{ 0x8000, { 21600, 0, DFF_Prop_adjust2Value } }, // 6
|
|
{ 0x6000, { DFF_Prop_adjustValue, 0x0406, 0 } }, // 7
|
|
{ 0x8000, { 21600, 0, 0x406 } }, // 8
|
|
{ 0xa000, { 0x408, 0, 0x406 } } // 9
|
|
};
|
|
const sal_Int32 mso_sptLeftUpArrowDefault[] =
|
|
{
|
|
3, 9340, 18500, 6200
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptLeftUpArrowTextRect[] =
|
|
{
|
|
{ { 2 MSO_I, 7 MSO_I }, { 1 MSO_I, 1 MSO_I } },
|
|
{ { 7 MSO_I, 2 MSO_I }, { 1 MSO_I, 1 MSO_I } }
|
|
};
|
|
const SvxMSDffHandle mso_sptLeftUpArrowHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL,
|
|
0x101, 0x102, 10800, 10800, 3 + 5, 21600, 0, 0x100 },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
|
|
0x100, 0, 10800, 10800, 0x102, 3 + 9, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoLeftUpArrow =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptLeftUpArrowVert),
|
|
const_cast<sal_uInt16*>(mso_sptLeftUpArrowSegm), sizeof( mso_sptLeftUpArrowSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptLeftUpArrowCalc),
|
|
const_cast<sal_Int32*>(mso_sptLeftUpArrowDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptLeftUpArrowTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptLeftUpArrowHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptBentUpArrowVert[] = // adjustment1 : x 0 - 21600, adjustment2 : x 0 - 21600
|
|
{ // adjustment3 : y 0 - 21600
|
|
{ 0, 8 MSO_I }, { 7 MSO_I, 8 MSO_I }, { 7 MSO_I, 2 MSO_I }, { 0 MSO_I, 2 MSO_I },
|
|
{ 5 MSO_I, 0 }, { 21600, 2 MSO_I }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 21600 },
|
|
{ 0, 21600 }
|
|
};
|
|
const sal_uInt16 mso_sptBentUpArrowSegm[] =
|
|
{
|
|
0x4000, 0x0008, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptBentUpArrowCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, // 0
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0, 0 } }, // 1
|
|
{ 0x2000, { DFF_Prop_adjust3Value, 0, 0 } }, // 2
|
|
{ 0x8000, { 21600, 0, DFF_Prop_adjustValue } }, // 3
|
|
{ 0x2001, { 0x0403, 1, 2 } }, // 4
|
|
{ 0x6000, { DFF_Prop_adjustValue, 0x0404, 0 } }, // 5
|
|
{ 0x8000, { 21600, 0, DFF_Prop_adjust2Value } }, // 6
|
|
{ 0x6000, { DFF_Prop_adjustValue, 0x0406, 0 } }, // 7
|
|
{ 0x6000, { 0x0407, 0x0406, 0 } }, // 8
|
|
{ 0x8000, { 21600, 0, 0x406 } }, // 9
|
|
{ 0xa000, { 0x409, 0, 0x406 } } // a
|
|
};
|
|
const sal_Int32 mso_sptBentUpArrowDefault[] =
|
|
{
|
|
3, 9340, 18500, 7200
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptBentUpArrowTextRect[] =
|
|
{
|
|
{ { 2 MSO_I, 7 MSO_I }, { 1 MSO_I, 1 MSO_I } },
|
|
{ { 7 MSO_I, 2 MSO_I }, { 1 MSO_I, 1 MSO_I } }
|
|
};
|
|
const SvxMSDffHandle mso_sptBentUpArrowHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL,
|
|
0x101, 0x102, 10800, 10800, 3 + 5, 21600, 0, 0x100 },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
|
|
0x100, 0, 10800, 10800, 0x102, 3 + 10, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoBentUpArrow =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptBentUpArrowVert),
|
|
const_cast<sal_uInt16*>(mso_sptBentUpArrowSegm), sizeof( mso_sptBentUpArrowSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptBentUpArrowCalc),
|
|
const_cast<sal_Int32*>(mso_sptBentUpArrowDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptBentUpArrowTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptBentUpArrowHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptCurvedRightVert[] =
|
|
{
|
|
{ 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 },
|
|
{ 2 MSO_I, 14 MSO_I }, { 22 MSO_I, 8 MSO_I }, { 2 MSO_I, 12 MSO_I },
|
|
{ 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 },
|
|
{ 0, 0 }, { 23 MSO_I, 3 MSO_I }, { 22 MSO_I, 0 }, { 0, 4 MSO_I },
|
|
{ 0, 0 }, { 23 MSO_I, 3 MSO_I }, { 0, 4 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 }
|
|
};
|
|
const sal_uInt16 mso_sptCurvedRightSegm[] =
|
|
{
|
|
0xa404,
|
|
0xa304,
|
|
0x0003,
|
|
0xa508,
|
|
0x6000,
|
|
0x8000,
|
|
0xa404,
|
|
0xa304,
|
|
0xa504,
|
|
0x6000,
|
|
0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptCurvedRightCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust3Value, 0, 0 } },
|
|
{ 0xa000, { DFF_Prop_adjustValue, 21600, DFF_Prop_adjust2Value } },
|
|
{ 0x2001, { 0x403, 1, 2 } },
|
|
{ 0x6000, { DFF_Prop_adjust2Value, DFF_Prop_adjust2Value, 21600 } },
|
|
{ 0xe000, { 0x405, DFF_Prop_adjust2Value, DFF_Prop_adjustValue } },
|
|
{ 0x2001, { 0x406, 1, 2 } },
|
|
{ 0x4002, { 21600, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x8000, { 21600, 0, DFF_Prop_adjust3Value } },
|
|
{ 0xa00f, { 0x409, 21600, 0x404 } },
|
|
{ 0x6000, { 0x404, 0x40a, 0 } },
|
|
{ 0x6000, { 0x40b, DFF_Prop_adjust2Value, 21600 } },
|
|
{ 0x6000, { 0x407, 0x40a, 0 } },
|
|
{ 0xa000, { 0x40c, 21600, DFF_Prop_adjustValue } },
|
|
{ 0xa000, { 0x405, 0, DFF_Prop_adjustValue } },
|
|
{ 0x2001, { 0x40f, 1, 2 } },
|
|
{ 0x6002, { 0x404, 0x407, 0 } },
|
|
{ 0x6000, { DFF_Prop_adjustValue, DFF_Prop_adjust2Value, 21600 } },
|
|
{ 0x2001, { 0x412, 1, 2 } },
|
|
{ 0xa000, { 0x411, 0, 0x413 } },
|
|
{ 0x0000, { 21600, 0, 0 } },
|
|
{ 0x0000, { 21600, 0, 0 } },
|
|
{ 0x0001, { 21600, 2, 1 } },
|
|
{ 0xa000, { 0x411, 0, 0x404 } },
|
|
{ 0x600f, { 0x418, 0x404, 21600 } },
|
|
{ 0x8000, { 21600, 0, 0x419 } },
|
|
{ 0x2000, { 0x408, 128, 0 } },
|
|
{ 0x2001, { 0x405, 1, 2 } },
|
|
{ 0x2000, { 0x405, 0, 128 } },
|
|
{ 0xe000, { DFF_Prop_adjustValue, 0x411, 0x40c } },
|
|
{ 0x600f, { 0x414, 0x404, 21600 } },
|
|
{ 0x8000, { 21600, 0, DFF_Prop_adjustValue } },
|
|
{ 0x2001, { 0x420, 1, 2 } },
|
|
{ 0x0001, { 21600, 21600, 1 } },
|
|
{ 0x6001, { 0x409, 0x409, 1 } },
|
|
{ 0xa000, { 0x422, 0, 0x423 } },
|
|
{ 0x200d, { 0x424, 0, 0 } },
|
|
{ 0x2000, { 0x425, 21600, 0 } },
|
|
{ 0x8001, { 21600, 21600, 0x426 } },
|
|
{ 0x2000, { 0x427, 64, 0 } },
|
|
{ 0x2001, { DFF_Prop_adjustValue, 1, 2 } },
|
|
{ 0x600f, { 0x421, 0x429, 21600 } },
|
|
{ 0x8000, { 21600, 0, 0x42a } },
|
|
{ 0x2000, { 0x42b, 64, 0 } },
|
|
{ 0x2001, { 0x404, 1, 2 } },
|
|
{ 0xa000, { DFF_Prop_adjust2Value, 0, 0x42d } },
|
|
{ 0x0001, { 21600, 2195, 16384 } },
|
|
{ 0x0001, { 21600, 14189, 16384 } }
|
|
};
|
|
const sal_Int32 mso_sptCurvedRightDefault[] =
|
|
{
|
|
3, 12960, 19440, 14400
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptCurvedRightTextRect[] =
|
|
{
|
|
{ { 47 MSO_I, 45 MSO_I }, { 48 MSO_I, 46 MSO_I } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptCurvedRightGluePoints[] =
|
|
{
|
|
{ 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 }
|
|
};
|
|
const SvxMSDffHandle mso_sptCurvedRightHandles[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
|
|
21600, 0x100, 10800, 10800, 0, 10800, 3 + 40, 3 + 29 },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
|
|
21600, 0x101, 10800, 10800, 0, 10800, 3 + 27, 3 + 21 },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
|
|
0x102, 21600, 10800, 10800, 3 + 44, 3 + 22, 3375, 21600 }
|
|
};
|
|
const mso_CustomShape msoCurvedRightArrow =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptCurvedRightVert),
|
|
const_cast<sal_uInt16*>(mso_sptCurvedRightSegm), sizeof( mso_sptCurvedRightSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptCurvedRightCalc),
|
|
const_cast<sal_Int32*>(mso_sptCurvedRightDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptCurvedRightTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptCurvedRightGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptCurvedRightHandles),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptCurvedDownVert[] =
|
|
{
|
|
{ 0, 0 }, { 3 MSO_I, 23 MSO_I }, { 0, 22 MSO_I }, { 4 MSO_I, 0 },
|
|
{ 15 MSO_I, 0 }, { 1 MSO_I, 23 MSO_I }, { 7 MSO_I, 0 }, { 13 MSO_I, 2 MSO_I },
|
|
{ 14 MSO_I, 2 MSO_I }, { 8 MSO_I, 22 MSO_I }, { 12 MSO_I, 2 MSO_I },
|
|
{ 0, 0 }, { 3 MSO_I, 23 MSO_I }, { 11 MSO_I, 2 MSO_I }, { 17 MSO_I, 26 MSO_I }, { 15 MSO_I, 0 },
|
|
{ 1 MSO_I, 23 MSO_I }, { 17 MSO_I, 26 MSO_I }, { 15 MSO_I, 22 MSO_I },
|
|
{ 0, 0 }, { 3 MSO_I, 23 MSO_I }, { 0, 22 MSO_I }, { 4 MSO_I, 0 },
|
|
{ 0, 0 }, { 3 MSO_I, 23 MSO_I }, { 4 MSO_I, 0 }, { 17 MSO_I, 26 MSO_I },
|
|
{ 15 MSO_I, 0 }, { 1 MSO_I, 23 MSO_I }, { 17 MSO_I, 26 MSO_I }, { 15 MSO_I, 22 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptCurvedDownSegm[] =
|
|
{
|
|
0xa604,
|
|
0xa504,
|
|
0x0003,
|
|
0xa308,
|
|
0x6000,
|
|
0x8000,
|
|
0xa604,
|
|
0xa504,
|
|
0xa304,
|
|
0x6000,
|
|
0x8000
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptCurvedDownTextRect[] =
|
|
{
|
|
{ { 45 MSO_I, 47 MSO_I }, { 46 MSO_I, 48 MSO_I } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptCurvedDownGluePoints[] =
|
|
{
|
|
{ 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 }
|
|
};
|
|
const SvxMSDffHandle mso_sptCurvedDownHandles[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
|
|
0x100, 21600, 10800, 10800, 3 + 40, 3 + 29, 0, 10800 },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
|
|
0x101, 21600, 10800, 10800, 3 + 27, 3 + 21, 0, 10800 },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
|
|
21600, 0x102, 10800, 10800, 3375, 21600, 3 + 44, 3 + 22 }
|
|
};
|
|
|
|
const mso_CustomShape msoCurvedDownArrow =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptCurvedDownVert),
|
|
const_cast<sal_uInt16*>(mso_sptCurvedDownSegm), sizeof( mso_sptCurvedDownSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptCurvedRightCalc),
|
|
const_cast<sal_Int32*>(mso_sptCurvedRightDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptCurvedDownTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptCurvedDownGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptCurvedDownHandles),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptCurvedUpVert[] =
|
|
{
|
|
{ 0, 22 MSO_I }, { 3 MSO_I, 21 MSO_I }, { 0, 0 }, { 4 MSO_I, 21 MSO_I },
|
|
{ 14 MSO_I, 22 MSO_I }, { 1 MSO_I, 21 MSO_I }, { 7 MSO_I, 21 MSO_I },
|
|
{ 12 MSO_I, 2 MSO_I }, { 13 MSO_I, 2 MSO_I }, { 8 MSO_I, 0 }, { 11 MSO_I, 2 MSO_I },
|
|
{ 0, 22 MSO_I }, { 3 MSO_I, 21 MSO_I }, { 10 MSO_I, 2 MSO_I }, { 16 MSO_I, 24 MSO_I },
|
|
{ 14 MSO_I, 22 MSO_I }, { 1 MSO_I, 21 MSO_I }, { 16 MSO_I, 24 MSO_I }, { 14 MSO_I, 0 },
|
|
{ 0, 22 MSO_I }, { 3 MSO_I, 21 MSO_I }, { 0, 0 }, { 4 MSO_I, 21 MSO_I },
|
|
{ 14 MSO_I, 22 MSO_I }, { 1 MSO_I, 21 MSO_I }, { 7 MSO_I, 21 MSO_I }, { 16 MSO_I, 24 MSO_I },
|
|
{ 14 MSO_I, 22 MSO_I }, { 1 MSO_I, 21 MSO_I }, { 16 MSO_I, 24 MSO_I }, { 14 MSO_I, 0 }
|
|
};
|
|
const sal_uInt16 mso_sptCurvedUpSegm[] =
|
|
{
|
|
0xa404,
|
|
0xa304,
|
|
0x0003,
|
|
0xa508,
|
|
0x6000,
|
|
0x8000,
|
|
0xa404,
|
|
0xa508,
|
|
0xa504,
|
|
0x6000,
|
|
0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptCurvedUpCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust3Value, 0, 0 } },
|
|
{ 0xa000, { DFF_Prop_adjustValue, 21600, DFF_Prop_adjust2Value } },
|
|
{ 0x2001, { 0x403, 1, 2 } },
|
|
{ 0x6000, { DFF_Prop_adjust2Value, DFF_Prop_adjust2Value, 21600 } },
|
|
{ 0xe000, { 0x405, DFF_Prop_adjust2Value, DFF_Prop_adjustValue } },
|
|
{ 0x2001, { 0x406, 1, 2 } },
|
|
{ 0x4002, { 21600, DFF_Prop_adjustValue, 0 } },
|
|
{ 0xa00f, { DFF_Prop_adjust3Value, 21600, 0x404 } },
|
|
{ 0x6000, { 0x404, 0x409, 0 } },
|
|
{ 0x6000, { 0x40a, DFF_Prop_adjust2Value, 21600 } },
|
|
{ 0x6000, { 0x407, 0x409, 0 } },
|
|
{ 0xa000, { 0x40b, 21600, DFF_Prop_adjustValue } },
|
|
{ 0xa000, { 0x405, 0, DFF_Prop_adjustValue } },
|
|
{ 0x2001, { 0x40e, 1, 2 } },
|
|
{ 0x6002, { 0x404, 0x407, 0 } },
|
|
{ 0x6000, { DFF_Prop_adjustValue, DFF_Prop_adjust2Value, 21600 } },
|
|
{ 0x2001, { 0x411, 1, 2 } },
|
|
{ 0xa000, { 0x410, 0, 0x412 } },
|
|
{ 0x0000, { 21600, 0, 0 } },
|
|
{ 0x0000, { 21600, 0, 0 } },
|
|
{ 0x0000, { 0, 0, 21600 } },
|
|
{ 0xa000, { 0x410, 0, 0x404 } },
|
|
{ 0x600f, { 0x417, 0x404, 21600 } },
|
|
{ 0x2000, { 0x408, 128, 0 } },
|
|
{ 0x2001, { 0x405, 1, 2 } },
|
|
{ 0x2000, { 0x405, 0, 128 } },
|
|
{ 0xe000, { DFF_Prop_adjustValue, 0x410, 0x40b } },
|
|
{ 0x8000, { 21600, 0, DFF_Prop_adjustValue } },
|
|
{ 0x2001, { 0x41d, 1, 2 } },
|
|
{ 0x0001, { 21600, 21600, 1 } },
|
|
{ 0x6001, { DFF_Prop_adjust3Value, DFF_Prop_adjust3Value, 1 } },
|
|
{ 0xa000, { 0x41f, 0, 0x420 } },
|
|
{ 0x200d, { 0x421, 0, 0 } },
|
|
{ 0x2000, { 0x422, 21600, 0 } },
|
|
{ 0x8001, { 21600, 21600, 0x423 } },
|
|
{ 0x2000, { 0x424, 64, 0 } },
|
|
{ 0x2001, { DFF_Prop_adjustValue, 1, 2 } },
|
|
{ 0x600f, { 0x41e, 0x426, 21600 } },
|
|
{ 0x2000, { 0x427, 0, 64 } },
|
|
{ 0x2001, { 0x404, 1, 2 } },
|
|
{ 0xa000, { DFF_Prop_adjust2Value, 0, 0x429 } },
|
|
{ 0x0001, { 21600, 2195, 16384 } },
|
|
{ 0x0001, { 21600, 14189, 16384 } }
|
|
};
|
|
const sal_Int32 mso_sptCurvedUpDefault[] =
|
|
{
|
|
3, 12960, 19440, 7200
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptCurvedUpTextRect[] =
|
|
{
|
|
{ { 41 MSO_I, 43 MSO_I }, { 42 MSO_I, 44 MSO_I } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptCurvedUpGluePoints[] =
|
|
{
|
|
{ 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 }
|
|
};
|
|
const SvxMSDffHandle mso_sptCurvedUpHandles[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
|
|
0x100, 0, 10800, 10800, 3 + 37, 3 + 27, 0, 10800 },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
|
|
0x101, 0, 10800, 10800, 3 + 25, 3 + 20, 0, 10800 },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
|
|
21600, 0x102, 10800, 10800, 3375, 21600, 0, 3 + 40 }
|
|
};
|
|
const mso_CustomShape msoCurvedUpArrow =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptCurvedUpVert),
|
|
const_cast<sal_uInt16*>(mso_sptCurvedUpSegm), sizeof( mso_sptCurvedUpSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptCurvedUpCalc),
|
|
const_cast<sal_Int32*>(mso_sptCurvedUpDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptCurvedUpTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptCurvedUpGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptCurvedUpHandles),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptCurvedLeftVert[] =
|
|
{
|
|
{ 22 MSO_I, 0 }, { 21 MSO_I, 3 MSO_I }, { 0, 0 }, { 21 MSO_I, 4 MSO_I },
|
|
{ 22 MSO_I, 14 MSO_I }, { 21 MSO_I, 1 MSO_I }, { 21 MSO_I, 7 MSO_I }, { 2 MSO_I, 12 MSO_I },
|
|
{ 2 MSO_I, 13 MSO_I }, { 0, 8 MSO_I }, { 2 MSO_I, 11 MSO_I },
|
|
{ 22 MSO_I, 0 }, { 21 MSO_I, 3 MSO_I }, { 2 MSO_I, 10 MSO_I }, { 24 MSO_I, 16 MSO_I },
|
|
{ 22 MSO_I, 14 MSO_I }, { 21 MSO_I, 1 MSO_I }, { 24 MSO_I, 16 MSO_I }, { 0, 14 MSO_I },
|
|
{ 22 MSO_I, 0 }, { 21 MSO_I, 3 MSO_I }, { 0, 0 }, { 21 MSO_I, 4 MSO_I },
|
|
{ 22 MSO_I, 14 MSO_I }, { 21 MSO_I, 1 MSO_I }, { 21 MSO_I, 7 MSO_I }, { 24 MSO_I, 16 MSO_I },
|
|
{ 22 MSO_I, 14 MSO_I }, { 21 MSO_I, 1 MSO_I }, { 24 MSO_I, 16 MSO_I }, { 0, 14 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptCurvedLeftSegm[] =
|
|
{
|
|
0xa604,
|
|
0xa504,
|
|
0x0003,
|
|
0xa308,
|
|
0x6000,
|
|
0x8000,
|
|
0xa604,
|
|
0xa308,
|
|
0x6000,
|
|
0x8000
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptCurvedLeftTextRect[] =
|
|
{
|
|
{ { 43 MSO_I, 41 MSO_I }, { 44 MSO_I, 42 MSO_I } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptCurvedLeftGluePoints[] =
|
|
{
|
|
{ 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 }
|
|
};
|
|
const SvxMSDffHandle mso_sptCurvedLeftHandles[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
|
|
0, 0x100, 10800, 10800, 0, 10800, 3 + 37, 3 + 27 },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
|
|
0, 0x101, 10800, 10800, 0, 10800, 3 + 25, 3 + 20 },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
|
|
0x102, 21600, 10800, 10800, 0, 3 + 40, 3375, 21600 }
|
|
};
|
|
const mso_CustomShape msoCurvedLeftArrow =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptCurvedLeftVert),
|
|
const_cast<sal_uInt16*>(mso_sptCurvedLeftSegm), sizeof( mso_sptCurvedLeftSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptCurvedUpCalc),
|
|
const_cast<sal_Int32*>(mso_sptCurvedUpDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptCurvedLeftTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptCurvedLeftGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptCurvedLeftHandles),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptStripedRightArrowVert[] = // adjustment1 : x 3375 - 21600
|
|
{ // adjustment2 : y 0 - 10800
|
|
{ 3375, 0 MSO_I }, { 1 MSO_I, 0 MSO_I }, { 1 MSO_I, 0 }, { 21600, 10800 },
|
|
{ 1 MSO_I, 21600 }, { 1 MSO_I, 2 MSO_I }, { 3375, 2 MSO_I }, { 0, 0 MSO_I },
|
|
{ 675, 0 MSO_I }, { 675, 2 MSO_I }, { 0, 2 MSO_I }, { 1350, 0 MSO_I },
|
|
{ 2700, 0 MSO_I }, { 2700, 2 MSO_I }, { 1350, 2 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptStripedRightArrowSegm[] =
|
|
{
|
|
0x4000, 0x0006, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptStripedRightArrowCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x8000, { 21600, 0, DFF_Prop_adjust2Value } },
|
|
{ 0x8000, { 21600, 0, 0x401 } },
|
|
{ 0x6001, { 0x403, 0x400, 10800 } },
|
|
{ 0x6000, { 0x401, 0x404, 0 } }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptStripedRightArrowTextRect[] =
|
|
{
|
|
{ { 3375, 0 MSO_I }, { 5 MSO_I, 2 MSO_I } }
|
|
};
|
|
const SvxMSDffHandle mso_sptStripedRightArrowHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0x100, 0x101, 10800, 10800, 3375, 21600, 0, 10800 }
|
|
};
|
|
const mso_CustomShape msoStripedRightArrow =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptStripedRightArrowVert),
|
|
const_cast<sal_uInt16*>(mso_sptStripedRightArrowSegm), sizeof( mso_sptStripedRightArrowSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptStripedRightArrowCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault16200and5400),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptStripedRightArrowTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptStripedRightArrowHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptNotchedRightArrowVert[] = // adjustment1 : x 0 - 21600 (default 16200)
|
|
{ // adjustment2 : y 0 - 10800 (default 5400)
|
|
{ 0, 1 MSO_I }, { 0 MSO_I, 1 MSO_I }, { 0 MSO_I, 0 }, { 21600, 10800 },
|
|
{ 0 MSO_I, 21600 }, { 0 MSO_I, 2 MSO_I }, { 0, 2 MSO_I }, { 5 MSO_I, 10800 }, { 0, 1 MSO_I }
|
|
};
|
|
const SvxMSDffCalculationData mso_sptNotchedRightArrowCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
|
|
{ 0x8000, { 21600, 0, DFF_Prop_adjust2Value } },
|
|
{ 0x8000, { 21600, 0, DFF_Prop_adjustValue } },
|
|
{ 0x8000, { 10800, 0, DFF_Prop_adjust2Value } },
|
|
{ 0x6001, { 0x403, 0x404, 10800 } },
|
|
{ 0x8000, { 21600, 0, 0x405 }}
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptNotchedRightArrowTextRect[] = // todo
|
|
{
|
|
{ { 5 MSO_I, 1 MSO_I }, { 6 MSO_I, 2 MSO_I } }
|
|
};
|
|
const SvxMSDffHandle mso_sptNotchedRightArrowHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0x100, 0x101, 10800, 10800, 0, 21600, 0, 10800 }
|
|
};
|
|
const mso_CustomShape msoNotchedRightArrow =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptNotchedRightArrowVert),
|
|
nullptr, 0,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptNotchedRightArrowCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault16200and5400),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptNotchedRightArrowTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptNotchedRightArrowHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptHomePlateVert[] = // adjustment1 : x 0 - 21600
|
|
{
|
|
{ 0, 0 }, { 0 MSO_I, 0 }, { 21600, 10800 }, { 0 MSO_I, 21600 },
|
|
{ 0, 21600 }
|
|
};
|
|
const sal_uInt16 mso_sptHomePlateSegm[] =
|
|
{
|
|
0x4000, 0x0004, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptHomePlateCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } }
|
|
};
|
|
const sal_Int32 mso_sptHomePlateDefault[] =
|
|
{
|
|
1, 16200
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptHomePlateTextRect[] = // todo
|
|
{
|
|
{ { 0, 0 }, { 21600, 21600 } }
|
|
};
|
|
const SvxMSDffHandle mso_sptHomePlateHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0x100, 0, 10800, 10800, 0, 21600, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoHomePlate =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptHomePlateVert),
|
|
const_cast<sal_uInt16*>(mso_sptHomePlateSegm), sizeof( mso_sptHomePlateSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptHomePlateCalc),
|
|
const_cast<sal_Int32*>(mso_sptHomePlateDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptHomePlateTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptHomePlateHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptChevronVert[] = // adjustment1 : x 0 - 21600
|
|
{
|
|
{ 0, 0 }, { 0 MSO_I, 0 }, { 21600, 10800 }, { 0 MSO_I, 21600 },
|
|
{ 0, 21600 }, { 1 MSO_I, 10800 }
|
|
};
|
|
const sal_uInt16 mso_sptChevronSegm[] =
|
|
{
|
|
0x4000, 0x0005, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptChevronCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x8000, { 21600, 0, 0x0400 } }
|
|
};
|
|
const sal_Int32 mso_sptChevronDefault[] =
|
|
{
|
|
1, 16200
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptChevronTextRect[] = // todo
|
|
{
|
|
{ { 0, 0 }, { 21600, 21600 } }
|
|
};
|
|
const SvxMSDffHandle mso_sptChevronHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0x100, 0, 10800, 10800, 0, 21600, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoChevron =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptChevronVert),
|
|
const_cast<sal_uInt16*>(mso_sptChevronSegm), sizeof( mso_sptChevronSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptChevronCalc),
|
|
const_cast<sal_Int32*>(mso_sptChevronDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptChevronTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptChevronHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptRightArrowCalloutVert[] = // adjustment1 : x 0 - 21000
|
|
{ // adjustment2 : y 0 - 10800
|
|
{ 0, 0 }, { 0 MSO_I, 0 }, { 0 MSO_I, 3 MSO_I }, { 2 MSO_I, 3 MSO_I },
|
|
{ 2 MSO_I, 1 MSO_I }, { 21600, 10800 }, { 2 MSO_I, 4 MSO_I }, { 2 MSO_I, 5 MSO_I },
|
|
{ 0 MSO_I, 5 MSO_I }, { 0 MSO_I, 21600 }, { 0, 21600 }
|
|
};
|
|
const sal_uInt16 mso_sptRightArrowCalloutSegm[] =
|
|
{
|
|
0x4000, 0x000a, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptRightArrowCalloutCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust3Value, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust4Value, 0, 0 } },
|
|
{ 0x8000, { 21600, 0, 0x0401 } },
|
|
{ 0x8000, { 21600, 0, 0x0403 } }
|
|
};
|
|
const sal_Int32 mso_sptRightArrowCalloutDefault[] =
|
|
{
|
|
4, 14400, 5400, 18000, 8100
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptRightArrowCalloutTextRect[] =
|
|
{
|
|
{ { 0, 0 }, { 0 MSO_I, 21600 } }
|
|
};
|
|
const SvxMSDffHandle mso_sptRightArrowCalloutHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
|
|
0x100, 0, 10800, 10800, 0, 0x102, MIN_INT32, 0x7fffffff },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL,
|
|
0x102, 0x103, 10800, 10800, 0x100, 21600, 0x101, 10800 },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
|
|
1, 0x101, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 0x103 }
|
|
};
|
|
const mso_CustomShape msoRightArrowCallout =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptRightArrowCalloutVert),
|
|
const_cast<sal_uInt16*>(mso_sptRightArrowCalloutSegm), sizeof( mso_sptRightArrowCalloutSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptRightArrowCalloutCalc),
|
|
const_cast<sal_Int32*>(mso_sptRightArrowCalloutDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptRightArrowCalloutTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptRightArrowCalloutHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptLeftArrowCalloutVert[] = // adjustment1 : x 0 - 21600, adjustment2 : y 0 - 10800
|
|
{ // adjustment3 : x 0 - 21600, adjustment4 : y 0 - 10800
|
|
{ 0 MSO_I, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0 MSO_I, 21600 },
|
|
{ 0 MSO_I, 5 MSO_I }, { 2 MSO_I, 5 MSO_I }, { 2 MSO_I, 4 MSO_I }, { 0, 10800 },
|
|
{ 2 MSO_I, 1 MSO_I }, { 2 MSO_I, 3 MSO_I }, { 0 MSO_I, 3 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptLeftArrowCalloutSegm[] =
|
|
{
|
|
0x4000, 0x000a, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptLeftArrowCalloutCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust3Value, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust4Value, 0, 0 } },
|
|
{ 0x8000, { 21600, 0, 0x0401 } },
|
|
{ 0x8000, { 21600, 0, 0x0403 } }
|
|
};
|
|
const sal_Int32 mso_sptLeftArrowCalloutDefault[] =
|
|
{
|
|
4, 7200, 5400, 3600, 8100
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptLeftArrowCalloutTextRect[] =
|
|
{
|
|
{ { 0 MSO_I, 0 }, { 21600, 21600 } }
|
|
};
|
|
const SvxMSDffHandle mso_sptLeftArrowCalloutHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL,
|
|
0x100, 0, 10800, 10800, 0x102, 21600, MIN_INT32, 0x7fffffff },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL,
|
|
0x102, 0x103, 10800, 10800, 0, 0x100, 0x101, 10800 },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
|
|
0, 0x101, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 0x103 }
|
|
};
|
|
const mso_CustomShape msoLeftArrowCallout =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptLeftArrowCalloutVert),
|
|
const_cast<sal_uInt16*>(mso_sptLeftArrowCalloutSegm), sizeof( mso_sptLeftArrowCalloutSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptLeftArrowCalloutCalc),
|
|
const_cast<sal_Int32*>(mso_sptLeftArrowCalloutDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptLeftArrowCalloutTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptLeftArrowCalloutHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptUpArrowCalloutVert[] =
|
|
{
|
|
{ 21600, 0 MSO_I }, { 21600, 21600 }, { 0, 21600 }, { 0, 0 MSO_I },
|
|
{ 3 MSO_I, 0 MSO_I }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I }, { 10800, 0 },
|
|
{ 4 MSO_I, 2 MSO_I }, { 5 MSO_I, 2 MSO_I }, { 5 MSO_I, 0 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptUpArrowCalloutSegm[] =
|
|
{
|
|
0x4000, 0x000a, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptUpArrowCalloutCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust3Value, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust4Value, 0, 0 } },
|
|
{ 0x8000, { 21600, 0, 0x0401 } },
|
|
{ 0x8000, { 21600, 0, 0x0403 } }
|
|
};
|
|
const sal_Int32 mso_sptUpArrowCalloutDefault[] =
|
|
{
|
|
4, 7200, 5400, 3600, 8100
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptUpArrowCalloutTextRect[] =
|
|
{
|
|
{ { 0, 0 MSO_I }, { 21600, 21600 } }
|
|
};
|
|
const SvxMSDffHandle mso_sptUpArrowCalloutHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL,
|
|
0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0x102, 21600 },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
|
|
0x103, 0x102, 10800, 10800, 0x101, 10800, 0, 0x100 },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
|
|
0x101, 0, 10800, 10800, 0, 0x103, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoUpArrowCallout =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptUpArrowCalloutVert),
|
|
const_cast<sal_uInt16*>(mso_sptUpArrowCalloutSegm), sizeof( mso_sptUpArrowCalloutSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptUpArrowCalloutCalc),
|
|
const_cast<sal_Int32*>(mso_sptUpArrowCalloutDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptUpArrowCalloutTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptUpArrowCalloutHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptDownArrowCalloutVert[] =
|
|
{
|
|
{ 0, 0 MSO_I }, { 0, 0 }, { 21600, 0 }, { 21600, 0 MSO_I },
|
|
{ 5 MSO_I, 0 MSO_I }, { 5 MSO_I, 2 MSO_I }, { 4 MSO_I, 2 MSO_I }, { 10800, 21600 },
|
|
{ 1 MSO_I, 2 MSO_I }, { 3 MSO_I, 2 MSO_I }, { 3 MSO_I, 0 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptDownArrowCalloutSegm[] =
|
|
{
|
|
0x4000, 0x000a, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptDownArrowCalloutCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust3Value, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust4Value, 0, 0 } },
|
|
{ 0x8000, { 21600, 0, 0x0401 } },
|
|
{ 0x8000, { 21600, 0, 0x0403 } }
|
|
};
|
|
const sal_Int32 mso_sptDownArrowCalloutDefault[] =
|
|
{
|
|
4, 14400, 5400, 18000, 8100
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptDownArrowCalloutTextRect[] =
|
|
{
|
|
{ { 0, 0 }, { 21600, 0 MSO_I } }
|
|
};
|
|
const SvxMSDffHandle mso_sptDownArrowCalloutHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
|
|
0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 0x102 },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL,
|
|
0x103, 0x102, 10800, 10800, 0x101, 10800, 0x100, 21600 },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
|
|
0x101, 1, 10800, 10800, 0, 0x103, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoDownArrowCallout =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptDownArrowCalloutVert),
|
|
const_cast<sal_uInt16*>(mso_sptDownArrowCalloutSegm), sizeof( mso_sptDownArrowCalloutSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptDownArrowCalloutCalc),
|
|
const_cast<sal_Int32*>(mso_sptDownArrowCalloutDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptDownArrowCalloutTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptDownArrowCalloutHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptLeftRightArrowCalloutVert[] =
|
|
{
|
|
{ 0 MSO_I, 0 }, { 4 MSO_I, 0 }, { 4 MSO_I, 3 MSO_I }, { 6 MSO_I, 3 MSO_I },
|
|
{ 6 MSO_I, 1 MSO_I }, { 21600, 10800 }, { 6 MSO_I, 5 MSO_I }, { 6 MSO_I, 7 MSO_I },
|
|
{ 4 MSO_I, 7 MSO_I }, { 4 MSO_I, 21600 }, { 0 MSO_I, 21600 }, { 0 MSO_I, 7 MSO_I },
|
|
{ 2 MSO_I, 7 MSO_I }, { 2 MSO_I, 5 MSO_I }, { 0, 10800 }, { 2 MSO_I, 1 MSO_I },
|
|
{ 2 MSO_I, 3 MSO_I }, { 0 MSO_I, 3 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptLeftRightArrowCalloutSegm[] =
|
|
{
|
|
0x4000, 0x0011, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptLeftRightArrowCalloutCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust3Value, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust4Value, 0, 0 } },
|
|
{ 0x8000, { 21600, 0, 0x0400 } },
|
|
{ 0x8000, { 21600, 0, 0x0401 } },
|
|
{ 0x8000, { 21600, 0, 0x0402 } },
|
|
{ 0x8000, { 21600, 0, 0x0403 } }
|
|
};
|
|
const sal_Int32 mso_sptLeftRightArrowCalloutDefault[] =
|
|
{
|
|
4, 5400, 5500, 2700, 8100
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptLeftRightArrowCalloutTextRect[] =
|
|
{
|
|
{ { 0 MSO_I, 0 }, { 4 MSO_I, 21600 } }
|
|
};
|
|
const SvxMSDffHandle mso_sptLeftRightArrowCalloutHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL,
|
|
0x100, 0, 10800, 10800, 0x102, 10800, MIN_INT32, 0x7fffffff },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL,
|
|
0x102, 0x103, 10800, 10800, 0, 0x100, 0x101, 10800 },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
|
|
0, 0x101, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 0x103 }
|
|
};
|
|
const mso_CustomShape msoLeftRightArrowCallout =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptLeftRightArrowCalloutVert),
|
|
const_cast<sal_uInt16*>(mso_sptLeftRightArrowCalloutSegm), sizeof( mso_sptLeftRightArrowCalloutSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptLeftRightArrowCalloutCalc),
|
|
const_cast<sal_Int32*>(mso_sptLeftRightArrowCalloutDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptLeftRightArrowCalloutTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptLeftRightArrowCalloutHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptUpDownArrowCalloutVert[] =
|
|
{
|
|
{ 0, 0 MSO_I }, { 0, 4 MSO_I }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 6 MSO_I },
|
|
{ 1 MSO_I, 6 MSO_I }, { 10800, 21600 }, { 5 MSO_I, 6 MSO_I }, { 7 MSO_I, 6 MSO_I },
|
|
{ 7 MSO_I, 4 MSO_I }, { 21600, 4 MSO_I }, { 21600, 0 MSO_I }, { 7 MSO_I, 0 MSO_I },
|
|
{ 7 MSO_I, 2 MSO_I }, { 5 MSO_I, 2 MSO_I }, { 10800, 0 }, { 1 MSO_I, 2 MSO_I },
|
|
{ 3 MSO_I, 2 MSO_I }, { 3 MSO_I, 0 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptUpDownArrowCalloutSegm[] =
|
|
{
|
|
0x4000, 0x0011, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptUpDownArrowCalloutCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust3Value, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust4Value, 0, 0 } },
|
|
{ 0x8000, { 21600, 0, 0x0400 } },
|
|
{ 0x8000, { 21600, 0, 0x0401 } },
|
|
{ 0x8000, { 21600, 0, 0x0402 } },
|
|
{ 0x8000, { 21600, 0, 0x0403 } }
|
|
};
|
|
const sal_Int32 mso_sptUpDownArrowCalloutDefault[] =
|
|
{
|
|
4, 5400, 5500, 2700, 8100
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptUpDownArrowCalloutTextRect[] =
|
|
{
|
|
{ { 0, 0 MSO_I }, { 21600, 4 MSO_I } }
|
|
};
|
|
const SvxMSDffHandle mso_sptUpDownArrowCalloutHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL,
|
|
0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0x102, 10800 },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
|
|
0x103, 0x102, 10800, 10800, 0x101, 10800, 0, 0x100 },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
|
|
0x101, 0, 10800, 10800, 0, 0x103, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoUpDownArrowCallout =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptUpDownArrowCalloutVert),
|
|
const_cast<sal_uInt16*>(mso_sptUpDownArrowCalloutSegm), sizeof( mso_sptUpDownArrowCalloutSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptUpDownArrowCalloutCalc),
|
|
const_cast<sal_Int32*>(mso_sptUpDownArrowCalloutDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptUpDownArrowCalloutTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptUpDownArrowCalloutHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptQuadArrowCalloutVert[] =
|
|
{
|
|
{ 0 MSO_I, 0 MSO_I }, { 3 MSO_I, 0 MSO_I }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
|
|
{ 10800, 0 }, { 5 MSO_I, 2 MSO_I }, { 7 MSO_I, 2 MSO_I }, { 7 MSO_I, 0 MSO_I },
|
|
{ 4 MSO_I, 0 MSO_I }, { 4 MSO_I, 3 MSO_I }, { 6 MSO_I, 3 MSO_I }, { 6 MSO_I, 1 MSO_I },
|
|
{ 21600, 10800 }, { 6 MSO_I, 5 MSO_I }, { 6 MSO_I, 7 MSO_I }, { 4 MSO_I, 7 MSO_I },
|
|
{ 4 MSO_I, 4 MSO_I }, { 7 MSO_I, 4 MSO_I }, { 7 MSO_I, 6 MSO_I }, { 5 MSO_I, 6 MSO_I },
|
|
{ 10800, 21600 }, { 1 MSO_I, 6 MSO_I }, { 3 MSO_I, 6 MSO_I }, { 3 MSO_I, 4 MSO_I },
|
|
{ 0 MSO_I, 4 MSO_I }, { 0 MSO_I, 7 MSO_I }, { 2 MSO_I, 7 MSO_I }, { 2 MSO_I, 5 MSO_I },
|
|
{ 0, 10800 }, { 2 MSO_I, 1 MSO_I }, { 2 MSO_I, 3 MSO_I }, { 0 MSO_I, 3 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptQuadArrowCalloutSegm[] =
|
|
{
|
|
0x4000, 0x001f, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptQuadArrowCalloutCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust3Value, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust4Value, 0, 0 } },
|
|
{ 0x8000, { 21600, 0, 0x0400 } },
|
|
{ 0x8000, { 21600, 0, 0x0401 } },
|
|
{ 0x8000, { 21600, 0, 0x0402 } },
|
|
{ 0x8000, { 21600, 0, 0x0403 } }
|
|
};
|
|
const sal_Int32 mso_sptQuadArrowCalloutDefault[] =
|
|
{
|
|
4, 5400, 8100, 2700, 9400
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptQuadArrowCalloutTextRect[] =
|
|
{
|
|
{ { 0 MSO_I, 0 MSO_I }, { 4 MSO_I, 4 MSO_I } }
|
|
};
|
|
const SvxMSDffHandle mso_sptQuadArrowCalloutHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
|
|
0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0x102, 0x101 },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL,
|
|
0x101, 0, 10800, 10800, 0x100, 10800, MIN_INT32, 0x7fffffff },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
|
|
0x103, 0x102, 10800, 10800, 0x101, 10800, 0, 0x100 }
|
|
};
|
|
const mso_CustomShape msoQuadArrowCallout =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptQuadArrowCalloutVert),
|
|
const_cast<sal_uInt16*>(mso_sptQuadArrowCalloutSegm), sizeof( mso_sptQuadArrowCalloutSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptQuadArrowCalloutCalc),
|
|
const_cast<sal_Int32*>(mso_sptQuadArrowCalloutDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptQuadArrowCalloutTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptQuadArrowCalloutHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptCircularArrowVert[] =
|
|
{
|
|
{ 0x03 MSO_I, 0x03 MSO_I },
|
|
{ 0x14 MSO_I, 0x14 MSO_I },
|
|
{ 0x13 MSO_I, 0x12 MSO_I },
|
|
{ 0x11 MSO_I, 0x10 MSO_I },
|
|
{ 0, 0 }, { 21600, 21600 },
|
|
{ 0x09 MSO_I, 0x08 MSO_I },
|
|
{ 0x0B MSO_I, 0x0A MSO_I },
|
|
{ 0x18 MSO_I, 0x17 MSO_I },
|
|
{ 0x2F MSO_I, 0x2E MSO_I },
|
|
{ 0x1D MSO_I, 0x1C MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptCircularArrowSegm[] =
|
|
{
|
|
0xa404, 0xa504, 0x0003, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptCircularArrowCalc[] =
|
|
{
|
|
{ 0x2000, { 0x0147, 0x0000, 0x0000 } },
|
|
{ 0x2000, { 0x0148, 0x0000, 0x0000 } },
|
|
{ 0x2000, { 0x0149, 0x0000, 0x0000 } },
|
|
{ 0x4000, { 0x2A30, 0x0149, 0x0000 } },
|
|
{ 0x4009, { 0x2A30, 0x0147, 0x0000 } },
|
|
{ 0x400A, { 0x2A30, 0x0147, 0x0000 } },
|
|
{ 0x4009, { 0x2A30, 0x0148, 0x0000 } },
|
|
{ 0x400A, { 0x2A30, 0x0148, 0x0000 } },
|
|
{ 0x2000, { 0x0404, 0x2A30, 0x0000 } },
|
|
{ 0x2000, { 0x0405, 0x2A30, 0x0000 } },
|
|
{ 0x2000, { 0x0406, 0x2A30, 0x0000 } },
|
|
{ 0x2000, { 0x0407, 0x2A30, 0x0000 } },
|
|
{ 0x6009, { 0x0403, 0x0147, 0x0000 } },
|
|
{ 0x600A, { 0x0403, 0x0147, 0x0000 } },
|
|
{ 0x6009, { 0x0403, 0x0148, 0x0000 } },
|
|
{ 0x600A, { 0x0403, 0x0148, 0x0000 } },
|
|
{ 0x2000, { 0x040C, 0x2A30, 0x0000 } },
|
|
{ 0x2000, { 0x040D, 0x2A30, 0x0000 } },
|
|
{ 0x2000, { 0x040E, 0x2A30, 0x0000 } },
|
|
{ 0x2000, { 0x040F, 0x2A30, 0x0000 } },
|
|
{ 0x8000, { 0x5460, 0x0000, 0x0403 } },
|
|
{ 0x4009, { 0x34BC, 0x0148, 0x0000 } },
|
|
{ 0x400A, { 0x34BC, 0x0148, 0x0000 } },
|
|
{ 0x2000, { 0x0415, 0x2A30, 0x0000 } },
|
|
{ 0x2000, { 0x0416, 0x2A30, 0x0000 } },
|
|
{ 0x2000, { 0x0149, 0x0000, 0x0A8C } },
|
|
{ 0x6009, { 0x0419, 0x0148, 0x0000 } },
|
|
{ 0x600A, { 0x0419, 0x0148, 0x0000 } },
|
|
{ 0x2000, { 0x041A, 0x2A30, 0x0000 } },
|
|
{ 0x2000, { 0x041B, 0x2A30, 0x0000 } },
|
|
{ 0xA000, { 0x041D, 0x0000, 0x0418 } },
|
|
{ 0xA000, { 0x041D, 0x0000, 0x0418 } },
|
|
{ 0x6001, { 0x041E, 0x041F, 0x0001 } },
|
|
{ 0xA000, { 0x041C, 0x0000, 0x0417 } },
|
|
{ 0xA000, { 0x041C, 0x0000, 0x0417 } },
|
|
{ 0x6001, { 0x0421, 0x0422, 0x0001 } },
|
|
{ 0x6000, { 0x0420, 0x0423, 0x0000 } },
|
|
{ 0x200D, { 0x0424, 0x0000, 0x0000 } },
|
|
{ 0x200E, { 0x0148, 0x002D, 0x0000 } },
|
|
{ 0x6009, { 0x0425, 0x0426, 0x0000 } },
|
|
{ 0x200E, { 0x0148, 0x002D, 0x0000 } },
|
|
{ 0x600A, { 0x0425, 0x0428, 0x0000 } },
|
|
{ 0x000E, { 0x0000, 0x002D, 0x0000 } },
|
|
{ 0x6009, { 0x0427, 0x042A, 0x0000 } },
|
|
{ 0x000E, { 0x0000, 0x002D, 0x0000 } },
|
|
{ 0x6009, { 0x0429, 0x042C, 0x0000 } },
|
|
{ 0x6000, { 0x041C, 0x042B, 0x0000 } },
|
|
{ 0x6000, { 0x041D, 0x042D, 0x0000 } }
|
|
};
|
|
const sal_Int32 mso_sptCircularArrowDefault[] =
|
|
{
|
|
3, 180, 0, 5500
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptCircularArrowTextRect[] = // todo
|
|
{
|
|
{ { 0, 0 }, { 21600, 21600 } }
|
|
};
|
|
const SvxMSDffHandle mso_sptCircularArrowHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::POLAR | SvxMSDffHandleFlags::RADIUS_RANGE,
|
|
10800, 0x100, 10800, 10800, 10800, 10800, -0x7f4c0000, 0x00b40000 },
|
|
{ SvxMSDffHandleFlags::POLAR | SvxMSDffHandleFlags::RADIUS_RANGE,
|
|
0x102, 0x101, 10800, 10800, 0, 10800, -0x7f4c0000, 0x00b40000 }
|
|
};
|
|
const mso_CustomShape msoCircularArrow =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptCircularArrowVert),
|
|
const_cast<sal_uInt16*>(mso_sptCircularArrowSegm), sizeof( mso_sptCircularArrowSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptCircularArrowCalc),
|
|
const_cast<sal_Int32*>(mso_sptCircularArrowDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptCircularArrowTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptCircularArrowHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptCubeVert[] =
|
|
{
|
|
{ 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 },
|
|
{ 0, 1 MSO_I }, { 2 MSO_I, 0 }, { 11 MSO_I, 0 }, { 4 MSO_I, 1 MSO_I },
|
|
{ 4 MSO_I, 12 MSO_I }, { 4 MSO_I, 1 MSO_I }, { 11 MSO_I, 0 }, { 11 MSO_I, 3 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptCubeSegm[] =
|
|
{
|
|
0x4000, 0x0005, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptCubeCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x6000, { DFF_Prop_geoTop, 0x400, 0 } },
|
|
{ 0x6000, { DFF_Prop_geoLeft, 0x400, 0 } },
|
|
{ 0xa000, { DFF_Prop_geoBottom, 0, 0x400 } },
|
|
{ 0xa000, { DFF_Prop_geoRight, 0, 0x400 } },
|
|
{ 0xa000, { DFF_Prop_geoRight, 0, 0x402 } }, // 5
|
|
{ 0x2001, { 0x405, 1, 2 } }, // 6
|
|
{ 0x6000, { 0x402, 0x406, 0 } }, // 7
|
|
{ 0xa000, { DFF_Prop_geoBottom, 0, 0x401 } }, // 8
|
|
{ 0x2001, { 0x408, 1, 2 } }, // 9
|
|
{ 0x6000, { 0x401, 0x409, 0 } }, // 10
|
|
{ 0x2000, { DFF_Prop_geoRight, 0, 0 } }, // 11
|
|
{ 0x2000, { DFF_Prop_geoBottom, 0, 0 } } // 12
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptCubeTextRect[] =
|
|
{
|
|
{ { 0, 1 MSO_I }, { 4 MSO_I, 12 MSO_I } }
|
|
};
|
|
const SvxMSDffHandle mso_sptCubeHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::SWITCHED,
|
|
0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 21600 }
|
|
};
|
|
const SvxMSDffVertPair mso_sptCubeGluePoints[] =
|
|
{
|
|
{ 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 }
|
|
};
|
|
const mso_CustomShape msoCube =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptCubeVert),
|
|
const_cast<sal_uInt16*>(mso_sptCubeSegm), sizeof( mso_sptCubeSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptCubeCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault5400),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptCubeTextRect),
|
|
21600, 21600,
|
|
10800, 10800,
|
|
std::span<const SvxMSDffVertPair>(mso_sptCubeGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptCubeHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptBevelVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
|
|
{ 0, 0 }, { 21600, 0 }, { 1 MSO_I, 0 MSO_I }, { 0 MSO_I, 0 MSO_I },
|
|
{ 21600, 0 }, { 21600, 21600 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 0 MSO_I },
|
|
{ 21600, 21600 }, { 0, 21600 }, { 0 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
|
|
{ 0, 21600 }, { 0, 0 }, { 0 MSO_I, 0 MSO_I }, { 0 MSO_I, 2 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptBevelSegm[] =
|
|
{
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptBevelCalc[] =
|
|
{
|
|
{ 0x2001, { DFF_Prop_adjustValue, 21599, 21600 } },
|
|
{ 0xa000, { DFF_Prop_geoRight, 0, 0x400 } },
|
|
{ 0xa000, { DFF_Prop_geoBottom, 0, 0x400 } }
|
|
};
|
|
|
|
const SvxMSDffTextRectangles mso_sptBevelTextRect[] =
|
|
{
|
|
{ { 0 MSO_I, 0 MSO_I }, { 1 MSO_I, 2 MSO_I } }
|
|
};
|
|
const SvxMSDffHandle mso_sptBevelHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::SWITCHED,
|
|
0x100, 0, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoBevel =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptBevelVert),
|
|
const_cast<sal_uInt16*>(mso_sptBevelSegm), sizeof( mso_sptBevelSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptBevelCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault2700),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptBevelTextRect),
|
|
21600, 21600,
|
|
10800, 10800,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptBevelHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptFoldedCornerVert[] = // adjustment1 : x 10800 - 21600
|
|
{
|
|
{ 0, 0 }, { 21600, 0 }, { 21600, 0 MSO_I }, { 0 MSO_I, 21600 },
|
|
{ 0, 21600 }, { 0 MSO_I, 21600 }, { 3 MSO_I, 0 MSO_I }, { 8 MSO_I, 9 MSO_I },
|
|
{ 10 MSO_I, 11 MSO_I }, { 21600, 0 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptFoldedCornerSegm[] =
|
|
{
|
|
0x4000, 0x0004, 0x6001, 0x8000,
|
|
0x4000, 0x0001, 0x2001, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptFoldedCornerCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x8000, { 21600, 0, 0x400 } },
|
|
{ 0x2001, { 0x0401, 8000, 10800 } },
|
|
{ 0x8000, { 21600, 0, 0x0402 } },
|
|
{ 0x2001, { 0x0401, 1, 2 } },
|
|
{ 0x2001, { 0x0401, 1, 4 } },
|
|
{ 0x2001, { 0x0401, 1, 7 } },
|
|
{ 0x2001, { 0x0401, 1, 16 } },
|
|
{ 0x6000, { 0x0403, 0x405, 0 } },
|
|
{ 0x6000, { 0x0400, 0x406, 0 } },
|
|
{ 0x8000, { 21600, 0, 0x404 } },
|
|
{ 0x6000, { 0x400, 0x407, 0 } }
|
|
};
|
|
const sal_Int32 mso_sptFoldedCornerDefault[] =
|
|
{
|
|
1, 18900
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptFoldedCornerTextRect[] =
|
|
{
|
|
{ { 0, 0 }, { 21600, 11 MSO_I } }
|
|
};
|
|
const SvxMSDffHandle mso_sptFoldedCornerHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0x100, 1, 10800, 10800, 10800, 21600, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoFoldedCorner =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptFoldedCornerVert),
|
|
const_cast<sal_uInt16*>(mso_sptFoldedCornerSegm), sizeof( mso_sptFoldedCornerSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptFoldedCornerCalc),
|
|
const_cast<sal_Int32*>(mso_sptFoldedCornerDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFoldedCornerTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptStandardGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptFoldedCornerHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptActionButtonBlankVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
|
|
{ 0, 0 }, { 21600, 0 }, { 1 MSO_I, 0 MSO_I }, { 0 MSO_I, 0 MSO_I },
|
|
{ 21600, 0 }, { 21600, 21600 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 0 MSO_I },
|
|
{ 21600, 21600 }, { 0, 21600 }, { 0 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
|
|
{ 0, 21600 }, { 0, 0 }, { 0 MSO_I, 0 MSO_I }, { 0 MSO_I, 2 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptActionButtonBlankSegm[] =
|
|
{
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptActionButtonBlankCalc[] =
|
|
{
|
|
{ 0x2001, { DFF_Prop_adjustValue, 21599, 21600 } },
|
|
{ 0xa000, { DFF_Prop_geoRight, 0, 0x400 } },
|
|
{ 0xa000, { DFF_Prop_geoBottom, 0, 0x400 } }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptActionButtonBlankTextRect[] =
|
|
{
|
|
{ { 0 MSO_I, 0 MSO_I }, { 1 MSO_I, 2 MSO_I } }
|
|
};
|
|
const SvxMSDffHandle mso_sptButtonHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::SWITCHED,
|
|
0x100, 0, 10800, 10800, 0, 5400, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoActionButtonBlank =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptActionButtonBlankVert),
|
|
const_cast<sal_uInt16*>(mso_sptActionButtonBlankSegm), sizeof( mso_sptActionButtonBlankSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptActionButtonBlankCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault1400),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptActionButtonBlankTextRect),
|
|
21600, 21600,
|
|
10800, 10800,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptButtonHandle),
|
|
};
|
|
|
|
const SvxMSDffTextRectangles mso_sptActionButtonTextRect[] =
|
|
{
|
|
{ { 1 MSO_I, 2 MSO_I }, { 3 MSO_I, 4 MSO_I } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptActionButtonHomeVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
|
|
{ 0, 0 }, { 21600, 0 }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
|
|
{ 21600, 0 }, { 21600, 21600 }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 2 MSO_I },
|
|
{ 21600, 21600 }, { 0, 21600 }, { 1 MSO_I, 4 MSO_I }, { 3 MSO_I, 4 MSO_I },
|
|
{ 0, 21600 }, { 0, 0 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 4 MSO_I },
|
|
|
|
{ 7 MSO_I, 0xa MSO_I }, { 0xc MSO_I, 0xe MSO_I }, { 0xc MSO_I, 0x10 MSO_I }, { 0x12 MSO_I, 0x10 MSO_I },
|
|
{ 0x12 MSO_I, 0x14 MSO_I }, { 0x16 MSO_I, 8 MSO_I }, { 0x18 MSO_I, 8 MSO_I }, { 0x18 MSO_I, 0x1a MSO_I },
|
|
{ 0x1c MSO_I, 0x1a MSO_I }, { 0x1c MSO_I, 8 MSO_I }, { 0x1e MSO_I, 8 MSO_I },
|
|
|
|
{ 0xc MSO_I, 0xe MSO_I }, { 0xc MSO_I, 0x10 MSO_I }, { 0x12 MSO_I, 0x10 MSO_I },{ 0x12 MSO_I, 0x14 MSO_I },
|
|
|
|
{ 0x20 MSO_I, 0x24 MSO_I }, { 0x22 MSO_I, 0x24 MSO_I }, { 0x22 MSO_I, 0x1a MSO_I }, { 0x18 MSO_I, 0x1a MSO_I },
|
|
{ 0x18 MSO_I, 8 MSO_I }, { 0x1c MSO_I, 8 MSO_I }, { 0x1c MSO_I, 0x1a MSO_I }, { 0x20 MSO_I, 0x1a MSO_I }
|
|
|
|
};
|
|
const sal_uInt16 mso_sptActionButtonHomeSegm[] =
|
|
{
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x000a, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0007, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptActionButtonHomeCalc[] = // adj value 0 - 5400
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x6000, { DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x6000, { DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 } },
|
|
{ 0xa000, { DFF_Prop_geoRight, 0, DFF_Prop_adjustValue } },
|
|
{ 0xa000, { DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue } },
|
|
{ 0x8000, { 10800, 0, DFF_Prop_adjustValue } },
|
|
{ 0x2001, { 0x0405, 1, 10800 } }, // scaling 6
|
|
{ 0x2001, { DFF_Prop_geoRight, 1, 2 } }, // lr center 7
|
|
{ 0x2001, { DFF_Prop_geoBottom, 1, 2 } }, // ul center 8
|
|
|
|
{ 0x4001, { -8000, 0x0406, 1 } }, // 9
|
|
{ 0x6000, { 0x0409, 0x0408, 0 } }, // a
|
|
{ 0x4001, { 2960, 0x0406, 1 } }, // b
|
|
{ 0x6000, { 0x040b, 0x0407, 0 } }, // c
|
|
{ 0x4001, { -5000, 0x0406, 1 } }, // d
|
|
{ 0x6000, { 0x040d, 0x0408, 0 } }, // e
|
|
{ 0x4001, { -7000, 0x0406, 1 } }, // f
|
|
{ 0x6000, { 0x040f, 0x0408, 0 } }, // 10
|
|
{ 0x4001, { 5000, 0x0406, 1 } }, // 11
|
|
{ 0x6000, { 0x0411, 0x0407, 0 } }, // 12
|
|
{ 0x4001, { -2960, 0x0406, 1 } }, // 13
|
|
{ 0x6000, { 0x0413, 0x0408, 0 } }, // 14
|
|
{ 0x4001, { 8000, 0x0406, 1 } }, // 15
|
|
{ 0x6000, { 0x0415,0x0407, 0 } }, // 16
|
|
{ 0x4001, { 6100, 0x0406, 1 } }, // 17
|
|
{ 0x6000, { 0x0417,0x0407, 0 } }, // 18
|
|
{ 0x4001, { 8260, 0x0406, 1 } }, // 19
|
|
{ 0x6000, { 0x0419, 0x0408, 0 } }, // 1a
|
|
{ 0x4001, { -6100, 0x0406, 1 } }, // 1b
|
|
{ 0x6000, { 0x041b, 0x0407, 0 } }, // 1c
|
|
{ 0x4001, { -8000, 0x0406, 1 } }, // 1d
|
|
{ 0x6000, { 0x041d, 0x0407, 0 } }, // 1e
|
|
{ 0x4001, { -1060, 0x0406, 1 } }, // 1f
|
|
{ 0x6000, { 0x041f, 0x0407, 0 } }, // 20
|
|
{ 0x4001, { 1060, 0x0406, 1 } }, // 21
|
|
{ 0x6000, { 0x0421, 0x0407, 0 } }, // 22
|
|
{ 0x4001, { 4020, 0x0406, 1 } }, // 23
|
|
{ 0x6000, { 0x0423, 0x0408, 0 } } // 24
|
|
|
|
};
|
|
const mso_CustomShape msoActionButtonHome =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptActionButtonHomeVert),
|
|
const_cast<sal_uInt16*>(mso_sptActionButtonHomeSegm), sizeof( mso_sptActionButtonHomeSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptActionButtonHomeCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault1400),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptActionButtonTextRect),
|
|
21600, 21600,
|
|
10800, 10800,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptButtonHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptActionButtonHelpVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
|
|
{ 0, 0 }, { 21600, 0 }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
|
|
{ 21600, 0 }, { 21600, 21600 }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 2 MSO_I },
|
|
{ 21600, 21600 }, { 0, 21600 }, { 1 MSO_I, 4 MSO_I }, { 3 MSO_I, 4 MSO_I },
|
|
{ 0, 21600 }, { 0, 0 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I,4 MSO_I },
|
|
{ 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 },
|
|
{ 0x12 MSO_I, 0x14 MSO_I }, { 0x12 MSO_I, 0x16 MSO_I }, // pp
|
|
{ 0x12 MSO_I, 0x18 MSO_I }, { 0x1a MSO_I, 8 MSO_I }, { 0x1c MSO_I, 8 MSO_I }, // ccp
|
|
{ 0x1e MSO_I, 8 MSO_I }, { 0x20 MSO_I, 0x22 MSO_I }, { 0x20 MSO_I, 0x24 MSO_I }, // ccp
|
|
{ 0x20 MSO_I, 0x26 MSO_I }, { 0x28 MSO_I, 0x2a MSO_I }, { 7 MSO_I, 0x2a MSO_I }, // ccp
|
|
{ 0x2c MSO_I, 0x2a MSO_I }, { 0x2e MSO_I, 0x26 MSO_I }, { 0x2e MSO_I, 0x24 MSO_I }, // ccp
|
|
{ 0x30 MSO_I, 0x24 MSO_I }, { 0x30 MSO_I, 0x32 MSO_I }, { 0x34 MSO_I, 0x36 MSO_I }, // ccp
|
|
{ 7 MSO_I, 0x36 MSO_I }, // p
|
|
{ 0x12 MSO_I, 0x36 MSO_I }, { 0x1c MSO_I, 0x32 MSO_I }, { 0x1c MSO_I, 0x24 MSO_I }, // ccp
|
|
{ 0x1c MSO_I, 0x38 MSO_I }, { 0x3a MSO_I, 0x3c MSO_I }, { 0x12 MSO_I, 0x3c MSO_I }, // ccp
|
|
{ 7 MSO_I, 0x3c MSO_I }, { 0x34 MSO_I, 8 MSO_I }, { 0x34 MSO_I, 0x16 MSO_I }, // ccp
|
|
{ 0x34 MSO_I, 0x14 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptActionButtonHelpSegm[] =
|
|
{
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0xa704, 0x6000, 0x8000,
|
|
0x4000, 0x0001, 0x2004, 0x0001, 0x2004, 0x0001, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptActionButtonHelpCalc[] = // adj value 0 - 5400
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x6000, { DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x6000, { DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 } },
|
|
{ 0xa000, { DFF_Prop_geoRight, 0, DFF_Prop_adjustValue } },
|
|
{ 0xa000, { DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue } },
|
|
{ 0x8000, { 10800, 0, DFF_Prop_adjustValue } },
|
|
{ 0x2001, { 0x0405, 1, 10800 } }, // scaling 6
|
|
{ 0x2001, { DFF_Prop_geoRight, 1, 2 } }, // lr center 7
|
|
{ 0x2001, { DFF_Prop_geoBottom, 1, 2 } }, // ul center 8
|
|
|
|
{ 0x4001, { -1690, 0x0406, 1 } }, // 9
|
|
{ 0x6000, { 0x0409, 0x0407, 0 } }, // a
|
|
{ 0x4001, { 4600, 0x0406, 1 } }, // b
|
|
{ 0x6000, { 0x040b, 0x0408, 0 } }, // c
|
|
{ 0x4001, { 1690, 0x0406, 1 } }, // d
|
|
{ 0x6000, { 0x040d, 0x0407, 0 } }, // e
|
|
{ 0x4001, { 7980, 0x0406, 1 } }, // f
|
|
{ 0x6000, { 0x040f, 0x0408, 0 } }, // 10
|
|
{ 0x4001, { 1270, 0x0406, 1 } }, // 11
|
|
{ 0x6000, { 0x0411, 0x0407, 0 } }, // 12
|
|
{ 0x4001, { 4000, 0x0406, 1 } }, // 13
|
|
{ 0x6000, { 0x0413, 0x0408, 0 } }, // 14
|
|
{ 0x4001, { 1750, 0x0406, 1 } }, // 15
|
|
{ 0x6000, { 0x0415, 0x0408, 0 } }, // 16
|
|
{ 0x4001, { 800, 0x0406, 1 } }, // 17
|
|
{ 0x6000, { 0x0417, 0x0408, 0 } }, // 18
|
|
{ 0x4001, { 1650, 0x0406, 1 } }, // 19
|
|
{ 0x6000, { 0x0419, 0x0407, 0 } }, // 1a
|
|
{ 0x4001, { 2340, 0x0406, 1 } }, // 1b
|
|
{ 0x6000, { 0x041b, 0x0407, 0 } }, // 1c
|
|
{ 0x4001, { 3640, 0x0406, 1 } }, // 1d
|
|
{ 0x6000, { 0x041d, 0x0407, 0 } }, // 1e
|
|
{ 0x4001, { 4670, 0x0406, 1 } }, // 1f
|
|
{ 0x6000, { 0x041f, 0x0407, 0 } }, // 20
|
|
{ 0x4001, { -1570, 0x0406, 1 } }, // 21
|
|
{ 0x6000, { 0x0421, 0x0408, 0 } }, // 22
|
|
{ 0x4001, { -3390, 0x0406, 1 } }, // 23
|
|
{ 0x6000, { 0x0423, 0x0408, 0 } }, // 24
|
|
{ 0x4001, { -6050, 0x0406, 1 } }, // 25
|
|
{ 0x6000, { 0x0425, 0x0408, 0 } }, // 26
|
|
{ 0x4001, { 2540, 0x0406, 1 } }, // 27
|
|
{ 0x6000, { 0x0427, 0x0407, 0 } }, // 28
|
|
{ 0x4001, { -8050, 0x0406, 1 } }, // 29
|
|
{ 0x6000, { 0x0429, 0x0408, 0 } }, // 2a
|
|
{ 0x4001, { -2540, 0x0406, 1 } }, // 2b
|
|
{ 0x6000, { 0x042b, 0x0407, 0 } }, // 2c
|
|
{ 0x4001, { -4460, 0x0406, 1 } }, // 2d
|
|
{ 0x6000, { 0x042d, 0x0407, 0 } }, // 2e
|
|
{ 0x4001, { -2330, 0x0406, 1 } }, // 2f
|
|
{ 0x6000, { 0x042f, 0x0407, 0 } }, // 30
|
|
{ 0x4001, { -4700, 0x0406, 1 } }, // 31
|
|
{ 0x6000, { 0x0431, 0x0408, 0 } }, // 32
|
|
{ 0x4001, { -1270, 0x0406, 1 } }, // 33
|
|
{ 0x6000, { 0x0433, 0x0407, 0 } }, // 34
|
|
{ 0x4001, { -5720, 0x0406, 1 } }, // 35
|
|
{ 0x6000, { 0x0435, 0x0408, 0 } }, // 36
|
|
{ 0x4001, { -2540, 0x0406, 1 } }, // 37
|
|
{ 0x6000, { 0x0437, 0x0408, 0 } }, // 38
|
|
{ 0x4001, { 1800, 0x0406, 1 } }, // 39
|
|
{ 0x6000, { 0x0439, 0x0407, 0 } }, // 3a
|
|
{ 0x4001, { -1700, 0x0406, 1 } }, // 3b
|
|
{ 0x6000, { 0x043b, 0x0408, 0 } }, // 3c
|
|
{ 0x4001, { 6290, 0x0406, 1 } }, // 3d
|
|
{ 0x6000, { 0x043d, 0x0408, 0 } } // 3e
|
|
};
|
|
const mso_CustomShape msoActionButtonHelp =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptActionButtonHelpVert),
|
|
const_cast<sal_uInt16*>(mso_sptActionButtonHelpSegm), sizeof( mso_sptActionButtonHelpSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptActionButtonHelpCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault1400),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptActionButtonTextRect),
|
|
21600, 21600,
|
|
10800, 10800,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptButtonHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptActionButtonInformationVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
|
|
{ 0, 0 }, { 21600, 0 }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
|
|
{ 21600, 0 }, { 21600, 21600 }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 2 MSO_I },
|
|
{ 21600, 21600 }, { 0, 21600 }, { 1 MSO_I, 4 MSO_I }, { 3 MSO_I, 4 MSO_I },
|
|
{ 0, 21600 }, { 0, 0 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 4 MSO_I },
|
|
{ 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 },
|
|
{ 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 },
|
|
{ 0x1a MSO_I, 0x1c MSO_I }, { 0x1e MSO_I, 0x1c MSO_I }, { 0x1e MSO_I, 0x20 MSO_I }, { 0x22 MSO_I, 0x20 MSO_I },
|
|
{ 0x22 MSO_I, 0x24 MSO_I }, { 0x1a MSO_I, 0x24 MSO_I }, { 0x1a MSO_I, 0x20 MSO_I }, { 0x26 MSO_I, 0x20 MSO_I },
|
|
{ 0x26 MSO_I, 0x28 MSO_I }, { 0x1a MSO_I, 0x28 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptActionButtonInformationSegm[] =
|
|
{
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0xa704, 0x6000, 0x8000,
|
|
0x4000, 0xa704, 0x6000, 0x8000,
|
|
0x4000, 0x0009, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptActionButtonInformationCalc[] = // adj value 0 - 5400
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x6000, { DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x6000, { DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 } },
|
|
{ 0xa000, { DFF_Prop_geoRight, 0, DFF_Prop_adjustValue } },
|
|
{ 0xa000, { DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue } },
|
|
{ 0x8000, { 10800, 0, DFF_Prop_adjustValue } },
|
|
{ 0x2001, { 0x0405, 1, 10800 } }, // scaling 6
|
|
{ 0x2001, { DFF_Prop_geoRight, 1, 2 } }, // lr center 7
|
|
{ 0x2001, { DFF_Prop_geoBottom, 1, 2 } }, // ul center 8
|
|
|
|
{ 0x4001, { -8050, 0x0406, 1 } }, // 9
|
|
{ 0x6000, { 0x0409, 0x0407, 0 } }, // a
|
|
{ 0x4001, { -8050, 0x0406, 1 } }, // b
|
|
{ 0x6000, { 0x040b, 0x0408, 0 } }, // c
|
|
{ 0x4001, { 8050, 0x0406, 1 } }, // d
|
|
{ 0x6000, { 0x040d, 0x0407, 0 } }, // e
|
|
{ 0x4001, { 8050, 0x0406, 1 } }, // f
|
|
{ 0x6000, { 0x040f, 0x0408, 0 } }, // 10
|
|
|
|
{ 0x4001, { -2060, 0x0406, 1 } }, // 11
|
|
{ 0x6000, { 0x0411, 0x0407, 0 } }, // 12
|
|
{ 0x4001, { -7620, 0x0406, 1 } }, // 13
|
|
{ 0x6000, { 0x0413, 0x0408, 0 } }, // 14
|
|
{ 0x4001, { 2060, 0x0406, 1 } }, // 15
|
|
{ 0x6000, { 0x0415, 0x0407, 0 } }, // 16
|
|
{ 0x4001, { -3500, 0x0406, 1 } }, // 17
|
|
{ 0x6000, { 0x0417, 0x0408, 0 } }, // 18
|
|
|
|
{ 0x4001, { -2960, 0x0406, 1 } }, // 19
|
|
{ 0x6000, { 0x0419, 0x0407, 0 } }, // 1a
|
|
{ 0x4001, { -2960, 0x0406, 1 } }, // 1b
|
|
{ 0x6000, { 0x041b, 0x0408, 0 } }, // 1c
|
|
{ 0x4001, { 1480, 0x0406, 1 } }, // 1d
|
|
{ 0x6000, { 0x041d, 0x0407, 0 } }, // 1e
|
|
{ 0x4001, { 5080, 0x0406, 1 } }, // 1f
|
|
{ 0x6000, { 0x041f, 0x0408, 0 } }, // 20
|
|
{ 0x4001, { 2960, 0x0406, 1 } }, // 21
|
|
{ 0x6000, { 0x0421, 0x0407, 0 } }, // 22
|
|
{ 0x4001, { 6140, 0x0406, 1 } }, // 23
|
|
{ 0x6000, { 0x0423, 0x0408, 0 } }, // 24
|
|
{ 0x4001, { -1480, 0x0406, 1 } }, // 25
|
|
{ 0x6000, { 0x0425, 0x0407, 0 } }, // 26
|
|
{ 0x4001, { -1920, 0x0406, 1 } }, // 27
|
|
{ 0x6000, { 0x0427, 0x0408, 0 } }, // 28
|
|
|
|
{ 0x4001, { -5560, 0x0406, 1 } }, // 29
|
|
{ 0x6000, { 0x0429, 0x0408, 0 } }, // 2a
|
|
|
|
};
|
|
const mso_CustomShape msoActionButtonInformation =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptActionButtonInformationVert),
|
|
const_cast<sal_uInt16*>(mso_sptActionButtonInformationSegm), sizeof( mso_sptActionButtonInformationSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptActionButtonInformationCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault1400),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptActionButtonTextRect),
|
|
21600, 21600,
|
|
10800, 10800,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptButtonHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptActionButtonBackPreviousVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
|
|
{ 0, 0 }, { 21600, 0 }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
|
|
{ 21600, 0 }, { 21600, 21600 }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 2 MSO_I },
|
|
{ 21600, 21600 }, { 0, 21600 }, { 1 MSO_I, 4 MSO_I }, { 3 MSO_I,4 MSO_I },
|
|
{ 0, 21600 }, { 0, 0 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 4 MSO_I },
|
|
|
|
{ 0xa MSO_I, 8 MSO_I }, { 0xe MSO_I, 0xc MSO_I }, { 0xe MSO_I, 0x10 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptActionButtonForwardBackSegm[] =
|
|
{
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0002, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptActionButtonForwardBackCalc[] = // adj value 0 - 5400
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x6000, { DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x6000, { DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 } },
|
|
{ 0xa000, { DFF_Prop_geoRight, 0, DFF_Prop_adjustValue } },
|
|
{ 0xa000, { DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue } },
|
|
{ 0x8000, { 10800, 0, DFF_Prop_adjustValue } },
|
|
{ 0x2001, { 0x0405, 1, 10800 } }, // scaling 6
|
|
{ 0x2001, { DFF_Prop_geoRight, 1, 2 } }, // lr center 7
|
|
{ 0x2001, { DFF_Prop_geoBottom, 1, 2 } }, // ul center 8
|
|
|
|
{ 0x4001, { -8050, 0x0406, 1 } }, // 9
|
|
{ 0x6000, { 0x0409, 0x0407, 0 } }, // a
|
|
{ 0x4001, { -8050, 0x0406, 1 } }, // b
|
|
{ 0x6000, { 0x040b, 0x0408, 0 } }, // c
|
|
{ 0x4001, { 8050, 0x0406, 1 } }, // d
|
|
{ 0x6000, { 0x040d, 0x0407, 0 } }, // e
|
|
{ 0x4001, { 8050, 0x0406, 1 } }, // f
|
|
{ 0x6000, { 0x040f, 0x0408, 0 } } // 10
|
|
};
|
|
const mso_CustomShape msoActionButtonBackPrevious =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptActionButtonBackPreviousVert),
|
|
const_cast<sal_uInt16*>(mso_sptActionButtonForwardBackSegm), sizeof( mso_sptActionButtonForwardBackSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptActionButtonForwardBackCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault1400),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptActionButtonTextRect),
|
|
21600, 21600,
|
|
10800, 10800,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptButtonHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptActionButtonForwardNextVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
|
|
{ 0, 0 }, { 21600, 0 }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
|
|
{ 21600, 0 }, { 21600, 21600 }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 2 MSO_I },
|
|
{ 21600, 21600 }, { 0, 21600 }, { 1 MSO_I, 4 MSO_I }, { 3 MSO_I, 4 MSO_I },
|
|
{ 0, 21600 }, { 0, 0 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 4 MSO_I },
|
|
|
|
{ 0xa MSO_I, 0xc MSO_I }, { 0xe MSO_I, 8 MSO_I }, { 0xa MSO_I, 0x10 MSO_I }
|
|
};
|
|
const mso_CustomShape msoActionButtonForwardNext =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptActionButtonForwardNextVert),
|
|
const_cast<sal_uInt16*>(mso_sptActionButtonForwardBackSegm), sizeof( mso_sptActionButtonForwardBackSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptActionButtonForwardBackCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault1400),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptActionButtonTextRect),
|
|
21600, 21600,
|
|
10800, 10800,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptButtonHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptActionButtonBeginningVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
|
|
{ 0, 0 }, { 21600, 0 }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
|
|
{ 21600, 0 }, { 21600, 21600 }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 2 MSO_I },
|
|
{ 21600, 21600 }, { 0, 21600 }, { 1 MSO_I, 4 MSO_I }, { 3 MSO_I, 4 MSO_I },
|
|
{ 0, 21600 }, { 0, 0 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 4 MSO_I },
|
|
|
|
{ 0xa MSO_I, 8 MSO_I }, { 0xe MSO_I, 0xc MSO_I }, { 0xe MSO_I, 0x10 MSO_I }, { 0x12 MSO_I, 0xc MSO_I },
|
|
{ 0x14 MSO_I, 0xc MSO_I }, { 0x14 MSO_I, 0x10 MSO_I }, { 0x12 MSO_I, 0x10 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptActionButtonBeginningEndSegm[] =
|
|
{
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
|
|
0x4000, 0x0002, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptActionButtonBeginningEndCalc[] = // adj value 0 - 5400
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x6000, { DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x6000, { DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 } },
|
|
{ 0xa000, { DFF_Prop_geoRight, 0, DFF_Prop_adjustValue } },
|
|
{ 0xa000, { DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue } },
|
|
{ 0x8000, { 10800, 0, DFF_Prop_adjustValue } },
|
|
{ 0x2001, { 0x0405, 1, 10800 } }, // scaling 6
|
|
{ 0x2001, { DFF_Prop_geoRight, 1, 2 } }, // lr center 7
|
|
{ 0x2001, { DFF_Prop_geoBottom, 1, 2 } }, // ul center 8
|
|
|
|
{ 0x4001, { -4020, 0x0406, 1 } }, // 9
|
|
{ 0x6000, { 0x0409, 0x0407, 0 } }, // a
|
|
{ 0x4001, { -8050, 0x0406, 1 } }, // b
|
|
{ 0x6000, { 0x040b, 0x0408, 0 } }, // c
|
|
{ 0x4001, { 8050, 0x0406, 1 } }, // d
|
|
{ 0x6000, { 0x040d, 0x0407, 0 } }, // e
|
|
{ 0x4001, { 8050, 0x0406, 1 } }, // f
|
|
{ 0x6000, { 0x040f, 0x0408, 0 } }, // 10
|
|
|
|
{ 0x4001, { -8050, 0x0406, 1 } }, // 11
|
|
{ 0x6000, { 0x0411, 0x0407, 0 } }, // 12
|
|
{ 0x4001, { -6140, 0x0406, 1 } }, // 13
|
|
{ 0x6000, { 0x0413, 0x0407, 0 } }, // 14
|
|
|
|
|
|
{ 0x4001, { 4020, 0x0406, 1 } }, // 15
|
|
{ 0x6000, { 0x0415, 0x0407, 0 } }, // 16
|
|
{ 0x4001, { 6140, 0x0406, 1 } }, // 17
|
|
{ 0x6000, { 0x0417, 0x0407, 0 } } // 18
|
|
};
|
|
const mso_CustomShape msoActionButtonBeginning =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptActionButtonBeginningVert),
|
|
const_cast<sal_uInt16*>(mso_sptActionButtonBeginningEndSegm), sizeof( mso_sptActionButtonBeginningEndSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptActionButtonBeginningEndCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault1400),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptActionButtonTextRect),
|
|
21600, 21600,
|
|
10800, 10800,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptButtonHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptActionButtonEndVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
|
|
{ 0, 0 }, { 21600, 0 }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
|
|
{ 21600, 0 }, { 21600, 21600 }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 2 MSO_I },
|
|
{ 21600, 21600 }, { 0, 21600 }, { 1 MSO_I, 4 MSO_I }, { 3 MSO_I, 4 MSO_I },
|
|
{ 0, 21600 }, { 0, 0 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 4 MSO_I },
|
|
|
|
{ 0x16 MSO_I, 8 MSO_I }, { 0x12 MSO_I, 0x10 MSO_I }, { 0x12 MSO_I, 0xc MSO_I },
|
|
|
|
{ 0x18 MSO_I, 0xc MSO_I }, { 0x18 MSO_I, 0x10 MSO_I }, { 0xe MSO_I, 0x10 MSO_I }, { 0xe MSO_I, 0xc MSO_I }
|
|
};
|
|
const mso_CustomShape msoActionButtonEnd =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptActionButtonEndVert),
|
|
const_cast<sal_uInt16*>(mso_sptActionButtonBeginningEndSegm), sizeof( mso_sptActionButtonBeginningEndSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptActionButtonBeginningEndCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault1400),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptActionButtonTextRect),
|
|
21600, 21600,
|
|
10800, 10800,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptButtonHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptActionButtonReturnVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
|
|
{ 0, 0 }, { 21600, 0 }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
|
|
{ 21600, 0 }, { 21600, 21600 }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 2 MSO_I },
|
|
{ 21600, 21600 }, { 0, 21600 }, { 1 MSO_I, 4 MSO_I }, { 3 MSO_I, 4 MSO_I },
|
|
{ 0, 21600 }, { 0, 0 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 4 MSO_I },
|
|
|
|
{ 0xa MSO_I, 0xc MSO_I }, { 0xe MSO_I, 0xc MSO_I }, { 0xe MSO_I, 0x10 MSO_I }, // ppp
|
|
{ 0xe MSO_I, 0x12 MSO_I }, { 0x14 MSO_I, 0x16 MSO_I }, { 0x18 MSO_I, 0x16 MSO_I }, // ccp
|
|
{ 7 MSO_I, 0x16 MSO_I }, // p
|
|
{ 0x1a MSO_I, 0x16 MSO_I }, { 0x1c MSO_I, 0x12 MSO_I }, { 0x1c MSO_I, 0x10 MSO_I }, // ccp
|
|
{ 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
|
|
{ 0x24 MSO_I, 0xc MSO_I }, { 0x24 MSO_I, 0x10 MSO_I }, // pp
|
|
{ 0x24 MSO_I, 0x26 MSO_I }, { 0x28 MSO_I, 0x2a MSO_I }, { 7 MSO_I, 0x2a MSO_I }, // ccp
|
|
{ 0x18 MSO_I, 0x2a MSO_I }, // p
|
|
{ 0x2c MSO_I, 0x2a MSO_I }, { 0xa MSO_I, 0x26 MSO_I }, { 0xa MSO_I, 0x10 MSO_I } // ccp
|
|
};
|
|
const sal_uInt16 mso_sptActionButtonReturnSegm[] =
|
|
{
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0002, 0x2001, 0x0001, 0x2001, 0x0006,0x2001, 0x0001, 0x2001, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptActionButtonReturnCalc[] = // adj value 0 - 5400
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x6000, { DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x6000, { DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 } },
|
|
{ 0xa000, { DFF_Prop_geoRight, 0, DFF_Prop_adjustValue } },
|
|
{ 0xa000, { DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue } },
|
|
{ 0x8000, { 10800, 0, DFF_Prop_adjustValue } },
|
|
{ 0x2001, { 0x0405, 1, 10800 } }, // scaling 6
|
|
{ 0x2001, { DFF_Prop_geoRight, 1, 2 } }, // lr center 7
|
|
{ 0x2001, { DFF_Prop_geoBottom, 1, 2 } }, // ul center 8
|
|
|
|
{ 0x4001, { -8050, 0x0406, 1 } }, // 9
|
|
{ 0x6000, { 0x0409, 0x0407, 0 } }, // a
|
|
{ 0x4001, { -3800, 0x0406, 1 } }, // b
|
|
{ 0x6000, { 0x040b, 0x0408, 0 } }, // c
|
|
{ 0x4001, { -4020, 0x0406, 1 } }, // d
|
|
{ 0x6000, { 0x040d, 0x0407, 0 } }, // e
|
|
{ 0x4001, { 2330, 0x0406, 1 } }, // f
|
|
{ 0x6000, { 0x040f, 0x0408, 0 } }, // 10
|
|
{ 0x4001, { 3390, 0x0406, 1 } }, // 11
|
|
{ 0x6000, { 0x0411, 0x0408, 0 } }, // 12
|
|
{ 0x4001, { -3100, 0x0406, 1 } }, // 13
|
|
{ 0x6000, { 0x0413, 0x0407, 0 } }, // 14
|
|
{ 0x4001, { 4230, 0x0406, 1 } }, // 15
|
|
{ 0x6000, { 0x0415, 0x0408, 0 } }, // 16
|
|
{ 0x4001, { -1910, 0x0406, 1 } }, // 17
|
|
{ 0x6000, { 0x0417, 0x0407, 0 } }, // 18
|
|
{ 0x4001, { 1190, 0x0406, 1 } }, // 19
|
|
{ 0x6000, { 0x0419, 0x0407, 0 } }, // 1a
|
|
{ 0x4001, { 2110, 0x0406, 1 } }, // 1b
|
|
{ 0x6000, { 0x041b, 0x0407, 0 } }, // 1c
|
|
{ 0x4001, { 4030, 0x0406, 1 } }, // 1d
|
|
{ 0x6000, { 0x041d, 0x0407, 0 } }, // 1e
|
|
{ 0x4001, { -7830, 0x0406, 1 } }, // 1f
|
|
{ 0x6000, { 0x041f, 0x0408, 0 } }, // 20
|
|
{ 0x4001, { 8250, 0x0406, 1 } }, // 21
|
|
{ 0x6000, { 0x0421, 0x0407, 0 } }, // 22
|
|
{ 0x4001, { 6140, 0x0406, 1 } }, // 23
|
|
{ 0x6000, { 0x0423, 0x0407, 0 } }, // 24
|
|
{ 0x4001, { 5510, 0x0406, 1 } }, // 25
|
|
{ 0x6000, { 0x0425, 0x0408, 0 } }, // 26
|
|
{ 0x4001, { 3180, 0x0406, 1 } }, // 27
|
|
{ 0x6000, { 0x0427, 0x0407, 0 } }, // 28
|
|
{ 0x4001, { 8450, 0x0406, 1 } }, // 29
|
|
{ 0x6000, { 0x0429, 0x0408, 0 } }, // 2a
|
|
{ 0x4001, { -5090, 0x0406, 1 } }, // 2b
|
|
{ 0x6000, { 0x042b, 0x0407, 0 } } // 2c
|
|
};
|
|
const mso_CustomShape msoActionButtonReturn =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptActionButtonReturnVert),
|
|
const_cast<sal_uInt16*>(mso_sptActionButtonReturnSegm), sizeof( mso_sptActionButtonReturnSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptActionButtonReturnCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault1400),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptActionButtonTextRect),
|
|
21600, 21600,
|
|
10800, 10800,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptButtonHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptActionButtonDocumentVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
|
|
{ 0, 0 }, { 21600, 0 }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
|
|
{ 21600, 0 }, { 21600, 21600 }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 2 MSO_I },
|
|
{ 21600, 21600 }, { 0, 21600 }, { 1 MSO_I, 4 MSO_I }, { 3 MSO_I, 4 MSO_I },
|
|
{ 0, 21600 }, { 0, 0 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 4 MSO_I },
|
|
|
|
{ 0xa MSO_I, 0xc MSO_I }, { 0xe MSO_I, 0xc MSO_I }, { 0x10 MSO_I, 0x12 MSO_I }, { 0x10 MSO_I, 0x14 MSO_I },
|
|
{ 0xa MSO_I, 0x14 MSO_I }, { 0xe MSO_I, 0xc MSO_I }, { 0x10 MSO_I, 0x12 MSO_I }, { 0xe MSO_I, 0x12 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptActionButtonDocumentSegm[] =
|
|
{
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
|
|
0x4000, 0x0004, 0x6001, 0x8000,
|
|
0x4000, 0x0002, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptActionButtonDocumentCalc[] = // adj value 0 - 5400
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x6000, { DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x6000, { DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 } },
|
|
{ 0xa000, { DFF_Prop_geoRight, 0, DFF_Prop_adjustValue } },
|
|
{ 0xa000, { DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue } },
|
|
{ 0x8000, { 10800, 0, DFF_Prop_adjustValue } },
|
|
{ 0x2001, { 0x0405, 1, 10800 } }, // scaling 6
|
|
{ 0x2001, { DFF_Prop_geoRight, 1, 2 } }, // lr center 7
|
|
{ 0x2001, { DFF_Prop_geoBottom, 1, 2 } }, // ul center 8
|
|
|
|
{ 0x4001, { -6350, 0x0406, 1 } }, // 9
|
|
{ 0x6000, { 0x0409, 0x0407, 0 } }, // a
|
|
{ 0x4001, { -7830, 0x0406, 1 } }, // b
|
|
{ 0x6000, { 0x040b, 0x0408, 0 } }, // c
|
|
{ 0x4001, { 1690, 0x0406, 1 } }, // d
|
|
{ 0x6000, { 0x040d, 0x0407, 0 } }, // e
|
|
{ 0x4001, { 6350, 0x0406, 1 } }, // f
|
|
{ 0x6000, { 0x040f, 0x0407, 0 } }, // 10
|
|
{ 0x4001, { -3810, 0x0406, 1 } }, // 11
|
|
{ 0x6000, { 0x0411, 0x0408, 0 } }, // 12
|
|
{ 0x4001, { 7830, 0x0406, 1 } }, // 13
|
|
{ 0x6000, { 0x0413, 0x0408, 0 } } // 14
|
|
};
|
|
const mso_CustomShape msoActionButtonDocument =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptActionButtonDocumentVert),
|
|
const_cast<sal_uInt16*>(mso_sptActionButtonDocumentSegm), sizeof( mso_sptActionButtonDocumentSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptActionButtonDocumentCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault1400),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptActionButtonTextRect),
|
|
21600, 21600,
|
|
10800, 10800,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptButtonHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptActionButtonSoundVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
|
|
{ 0, 0 }, { 21600, 0 }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
|
|
{ 21600, 0 }, { 21600, 21600 }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 2 MSO_I },
|
|
{ 21600, 21600 }, { 0, 21600 }, { 1 MSO_I, 4 MSO_I }, { 3 MSO_I, 4 MSO_I },
|
|
{ 0, 21600 }, { 0, 0 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 4 MSO_I },
|
|
|
|
{ 0xa MSO_I, 0xc MSO_I }, { 0xe MSO_I, 0xc MSO_I }, { 0x10 MSO_I, 0x12 MSO_I }, { 0x10 MSO_I, 0x14 MSO_I },
|
|
{ 0xe MSO_I, 0x16 MSO_I }, { 0xa MSO_I, 0x16 MSO_I }, { 0x18 MSO_I, 8 MSO_I }, { 0x1a MSO_I, 8 MSO_I },
|
|
|
|
{ 0x18 MSO_I, 0xc MSO_I }, { 0x1a MSO_I, 0x1c MSO_I },
|
|
|
|
{ 0x18 MSO_I, 0x16 MSO_I }, { 0x1a MSO_I, 0x1e MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptActionButtonSoundSegm[] =
|
|
{
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
|
|
0x4000, 0x0005, 0x6001, 0x8000,
|
|
0x4000, 0x0001, 0x8000,
|
|
0x4000, 0x0001, 0x8000,
|
|
0x4000, 0x0001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptActionButtonSoundCalc[] = // adj value 0 - 5400
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x6000, { DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x6000, { DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 } },
|
|
{ 0xa000, { DFF_Prop_geoRight, 0, DFF_Prop_adjustValue } },
|
|
{ 0xa000, { DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue } },
|
|
{ 0x8000, { 10800, 0, DFF_Prop_adjustValue } },
|
|
{ 0x2001, { 0x0405, 1, 10800 } }, // scaling 6
|
|
{ 0x2001, { DFF_Prop_geoRight, 1, 2 } }, // lr center 7
|
|
{ 0x2001, { DFF_Prop_geoBottom, 1, 2 } }, // ul center 8
|
|
|
|
{ 0x4001, { -8050, 0x0406, 1 } }, // 9
|
|
{ 0x6000, { 0x0409, 0x0407, 0 } }, // a
|
|
{ 0x4001, { -2750, 0x0406, 1 } }, // b
|
|
{ 0x6000, { 0x040b, 0x0408, 0 } }, // c
|
|
{ 0x4001, { -2960, 0x0406, 1 } }, // d
|
|
{ 0x6000, { 0x040d, 0x0407, 0 } }, // e
|
|
{ 0x4001, { 2120, 0x0406, 1 } }, // f
|
|
{ 0x6000, { 0x040f, 0x0407, 0 } }, // 10
|
|
{ 0x4001, { -8050, 0x0406, 1 } }, // 11
|
|
{ 0x6000, { 0x0411, 0x0408, 0 } }, // 12
|
|
{ 0x4001, { 8050, 0x0406, 1 } }, // 13
|
|
{ 0x6000, { 0x0413, 0x0408, 0 } }, // 14
|
|
{ 0x4001, { 2750, 0x0406, 1 } }, // 15
|
|
{ 0x6000, { 0x0415, 0x0408, 0 } }, // 16
|
|
{ 0x4001, { 4020, 0x0406, 1 } }, // 17
|
|
{ 0x6000, { 0x0417, 0x0407, 0 } }, // 18
|
|
{ 0x4001, { 8050, 0x0406, 1 } }, // 19
|
|
{ 0x6000, { 0x0419, 0x0407, 0 } }, // 1a
|
|
{ 0x4001, { -5930, 0x0406, 1 } }, // 1b
|
|
{ 0x6000, { 0x041b, 0x0408, 0 } }, // 1c
|
|
{ 0x4001, { 5930, 0x0406, 1 } }, // 1d
|
|
{ 0x6000, { 0x041d, 0x0408, 0 } } // 1e
|
|
};
|
|
const mso_CustomShape msoActionButtonSound =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptActionButtonSoundVert),
|
|
const_cast<sal_uInt16*>(mso_sptActionButtonSoundSegm), sizeof( mso_sptActionButtonSoundSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptActionButtonSoundCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault1400),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptActionButtonTextRect),
|
|
21600, 21600,
|
|
10800, 10800,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptButtonHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptActionButtonMovieVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
|
|
{ 0, 0 }, { 21600, 0 }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
|
|
{ 21600, 0 }, { 21600, 21600 }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 2 MSO_I },
|
|
{ 21600, 21600 }, { 0, 21600 }, { 1 MSO_I, 4 MSO_I }, { 3 MSO_I, 4 MSO_I },
|
|
{ 0, 21600 }, { 0, 0 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 4 MSO_I },
|
|
|
|
{ 0xa MSO_I, 0xc MSO_I }, { 0xe MSO_I, 0xc MSO_I }, { 0x10 MSO_I, 0x12 MSO_I }, { 0x14 MSO_I, 0x12 MSO_I },
|
|
{ 0x16 MSO_I, 0x18 MSO_I }, { 0x16 MSO_I, 0x1a MSO_I }, { 0x1c MSO_I, 0x1a MSO_I }, { 0x1e MSO_I, 0x18 MSO_I },
|
|
{ 0x20 MSO_I, 0x18 MSO_I }, { 0x20 MSO_I, 0x22 MSO_I }, { 0x1e MSO_I, 0x22 MSO_I }, { 0x1c MSO_I, 0x24 MSO_I },
|
|
{ 0x16 MSO_I, 0x24 MSO_I }, { 0x16 MSO_I, 0x26 MSO_I }, { 0x2a MSO_I, 0x26 MSO_I }, { 0x2a MSO_I, 0x28 MSO_I },
|
|
{ 0x10 MSO_I, 0x28 MSO_I }, { 0xe MSO_I, 0x2c MSO_I }, { 0xa MSO_I, 0x2c MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptActionButtonMovieSegm[] =
|
|
{
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0003, 0x6001, 0x8000,
|
|
0x4000, 0x0012, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptActionButtonMovieCalc[] = // adj value 0 - 5400
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x6000, { DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x6000, { DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 } },
|
|
{ 0xa000, { DFF_Prop_geoRight, 0, DFF_Prop_adjustValue } },
|
|
{ 0xa000, { DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue } },
|
|
{ 0x8000, { 10800, 0, DFF_Prop_adjustValue } },
|
|
{ 0x2001, { 0x0405, 1, 10800 } }, // scaling 6
|
|
{ 0x2001, { DFF_Prop_geoRight, 1, 2 } }, // lr center 7
|
|
{ 0x2001, { DFF_Prop_geoBottom, 1, 2 } }, // ul center 8
|
|
|
|
{ 0x4001, { -8050, 0x0406, 1 } }, // 9
|
|
{ 0x6000, { 0x0409, 0x0407, 0 } }, // a
|
|
{ 0x4001, { -4020, 0x0406, 1 } }, // b
|
|
{ 0x6000, { 0x040b, 0x0408, 0 } }, // c
|
|
{ 0x4001, { -7000, 0x0406, 1 } }, // d
|
|
{ 0x6000, { 0x040d, 0x0407, 0 } }, // e
|
|
{ 0x4001, { -6560, 0x0406, 1 } }, // f
|
|
{ 0x6000, { 0x040f, 0x0407, 0 } }, // 10
|
|
{ 0x4001, { -3600, 0x0406, 1 } }, // 11
|
|
{ 0x6000, { 0x0411, 0x0408, 0 } }, // 12
|
|
{ 0x4001, { 4020, 0x0406, 1 } }, // 13
|
|
{ 0x6000, { 0x0413, 0x0407, 0 } }, // 14
|
|
{ 0x4001, { 4660, 0x0406, 1 } }, // 15
|
|
{ 0x6000, { 0x0415, 0x0407, 0 } }, // 16
|
|
{ 0x4001, { -2960, 0x0406, 1 } }, // 17
|
|
{ 0x6000, { 0x0417, 0x0408, 0 } }, // 18
|
|
{ 0x4001, { -2330, 0x0406, 1 } }, // 19
|
|
{ 0x6000, { 0x0419, 0x0408, 0 } }, // 1a
|
|
{ 0x4001, { 6780, 0x0406, 1 } }, // 1b
|
|
{ 0x6000, { 0x041b, 0x0407, 0 } }, // 1c
|
|
{ 0x4001, { 7200, 0x0406, 1 } }, // 1d
|
|
{ 0x6000, { 0x041d, 0x0407, 0 } }, // 1e
|
|
{ 0x4001, { 8050, 0x0406, 1 } }, // 1f
|
|
{ 0x6000, { 0x041f, 0x0407, 0 } }, // 20
|
|
{ 0x4001, { 2960, 0x0406, 1 } }, // 21
|
|
{ 0x6000, { 0x0421, 0x0408, 0 } }, // 22
|
|
{ 0x4001, { 2330, 0x0406, 1 } }, // 23
|
|
{ 0x6000, { 0x0423, 0x0408, 0 } }, // 24
|
|
{ 0x4001, { 3800, 0x0406, 1 } }, // 25
|
|
{ 0x6000, { 0x0425, 0x0408, 0 } }, // 26
|
|
{ 0x4001, { -1060, 0x0406, 1 } }, // 27
|
|
{ 0x6000, { 0x0427, 0x0408, 0 } }, // 28
|
|
{ 0x4001, { -6350, 0x0406, 1 } }, // 29
|
|
{ 0x6000, { 0x0429, 0x0407, 0 } }, // 2a
|
|
{ 0x4001, { -640, 0x0406, 1 } }, // 2b
|
|
{ 0x6000, { 0x042b, 0x0408, 0 } } // 2c
|
|
};
|
|
const mso_CustomShape msoActionButtonMovie =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptActionButtonMovieVert),
|
|
const_cast<sal_uInt16*>(mso_sptActionButtonMovieSegm), sizeof( mso_sptActionButtonMovieSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptActionButtonMovieCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault1400),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptActionButtonTextRect),
|
|
21600, 21600,
|
|
10800, 10800,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptButtonHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptSmileyFaceVert[] = // adj value 15510 - 17520
|
|
{
|
|
{ 10800, 10800 }, { 10800, 10800 }, { 0, 360 },
|
|
{ 7305, 7515 }, { 1000, 1865 }, { 0, 360 },
|
|
{ 14295, 7515 }, { 1000, 1865 }, { 0, 360 },
|
|
{ 4870, 1 MSO_I }, { 8680, 2 MSO_I }, { 12920, 2 MSO_I }, { 16730, 1 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptSmileyFaceSegm[] =
|
|
{
|
|
0xa203, 0x6000, 0x8000,
|
|
0xa203, 0x6000, 0x8000,
|
|
0xa203, 0x6000, 0x8000,
|
|
0x4000, 0x2001, 0xaa00, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptSmileyFaceCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 14510 } },
|
|
{ 0x8000, { 18520, 0, 0x400 } },
|
|
{ 0x4000, { 14510, 0x400, 0 } }
|
|
};
|
|
|
|
const sal_Int32 mso_sptSmileyFaceDefault[] =
|
|
{
|
|
1, 18520
|
|
};
|
|
const SvxMSDffHandle mso_sptSmileyHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
10800, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 14510, 18520 }
|
|
};
|
|
const mso_CustomShape msoSmileyFace =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptSmileyFaceVert),
|
|
const_cast<sal_uInt16*>(mso_sptSmileyFaceSegm), sizeof( mso_sptSmileyFaceSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptSmileyFaceCalc),
|
|
const_cast<sal_Int32*>(mso_sptSmileyFaceDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptEllipseTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptEllipseGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptSmileyHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptDonutVert[] = // adj value 0 - 10800
|
|
{
|
|
{ 10800, 10800 }, { 10800, 10800 }, { 0, 360 },
|
|
{ 10800, 10800 }, { 1 MSO_I, 1 MSO_I }, { 0, 360 }
|
|
};
|
|
const sal_uInt16 mso_sptDonutSegm[] =
|
|
{
|
|
0xa203, 0x6000, 0xa203, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptDonutCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x8000, { 10800, 0, DFF_Prop_adjustValue } }
|
|
};
|
|
const SvxMSDffHandle mso_sptDonutHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0x100, 10800, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoDonut =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptDonutVert),
|
|
const_cast<sal_uInt16*>(mso_sptDonutSegm), sizeof( mso_sptDonutSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptDonutCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault5400),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptEllipseTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptEllipseGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptDonutHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptNoSmokingVert[] = // adj value 0 - 7200
|
|
{
|
|
{ 10800, 10800 }, { 10800, 10800 }, { 0, 360 },
|
|
{ 0 MSO_I, 0 MSO_I }, { 1 MSO_I, 1 MSO_I },
|
|
{ 9 MSO_I, 0xa MSO_I }, { 0xb MSO_I, 0xc MSO_I }, { 0 MSO_I, 0 MSO_I }, { 1 MSO_I, 1 MSO_I },
|
|
{ 0xd MSO_I, 0xe MSO_I }, { 0xf MSO_I, 0x10 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptNoSmokingSegm[] =
|
|
{
|
|
0xa203, 0x6000, 0xa404, 0x6000, 0xa404, 0x6000, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptNoSmokingCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, // 0
|
|
{ 0x8000, { 21600, 0, DFF_Prop_adjustValue } }, // 1
|
|
{ 0x8000, { 10800, 0, DFF_Prop_adjustValue } }, // 2
|
|
{ 0x2001, { DFF_Prop_adjustValue, 1, 2 } }, // 3
|
|
{ 0xa080, { 0x403, 0, 0x402 } }, // 4
|
|
{ 0x8000, { 10800, 0, 0x403 } }, // 5 x1
|
|
{ 0x4000, { 10800, 0x403, 0 } }, // 6 x2
|
|
{ 0x8000, { 10800, 0, 0x404 } }, // 7 y1
|
|
{ 0x4000, { 10800, 0x404, 0 } }, // 8 y2
|
|
{ 0x6081, { 0x405, 0x407, 45 } }, // 9
|
|
{ 0x6082, { 0x405, 0x407, 45 } }, // a
|
|
{ 0x6081, { 0x405, 0x408, 45 } }, // b
|
|
{ 0x6082, { 0x405, 0x408, 45 } }, // c
|
|
{ 0x6081, { 0x406, 0x408, 45 } }, // d
|
|
{ 0x6082, { 0x406, 0x408, 45 } }, // e
|
|
{ 0x6081, { 0x406, 0x407, 45 } }, // f
|
|
{ 0x6082, { 0x406, 0x407, 45 } } // 10
|
|
};
|
|
const SvxMSDffHandle mso_sptNoSmokingHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0x100, 10800, 10800, 10800, 0, 7200, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoNoSmoking =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptNoSmokingVert),
|
|
const_cast<sal_uInt16*>(mso_sptNoSmokingSegm), sizeof( mso_sptNoSmokingSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptNoSmokingCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault2700),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptEllipseTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptEllipseGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptNoSmokingHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptBlockArcVert[] = // adj value 0 (degrees)
|
|
{ // adj value 1: 0 -> 10800;
|
|
{ 0, 0 }, { 21600, 21600 }, { 4 MSO_I, 3 MSO_I }, { 2 MSO_I, 3 MSO_I },
|
|
{ 5 MSO_I, 5 MSO_I }, { 6 MSO_I, 6 MSO_I }, { 2 MSO_I, 3 MSO_I }, { 4 MSO_I, 3 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptBlockArcSegm[] =
|
|
{
|
|
0xA404, 0xa504, 0x6001, 0x8000
|
|
};
|
|
const sal_Int32 mso_sptBlockArcDefault[] =
|
|
{
|
|
2, 180, 5400
|
|
};
|
|
const SvxMSDffCalculationData mso_sptBlockArcCalc[] =
|
|
{
|
|
{ 0x400a, { 10800, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x4009, { 10800, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x2000, { 0x400, 10800, 0 } },
|
|
{ 0x2000, { 0x401, 10800, 0 } },
|
|
{ 0x8000, { 21600, 0, 0x402 } },
|
|
{ 0x8000, { 10800, 0, DFF_Prop_adjust2Value } },
|
|
{ 0x4000, { 10800, DFF_Prop_adjust2Value, 0 } },
|
|
{ 0x600a, { 0x405, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x6009, { 0x405, DFF_Prop_adjustValue, 0 } }
|
|
};
|
|
const SvxMSDffHandle mso_sptBlockArcHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::POLAR | SvxMSDffHandleFlags::RADIUS_RANGE,
|
|
0x101, 0x100, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoBlockArc =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptBlockArcVert),
|
|
const_cast<sal_uInt16*>(mso_sptBlockArcSegm), sizeof( mso_sptBlockArcSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptBlockArcCalc),
|
|
const_cast<sal_Int32*>(mso_sptBlockArcDefault),
|
|
std::span<const SvxMSDffTextRectangles>(),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptBlockArcHandle),
|
|
};
|
|
|
|
// aware : control points are always part of the bounding box
|
|
const SvxMSDffVertPair mso_sptHeartVert[] =
|
|
{
|
|
{ 10800, 21599 }, { 321, 6886 }, { 70, 6036 }, // ppp
|
|
{ -9, 5766 }, { -1, 5474 }, { 2, 5192 }, // ccp
|
|
{ 6, 4918 }, { 43, 4641 }, { 101, 4370 }, // ccp
|
|
{ 159, 4103 }, { 245, 3837 }, { 353, 3582 }, // ccp
|
|
{ 460, 3326 }, { 591, 3077 }, { 741, 2839 }, // ccp
|
|
{ 892, 2598 }, { 1066, 2369 }, { 1253, 2155 }, // ccp
|
|
{ 1443, 1938 }, { 1651, 1732 }, { 1874, 1543 }, // ccp
|
|
{ 2097, 1351 }, { 2337, 1174 }, { 2587, 1014 }, // ccp
|
|
{ 2839, 854 }, { 3106, 708 }, { 3380, 584 }, // ccp
|
|
{ 3656, 459 }, { 3945, 350 }, { 4237, 264 }, // ccp
|
|
{ 4533, 176 }, { 4838, 108 }, { 5144, 66 }, // ccp
|
|
{ 5454, 22 }, { 5771, 1 }, { 6086, 3 }, // ccp
|
|
{ 6407, 7 }, { 6731, 35 }, { 7048, 89 }, // ccp
|
|
{ 7374, 144 }, { 7700, 226 }, { 8015, 335 }, // ccp
|
|
{ 8344, 447 }, { 8667, 590 }, { 8972, 756 }, // ccp
|
|
{ 9297, 932 }, { 9613, 1135 }, { 9907, 1363 }, // ccp
|
|
{ 10224, 1609 }, { 10504, 1900 }, { 10802, 2169 }, // ccp
|
|
{ 11697, 1363 }, // p
|
|
{ 11971, 1116 }, { 12304, 934 }, { 12630, 756 }, // ccp
|
|
{ 12935, 590 }, { 13528, 450 }, { 13589, 335 }, // ccp
|
|
{ 13901, 226 }, { 14227, 144 }, { 14556, 89 }, // ccp
|
|
{ 14872, 35 }, { 15195, 7 }, { 15517, 3 }, // ccp
|
|
{ 15830, 0 }, { 16147, 22 }, { 16458, 66 }, // ccp
|
|
{ 16764, 109 }, { 17068, 177 }, { 17365, 264 }, // ccp
|
|
{ 17658, 349 }, { 17946, 458 }, { 18222, 584 }, // ccp
|
|
{ 18496, 708 }, { 18762, 854 }, { 19015, 1014 }, // ccp
|
|
{ 19264, 1172 }, { 19504, 1349 }, { 19730, 1543 }, // ccp
|
|
{ 19950, 1731 }, { 20158, 1937 }, { 20350, 2155 }, // ccp
|
|
{ 20536, 2369 }, { 20710, 2598 }, { 20861, 2839 }, // ccp
|
|
{ 21010, 3074 }, { 21143, 3323 }, { 21251, 3582 }, // ccp
|
|
{ 21357, 3835 }, { 21443, 4099 }, { 21502, 4370 }, // ccp
|
|
{ 21561, 4639 }, { 21595, 4916 }, { 21600, 5192 }, // ccp
|
|
{ 21606, 5474 }, { 21584, 5760 }, { 21532, 6036 }, // ccp
|
|
{ 21478, 6326 }, { 21366, 6603 }, { 21282, 6887 }, // ccp
|
|
{ 10802, 21602 } // p
|
|
};
|
|
const sal_uInt16 mso_sptHeartSegm[] =
|
|
{
|
|
0x4000, 0x0002, 0x2010, 0x0001, 0x2010, 0x0001, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptHeartTextRect[] =
|
|
{
|
|
{ { 5080, 2540 }, { 16520, 13550 } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptHeartGluePoints[] =
|
|
{
|
|
{ 10800, 2180 }, { 3090, 10800 }, { 10800, 21600 }, { 18490, 10800 }
|
|
};
|
|
const mso_CustomShape msoHeart =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptHeartVert),
|
|
const_cast<sal_uInt16*>(mso_sptHeartSegm), sizeof( mso_sptHeartSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptHeartTextRect),
|
|
21615, 21602,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptHeartGluePoints),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptLightningBoldVert[] =
|
|
{
|
|
{ 8458, 0 }, { 0, 3923 }, { 7564, 8416 }, { 4993, 9720 },
|
|
{ 12197, 13904 }, { 9987, 14934 }, { 21600, 21600 }, { 14768, 12911 },
|
|
{ 16558, 12016 }, { 11030, 6840 }, { 12831, 6120 }, { 8458, 0 }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptLightningBoldTextRect[] =
|
|
{
|
|
{ { 8680, 7410 }, { 13970, 14190 } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptLightningBoldGluePoints[] =
|
|
{
|
|
{ 8458, 0 }, { 0, 3923 }, { 4993, 9720 }, { 9987, 14934 }, { 21600, 21600 },
|
|
{ 16558, 12016 }, { 12831, 6120 }
|
|
};
|
|
const mso_CustomShape msoLightningBold =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptLightningBoldVert),
|
|
nullptr, 0,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptLightningBoldTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptLightningBoldGluePoints),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptSunVert[] = // adj value 2700 -> 10125
|
|
{
|
|
{ 0, 10800 }, { 4 MSO_I, 8 MSO_I }, { 4 MSO_I, 9 MSO_I },
|
|
{ 0x0a MSO_I, 0x0b MSO_I }, { 0x0c MSO_I, 0x0d MSO_I }, { 0x0e MSO_I, 0x0f MSO_I },
|
|
{ 0x10 MSO_I, 0x11 MSO_I }, { 0x12 MSO_I, 0x13 MSO_I }, { 0x14 MSO_I, 0x15 MSO_I },
|
|
{ 0x16 MSO_I, 0x17 MSO_I }, { 0x18 MSO_I, 0x19 MSO_I }, { 0x1a MSO_I, 0x1b MSO_I },
|
|
{ 0x1c MSO_I, 0x1d MSO_I }, { 0x1e MSO_I, 0x1f MSO_I }, { 0x20 MSO_I, 0x21 MSO_I },
|
|
{ 0x22 MSO_I, 0x23 MSO_I }, { 0x24 MSO_I, 0x25 MSO_I }, { 0x26 MSO_I, 0x27 MSO_I },
|
|
{ 0x28 MSO_I, 0x29 MSO_I }, { 0x2a MSO_I, 0x2b MSO_I }, { 0x2c MSO_I, 0x2d MSO_I },
|
|
{ 0x2e MSO_I, 0x2f MSO_I }, { 0x30 MSO_I, 0x31 MSO_I }, { 0x32 MSO_I, 0x33 MSO_I },
|
|
{ 10800, 10800 }, { 0x36 MSO_I, 0x36 MSO_I }, { 0, 360 }
|
|
};
|
|
const sal_uInt16 mso_sptSunSegm[] =
|
|
{
|
|
0x4000, 0x0002, 0x6001, 0x8000,
|
|
0x4000, 0x0002, 0x6001, 0x8000,
|
|
0x4000, 0x0002, 0x6001, 0x8000,
|
|
0x4000, 0x0002, 0x6001, 0x8000,
|
|
0x4000, 0x0002, 0x6001, 0x8000,
|
|
0x4000, 0x0002, 0x6001, 0x8000,
|
|
0x4000, 0x0002, 0x6001, 0x8000,
|
|
0x4000, 0x0002, 0x6001, 0x8000,
|
|
0xa203, 0x6000, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptSunCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x8000, { 21600, 0, DFF_Prop_adjustValue } },
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 2700 } },
|
|
{ 0x2001, { 0x402, 5080, 7425 } },
|
|
{ 0x2000, { 0x403, 2540, 0 } },
|
|
{ 0x8000, { 10125, 0, DFF_Prop_adjustValue } },
|
|
{ 0x2001, { 0x405, 2120, 7425 } },
|
|
{ 0x2000, { 0x406, 210, 0 } },
|
|
{ 0x4000, { 10800, 0x407, 0 } }, // y1 (0x8)
|
|
{ 0x8000, { 10800, 0, 0x407 } }, // y2 (0x9)
|
|
{ 0x0081, { 0, 10800, 45 } }, // 0xa
|
|
{ 0x0082, { 0, 10800, 45 } }, // 0xb
|
|
{ 0x6081, { 0x404, 0x408, 45 } }, // 0xc
|
|
{ 0x6082, { 0x404, 0x408, 45 } }, // 0xd
|
|
{ 0x6081, { 0x404, 0x409, 45 } }, // 0xe
|
|
{ 0x6082, { 0x404, 0x409, 45 } }, // 0xf
|
|
{ 0x0081, { 0, 10800, 90 } }, // 0x10
|
|
{ 0x0082, { 0, 10800, 90 } }, // 0x11
|
|
{ 0x6081, { 0x404, 0x408, 90 } }, // 0x12
|
|
{ 0x6082, { 0x404, 0x408, 90 } }, // 0x13
|
|
{ 0x6081, { 0x404, 0x409, 90 } }, // 0x14
|
|
{ 0x6082, { 0x404, 0x409, 90 } }, // 0x15
|
|
{ 0x0081, { 0, 10800, 135 } }, // 0x16
|
|
{ 0x0082, { 0, 10800, 135 } }, // 0x17
|
|
{ 0x6081, { 0x404, 0x408, 135 } }, // 0x18
|
|
{ 0x6082, { 0x404, 0x408, 135 } }, // 0x19
|
|
{ 0x6081, { 0x404, 0x409, 135 } }, // 0x1a
|
|
{ 0x6082, { 0x404, 0x409, 135 } }, // 0x1b
|
|
{ 0x0081, { 0, 10800, 180 } }, // 0x1c
|
|
{ 0x0082, { 0, 10800, 180 } }, // 0x1d
|
|
{ 0x6081, { 0x404, 0x408, 180 } }, // 0x1e
|
|
{ 0x6082, { 0x404, 0x408, 180 } }, // 0x1f
|
|
{ 0x6081, { 0x404, 0x409, 180 } }, // 0x20
|
|
{ 0x6082, { 0x404, 0x409, 180 } }, // 0x21
|
|
{ 0x0081, { 0, 10800, 225 } }, // 0x22
|
|
{ 0x0082, { 0, 10800, 225 } }, // 0x23
|
|
{ 0x6081, { 0x404, 0x408, 225 } }, // 0x24
|
|
{ 0x6082, { 0x404, 0x408, 225 } }, // 0x25
|
|
{ 0x6081, { 0x404, 0x409, 225 } }, // 0x26
|
|
{ 0x6082, { 0x404, 0x409, 225 } }, // 0x27
|
|
{ 0x0081, { 0, 10800, 270 } }, // 0x28
|
|
{ 0x0082, { 0, 10800, 270 } }, // 0x29
|
|
{ 0x6081, { 0x404, 0x408, 270 } }, // 0x2a
|
|
{ 0x6082, { 0x404, 0x408, 270 } }, // 0x2b
|
|
{ 0x6081, { 0x404, 0x409, 270 } }, // 0x2c
|
|
{ 0x6082, { 0x404, 0x409, 270 } }, // 0x2d
|
|
{ 0x0081, { 0, 10800, 315 } }, // 0x2e
|
|
{ 0x0082, { 0, 10800, 315 } }, // 0x2f
|
|
{ 0x6081, { 0x404, 0x408, 315 } }, // 0x30
|
|
{ 0x6082, { 0x404, 0x408, 315 } }, // 0x31
|
|
{ 0x6081, { 0x404, 0x409, 315 } }, // 0x32
|
|
{ 0x6082, { 0x404, 0x409, 315 } }, // 0x33
|
|
{ 0x2081, { DFF_Prop_adjustValue, 10800, 45 } }, // 0x34 ( textbox )
|
|
{ 0x2081, { DFF_Prop_adjustValue, 10800, 225 } }, // 0x35
|
|
{ 0x8000, { 10800, 0, DFF_Prop_adjustValue } }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptSunTextRect[] =
|
|
{
|
|
{ { 0x34 MSO_I, 0x34 MSO_I }, { 0x35 MSO_I, 0x35 MSO_I } }
|
|
};
|
|
const SvxMSDffHandle mso_sptSunHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0x100, 10800, 10800, 10800, 2700, 10125, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoSun =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptSunVert),
|
|
const_cast<sal_uInt16*>(mso_sptSunSegm), sizeof( mso_sptSunSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptSunCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault5400),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptSunTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptStandardGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptSunHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptMoonVert[] = // adj value 0 -> 18900
|
|
{
|
|
{ 21600, 0 },
|
|
{ 3 MSO_I, 4 MSO_I }, { 0 MSO_I, 5080 }, { 0 MSO_I, 10800 }, // ccp
|
|
{ 0 MSO_I, 16520 }, { 3 MSO_I, 5 MSO_I }, { 21600, 21600 }, // ccp
|
|
{ 9740, 21600 }, { 0, 16730 }, { 0, 10800 }, // ccp
|
|
{ 0, 4870 }, { 9740, 0 }, { 21600, 0 } // ccp
|
|
};
|
|
const sal_uInt16 mso_sptMoonSegm[] =
|
|
{
|
|
0x4000, 0x2004, 0x6000, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptMoonCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x8000, { 21600, 0, DFF_Prop_adjustValue } },
|
|
{ 0x2001, { 0x401, 1, 2 } },
|
|
{ 0x6000, { 0x402, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x2001, { DFF_Prop_adjustValue, 1794, 10000 } },
|
|
{ 0x8000, { 21600, 0, 0x0404 } },
|
|
{ 0x2001, { DFF_Prop_adjustValue, 400, 18900 } },
|
|
{ 0x8081, { 0, 10800, 0x406 } },
|
|
{ 0x8082, { 0, 10800, 0x406 } },
|
|
{ 0x6000, { 0x407, 0x407, 0 } },
|
|
{ 0x8000, { 21600, 0, 0x408 } }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptMoonTextRect[] =
|
|
{
|
|
{ { 9 MSO_I, 8 MSO_I }, { 0 MSO_I, 0xa MSO_I } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptMoonGluePoints[] =
|
|
{
|
|
{ 21600, 0 }, { 0, 10800 }, { 21600, 21600 }, { 0 MSO_I, 10800 }
|
|
};
|
|
const SvxMSDffHandle mso_sptMoonHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0x100, 10800, 10800, 10800, 0, 18900, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoMoon =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptMoonVert),
|
|
const_cast<sal_uInt16*>(mso_sptMoonSegm), sizeof( mso_sptMoonSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptMoonCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault10800),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptMoonTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptMoonGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptMoonHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptBracketPairVert[] = // adj value 0 -> 10800
|
|
{
|
|
{ 0 MSO_I, 0 }, { 0, 1 MSO_I }, // left top alignment
|
|
{ 0, 2 MSO_I }, { 0 MSO_I, 21600 }, // left bottom "
|
|
{ 3 MSO_I, 21600 }, { 21600, 2 MSO_I }, // right bottom "
|
|
{ 21600, 1 MSO_I }, { 3 MSO_I, 0 }, // right top "
|
|
{ 0 MSO_I, 0 }, { 0, 1 MSO_I }, // filling area
|
|
{ 0, 2 MSO_I }, { 0 MSO_I, 21600 },
|
|
{ 3 MSO_I, 21600 }, { 21600, 2 MSO_I },
|
|
{ 21600, 1 MSO_I }, { 3 MSO_I, 0 }
|
|
};
|
|
const sal_uInt16 mso_sptBracketPairSegm[] =
|
|
{
|
|
0x4000, 0xa701, 0x0001, 0xa801, 0xaa00, 0x8000,
|
|
0x4000, 0xa701, 0x0001, 0xa801, 0xaa00, 0x8000,
|
|
0x4000, 0xa701, 0x0001, 0xa801, 0x0001, // filling area
|
|
0xa701, 0x0001, 0xa801, 0x6000, 0xab00, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptBracketPairCalc[] =
|
|
{
|
|
{ 0x6000, { DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x6000, { DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 } },
|
|
{ 0xa000, { DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue } },
|
|
{ 0xa000, { DFF_Prop_geoRight, 0, DFF_Prop_adjustValue } },
|
|
{ 0x2082, { DFF_Prop_adjustValue, 0, 45 } },
|
|
{ 0x2000, { 0x404, 0, 10800 } },
|
|
{ 0x8000, { 0, 0, DFF_Prop_adjustValue } },
|
|
{ 0xa000, { 0x406, 0, 0x405 } },
|
|
{ 0xa000, { DFF_Prop_geoLeft, 0, 0x407 } },
|
|
{ 0xa000, { DFF_Prop_geoTop, 0, 0x407 } },
|
|
{ 0x6000, { DFF_Prop_geoRight, 0x407, 0 } },
|
|
{ 0x6000, { DFF_Prop_geoBottom, 0x407, 0 } },
|
|
{ 0xa000, { DFF_Prop_geoLeft, 0, 0x405 } },
|
|
{ 0xa000, { DFF_Prop_geoTop, 0, 0x405 } },
|
|
{ 0x6000, { DFF_Prop_geoRight, 0x405, 0 } },
|
|
{ 0x6000, { DFF_Prop_geoBottom, 0x405, 0 } }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptBracketPairTextRect[] =
|
|
{
|
|
{ { 8 MSO_I, 9 MSO_I }, { 0xa MSO_I, 0xb MSO_I } }
|
|
};
|
|
const SvxMSDffHandle mso_sptBracketPairHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::SWITCHED,
|
|
0x100, 0, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoBracketPair =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptBracketPairVert),
|
|
const_cast<sal_uInt16*>(mso_sptBracketPairSegm), sizeof( mso_sptBracketPairSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptBracketPairCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault3700),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptBracketPairTextRect),
|
|
21600, 21600,
|
|
10800, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptStandardGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptBracketPairHandle),
|
|
};
|
|
|
|
const sal_uInt16 mso_sptPlaqueSegm[] =
|
|
{
|
|
0x4000, 0xa801, 0x0001, 0xa701, 0x0001, 0xa801, 0x0001, 0xa701, 0x6000, 0x8000
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptPlaqueTextRect[] =
|
|
{
|
|
{ { 0xc MSO_I, 0xd MSO_I }, { 0xe MSO_I, 0xf MSO_I } }
|
|
};
|
|
const SvxMSDffHandle mso_sptPlaqueHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::SWITCHED,
|
|
0x100, 0, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoPlaque =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptBracketPairVert),
|
|
const_cast<sal_uInt16*>(mso_sptPlaqueSegm), sizeof( mso_sptPlaqueSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptBracketPairCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault3600),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptPlaqueTextRect),
|
|
21600, 21600,
|
|
10800, 10800,
|
|
std::span<const SvxMSDffVertPair>(mso_sptStandardGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptPlaqueHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptBracePairVert[] = // adj value 0 -> 5400
|
|
{
|
|
{ 4 MSO_I, 0 }, { 0 MSO_I, 1 MSO_I }, { 0 MSO_I, 6 MSO_I }, { 0 ,10800 }, // left bracket
|
|
{ 0 MSO_I, 7 MSO_I }, { 0 MSO_I, 2 MSO_I }, { 4 MSO_I, 21600 },
|
|
{ 8 MSO_I, 21600 }, { 3 MSO_I, 2 MSO_I }, { 3 MSO_I, 7 MSO_I }, { 21600, 10800 }, // right bracket
|
|
{ 3 MSO_I, 6 MSO_I }, { 3 MSO_I, 1 MSO_I }, { 8 MSO_I, 0 },
|
|
{ 4 MSO_I, 0 }, { 0 MSO_I, 1 MSO_I }, { 0 MSO_I, 6 MSO_I }, { 0 ,10800 }, // filling area
|
|
{ 0 MSO_I, 7 MSO_I }, { 0 MSO_I, 2 MSO_I }, { 4 MSO_I, 21600 },
|
|
{ 8 MSO_I, 21600 }, { 3 MSO_I, 2 MSO_I }, { 3 MSO_I, 7 MSO_I }, { 21600, 10800 },
|
|
{ 3 MSO_I, 6 MSO_I }, { 3 MSO_I, 1 MSO_I }, { 8 MSO_I, 0 }
|
|
};
|
|
const sal_uInt16 mso_sptBracePairSegm[] =
|
|
{
|
|
0x4000, 0xa701, 0x0001, 0xa801, 0xa701, 0x0001, 0xa801, 0xaa00, 0x8000,
|
|
0x4000, 0xa701, 0x0001, 0xa801, 0xa701, 0x0001, 0xa801, 0xaa00, 0x8000,
|
|
0x4000, 0xa701, 0x0001, 0xa801, 0xa701, 0x0001, 0xa801, 0x0001, // filling area
|
|
0xa701, 0x0001, 0xa801, 0xa701, 0x0001, 0xa801, 0x6000, 0xab00, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptBracePairCalc[] =
|
|
{
|
|
{ 0x6000, { DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x6000, { DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 } },
|
|
{ 0xa000, { DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue } },
|
|
{ 0xa000, { DFF_Prop_geoRight, 0, DFF_Prop_adjustValue } },
|
|
{ 0x2001, { 0x400, 2, 1 } }, // 4
|
|
{ 0x2001, { DFF_Prop_adjustValue, 2, 1 } }, // 5
|
|
{ 0x8000, { 10800, 0, DFF_Prop_adjustValue } }, // 6
|
|
{ 0x8000, { 21600, 0, 0x406 } }, // 7
|
|
{ 0xa000, { DFF_Prop_geoRight, 0, 0x405 } }, // 8
|
|
{ 0x2001, { DFF_Prop_adjustValue, 1, 3 } }, // 9
|
|
{ 0x6000, { 0x409, DFF_Prop_adjustValue, 0 } }, // xa
|
|
{ 0x6000, { DFF_Prop_geoLeft, 0x40a, 0 } }, // xb
|
|
{ 0x6000, { DFF_Prop_geoTop, 0x409, 0 } }, // xc
|
|
{ 0xa000, { DFF_Prop_geoRight, 0, 0x40a } }, // xd
|
|
{ 0xa000, { DFF_Prop_geoBottom, 0, 0x409 } } // xe
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptBracePairTextRect[] =
|
|
{
|
|
{ { 0xb MSO_I, 0xc MSO_I }, { 0xd MSO_I, 0xe MSO_I } }
|
|
};
|
|
const SvxMSDffHandle mso_sptBracePairHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::SWITCHED,
|
|
0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 5400 }
|
|
};
|
|
const mso_CustomShape msoBracePair =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptBracePairVert),
|
|
const_cast<sal_uInt16*>(mso_sptBracePairSegm), sizeof( mso_sptBracePairSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptBracePairCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault1800),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptBracePairTextRect),
|
|
21600, 21600,
|
|
10800, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptStandardGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptBracePairHandle),
|
|
};
|
|
|
|
const SvxMSDffCalculationData mso_sptBracketCalc[] =
|
|
{
|
|
{ 0x2001, { DFF_Prop_adjustValue, 1, 2 } },
|
|
{ 0x6000, { DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 } },
|
|
{ 0xa000, { DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue } },
|
|
{ 0x6000, { DFF_Prop_geoTop, 0x400, 0 } },
|
|
{ 0xa000, { DFF_Prop_geoBottom, 0, 0x400 } }
|
|
};
|
|
const sal_uInt16 mso_sptBracketSegm[] =
|
|
{
|
|
0x4000, 0x2001, 0x0001, 0x2001, 0x8000
|
|
};
|
|
const SvxMSDffVertPair mso_sptLeftBracketVert[] = // adj value 0 -> 10800
|
|
{
|
|
{ 21600, 0 }, { 10800, 0 }, { 0, 3 MSO_I }, { 0, 1 MSO_I },
|
|
{ 0, 2 MSO_I }, { 0, 4 MSO_I }, { 10800, 21600 }, { 21600, 21600 }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptLeftBracketTextRect[] =
|
|
{
|
|
{ { 6350, 3 MSO_I }, { 21600, 4 MSO_I } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptLeftBracketGluePoints[] =
|
|
{
|
|
{ 21600, 0 }, { 0, 10800 }, { 21600, 21600 }
|
|
};
|
|
const SvxMSDffHandle mso_sptLeftBracketHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 10800 }
|
|
};
|
|
const mso_CustomShape msoLeftBracket =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptLeftBracketVert),
|
|
const_cast<sal_uInt16*>(mso_sptBracketSegm), sizeof( mso_sptBracketSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptBracketCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault1800),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptLeftBracketTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptLeftBracketGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptLeftBracketHandle),
|
|
};
|
|
const SvxMSDffVertPair mso_sptRightBracketVert[] = // adj value 0 -> 10800
|
|
{
|
|
{ 0, 0 }, { 10800, 0 }, { 21600, 3 MSO_I }, { 21600, 1 MSO_I },
|
|
{ 21600, 2 MSO_I }, { 21600, 4 MSO_I }, { 10800, 21600 }, { 0, 21600 }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptRightBracketTextRect[] =
|
|
{
|
|
{ { 0, 3 MSO_I }, { 15150, 4 MSO_I } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptRightBracketGluePoints[] =
|
|
{
|
|
{ 0, 0 }, { 0, 21600 }, { 21600, 10800 }
|
|
};
|
|
const SvxMSDffHandle mso_sptRightBracketHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
1, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 10800 }
|
|
};
|
|
const mso_CustomShape msoRightBracket =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptRightBracketVert),
|
|
const_cast<sal_uInt16*>(mso_sptBracketSegm), sizeof( mso_sptBracketSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptBracketCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault1800),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptRightBracketTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptRightBracketGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptRightBracketHandle),
|
|
};
|
|
|
|
const SvxMSDffCalculationData mso_sptBraceCalc[] =
|
|
{
|
|
{ 0x2001, { DFF_Prop_adjustValue, 1, 2 } },
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0xa000, { 0x404, 0, DFF_Prop_adjustValue } },
|
|
{ 0xa000, { 0x404, 0, 0x400 } },
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
|
|
{ 0x6000, { 0x404, 0x400, 0 } },
|
|
{ 0x6000, { 0x404, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x8000, { 21600, 0, DFF_Prop_adjustValue } },
|
|
{ 0x8000, { 21600, 0, 0x400 } },
|
|
{ 0x2001, { DFF_Prop_adjustValue, 10000, 31953 } },
|
|
{ 0x8000, { 21600, 0, 0x409 } }
|
|
};
|
|
const sal_uInt16 mso_sptBraceSegm[] =
|
|
{
|
|
0x4000, 0x2001, 0x0001, 0x2002, 0x0001, 0x2001, 0x8000
|
|
};
|
|
const sal_Int32 mso_sptBraceDefault[] =
|
|
{
|
|
2, 1800, 10800
|
|
};
|
|
const SvxMSDffVertPair mso_sptLeftBraceVert[] =
|
|
{
|
|
{ 21600, 0 }, // p
|
|
{ 16200, 0 }, { 10800, 0 MSO_I }, { 10800, 1 MSO_I }, // ccp
|
|
{ 10800, 2 MSO_I }, // p
|
|
{ 10800, 3 MSO_I }, { 5400, 4 MSO_I }, { 0, 4 MSO_I }, // ccp
|
|
{ 5400, 4 MSO_I }, { 10800, 5 MSO_I }, { 10800, 6 MSO_I }, // ccp
|
|
{ 10800, 7 MSO_I }, // p
|
|
{ 10800, 8 MSO_I }, { 16200, 21600 }, { 21600, 21600 } // ccp
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptLeftBraceTextRect[] =
|
|
{
|
|
{ { 13800, 9 MSO_I }, { 21600, 10 MSO_I } }
|
|
};
|
|
const SvxMSDffHandle mso_sptLeftBraceHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
10800, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 5400 },
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0, 0x101, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 21600 }
|
|
};
|
|
const mso_CustomShape msoLeftBrace = // adj value0 0 -> 5400
|
|
{ // adj value1 0 -> 21600
|
|
std::span<const SvxMSDffVertPair>(mso_sptLeftBraceVert),
|
|
const_cast<sal_uInt16*>(mso_sptBraceSegm), sizeof( mso_sptBraceSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptBraceCalc),
|
|
const_cast<sal_Int32*>(mso_sptBraceDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptLeftBraceTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptLeftBracketGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptLeftBraceHandle),
|
|
};
|
|
const SvxMSDffVertPair mso_sptRightBraceVert[] =
|
|
{
|
|
{ 0, 0 }, // p
|
|
{ 5400, 0 }, { 10800, 0 MSO_I }, { 10800, 1 MSO_I }, // ccp
|
|
{ 10800, 2 MSO_I }, // p
|
|
{ 10800, 3 MSO_I }, { 16200, 4 MSO_I }, { 21600, 4 MSO_I }, // ccp
|
|
{ 16200, 4 MSO_I }, { 10800, 5 MSO_I }, { 10800, 6 MSO_I }, // ccp
|
|
{ 10800, 7 MSO_I }, // p
|
|
{ 10800, 8 MSO_I }, { 5400, 21600 }, { 0, 21600 } // ccp
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptRightBraceTextRect[] =
|
|
{
|
|
{ { 0, 9 MSO_I }, { 7800, 10 MSO_I } }
|
|
};
|
|
const SvxMSDffHandle mso_sptRightBraceHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
10800, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 5400 },
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
1, 0x101, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 21600 }
|
|
};
|
|
const mso_CustomShape msoRightBrace = // adj value0 0 -> 5400
|
|
{ // adj value1 0 -> 21600
|
|
std::span<const SvxMSDffVertPair>(mso_sptRightBraceVert),
|
|
const_cast<sal_uInt16*>(mso_sptBraceSegm), sizeof( mso_sptBraceSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptBraceCalc),
|
|
const_cast<sal_Int32*>(mso_sptBraceDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptRightBraceTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptRightBracketGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptRightBraceHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptIrregularSeal1Vert[] =
|
|
{
|
|
{ 10901, 5905 }, { 8458, 2399 }, { 7417, 6425 }, { 476, 2399 },
|
|
{ 4732, 7722 }, { 106, 8718 }, { 3828, 11880 }, { 243, 14689 },
|
|
{ 5772, 14041 }, { 4868, 17719 }, { 7819, 15730 }, { 8590, 21600 },
|
|
{ 10637, 15038 }, { 13349, 19840 }, { 14125, 14561 }, { 18248, 18195 },
|
|
{ 16938, 13044 }, { 21600, 13393 }, { 17710, 10579 }, { 21198, 8242 },
|
|
{ 16806, 7417 }, { 18482, 4560 }, { 14257, 5429 }, { 14623, 106 }, { 10901, 5905 }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptIrregularSeal1TextRect[] =
|
|
{
|
|
{ { 4680, 6570 }, { 16140, 13280 } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptIrregularSeal1GluePoints[] =
|
|
{
|
|
{ 14623, 106 }, { 106, 8718 }, { 8590, 21600 }, { 21600, 13393 }
|
|
};
|
|
const mso_CustomShape msoIrregularSeal1 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptIrregularSeal1Vert),
|
|
nullptr, 0,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptIrregularSeal1TextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptIrregularSeal1GluePoints),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptIrregularSeal2Vert[] =
|
|
{
|
|
{ 11464, 4340 }, { 9722, 1887 }, { 8548, 6383 }, { 4503, 3626 },
|
|
{ 5373, 7816 }, { 1174, 8270 }, { 3934, 11592 }, { 0, 12875 },
|
|
{ 3329, 15372 }, { 1283, 17824 }, { 4804, 18239 }, { 4918, 21600 },
|
|
{ 7525, 18125 }, { 8698, 19712 }, { 9871, 17371 }, { 11614, 18844 },
|
|
{ 12178, 15937 }, { 14943, 17371 }, { 14640, 14348 }, { 18878, 15632 },
|
|
{ 16382, 12311 }, { 18270, 11292 }, { 16986, 9404 }, { 21600, 6646 },
|
|
{ 16382, 6533 }, { 18005, 3172 }, { 14524, 5778 }, { 14789, 0 },
|
|
{ 11464, 4340 }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptIrregularSeal2TextRect[] =
|
|
{
|
|
{ { 5400, 6570 }, { 14160, 15290 } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptIrregularSeal2GluePoints[] =
|
|
{
|
|
{ 9722, 1887 }, { 0, 12875 }, { 11614, 18844 }, { 21600, 6646 }
|
|
};
|
|
const mso_CustomShape msoIrregularSeal2 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptIrregularSeal2Vert),
|
|
nullptr, 0,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptIrregularSeal2TextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptIrregularSeal2GluePoints),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptSeal4Vert[] = // adjustment1 : 0 - 10800
|
|
{
|
|
{ 0, 10800 }, { 4 MSO_I, 4 MSO_I }, { 10800, 0 }, { 3 MSO_I, 4 MSO_I },
|
|
{ 21600, 10800 }, { 3 MSO_I, 3 MSO_I }, { 10800, 21600 }, { 4 MSO_I, 3 MSO_I },
|
|
{ 0, 10800 }
|
|
};
|
|
const SvxMSDffCalculationData mso_sptSeal4Calc[] =
|
|
{
|
|
{ 0x0000, { 7600, 0, 0 } },
|
|
{ 0x6001, { 0x400, DFF_Prop_adjustValue, 10800 } },
|
|
{ 0xa000, { 0x400, 0, 0x401 } },
|
|
{ 0x4000, { 10800, 0x402, 0 } },
|
|
{ 0x8000, { 10800, 0, 0x402 } }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptSeal4TextRect[] =
|
|
{
|
|
{ { 4 MSO_I, 4 MSO_I }, { 3 MSO_I, 3 MSO_I } }
|
|
};
|
|
const SvxMSDffHandle mso_sptSealHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0x100, 10800, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoSeal4 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptSeal4Vert),
|
|
nullptr, 0,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptSeal4Calc),
|
|
const_cast<sal_Int32*>(mso_sptDefault8100),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptSeal4TextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptSealHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptStarVert[] =
|
|
{
|
|
{ 10797, 0 }, { 8278, 8256 }, { 0, 8256 }, { 6722, 13405 },
|
|
{ 4198, 21600 }, { 10797, 16580 }, { 17401, 21600 }, { 14878, 13405 },
|
|
{ 21600, 8256 }, { 13321, 8256 }, { 10797, 0 }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptStarTextRect[] =
|
|
{
|
|
{ { 6722, 8256 }, { 14878, 15460 } }
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptStarGluePoints[] =
|
|
{
|
|
{ 10800, 0 }, { 0, 8259 }, { 4200, 21600 }, { 17400, 21600 }, { 21600, 8259 }
|
|
};
|
|
const mso_CustomShape msoStar =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptStarVert),
|
|
nullptr, 0,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptStarTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>( mso_sptStarGluePoints ),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffCalculationData mso_sptSeal24Calc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, // 0x00
|
|
{ 0x2081, { 0x400, 10800, 315 } }, // 0x01 ( textframe )
|
|
{ 0x2082, { 0x400, 10800, 315 } }, // 0x02
|
|
{ 0x2081, { 0x400, 10800, 135 } }, // 0x03
|
|
{ 0x2082, { 0x400, 10800, 135 } }, // 0x04
|
|
{ 0x0081, { 0, 10800, 0 } },
|
|
{ 0x0082, { 0, 10800, 0 } },
|
|
{ 0x2081, { 0x400, 10800, 7 } },
|
|
{ 0x2082, { 0x400, 10800, 7 } },
|
|
{ 0x0081, { 0, 10800, 15 } },
|
|
{ 0x0082, { 0, 10800, 15 } },
|
|
{ 0x2081, { 0x400, 10800, 22 } },
|
|
{ 0x2082, { 0x400, 10800, 22 } },
|
|
{ 0x0081, { 0, 10800, 30 } },
|
|
{ 0x0082, { 0, 10800, 30 } },
|
|
{ 0x2081, { 0x400, 10800, 37 } },
|
|
{ 0x2082, { 0x400, 10800, 37 } },
|
|
{ 0x0081, { 0, 10800, 45 } },
|
|
{ 0x0082, { 0, 10800, 45 } },
|
|
{ 0x2081, { 0x400, 10800, 52 } },
|
|
{ 0x2082, { 0x400, 10800, 52 } },
|
|
{ 0x0081, { 0, 10800, 60 } },
|
|
{ 0x0082, { 0, 10800, 60 } },
|
|
{ 0x2081, { 0x400, 10800, 67 } },
|
|
{ 0x2082, { 0x400, 10800, 67 } },
|
|
{ 0x0081, { 0, 10800, 75 } },
|
|
{ 0x0082, { 0, 10800, 75 } },
|
|
{ 0x2081, { 0x400, 10800, 82 } },
|
|
{ 0x2082, { 0x400, 10800, 82 } },
|
|
{ 0x0081, { 0, 10800, 90 } },
|
|
{ 0x0082, { 0, 10800, 90 } },
|
|
{ 0x2081, { 0x400, 10800, 97 } },
|
|
{ 0x2082, { 0x400, 10800, 97 } },
|
|
{ 0x0081, { 0, 10800, 105 } },
|
|
{ 0x0082, { 0, 10800, 105 } },
|
|
{ 0x2081, { 0x400, 10800, 112 } },
|
|
{ 0x2082, { 0x400, 10800, 112 } },
|
|
{ 0x0081, { 0, 10800, 120 } },
|
|
{ 0x0082, { 0, 10800, 120 } },
|
|
{ 0x2081, { 0x400, 10800, 127 } },
|
|
{ 0x2082, { 0x400, 10800, 127 } },
|
|
{ 0x0081, { 0, 10800, 135 } },
|
|
{ 0x0082, { 0, 10800, 135 } },
|
|
{ 0x2081, { 0x400, 10800, 142 } },
|
|
{ 0x2082, { 0x400, 10800, 142 } },
|
|
{ 0x0081, { 0, 10800, 150 } },
|
|
{ 0x0082, { 0, 10800, 150 } },
|
|
{ 0x2081, { 0x400, 10800, 157 } },
|
|
{ 0x2082, { 0x400, 10800, 157 } },
|
|
{ 0x0081, { 0, 10800, 165 } },
|
|
{ 0x0082, { 0, 10800, 165 } },
|
|
{ 0x2081, { 0x400, 10800, 172 } },
|
|
{ 0x2082, { 0x400, 10800, 172 } },
|
|
{ 0x0081, { 0, 10800, 180 } },
|
|
{ 0x0082, { 0, 10800, 180 } },
|
|
{ 0x2081, { 0x400, 10800, 187 } },
|
|
{ 0x2082, { 0x400, 10800, 187 } },
|
|
{ 0x0081, { 0, 10800, 195 } },
|
|
{ 0x0082, { 0, 10800, 195 } },
|
|
{ 0x2081, { 0x400, 10800, 202 } },
|
|
{ 0x2082, { 0x400, 10800, 202 } },
|
|
{ 0x0081, { 0, 10800, 210 } },
|
|
{ 0x0082, { 0, 10800, 210 } },
|
|
{ 0x2081, { 0x400, 10800, 217 } },
|
|
{ 0x2082, { 0x400, 10800, 217 } },
|
|
{ 0x0081, { 0, 10800, 225 } },
|
|
{ 0x0082, { 0, 10800, 225 } },
|
|
{ 0x2081, { 0x400, 10800, 232 } },
|
|
{ 0x2082, { 0x400, 10800, 232 } },
|
|
{ 0x0081, { 0, 10800, 240 } },
|
|
{ 0x0082, { 0, 10800, 240 } },
|
|
{ 0x2081, { 0x400, 10800, 247 } },
|
|
{ 0x2082, { 0x400, 10800, 247 } },
|
|
{ 0x0081, { 0, 10800, 255 } },
|
|
{ 0x0082, { 0, 10800, 255 } },
|
|
{ 0x2081, { 0x400, 10800, 262 } },
|
|
{ 0x2082, { 0x400, 10800, 262 } },
|
|
{ 0x0081, { 0, 10800, 270 } },
|
|
{ 0x0082, { 0, 10800, 270 } },
|
|
{ 0x2081, { 0x400, 10800, 277 } },
|
|
{ 0x2082, { 0x400, 10800, 277 } },
|
|
{ 0x0081, { 0, 10800, 285 } },
|
|
{ 0x0082, { 0, 10800, 285 } },
|
|
{ 0x2081, { 0x400, 10800, 292 } },
|
|
{ 0x2082, { 0x400, 10800, 292 } },
|
|
{ 0x0081, { 0, 10800, 300 } },
|
|
{ 0x0082, { 0, 10800, 300 } },
|
|
{ 0x2081, { 0x400, 10800, 307 } },
|
|
{ 0x2082, { 0x400, 10800, 307 } },
|
|
{ 0x0081, { 0, 10800, 315 } },
|
|
{ 0x0082, { 0, 10800, 315 } },
|
|
{ 0x2081, { 0x400, 10800, 322 } },
|
|
{ 0x2082, { 0x400, 10800, 322 } },
|
|
{ 0x0081, { 0, 10800, 330 } },
|
|
{ 0x0082, { 0, 10800, 330 } },
|
|
{ 0x2081, { 0x400, 10800, 337 } },
|
|
{ 0x2082, { 0x400, 10800, 337 } },
|
|
{ 0x0081, { 0, 10800, 345 } },
|
|
{ 0x0082, { 0, 10800, 345 } },
|
|
{ 0x2081, { 0x400, 10800, 352 } },
|
|
{ 0x2082, { 0x400, 10800, 352 } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptSeal8Vert[] = // adj value 0 -> 10800
|
|
{
|
|
{ 5 MSO_I, 6 MSO_I }, { 11 MSO_I, 12 MSO_I }, { 17 MSO_I, 18 MSO_I }, { 23 MSO_I, 24 MSO_I },
|
|
{ 29 MSO_I, 30 MSO_I }, { 35 MSO_I, 36 MSO_I }, { 41 MSO_I, 42 MSO_I }, { 47 MSO_I, 48 MSO_I },
|
|
{ 53 MSO_I, 54 MSO_I }, { 59 MSO_I, 60 MSO_I }, { 65 MSO_I, 66 MSO_I }, { 71 MSO_I, 72 MSO_I },
|
|
{ 77 MSO_I, 78 MSO_I }, { 83 MSO_I, 84 MSO_I }, { 89 MSO_I, 90 MSO_I }, { 95 MSO_I, 96 MSO_I },
|
|
{ 5 MSO_I, 6 MSO_I }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptSealTextRect[] =
|
|
{
|
|
{ { 1 MSO_I, 2 MSO_I }, { 3 MSO_I, 4 MSO_I } }
|
|
};
|
|
const mso_CustomShape msoSeal8 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptSeal8Vert),
|
|
nullptr, 0,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptSeal24Calc),
|
|
const_cast<sal_Int32*>(mso_sptDefault2500),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptSealTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptSealHandle),
|
|
};
|
|
const SvxMSDffVertPair mso_sptSeal16Vert[] = // adj value 0 -> 10800
|
|
{
|
|
{ 0x05 MSO_I, 0x06 MSO_I }, { 0x07 MSO_I, 0x08 MSO_I }, { 0x09 MSO_I, 0x0a MSO_I }, { 0x0b MSO_I, 0x0c MSO_I },
|
|
{ 0x0d MSO_I, 0x0e MSO_I }, { 0x0f MSO_I, 0x10 MSO_I }, { 0x11 MSO_I, 0x12 MSO_I }, { 0x13 MSO_I, 0x14 MSO_I },
|
|
{ 0x15 MSO_I, 0x16 MSO_I }, { 0x17 MSO_I, 0x18 MSO_I }, { 0x19 MSO_I, 0x1a MSO_I }, { 0x1b MSO_I, 0x1c MSO_I },
|
|
{ 0x1d MSO_I, 0x1e MSO_I }, { 0x1f MSO_I, 0x20 MSO_I }, { 0x21 MSO_I, 0x22 MSO_I }, { 0x23 MSO_I, 0x24 MSO_I },
|
|
{ 0x25 MSO_I, 0x26 MSO_I }, { 0x27 MSO_I, 0x28 MSO_I }, { 0x29 MSO_I, 0x2a MSO_I }, { 0x2b MSO_I, 0x2c MSO_I },
|
|
{ 0x2d MSO_I, 0x2e MSO_I }, { 0x2f MSO_I, 0x30 MSO_I }, { 0x31 MSO_I, 0x32 MSO_I }, { 0x33 MSO_I, 0x34 MSO_I },
|
|
{ 0x35 MSO_I, 0x36 MSO_I }, { 0x37 MSO_I, 0x38 MSO_I }, { 0x39 MSO_I, 0x3a MSO_I }, { 0x3b MSO_I, 0x3c MSO_I },
|
|
{ 0x3d MSO_I, 0x3e MSO_I }, { 0x3f MSO_I, 0x40 MSO_I }, { 0x41 MSO_I, 0x42 MSO_I }, { 0x43 MSO_I, 0x44 MSO_I },
|
|
{ 0x05 MSO_I, 0x06 MSO_I }
|
|
};
|
|
const SvxMSDffCalculationData mso_sptSeal16Calc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, // 0x00
|
|
{ 0x2081, { 0x400, 10800, 315 } }, // 0x01 ( textframe )
|
|
{ 0x2082, { 0x400, 10800, 315 } }, // 0x02
|
|
{ 0x2081, { 0x400, 10800, 135 } }, // 0x03
|
|
{ 0x2082, { 0x400, 10800, 135 } }, // 0x04
|
|
{ 0x0081, { 0, 10800, 0 } },
|
|
{ 0x0082, { 0, 10800, 0 } },
|
|
{ 0x2081, { 0x400, 10800, 11 } },
|
|
{ 0x2082, { 0x400, 10800, 11 } },
|
|
{ 0x0081, { 0, 10800, 22 } },
|
|
{ 0x0082, { 0, 10800, 22 } },
|
|
{ 0x2081, { 0x400, 10800, 33 } },
|
|
{ 0x2082, { 0x400, 10800, 33 } },
|
|
{ 0x0081, { 0, 10800, 45 } },
|
|
{ 0x0082, { 0, 10800, 45 } },
|
|
{ 0x2081, { 0x400, 10800, 56 } },
|
|
{ 0x2082, { 0x400, 10800, 56 } },
|
|
{ 0x0081, { 0, 10800, 67 } },
|
|
{ 0x0082, { 0, 10800, 67 } },
|
|
{ 0x2081, { 0x400, 10800, 78 } },
|
|
{ 0x2082, { 0x400, 10800, 78 } },
|
|
{ 0x0081, { 0, 10800, 90 } },
|
|
{ 0x0082, { 0, 10800, 90 } },
|
|
{ 0x2081, { 0x400, 10800, 101 } },
|
|
{ 0x2082, { 0x400, 10800, 101 } },
|
|
{ 0x0081, { 0, 10800, 112 } },
|
|
{ 0x0082, { 0, 10800, 112 } },
|
|
{ 0x2081, { 0x400, 10800, 123 } },
|
|
{ 0x2082, { 0x400, 10800, 123 } },
|
|
{ 0x0081, { 0, 10800, 135 } },
|
|
{ 0x0082, { 0, 10800, 135 } },
|
|
{ 0x2081, { 0x400, 10800, 146 } },
|
|
{ 0x2082, { 0x400, 10800, 146 } },
|
|
{ 0x0081, { 0, 10800, 157 } },
|
|
{ 0x0082, { 0, 10800, 157 } },
|
|
{ 0x2081, { 0x400, 10800, 168 } },
|
|
{ 0x2082, { 0x400, 10800, 168 } },
|
|
{ 0x0081, { 0, 10800, 180 } },
|
|
{ 0x0082, { 0, 10800, 180 } },
|
|
{ 0x2081, { 0x400, 10800, 191 } },
|
|
{ 0x2082, { 0x400, 10800, 191 } },
|
|
{ 0x0081, { 0, 10800, 202 } },
|
|
{ 0x0082, { 0, 10800, 202 } },
|
|
{ 0x2081, { 0x400, 10800, 213 } },
|
|
{ 0x2082, { 0x400, 10800, 213 } },
|
|
{ 0x0081, { 0, 10800, 225 } },
|
|
{ 0x0082, { 0, 10800, 225 } },
|
|
{ 0x2081, { 0x400, 10800, 236 } },
|
|
{ 0x2082, { 0x400, 10800, 236 } },
|
|
{ 0x0081, { 0, 10800, 247 } },
|
|
{ 0x0082, { 0, 10800, 247 } },
|
|
{ 0x2081, { 0x400, 10800, 258 } },
|
|
{ 0x2082, { 0x400, 10800, 258 } },
|
|
{ 0x0081, { 0, 10800, 270 } },
|
|
{ 0x0082, { 0, 10800, 270 } },
|
|
{ 0x2081, { 0x400, 10800, 281 } },
|
|
{ 0x2082, { 0x400, 10800, 281 } },
|
|
{ 0x0081, { 0, 10800, 292 } },
|
|
{ 0x0082, { 0, 10800, 292 } },
|
|
{ 0x2081, { 0x400, 10800, 303 } },
|
|
{ 0x2082, { 0x400, 10800, 303 } },
|
|
{ 0x0081, { 0, 10800, 315 } },
|
|
{ 0x0082, { 0, 10800, 315 } },
|
|
{ 0x2081, { 0x400, 10800, 326 } },
|
|
{ 0x2082, { 0x400, 10800, 326 } },
|
|
{ 0x0081, { 0, 10800, 337 } },
|
|
{ 0x0082, { 0, 10800, 337 } },
|
|
{ 0x2081, { 0x400, 10800, 348 } },
|
|
{ 0x2082, { 0x400, 10800, 348 } }
|
|
};
|
|
const mso_CustomShape msoSeal16 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptSeal16Vert),
|
|
nullptr, 0,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptSeal16Calc),
|
|
const_cast<sal_Int32*>(mso_sptDefault2500),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptSealTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptSealHandle),
|
|
};
|
|
const SvxMSDffVertPair mso_sptSeal24Vert[] =
|
|
{
|
|
{ 0x05 MSO_I, 0x06 MSO_I }, { 0x07 MSO_I, 0x08 MSO_I }, { 0x09 MSO_I, 0x0a MSO_I }, { 0x0b MSO_I, 0x0c MSO_I },
|
|
{ 0x0d MSO_I, 0x0e MSO_I }, { 0x0f MSO_I, 0x10 MSO_I }, { 0x11 MSO_I, 0x12 MSO_I }, { 0x13 MSO_I, 0x14 MSO_I },
|
|
{ 0x15 MSO_I, 0x16 MSO_I }, { 0x17 MSO_I, 0x18 MSO_I }, { 0x19 MSO_I, 0x1a MSO_I }, { 0x1b MSO_I, 0x1c MSO_I },
|
|
{ 0x1d MSO_I, 0x1e MSO_I }, { 0x1f MSO_I, 0x20 MSO_I }, { 0x21 MSO_I, 0x22 MSO_I }, { 0x23 MSO_I, 0x24 MSO_I },
|
|
{ 0x25 MSO_I, 0x26 MSO_I }, { 0x27 MSO_I, 0x28 MSO_I }, { 0x29 MSO_I, 0x2a MSO_I }, { 0x2b MSO_I, 0x2c MSO_I },
|
|
{ 0x2d MSO_I, 0x2e MSO_I }, { 0x2f MSO_I, 0x30 MSO_I }, { 0x31 MSO_I, 0x32 MSO_I }, { 0x33 MSO_I, 0x34 MSO_I },
|
|
{ 0x35 MSO_I, 0x36 MSO_I }, { 0x37 MSO_I, 0x38 MSO_I }, { 0x39 MSO_I, 0x3a MSO_I }, { 0x3b MSO_I, 0x3c MSO_I },
|
|
{ 0x3d MSO_I, 0x3e MSO_I }, { 0x3f MSO_I, 0x40 MSO_I }, { 0x41 MSO_I, 0x42 MSO_I }, { 0x43 MSO_I, 0x44 MSO_I },
|
|
{ 0x45 MSO_I, 0x46 MSO_I }, { 0x47 MSO_I, 0x48 MSO_I }, { 0x49 MSO_I, 0x4a MSO_I }, { 0x4b MSO_I, 0x4c MSO_I },
|
|
{ 0x4d MSO_I, 0x4e MSO_I }, { 0x4f MSO_I, 0x50 MSO_I }, { 0x51 MSO_I, 0x52 MSO_I }, { 0x53 MSO_I, 0x54 MSO_I },
|
|
{ 0x55 MSO_I, 0x56 MSO_I }, { 0x57 MSO_I, 0x58 MSO_I }, { 0x59 MSO_I, 0x5a MSO_I }, { 0x5b MSO_I, 0x5c MSO_I },
|
|
{ 0x5d MSO_I, 0x5e MSO_I }, { 0x5f MSO_I, 0x60 MSO_I }, { 0x61 MSO_I, 0x62 MSO_I }, { 0x63 MSO_I, 0x64 MSO_I },
|
|
{ 0x05 MSO_I, 0x06 MSO_I }
|
|
};
|
|
const mso_CustomShape msoSeal24 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptSeal24Vert),
|
|
nullptr, 0,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptSeal24Calc),
|
|
const_cast<sal_Int32*>(mso_sptDefault2500),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptSealTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptSealHandle),
|
|
};
|
|
const SvxMSDffCalculationData mso_sptSeal32Calc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, // 0x00
|
|
{ 0x2081, { 0x400, 10800, 315 } }, // 0x01 ( textframe )
|
|
{ 0x2082, { 0x400, 10800, 315 } }, // 0x02
|
|
{ 0x2081, { 0x400, 10800, 135 } }, // 0x03
|
|
{ 0x2082, { 0x400, 10800, 135 } }, // 0x04
|
|
{ 0x0081, { 0, 10800, 0 } },
|
|
{ 0x0082, { 0, 10800, 0 } },
|
|
{ 0x2081, { 0x400, 10800, 5 } },
|
|
{ 0x2082, { 0x400, 10800, 5 } },
|
|
{ 0x0081, { 0, 10800, 11 } },
|
|
{ 0x0082, { 0, 10800, 11 } },
|
|
{ 0x2081, { 0x400, 10800, 16 } },
|
|
{ 0x2082, { 0x400, 10800, 16 } },
|
|
{ 0x0081, { 0, 10800, 22 } },
|
|
{ 0x0082, { 0, 10800, 22 } },
|
|
{ 0x2081, { 0x400, 10800, 28 } },
|
|
{ 0x2082, { 0x400, 10800, 28 } },
|
|
{ 0x0081, { 0, 10800, 33 } },
|
|
{ 0x0082, { 0, 10800, 33 } },
|
|
{ 0x2081, { 0x400, 10800, 39 } },
|
|
{ 0x2082, { 0x400, 10800, 39 } },
|
|
{ 0x0081, { 0, 10800, 45 } },
|
|
{ 0x0082, { 0, 10800, 45 } },
|
|
{ 0x2081, { 0x400, 10800, 50 } },
|
|
{ 0x2082, { 0x400, 10800, 50 } },
|
|
{ 0x0081, { 0, 10800, 56 } },
|
|
{ 0x0082, { 0, 10800, 56 } },
|
|
{ 0x2081, { 0x400, 10800, 61 } },
|
|
{ 0x2082, { 0x400, 10800, 61 } },
|
|
{ 0x0081, { 0, 10800, 67 } },
|
|
{ 0x0082, { 0, 10800, 67 } },
|
|
{ 0x2081, { 0x400, 10800, 73 } },
|
|
{ 0x2082, { 0x400, 10800, 73 } },
|
|
{ 0x0081, { 0, 10800, 78 } },
|
|
{ 0x0082, { 0, 10800, 78 } },
|
|
{ 0x2081, { 0x400, 10800, 84 } },
|
|
{ 0x2082, { 0x400, 10800, 84 } },
|
|
{ 0x0081, { 0, 10800, 90 } },
|
|
{ 0x0082, { 0, 10800, 90 } },
|
|
{ 0x2081, { 0x400, 10800, 95 } },
|
|
{ 0x2082, { 0x400, 10800, 95 } },
|
|
{ 0x0081, { 0, 10800, 101 } },
|
|
{ 0x0082, { 0, 10800, 101 } },
|
|
{ 0x2081, { 0x400, 10800, 106 } },
|
|
{ 0x2082, { 0x400, 10800, 106 } },
|
|
{ 0x0081, { 0, 10800, 112 } },
|
|
{ 0x0082, { 0, 10800, 112 } },
|
|
{ 0x2081, { 0x400, 10800, 118 } },
|
|
{ 0x2082, { 0x400, 10800, 118 } },
|
|
{ 0x0081, { 0, 10800, 123 } },
|
|
{ 0x0082, { 0, 10800, 123 } },
|
|
{ 0x2081, { 0x400, 10800, 129 } },
|
|
{ 0x2082, { 0x400, 10800, 129 } },
|
|
{ 0x0081, { 0, 10800, 135 } },
|
|
{ 0x0082, { 0, 10800, 135 } },
|
|
{ 0x2081, { 0x400, 10800, 140 } },
|
|
{ 0x2082, { 0x400, 10800, 140 } },
|
|
{ 0x0081, { 0, 10800, 146 } },
|
|
{ 0x0082, { 0, 10800, 146 } },
|
|
{ 0x2081, { 0x400, 10800, 151 } },
|
|
{ 0x2082, { 0x400, 10800, 151 } },
|
|
{ 0x0081, { 0, 10800, 157 } },
|
|
{ 0x0082, { 0, 10800, 157 } },
|
|
{ 0x2081, { 0x400, 10800, 163 } },
|
|
{ 0x2082, { 0x400, 10800, 163 } },
|
|
{ 0x0081, { 0, 10800, 168 } },
|
|
{ 0x0082, { 0, 10800, 168 } },
|
|
{ 0x2081, { 0x400, 10800, 174 } },
|
|
{ 0x2082, { 0x400, 10800, 174 } },
|
|
{ 0x0081, { 0, 10800, 180 } },
|
|
{ 0x0082, { 0, 10800, 180 } },
|
|
{ 0x2081, { 0x400, 10800, 185 } },
|
|
{ 0x2082, { 0x400, 10800, 185 } },
|
|
{ 0x0081, { 0, 10800, 191 } },
|
|
{ 0x0082, { 0, 10800, 191 } },
|
|
{ 0x2081, { 0x400, 10800, 196 } },
|
|
{ 0x2082, { 0x400, 10800, 196 } },
|
|
{ 0x0081, { 0, 10800, 202 } },
|
|
{ 0x0082, { 0, 10800, 202 } },
|
|
{ 0x2081, { 0x400, 10800, 208 } },
|
|
{ 0x2082, { 0x400, 10800, 208 } },
|
|
{ 0x0081, { 0, 10800, 213 } },
|
|
{ 0x0082, { 0, 10800, 213 } },
|
|
{ 0x2081, { 0x400, 10800, 219 } },
|
|
{ 0x2082, { 0x400, 10800, 219 } },
|
|
{ 0x0081, { 0, 10800, 225 } },
|
|
{ 0x0082, { 0, 10800, 225 } },
|
|
{ 0x2081, { 0x400, 10800, 230 } },
|
|
{ 0x2082, { 0x400, 10800, 230 } },
|
|
{ 0x0081, { 0, 10800, 236 } },
|
|
{ 0x0082, { 0, 10800, 236 } },
|
|
{ 0x2081, { 0x400, 10800, 241 } },
|
|
{ 0x2082, { 0x400, 10800, 241 } },
|
|
{ 0x0081, { 0, 10800, 247 } },
|
|
{ 0x0082, { 0, 10800, 247 } },
|
|
{ 0x2081, { 0x400, 10800, 253 } },
|
|
{ 0x2082, { 0x400, 10800, 253 } },
|
|
{ 0x0081, { 0, 10800, 258 } },
|
|
{ 0x0082, { 0, 10800, 258 } },
|
|
{ 0x2081, { 0x400, 10800, 264 } },
|
|
{ 0x2082, { 0x400, 10800, 264 } },
|
|
{ 0x0081, { 0, 10800, 270 } },
|
|
{ 0x0082, { 0, 10800, 270 } },
|
|
{ 0x2081, { 0x400, 10800, 275 } },
|
|
{ 0x2082, { 0x400, 10800, 275 } },
|
|
{ 0x0081, { 0, 10800, 281 } },
|
|
{ 0x0082, { 0, 10800, 281 } },
|
|
{ 0x2081, { 0x400, 10800, 286 } },
|
|
{ 0x2082, { 0x400, 10800, 286 } },
|
|
{ 0x0081, { 0, 10800, 292 } },
|
|
{ 0x0082, { 0, 10800, 292 } },
|
|
{ 0x2081, { 0x400, 10800, 298 } },
|
|
{ 0x2082, { 0x400, 10800, 298 } },
|
|
{ 0x0081, { 0, 10800, 303 } },
|
|
{ 0x0082, { 0, 10800, 303 } },
|
|
{ 0x2081, { 0x400, 10800, 309 } },
|
|
{ 0x2082, { 0x400, 10800, 309 } },
|
|
{ 0x0081, { 0, 10800, 315 } },
|
|
{ 0x0082, { 0, 10800, 315 } },
|
|
{ 0x2081, { 0x400, 10800, 320 } },
|
|
{ 0x2082, { 0x400, 10800, 320 } },
|
|
{ 0x0081, { 0, 10800, 326 } },
|
|
{ 0x0082, { 0, 10800, 326 } },
|
|
{ 0x2081, { 0x400, 10800, 331 } },
|
|
{ 0x2082, { 0x400, 10800, 331 } },
|
|
{ 0x0081, { 0, 10800, 337 } },
|
|
{ 0x0082, { 0, 10800, 337 } },
|
|
{ 0x2081, { 0x400, 10800, 343 } },
|
|
{ 0x2082, { 0x400, 10800, 343 } },
|
|
{ 0x0081, { 0, 10800, 348 } },
|
|
{ 0x0082, { 0, 10800, 348 } },
|
|
{ 0x2081, { 0x400, 10800, 354 } },
|
|
{ 0x2082, { 0x400, 10800, 354 } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptSeal32Vert[] =
|
|
{
|
|
{ 0x05 MSO_I, 0x06 MSO_I }, { 0x07 MSO_I, 0x08 MSO_I }, { 0x09 MSO_I, 0x0a MSO_I }, { 0x0b MSO_I, 0x0c MSO_I },
|
|
{ 0x0d MSO_I, 0x0e MSO_I }, { 0x0f MSO_I, 0x10 MSO_I }, { 0x11 MSO_I, 0x12 MSO_I }, { 0x13 MSO_I, 0x14 MSO_I },
|
|
{ 0x15 MSO_I, 0x16 MSO_I }, { 0x17 MSO_I, 0x18 MSO_I }, { 0x19 MSO_I, 0x1a MSO_I }, { 0x1b MSO_I, 0x1c MSO_I },
|
|
{ 0x1d MSO_I, 0x1e MSO_I }, { 0x1f MSO_I, 0x20 MSO_I }, { 0x21 MSO_I, 0x22 MSO_I }, { 0x23 MSO_I, 0x24 MSO_I },
|
|
{ 0x25 MSO_I, 0x26 MSO_I }, { 0x27 MSO_I, 0x28 MSO_I }, { 0x29 MSO_I, 0x2a MSO_I }, { 0x2b MSO_I, 0x2c MSO_I },
|
|
{ 0x2d MSO_I, 0x2e MSO_I }, { 0x2f MSO_I, 0x30 MSO_I }, { 0x31 MSO_I, 0x32 MSO_I }, { 0x33 MSO_I, 0x34 MSO_I },
|
|
{ 0x35 MSO_I, 0x36 MSO_I }, { 0x37 MSO_I, 0x38 MSO_I }, { 0x39 MSO_I, 0x3a MSO_I }, { 0x3b MSO_I, 0x3c MSO_I },
|
|
{ 0x3d MSO_I, 0x3e MSO_I }, { 0x3f MSO_I, 0x40 MSO_I }, { 0x41 MSO_I, 0x42 MSO_I }, { 0x43 MSO_I, 0x44 MSO_I },
|
|
{ 0x45 MSO_I, 0x46 MSO_I }, { 0x47 MSO_I, 0x48 MSO_I }, { 0x49 MSO_I, 0x4a MSO_I }, { 0x4b MSO_I, 0x4c MSO_I },
|
|
{ 0x4d MSO_I, 0x4e MSO_I }, { 0x4f MSO_I, 0x50 MSO_I }, { 0x51 MSO_I, 0x52 MSO_I }, { 0x53 MSO_I, 0x54 MSO_I },
|
|
{ 0x55 MSO_I, 0x56 MSO_I }, { 0x57 MSO_I, 0x58 MSO_I }, { 0x59 MSO_I, 0x5a MSO_I }, { 0x5b MSO_I, 0x5c MSO_I },
|
|
{ 0x5d MSO_I, 0x5e MSO_I }, { 0x5f MSO_I, 0x60 MSO_I }, { 0x61 MSO_I, 0x62 MSO_I }, { 0x63 MSO_I, 0x64 MSO_I },
|
|
{ 0x65 MSO_I, 0x66 MSO_I }, { 0x67 MSO_I, 0x68 MSO_I }, { 0x69 MSO_I, 0x6a MSO_I }, { 0x6b MSO_I, 0x6c MSO_I },
|
|
{ 0x6d MSO_I, 0x6e MSO_I }, { 0x6f MSO_I, 0x70 MSO_I }, { 0x71 MSO_I, 0x72 MSO_I }, { 0x73 MSO_I, 0x74 MSO_I },
|
|
{ 0x75 MSO_I, 0x76 MSO_I }, { 0x77 MSO_I, 0x78 MSO_I }, { 0x79 MSO_I, 0x7a MSO_I }, { 0x7b MSO_I, 0x7c MSO_I },
|
|
{ 0x7d MSO_I, 0x7e MSO_I }, { 0x7f MSO_I, 0x80 MSO_I }, { 0x81 MSO_I, 0x82 MSO_I }, { 0x83 MSO_I, 0x84 MSO_I },
|
|
{ 0x05 MSO_I, 0x06 MSO_I }
|
|
};
|
|
const mso_CustomShape msoSeal32 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptSeal32Vert),
|
|
nullptr, 0,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptSeal32Calc),
|
|
const_cast<sal_Int32*>(mso_sptDefault2500),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptSealTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptSealHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptRibbon2Vert[] = // adjustment1 : x 2700 - 8100 def 5400
|
|
{ // adjustment2 : y 14400 - 21600 def 18900
|
|
{ 12 MSO_I, 1 MSO_I }, { 12 MSO_I, 13 MSO_I }, // pp
|
|
{ 12 MSO_I, 14 MSO_I }, { 15 MSO_I, 21600 }, { 16 MSO_I, 21600 }, // ccp
|
|
{ 0, 21600 }, { 2750, 7 MSO_I }, { 0, 2 MSO_I }, { 0 MSO_I, 2 MSO_I }, // pppp
|
|
{ 0 MSO_I, 4 MSO_I }, // p
|
|
{ 0 MSO_I, 5 MSO_I }, { 10 MSO_I, 0 }, { 11 MSO_I, 0 }, // ccp
|
|
{ 17 MSO_I, 0 }, // p
|
|
{ 18 MSO_I, 0 }, { 19 MSO_I, 5 MSO_I }, { 19 MSO_I, 4 MSO_I }, // ccp
|
|
{ 19 MSO_I, 2 MSO_I }, { 21600, 2 MSO_I }, { 18850, 7 MSO_I }, { 21600, 21600 }, // pppp
|
|
{ 20 MSO_I, 21600 }, // p
|
|
{ 21 MSO_I, 21600 }, { 22 MSO_I, 14 MSO_I }, { 22 MSO_I, 13 MSO_I }, // ccp
|
|
{ 22 MSO_I, 1 MSO_I }, { 12 MSO_I, 1 MSO_I }, { 12 MSO_I, 13 MSO_I }, // ppp
|
|
{ 12 MSO_I, 23 MSO_I }, { 15 MSO_I, 24 MSO_I }, { 16 MSO_I, 24 MSO_I }, // ccp
|
|
{ 11 MSO_I, 24 MSO_I }, // p
|
|
{ 10 MSO_I, 24 MSO_I }, { 0 MSO_I, 26 MSO_I }, { 0 MSO_I, 25 MSO_I }, // ccp
|
|
{ 0 MSO_I, 27 MSO_I }, { 10 MSO_I, 1 MSO_I }, { 11 MSO_I, 1 MSO_I }, // ccp
|
|
|
|
{ 22 MSO_I, 1 MSO_I }, { 22 MSO_I, 13 MSO_I }, // pp
|
|
{ 22 MSO_I, 23 MSO_I }, { 21 MSO_I, 24 MSO_I }, { 20 MSO_I, 24 MSO_I }, // ccp
|
|
{ 17 MSO_I, 24 MSO_I }, // p
|
|
{ 18 MSO_I, 24 MSO_I }, { 19 MSO_I, 26 MSO_I }, { 19 MSO_I, 25 MSO_I }, // ccp
|
|
{ 19 MSO_I, 27 MSO_I }, { 18 MSO_I, 1 MSO_I }, { 17 MSO_I, 1 MSO_I }, // ccp
|
|
|
|
{ 0 MSO_I, 25 MSO_I }, { 0 MSO_I, 2 MSO_I }, // pp
|
|
|
|
{ 19 MSO_I, 25 MSO_I }, { 19 MSO_I, 2 MSO_I } // pp
|
|
};
|
|
const sal_uInt16 mso_sptRibbon2Segm[] =
|
|
{
|
|
0x4000, 0x0001, 0x2001, 0x0005, 0x2001, 0x0001, 0x2001, 0x0005, 0x2001, 0x0001, 0x6001, 0x8000,
|
|
0x4000, 0x0001, 0x2001, 0x0001, 0x2002, 0x6001, 0x8000,
|
|
0x4000, 0x0001, 0x2001, 0x0001, 0x2002, 0x6001, 0x8000,
|
|
0x4000, 0x0001, 0x8000,
|
|
0x4000, 0x0001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptRibbon2Calc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, // 00
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0, 0 } }, // 01
|
|
{ 0x8000, { 21600, 0, 0x401 } }, // 02
|
|
{ 0x2001, { 0x402, 1, 2 } }, // 03
|
|
{ 0x2001, { 0x403, 1, 2 } }, // 04
|
|
{ 0x2001, { 0x404, 1, 2 } }, // 05
|
|
{ 0x2001, { 0x401, 1, 2 } }, // 06
|
|
{ 0x8000, { 21600, 0, 0x406 } }, // 07
|
|
{ 0x0000, { 420, 0, 0 } }, // 08
|
|
{ 0x2001, { 0x408, 2, 1 } }, // 09
|
|
{ 0x6000, { 0x400, 0x408, 0 } }, // 10
|
|
{ 0x6000, { 0x400, 0x409, 0 } }, // 11
|
|
{ 0x2000, { 0x400, 2700, 0 } }, // 12
|
|
{ 0x8000, { 21600, 0, 0x404 } }, // 13
|
|
{ 0x8000, { 21600, 0, 0x405 } }, // 14
|
|
{ 0xa000, { 0x40c, 0, 0x408 } }, // 15
|
|
{ 0xa000, { 0x40c, 0, 0x409 } }, // 16
|
|
|
|
{ 0x8000, { 21600, 0, 0x40b } }, // 17
|
|
{ 0x8000, { 21600, 0, 0x40a } }, // 18
|
|
{ 0x8000, { 21600, 0, 0x400 } }, // 19
|
|
{ 0x8000, { 21600, 0, 0x410 } }, // 20
|
|
{ 0x8000, { 21600, 0, 0x40f } }, // 21
|
|
{ 0x8000, { 21600, 0, 0x40c } }, // 22
|
|
|
|
{ 0xa000, { 0x40d, 0, 0x405 } }, // 23
|
|
{ 0x6000, { 0x401, 0x403, 0 } }, // 24
|
|
{ 0x6000, { 0x401, 0x404, 0 } }, // 25
|
|
{ 0x6000, { 0x419, 0x405, 0 } }, // 26
|
|
{ 0xa000, { 0x419, 0, 0x405 } } // 27
|
|
};
|
|
const sal_Int32 mso_sptRibbon2Default[] =
|
|
{
|
|
2, 5400, 18900
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptRibbon2TextRect[] =
|
|
{
|
|
{ { 0 MSO_I, 0 }, { 19 MSO_I, 1 MSO_I } }
|
|
};
|
|
const SvxMSDffHandle mso_sptRibbon2Handle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0x100, 0, 10800, 10800, 2700, 8100, MIN_INT32, 0x7fffffff },
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
10800, 0x101, 10800, 10800, MIN_INT32, 0x7fffffff, 14400, 21600 }
|
|
};
|
|
const mso_CustomShape msoRibbon2 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptRibbon2Vert),
|
|
const_cast<sal_uInt16*>(mso_sptRibbon2Segm), sizeof( mso_sptRibbon2Segm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptRibbon2Calc),
|
|
const_cast<sal_Int32*>(mso_sptRibbon2Default),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptRibbon2TextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptRibbon2Handle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptRibbonVert[] =
|
|
{
|
|
{ 0, 0 }, { 3 MSO_I, 0 },
|
|
{ 4 MSO_I, 11 MSO_I }, { 4 MSO_I, 10 MSO_I }, { 5 MSO_I, 10 MSO_I }, { 5 MSO_I, 11 MSO_I },
|
|
{ 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 },
|
|
{ 0 MSO_I, 16 MSO_I }, { 0 MSO_I, 15 MSO_I }, { 0, 15 MSO_I }, { 2700, 14 MSO_I },
|
|
|
|
{ 4 MSO_I, 11 MSO_I },
|
|
{ 3 MSO_I, 12 MSO_I }, { 1 MSO_I, 12 MSO_I },
|
|
{ 0 MSO_I, 13 MSO_I }, { 1 MSO_I, 10 MSO_I }, { 4 MSO_I, 10 MSO_I },
|
|
{ 5 MSO_I, 11 MSO_I },
|
|
{ 6 MSO_I, 12 MSO_I }, { 8 MSO_I, 12 MSO_I },
|
|
{ 9 MSO_I, 13 MSO_I }, { 8 MSO_I, 10 MSO_I }, { 5 MSO_I, 10 MSO_I },
|
|
{ 0 MSO_I, 13 MSO_I },
|
|
{ 0 MSO_I, 15 MSO_I },
|
|
{ 9 MSO_I, 13 MSO_I },
|
|
{ 9 MSO_I, 15 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptRibbonSegm[] =
|
|
{
|
|
0x4000, 0x0001, 0xa701, 0x0003, 0xa801, 0x0005, 0xa801, 0x0001, 0xa701, 0x0003, 0x6000, 0x8000,
|
|
0x4000, 0xaa00, 0xa801, 0x0001, 0xa702, 0x0001, 0x8000,
|
|
0x4000, 0xaa00, 0xa801, 0x0001, 0xa702, 0x0001, 0x8000,
|
|
0x4000, 0xaa00, 0x0001, 0x8000,
|
|
0x4000, 0xaa00, 0x0001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptRibbonCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, // 00
|
|
{ 0x2000, { 0x400, 675, 0 } }, // 01
|
|
{ 0x2000, { 0x401, 675, 0 } }, // 02
|
|
{ 0x2000, { 0x402, 675, 0 } }, // 03
|
|
{ 0x2000, { 0x403, 675, 0 } }, // 04
|
|
{ 0x8000, { 21600, 0, 0x404 } }, // 05
|
|
{ 0x8000, { 21600, 0, 0x403 } }, // 06
|
|
{ 0x8000, { 21600, 0, 0x402 } }, // 07
|
|
{ 0x8000, { 21600, 0, 0x401 } }, // 08
|
|
{ 0x8000, { 21600, 0, 0x400 } }, // 09
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0, 0 } }, // 10
|
|
{ 0x2001, { 0x40a, 1, 4 } }, // 11
|
|
{ 0x2001, { 0x40b, 2, 1 } }, // 12
|
|
{ 0x2001, { 0x40b, 3, 1 } }, // 13
|
|
{ 0x8000, { 10800, 0, 0x40c } }, // 14
|
|
{ 0x8000, { 21600, 0, 0x40a } }, // 15
|
|
{ 0x8000, { 21600, 0, 0x40b } }, // 16
|
|
{ 0x0001, { 21600, 1, 2 } }, // 17
|
|
{ 0x0000, { 21600, 0, 2700 } }, // 18
|
|
{ 0x2000, { 0x411, 0, 2700 } } // 19
|
|
};
|
|
const sal_Int32 mso_sptRibbonDefault[] =
|
|
{
|
|
2, 5400, 2700
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptRibbonTextRect[] =
|
|
{
|
|
{ { 0 MSO_I, 10 MSO_I }, { 9 MSO_I, 21600 } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptRibbonGluePoints[] =
|
|
{
|
|
{ 17 MSO_I, 10 MSO_I }, { 2700, 14 MSO_I }, { 17 MSO_I, 21600 }, { 18 MSO_I, 14 MSO_I }
|
|
};
|
|
const SvxMSDffHandle mso_sptRibbonHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0x100, 0, 10800, 10800, 2700, 8100, MIN_INT32, 0x7fffffff },
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
10800, 0x101, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 7200 }
|
|
};
|
|
const mso_CustomShape msoRibbon =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptRibbonVert),
|
|
const_cast<sal_uInt16*>(mso_sptRibbonSegm), sizeof( mso_sptRibbonSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptRibbonCalc),
|
|
const_cast<sal_Int32*>(mso_sptRibbonDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptRibbonTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptRibbonGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptRibbonHandle),
|
|
};
|
|
//msosptEllipseRibbon
|
|
//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
|
|
//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
|
|
const SvxMSDffVertPair mso_sptEllipseRibbonVert[] =
|
|
{
|
|
{ 9 MSO_I , 38 MSO_I },
|
|
{ 8 MSO_I , 37 MSO_I },
|
|
{ 0 , 27 MSO_I },
|
|
{ 0 MSO_I , 26 MSO_I },
|
|
{ 9 MSO_I , 13 MSO_I },
|
|
{ 8 MSO_I , 4 MSO_I },
|
|
{ 0 MSO_I , 25 MSO_I },
|
|
{ 22 MSO_I , 25 MSO_I },
|
|
{ 9 MSO_I , 38 MSO_I },
|
|
{ 8 MSO_I , 37 MSO_I },
|
|
{ 22 MSO_I , 26 MSO_I },
|
|
{ 3 MSO_I , 27 MSO_I },
|
|
{ 7 MSO_I , 40 MSO_I },
|
|
{ 3 MSO_I , 0 },
|
|
{ 9 MSO_I , 35 MSO_I },
|
|
{ 8 MSO_I , 10 MSO_I },
|
|
{ 3 MSO_I , 0 },
|
|
{ 21 MSO_I , 33 MSO_I },
|
|
{ 9 MSO_I , 36 MSO_I },
|
|
{ 8 MSO_I , 1 MSO_I },
|
|
{ 21 MSO_I , 31 MSO_I },
|
|
{ 20 MSO_I , 31 MSO_I },
|
|
{ 9 MSO_I , 35 MSO_I },
|
|
{ 8 MSO_I , 10 MSO_I },
|
|
{ 20 MSO_I , 33 MSO_I },
|
|
{ 0 , 0 },
|
|
{ 5 MSO_I , 40 MSO_I },
|
|
{ 9 MSO_I , 36 MSO_I },
|
|
{ 8 MSO_I , 1 MSO_I },
|
|
{ 20 MSO_I , 31 MSO_I },
|
|
{ 0 MSO_I , 32 MSO_I },
|
|
{ 20 MSO_I , 33 MSO_I },
|
|
{ 9 MSO_I , 36 MSO_I },
|
|
{ 8 MSO_I , 1 MSO_I },
|
|
{ 21 MSO_I , 31 MSO_I },
|
|
{ 22 MSO_I , 32 MSO_I },
|
|
{ 21 MSO_I , 33 MSO_I },
|
|
{ 0 MSO_I , 26 MSO_I },
|
|
{ 0 MSO_I , 32 MSO_I },
|
|
{ 22 MSO_I , 26 MSO_I },
|
|
{ 22 MSO_I , 32 MSO_I }
|
|
};
|
|
|
|
const sal_uInt16 mso_sptEllipseRibbonSegm[] =
|
|
{
|
|
0xa30c /*ar*/,0x0002/*l*/,0xa50c/*wa*/,0x0001/*l*/,
|
|
0x6001/*x*/, 0x8000/*e*/,0xa504/*wr*/,0xaa00/*nf*/,
|
|
0x0001/*l*/, 0x8000/*e*/,0xa304/*ar*/,0xaa00/*nf*/,
|
|
0x0001/*l*/, 0x8000/*e*/,0x4000/*m*/,0xaa00/*nf*/,
|
|
0x0001/*l*/, 0x8000/*e*/,0x4000/*m*/,0xaa00/*nf*/,
|
|
0x0001/*l*/, 0x8000/*e*/
|
|
};
|
|
|
|
const SvxMSDffCalculationData mso_sptEllipseRibbonCalc[] =
|
|
{
|
|
{ 0x2000 , { DFF_Prop_adjustValue , 0 , 0 } }, //val #0
|
|
{ 0x2000 , { DFF_Prop_adjust2Value , 0 , 0 } }, //val #1
|
|
{ 0x2000 , { DFF_Prop_adjust3Value , 0 , 0 } }, //val #2
|
|
{ 0x2000 , { DFF_Prop_geoRight , 0 , 0 } }, //val width
|
|
{ 0x2000 , { DFF_Prop_geoBottom , 0 , 0 } }, //val height
|
|
{ 0x2001 , { DFF_Prop_geoRight , 1 , 8 } }, //prod width 1 8
|
|
{ 0x2001 , { DFF_Prop_geoRight , 1 , 2 } }, //prod width 1 2
|
|
{ 0x2001 , { DFF_Prop_geoRight , 7 , 8 } }, //prod width 7 8
|
|
{ 0x2001 , { DFF_Prop_geoRight , 3 , 2 } }, //prod width 3 2
|
|
{ 0x8000 , { 0 , 0 , 0x406 } }, //sum 0 0 @6
|
|
{ 0xa000 , { DFF_Prop_geoBottom , 0 , DFF_Prop_adjust3Value } }, //sum height 0 #2
|
|
{ 0x2001 , { 0x40a , 30573 , 4096 } }, //prod @10 30573 4096
|
|
{ 0x2001 , { 0x40b , 2 , 1 } }, //prod @11 2 1
|
|
{ 0xa000 , { DFF_Prop_geoBottom , 0 , 0x40c } }, //sum height 0 @12
|
|
{ 0x6000 , { 0x40b , DFF_Prop_adjust3Value , 0 } }, //sum @11 #2 0
|
|
{ 0xe000 , { 0x40b , DFF_Prop_geoBottom , DFF_Prop_adjust2Value } }, //sum @11 height #1
|
|
{ 0xa000 , { DFF_Prop_geoBottom , 0 , DFF_Prop_adjust2Value } }, //sum height 0 #1
|
|
{ 0x2001 , { 0x410 , 1 , 2 } }, //prod @16 1 2
|
|
{ 0x6000 , { 0x40b , 0x411 , 0 } }, //sum @11 @17 0
|
|
{ 0xe000 , { 0x40e , DFF_Prop_adjust2Value , DFF_Prop_geoBottom } }, //sum @14 #1 height
|
|
{ 0x6000 , { DFF_Prop_adjustValue , 0x405 , 0 } }, //sum #0 @5 0
|
|
{ 0xa000 , { DFF_Prop_geoRight , 0 , 0x414 } }, //sum width 0 @20
|
|
{ 0xa000 , { DFF_Prop_geoRight , 0 , DFF_Prop_adjustValue } }, //sum width 0 #0
|
|
{ 0xa000 , { 0x406 , 0 , DFF_Prop_adjustValue } }, //sum @6 0 #0
|
|
{ 0xe00f , { 0x417 , DFF_Prop_geoRight , 0x40b } }, //ellipse @23 width @11
|
|
{ 0xe000 , { 0x418 , DFF_Prop_geoBottom , 0x40b } }, //sum @24 height @11
|
|
{ 0xe000 , { 0x419 , 0x40b , 0x413 } }, //sum @25 @11 @19
|
|
{ 0xe000 , { DFF_Prop_adjust3Value , 0x40b , 0x413 } }, //sum #2 @11 @19
|
|
{ 0x2001 , { 0x40b , 2391 , 32768 } }, //prod @11 2391 32768
|
|
{ 0xa000 , { 0x406 , 0 , 0x414 } }, //sum @6 0 @20
|
|
{ 0xe00f , { 0x41d , DFF_Prop_geoRight , 0x40b } }, //ellipse @29 width @11
|
|
{ 0xe000 , { DFF_Prop_adjust2Value , 0x41e , 0x40b } }, //sum #1 @30 @11
|
|
{ 0xe000 , { 0x419 , DFF_Prop_adjust2Value , DFF_Prop_geoBottom } }, //sum @25 #1 height
|
|
{ 0xe000 , { DFF_Prop_geoBottom , 0x41e , 0x40e } }, //sum height @30 @14
|
|
{ 0x6000 , { 0x40b , 0x40e , 0 } }, //sum @11 @14 0
|
|
{ 0xa000 , { DFF_Prop_geoBottom , 0 , 0x422 } }, //sum height 0 @34
|
|
{ 0xe000 , { 0x423 , 0x413 , 0x40b } }, //sum @35 @19 @11
|
|
{ 0xe000 , { 0x40a , 0x40f , 0x40b } }, //sum @10 @15 @11
|
|
{ 0xe000 , { 0x423 , 0x40f , 0x40b } }, //sum @35 @15 @11
|
|
{ 0xe000 , { 0x41c , 0x40e , 0x412 } }, //sum @28 @14 @18
|
|
{ 0xa000 , { DFF_Prop_geoBottom , 0 , 0x427 } }, //sum height 0 @39
|
|
{ 0xa000 , { 0x413 , 0 , 0x412 } }, //sum @19 0 @18
|
|
{ 0x2001 , { 0x429 , 2 , 3 } }, //prod @41 2 3
|
|
{ 0xa000 , { DFF_Prop_adjust2Value , 0 , 0x42a } }, //sum #1 0 @42
|
|
{ 0xa000 , { DFF_Prop_adjust3Value , 0 , 0x42a } }, //sum #2 0 @42
|
|
{ 0x2004 , { 0x42c , 20925 , 0 } }, //min @44 20925
|
|
{ 0x2001 , { DFF_Prop_geoRight , 3 , 8 } }, //prod width 3 8
|
|
{ 0x2000 , { 0x42e , 0 , 4 } }, //sum @46 0 4
|
|
};
|
|
|
|
const SvxMSDffTextRectangles mso_sptEllipseRibbonTextRect[] =
|
|
{//@0,@1,@22,@25
|
|
{ { 0 MSO_I, 1 MSO_I }, { 22 MSO_I, 25 MSO_I } }
|
|
};
|
|
|
|
const sal_Int32 mso_sptEllipseRibbonDefault[] =
|
|
{
|
|
3,5400,5400,18900
|
|
};
|
|
|
|
const SvxMSDffHandle mso_sptEllipseRibbonHandle[] =
|
|
{
|
|
//position="#0,bottomRight" xrange="@5,@47
|
|
//position="center,#1" yrange="@10,@43
|
|
//position="topLeft,#2" yrange="@27,@45
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL| SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL,
|
|
0x100, 21600, 0, 0, 0x8/*5+3*/, 0x32/*47+3*/, MIN_INT32, 0x7fffffff },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL,
|
|
10800, 0x101, 0, 0, MIN_INT32, 0x7fffffff,0xd/*10+3*/, 0x2e /*43+3*/ },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL,
|
|
0, 0x102, 0, 0, MIN_INT32, 0x7fffffff,0x1e/*27+3*/, 0x30 /*45+3*/ }
|
|
};
|
|
|
|
const mso_CustomShape msosptEllipseRibbon =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptEllipseRibbonVert),
|
|
const_cast<sal_uInt16*>(mso_sptEllipseRibbonSegm), sizeof( mso_sptEllipseRibbonSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptEllipseRibbonCalc),
|
|
const_cast<sal_Int32*>(mso_sptEllipseRibbonDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptEllipseRibbonTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptEllipseRibbonHandle),
|
|
};
|
|
|
|
//msosptEllipseRibbon2
|
|
//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
|
|
const SvxMSDffVertPair mso_sptEllipseRibbon2Vert[] =
|
|
{
|
|
{ 9 MSO_I , 34 MSO_I },
|
|
{ 8 MSO_I , 35 MSO_I },
|
|
{ 0 , 24 MSO_I },
|
|
{ 0 MSO_I , 23 MSO_I },
|
|
{ 9 MSO_I , 0 },
|
|
{ 8 MSO_I , 11 MSO_I },
|
|
{ 0 MSO_I , 22 MSO_I },
|
|
{ 19 MSO_I , 22 MSO_I },
|
|
{ 9 MSO_I , 34 MSO_I },
|
|
{ 8 MSO_I , 35 MSO_I },
|
|
{ 19 MSO_I , 23 MSO_I },
|
|
{ 3 MSO_I , 24 MSO_I },
|
|
{ 7 MSO_I , 36 MSO_I },
|
|
{ 3 MSO_I , 4 MSO_I },
|
|
{ 9 MSO_I , 31 MSO_I },
|
|
{ 8 MSO_I , 32 MSO_I },
|
|
{ 3 MSO_I , 4 MSO_I },
|
|
{ 18 MSO_I , 30 MSO_I },
|
|
{ 9 MSO_I , 1 MSO_I },
|
|
{ 8 MSO_I , 33 MSO_I },
|
|
{ 18 MSO_I , 28 MSO_I },
|
|
{ 17 MSO_I , 28 MSO_I },
|
|
{ 9 MSO_I , 31 MSO_I },
|
|
{ 8 MSO_I , 32 MSO_I },
|
|
{ 17 MSO_I , 30 MSO_I },
|
|
{ 0 , 4l MSO_I },
|
|
{ 5 MSO_I , 36 MSO_I },
|
|
{ 9 MSO_I , 1 MSO_I },
|
|
{ 8 MSO_I , 33 MSO_I },
|
|
{ 17 MSO_I , 28 MSO_I },
|
|
{ 0 MSO_I , 29 MSO_I },
|
|
{ 17 MSO_I , 30 MSO_I },
|
|
{ 9 MSO_I , 1 MSO_I },
|
|
{ 8 MSO_I , 33 MSO_I },
|
|
{ 18 MSO_I , 28 MSO_I },
|
|
{ 19 MSO_I , 29 MSO_I },
|
|
{ 18 MSO_I , 30 MSO_I },
|
|
{ 0 MSO_I , 23 MSO_I },
|
|
{ 0 MSO_I , 29 MSO_I },
|
|
{ 19 MSO_I , 23 MSO_I },
|
|
{ 19 MSO_I , 29 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptEllipseRibbon2Segm[] =
|
|
{
|
|
0xa50c/*wr*/,0x0002/*l*/,0xa30c/*at*/,0x0001/*l*/,
|
|
0x6001/*x*/, 0x8000/*e*/,0xa304/*ar*/,0xaa00/*nf*/,
|
|
0x0001/*l*/, 0x8000/*e*/,0xa504/*wr*/,0xaa00/*nf*/,
|
|
0x0001/*l*/, 0x8000/*e*/,0x4000/*m*/,0xaa00/*nf*/,
|
|
0x0001/*l*/, 0x8000/*e*/,0x4000/*m*/,0xaa00/*nf*/,
|
|
0x0001/*l*/, 0x8000/*e*/
|
|
};
|
|
|
|
const SvxMSDffCalculationData mso_sptEllipseRibbon2Calc[] =
|
|
{
|
|
{ 0x2000 , { DFF_Prop_adjustValue , 0 , 0 } }, //val #0
|
|
{ 0x2000 , { DFF_Prop_adjust2Value , 0 , 0 } }, //val #1
|
|
{ 0x2000 , { DFF_Prop_adjust3Value , 0 , 0 } }, //val #2
|
|
{ 0x2000 , { DFF_Prop_geoRight , 0 , 0 } }, //val width
|
|
{ 0x2000 , { DFF_Prop_geoBottom , 0 , 0 } }, //val height
|
|
{ 0x2001 , { DFF_Prop_geoRight , 1 , 8 } }, //prod width 1 8
|
|
{ 0x2001 , { DFF_Prop_geoRight , 1 , 2 } }, //prod width 1 2
|
|
{ 0x2001 , { DFF_Prop_geoRight , 7 , 8 } }, //prod width 7 8
|
|
{ 0x2001 , { DFF_Prop_geoRight , 3 , 2 } }, //prod width 3 2
|
|
{ 0x8000 , { 0 , 0 , 0x406 } }, //sum 0 0 @6
|
|
{ 0x2001 , { DFF_Prop_adjust3Value , 30573 , 4096 } }, //prod #2 30573 4096
|
|
{ 0x2001 , { 0x40a , 2 , 1 } }, //prod @10 2 1
|
|
{ 0xe000 , { 0x40a , DFF_Prop_geoBottom , DFF_Prop_adjust3Value } }, //sum @10 height #2
|
|
{ 0x6000 , { 0x40a , DFF_Prop_adjust2Value , 0 } }, //sum @10 #1 0
|
|
{ 0x2001 , { DFF_Prop_adjust2Value , 1 , 2 } }, //prod #1 1 2
|
|
{ 0x6000 , { 0x40a , 0x40e , 0 } }, //sum @10 @14 0
|
|
{ 0xa000 , { 0x40c , 0 , DFF_Prop_adjust2Value } }, //sum @12 0 #1
|
|
{ 0x6000 , { DFF_Prop_adjustValue , 0x405 , 0 } }, //sum #0 @5 0
|
|
{ 0xa000 , { DFF_Prop_geoRight , 0 , 0x411 } }, //sum width 0 @17
|
|
{ 0xa000 , { DFF_Prop_geoRight , 0 , DFF_Prop_adjustValue } }, //sum width 0 #0
|
|
{ 0xa000 , { 0x406 , 0 , DFF_Prop_adjustValue } }, //sum @6 0 #0
|
|
{ 0xe00f , { 0x414 , DFF_Prop_geoRight , 0x40a } }, //ellipse @20 width @10
|
|
{ 0xa000 , { 0x40a , 0 , 0x415 } }, //sum @10 0 @21
|
|
{ 0xe000 , { 0x416 , 0x410 , 0x40a } }, //sum @22 @16 @10
|
|
{ 0xe000 , { DFF_Prop_adjust3Value , 0x410 , 0x40a } }, //sum #2 @16 @10
|
|
{ 0x2001 , { 0x40a , 2391 , 32768 } }, //prod @10 2391 32768
|
|
{ 0xa000 , { 0x406 , 0 , 0x411 } }, //sum @6 0 @17
|
|
{ 0xe00f , { 0x41a , DFF_Prop_geoRight , 0x40a } }, //ellipse @26 width @10
|
|
{ 0xe000 , { 0x40a , DFF_Prop_adjust2Value , 0x41b } }, //sum @10 #1 @27
|
|
{ 0x6000 , { 0x416 , DFF_Prop_adjust2Value , 0 } }, //sum @22 #1 0
|
|
{ 0xa000 , { 0x40c , 0 , 0x41b } }, //sum @12 0 @27
|
|
{ 0xa000 , { DFF_Prop_geoBottom , 0 , DFF_Prop_adjust3Value } }, //sum height 0 #2
|
|
{ 0x6000 , { 0x40a , 0x40c , 0 } }, //sum @10 @12 0
|
|
{ 0xe000 , { 0x420 , 0x40a , 0x410 } }, //sum @32 @10 @16
|
|
{ 0xe000 , { 0x41f , 0x40a , 0x40d } }, //sum @31 @10 @13
|
|
{ 0xe000 , { 0x420 , 0x40a , 0x40d } }, //sum @32 @10 @13
|
|
{ 0xe000 , { 0x419 , 0x40c , 0x40f } }, //sum @25 @12 @15
|
|
{ 0xa000 , { 0x410 , 0 , 0x40f } }, //sum @16 0 @15
|
|
{ 0x2001 , { 0x425 , 2 , 3 } }, //prod @37 2 3
|
|
{ 0x6000 , { 0x401 , 0x426 , 0 } }, //sum @1 @38 0
|
|
{ 0x6000 , { DFF_Prop_adjust3Value , 0x426 , 0 } }, //sum #2 @38 0
|
|
{ 0x2005 , { 0x428 , 675 , 0 } }, //max @40 675
|
|
{ 0x2001 , { DFF_Prop_geoRight , 3 , 8 } }, //prod width 3 8
|
|
{ 0x2000 , { 0x42a , 0 , 4 } } //sum @42 0 4
|
|
};
|
|
|
|
const SvxMSDffTextRectangles mso_sptEllipseRibbon2TextRect[] =
|
|
{//@0,@22,@19,@1
|
|
{ { 0 MSO_I, 22 MSO_I }, { 19 MSO_I, 1 MSO_I } }
|
|
};
|
|
|
|
const sal_Int32 mso_sptEllipseRibbon2Default[] =
|
|
{
|
|
3,5400,16200,2700
|
|
};
|
|
|
|
const SvxMSDffHandle mso_sptEllipseRibbon2Handle[] =
|
|
{
|
|
//position="#0,topLeft" xrange="@5,@43
|
|
//position="center,#1" yrange="@39,@31
|
|
//position="topLeft,#2" yrange="@41,@24
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL| SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL,
|
|
0x100, 0, 0, 0, 0x8/*5+3*/, 0x2e/*43+3*/, MIN_INT32, 0x7fffffff },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL,
|
|
10800, 0x101, 0, 0, MIN_INT32, 0x7fffffff,0x2a/*39+3*/, 0x22 /*31+3*/ },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL,
|
|
0, 0x102, 0, 0, MIN_INT32, 0x7fffffff,0x2c/*41+3*/, 0x1b /*24+3*/ }
|
|
};
|
|
|
|
const mso_CustomShape msosptEllipseRibbon2 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptEllipseRibbon2Vert),
|
|
const_cast<sal_uInt16*>(mso_sptEllipseRibbon2Segm), sizeof( mso_sptEllipseRibbon2Segm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptEllipseRibbon2Calc),
|
|
const_cast<sal_Int32*>(mso_sptEllipseRibbon2Default),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptEllipseRibbon2TextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptEllipseRibbon2Handle),
|
|
};
|
|
// End
|
|
const SvxMSDffVertPair mso_sptVerticalScrollVert[] = // adjustment1 : 0 - 5400
|
|
{
|
|
{ 1 MSO_I, 21600 }, { 0, 11 MSO_I }, { 1 MSO_I, 12 MSO_I }, { 0 MSO_I, 12 MSO_I },
|
|
{ 0 MSO_I, 1 MSO_I }, { 4 MSO_I, 0 }, { 2 MSO_I, 0 }, { 21600, 1 MSO_I },
|
|
{ 2 MSO_I, 0 MSO_I }, { 3 MSO_I, 0 MSO_I }, { 3 MSO_I, 11 MSO_I }, { 5 MSO_I, 21600 },
|
|
|
|
{ 6 MSO_I, 1 MSO_I }, { 4 MSO_I, 0 MSO_I }, { 8 MSO_I, 9 MSO_I }, { 4 MSO_I, 1 MSO_I },
|
|
|
|
{ 0 MSO_I, 11 MSO_I }, { 1 MSO_I, 21600 }, { 0, 11 MSO_I }, { 1 MSO_I, 12 MSO_I },
|
|
{ 9 MSO_I, 10 MSO_I }, { 1 MSO_I, 11 MSO_I },
|
|
|
|
{ 4 MSO_I, 0 }, { 6 MSO_I, 1 MSO_I },
|
|
|
|
{ 0 MSO_I, 12 MSO_I }, { 0 MSO_I, 11 MSO_I },
|
|
|
|
{ 4 MSO_I, 0 MSO_I },
|
|
{ 2 MSO_I, 0 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptVerticalScrollSegm[] =
|
|
{
|
|
0x4000, 0xa702, 0x0002, 0xa801, 0x0001, 0xa702, 0x0002, 0xa801, 0x6001, 0x8000,
|
|
0x4000, 0xa801, 0xa702, 0x6000, 0x8000,
|
|
0x4000, 0xa803, 0xa702, 0x6001, 0x8000,
|
|
0x4000, 0xa701, 0x8000,
|
|
0x4000, 0x0001, 0x8000,
|
|
0x4000, 0x0001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptScrollCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x2001, { 0x400, 1, 2 } },
|
|
{ 0xa000, { DFF_Prop_geoRight, 0, 0x401 } },
|
|
{ 0xa000, { DFF_Prop_geoRight, 0, 0x400 } },
|
|
{ 0x6000, { 0x400, 0x401, 0 } },
|
|
{ 0xa000, { DFF_Prop_geoRight, 0, 0x404 } },
|
|
{ 0x2001, { 0x400, 2, 1 } },
|
|
{ 0x2001, { 0x401, 1, 2 } },
|
|
{ 0x6000, { 0x400, 0x407, 0 } },
|
|
{ 0x6000, { 0x401, 0x407, 0 } },
|
|
{ 0xa000, { DFF_Prop_geoBottom, 0, 0x409 } },
|
|
{ 0xa000, { DFF_Prop_geoBottom, 0, 0x401 } },
|
|
{ 0xa000, { DFF_Prop_geoBottom, 0, 0x400 } },
|
|
{ 0xa000, { DFF_Prop_geoBottom, 0, 0x404 } }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptScrollTextRect[] =
|
|
{
|
|
{ { 0 MSO_I, 0 MSO_I }, { 3 MSO_I, 12 MSO_I } }
|
|
};
|
|
const SvxMSDffHandle mso_sptVerticalScrollHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 5400 }
|
|
};
|
|
const mso_CustomShape msoVerticalScroll =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptVerticalScrollVert),
|
|
const_cast<sal_uInt16*>(mso_sptVerticalScrollSegm), sizeof( mso_sptVerticalScrollSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptScrollCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault2700),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptScrollTextRect),
|
|
21600, 21600,
|
|
11000, 10800,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptVerticalScrollHandle),
|
|
};
|
|
const SvxMSDffVertPair mso_sptHorizontalScrollVert[] = // adjustment1 : 0 - 5400
|
|
{
|
|
{ 0, 4 MSO_I }, { 1 MSO_I, 0 MSO_I }, { 3 MSO_I, 0 MSO_I }, { 3 MSO_I, 1 MSO_I },
|
|
{ 2 MSO_I, 0 }, { 21600, 1 MSO_I }, { 21600, 13 MSO_I }, { 2 MSO_I, 12 MSO_I },
|
|
{ 0 MSO_I, 12 MSO_I }, { 0 MSO_I, 11 MSO_I }, { 1 MSO_I, 21600 }, { 0, 11 MSO_I },
|
|
|
|
{ 1 MSO_I, 4 MSO_I }, { 9 MSO_I, 8 MSO_I }, { 0 MSO_I, 4 MSO_I }, { 1 MSO_I, 6 MSO_I },
|
|
|
|
{ 2 MSO_I, 1 MSO_I }, { 3 MSO_I, 9 MSO_I }, { 3 MSO_I, 1 MSO_I }, { 2 MSO_I, 0 },
|
|
{ 21600, 1 MSO_I }, { 2 MSO_I, 0 MSO_I },
|
|
|
|
{ 1 MSO_I, 6 MSO_I },
|
|
{ 0, 4 MSO_I },
|
|
|
|
{ 2 MSO_I, 0 MSO_I },
|
|
{ 3 MSO_I, 0 MSO_I },
|
|
|
|
{ 0 MSO_I, 4 MSO_I },
|
|
{ 0 MSO_I, 11 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptHorizontalScrollSegm[] =
|
|
{
|
|
0x4000, 0xa801, 0x0002, 0xa802, 0x0001, 0xa801, 0x0002, 0xa802, 0x6001, 0x8000,
|
|
0x4000, 0xa803, 0x6000, 0x8000,
|
|
0x4000, 0xa803, 0xa702, 0x6000, 0x8000,
|
|
0x4000, 0xa701, 0x8000,
|
|
0x4000, 0x0001, 0x8000,
|
|
0x4000, 0x0001, 0x8000
|
|
};
|
|
const SvxMSDffHandle mso_sptHorizontalScrollHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0x100, 0, 10800, 10800, 0, 5400, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoHorizontalScroll =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptHorizontalScrollVert),
|
|
const_cast<sal_uInt16*>(mso_sptHorizontalScrollSegm), sizeof( mso_sptHorizontalScrollSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptScrollCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault2700),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptScrollTextRect),
|
|
21600, 21600,
|
|
10800, 11000,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptHorizontalScrollHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptFlowChartProcessVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 }, { 0, 0 }
|
|
};
|
|
const mso_CustomShape msoFlowChartProcess =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartProcessVert),
|
|
nullptr, 0,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptStandardGluePoints),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptFlowChartAlternateProcessVert[] =
|
|
{
|
|
{ 0, 2 MSO_I }, { 0 MSO_I, 0 }, { 1 MSO_I, 0 }, { 21600, 2 MSO_I },
|
|
{ 21600, 3 MSO_I }, { 1 MSO_I, 21600 }, { 0 MSO_I, 21600 }, { 0, 3 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptFlowChartAlternateProcessSegm[] =
|
|
{
|
|
0x4000, 0xa801, 0x0001, 0xa701, 0x0001, 0xa801, 0x0001, 0xa701, 0x6000, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptFlowChartAlternateProcessCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_geoLeft, 3600, 0 } },
|
|
{ 0x2000, { DFF_Prop_geoRight, 0, 3600 } },
|
|
{ 0x2000, { DFF_Prop_geoTop, 3600, 0 } },
|
|
{ 0x2000, { DFF_Prop_geoBottom, 0, 3600 } },
|
|
{ 0x2000, { DFF_Prop_geoLeft, 1054, 0 } },
|
|
{ 0x2000, { DFF_Prop_geoRight, 0, 1054 } },
|
|
{ 0x2000, { DFF_Prop_geoTop, 1054, 0 } },
|
|
{ 0x2000, { DFF_Prop_geoBottom,0, 1054 } }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptFlowChartAlternateProcessTextRect[] =
|
|
{
|
|
{ { 4 MSO_I, 6 MSO_I }, { 5 MSO_I, 7 MSO_I } }
|
|
};
|
|
const mso_CustomShape msoFlowChartAlternateProcess =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartAlternateProcessVert),
|
|
const_cast<sal_uInt16*>(mso_sptFlowChartAlternateProcessSegm), sizeof( mso_sptFlowChartAlternateProcessSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptFlowChartAlternateProcessCalc),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFlowChartAlternateProcessTextRect),
|
|
21600, 21600,
|
|
10800, 10800,
|
|
std::span<const SvxMSDffVertPair>(mso_sptStandardGluePoints),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptFlowChartDecisionVert[] =
|
|
{
|
|
{ 0, 10800 }, { 10800, 0 }, { 21600, 10800 }, { 10800, 21600 }, { 0, 10800 }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptFlowChartDecisionTextRect[] =
|
|
{
|
|
{ { 5400, 5400 }, { 16200, 16200 } }
|
|
};
|
|
const mso_CustomShape msoFlowChartDecision =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartDecisionVert),
|
|
nullptr, 0,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFlowChartDecisionTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptStandardGluePoints),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptFlowChartInputOutputVert[] =
|
|
{
|
|
{ 4230, 0 }, { 21600, 0 }, { 17370, 21600 }, { 0, 21600 }, { 4230, 0 }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptFlowChartInputOutputTextRect[] =
|
|
{
|
|
{ { 4230, 0 }, { 17370, 21600 } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptFlowChartInputOutputGluePoints[] =
|
|
{
|
|
{ 12960, 0 }, { 10800, 0 }, { 2160, 10800 }, { 8600, 21600 }, { 10800, 21600 }, { 19400, 10800 }
|
|
};
|
|
const mso_CustomShape msoFlowChartInputOutput =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartInputOutputVert),
|
|
nullptr, 0,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFlowChartInputOutputTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartInputOutputGluePoints),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptFlowChartPredefinedProcessVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
|
|
|
|
{ 2540, 0 }, { 2540, 21600 },
|
|
|
|
{ 21600 - 2540, 0 }, { 21600 - 2540, 21600 }
|
|
};
|
|
const sal_uInt16 mso_sptFlowChartPredefinedProcessSegm[] =
|
|
{
|
|
0x4000, 0x0003, 0x6000, 0x8000,
|
|
0x4000, 0x0001, 0x8000,
|
|
0x4000, 0x0001, 0x8000
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptFlowChartPredefinedProcessTextRect[] =
|
|
{
|
|
{ { 2540, 0 }, { 21600 - 2540, 21600 } }
|
|
};
|
|
const mso_CustomShape msoFlowChartPredefinedProcess =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartPredefinedProcessVert),
|
|
const_cast<sal_uInt16*>(mso_sptFlowChartPredefinedProcessSegm), sizeof( mso_sptFlowChartPredefinedProcessSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFlowChartPredefinedProcessTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptFlowChartInternalStorageVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
|
|
|
|
{ 4230, 0 }, { 4230, 21600 },
|
|
|
|
{ 0, 4230 }, { 21600, 4230 }
|
|
};
|
|
const sal_uInt16 mso_sptFlowChartInternalStorageSegm[] =
|
|
{
|
|
0x4000, 0x0003, 0x6000, 0x8000,
|
|
0x4000, 0x0001, 0x8000,
|
|
0x4000, 0x0001, 0x8000
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptFlowChartInternalStorageTextRect[] =
|
|
{
|
|
{ { 4230, 4230 }, { 21600, 21600 } }
|
|
};
|
|
const mso_CustomShape msoFlowChartInternalStorage =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartInternalStorageVert),
|
|
const_cast<sal_uInt16*>(mso_sptFlowChartInternalStorageSegm), sizeof( mso_sptFlowChartInternalStorageSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFlowChartInternalStorageTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptFlowChartDocumentVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 0 }, { 21600, 17360 },
|
|
{ 13050, 17220 }, { 13340, 20770 }, { 5620, 21600 }, // ccp
|
|
{ 2860, 21100 }, { 1850, 20700 }, { 0, 20120 } // ccp
|
|
};
|
|
const sal_uInt16 mso_sptFlowChartDocumentSegm[] =
|
|
{
|
|
0x4000, 0x0002, 0x2002, 0x6000, 0x8000
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptFlowChartDocumentTextRect[] =
|
|
{
|
|
{ { 0, 0 }, { 21600, 17360 } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptFlowChartDocumentGluePoints[] =
|
|
{
|
|
{ 10800, 0 }, { 0, 10800 }, { 10800, 20320 }, { 21600, 10800 }
|
|
};
|
|
const mso_CustomShape msoFlowChartDocument =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartDocumentVert),
|
|
const_cast<sal_uInt16*>(mso_sptFlowChartDocumentSegm), sizeof( mso_sptFlowChartDocumentSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFlowChartDocumentTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartDocumentGluePoints),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptFlowChartMultidocumentVert[] =
|
|
{
|
|
{ 0, 3600 }, { 1500, 3600 }, { 1500, 1800 }, { 3000, 1800 },
|
|
{ 3000, 0 }, { 21600, 0 }, { 21600, 14409 }, { 21600 - 1500, 14409 },
|
|
{ 21600 - 1500, 14409 + 1800 }, { 21600 - 3000, 14409 + 1800 }, { 21600 - 3000, 14409 + 3600 },
|
|
{ 11610, 14293 + 3600 }, { 11472, 17239 + 3600 }, { 4833, 17928 + 3600 }, // ccp
|
|
{ 2450, 17513 + 3600 }, { 1591, 17181 + 3600 }, { 0, 16700 + 3600 }, // ccp
|
|
|
|
{ 1500, 3600 }, { 21600 - 3000, 3600 }, { 21600 - 3000, 14409 + 1800 },
|
|
|
|
{ 3000, 1800 }, { 21600 - 1500, 1800 }, { 21600 - 1500, 14409 }
|
|
};
|
|
const sal_uInt16 mso_sptFlowChartMultidocumentSegm[] =
|
|
{
|
|
0x4000, 0x000a, 0x2002, 0x6000, 0x8000,
|
|
0x4000, 0xaa00, 0x0002, 0x8000, // NO FILL
|
|
0x4000, 0xaa00, 0x0002, 0x8000 // NO FILL
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptFlowChartMultidocumentTextRect[] =
|
|
{
|
|
{ { 0, 3600 }, { 21600 - 3000, 14409 + 3600 } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptFlowChartMultidocumentGluePoints[] =
|
|
{
|
|
{ 10800, 0 }, { 0, 10800 }, { 10800, 19890 }, { 21600, 10800 }
|
|
};
|
|
const mso_CustomShape msoFlowChartMultidocument =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartMultidocumentVert),
|
|
const_cast<sal_uInt16*>(mso_sptFlowChartMultidocumentSegm), sizeof( mso_sptFlowChartMultidocumentSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFlowChartMultidocumentTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartMultidocumentGluePoints),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptFlowChartTerminatorVert[] =
|
|
{
|
|
{ 3470, 21600 }, { 0, 10800 }, { 3470, 0 }, { 18130, 0 },
|
|
{ 21600, 10800 }, { 18130, 21600 }
|
|
};
|
|
const sal_uInt16 mso_sptFlowChartTerminatorSegm[] =
|
|
{
|
|
0x4000, 0xa702, 0x0001, 0xa702, 0x6000, 0x8000
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptFlowChartTerminatorTextRect[] =
|
|
{
|
|
{ { 1060, 3180 }, { 20540, 18420 } }
|
|
};
|
|
const mso_CustomShape msoFlowChartTerminator =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartTerminatorVert),
|
|
const_cast<sal_uInt16*>(mso_sptFlowChartTerminatorSegm), sizeof( mso_sptFlowChartTerminatorSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFlowChartTerminatorTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptStandardGluePoints),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptFlowChartPreparationVert[] =
|
|
{
|
|
{ 4350, 0 }, { 17250, 0 }, { 21600, 10800 }, { 17250, 21600 },
|
|
{ 4350, 21600 }, { 0, 10800 }, { 4350, 0 }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptFlowChartPreparationTextRect[] =
|
|
{
|
|
{ { 4350, 0 }, { 17250, 21600 } }
|
|
};
|
|
const mso_CustomShape msoFlowChartPreparation =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartPreparationVert),
|
|
nullptr, 0,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFlowChartPreparationTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptStandardGluePoints),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptFlowChartManualInputVert[] =
|
|
{
|
|
{ 0, 4300 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 }, { 0, 4300 }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptFlowChartManualInputTextRect[] =
|
|
{
|
|
{ { 0, 4300 }, { 21600, 21600 } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptFlowChartManualInputGluePoints[] =
|
|
{
|
|
{ 10800, 2150 }, { 0, 10800 }, { 10800, 19890 }, { 21600, 10800 }
|
|
};
|
|
const mso_CustomShape msoFlowChartManualInput =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartManualInputVert),
|
|
nullptr, 0,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFlowChartManualInputTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartManualInputGluePoints),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptFlowChartManualOperationVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 0 }, { 17250, 21600 }, { 4350, 21600 }, { 0, 0 }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptFlowChartManualOperationTextRect[] =
|
|
{
|
|
{ { 4350, 0 }, { 17250, 21600 } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptFlowChartManualOperationGluePoints[] =
|
|
{
|
|
{ 10800, 0 }, { 2160, 10800 }, { 10800, 21600 }, { 19440, 10800 }
|
|
};
|
|
const mso_CustomShape msoFlowChartManualOperation =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartManualOperationVert),
|
|
nullptr, 0,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFlowChartManualOperationTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartManualOperationGluePoints),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptFlowChartConnectorVert[] =
|
|
{
|
|
{ 10800, 10800 }, { 10800, 10800 }, { 0, 360 }
|
|
};
|
|
const sal_uInt16 mso_sptFlowChartConnectorSegm[] =
|
|
{
|
|
0xa203, 0x6000, 0x8000
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptFlowChartConnectorTextRect[] =
|
|
{
|
|
{ { 3180, 3180 }, { 18420, 18420 } }
|
|
};
|
|
const mso_CustomShape msoFlowChartConnector =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartConnectorVert),
|
|
const_cast<sal_uInt16*>(mso_sptFlowChartConnectorSegm), sizeof( mso_sptFlowChartConnectorSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFlowChartConnectorTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptEllipseGluePoints),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptFlowChartOffpageConnectorVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 0 }, { 21600, 17150 }, { 10800, 21600 },
|
|
{ 0, 17150 }, { 0, 0 }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptFlowChartOffpageConnectorTextRect[] =
|
|
{
|
|
{ { 0, 0 }, { 21600, 17150 } }
|
|
};
|
|
const mso_CustomShape msoFlowChartOffpageConnector =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartOffpageConnectorVert),
|
|
nullptr, 0,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFlowChartOffpageConnectorTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptStandardGluePoints),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptFlowChartPunchedCardVert[] =
|
|
{
|
|
{ 4300, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
|
|
{ 0, 4300 }, { 4300, 0 }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptFlowChartPunchedCardTextRect[] =
|
|
{
|
|
{ { 0, 4300 }, { 21600, 21600 } }
|
|
};
|
|
const mso_CustomShape msoFlowChartPunchedCard =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartPunchedCardVert),
|
|
nullptr, 0,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFlowChartPunchedCardTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptStandardGluePoints),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptFlowChartPunchedTapeVert[] =
|
|
{
|
|
{ 0, 2230 }, // p
|
|
{ 820, 3990 }, { 3410, 3980 }, { 5370, 4360 }, // ccp
|
|
{ 7430, 4030 }, { 10110, 3890 }, { 10690, 2270 }, // ccp
|
|
{ 11440, 300 }, { 14200, 160 }, { 16150, 0 }, // ccp
|
|
{ 18670, 170 }, { 20690, 390 }, { 21600, 2230 }, // ccp
|
|
{ 21600, 19420 }, // p
|
|
{ 20640, 17510 }, { 18320, 17490 }, { 16140, 17240 }, // ccp
|
|
{ 14710, 17370 }, { 11310, 17510 }, { 10770, 19430 }, // ccp
|
|
{ 10150, 21150 }, { 7380, 21290 }, { 5290, 21600 }, // ccp
|
|
{ 3220, 21250 }, { 610, 21130 }, { 0, 19420 } // ccp
|
|
};
|
|
const sal_uInt16 mso_sptFlowChartPunchedTapeSegm[] =
|
|
{
|
|
0x4000, 0x2004, 0x0001, 0x2004, 0x6000, 0x8000
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptFlowChartPunchedTapeTextRect[] =
|
|
{
|
|
{ { 0, 4360 }, { 21600, 17240 } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptFlowChartPunchedTapeGluePoints[] =
|
|
{
|
|
{ 10800, 2020 }, { 0, 10800 }, { 10800, 19320 }, { 21600, 10800 }
|
|
};
|
|
const mso_CustomShape msoFlowChartPunchedTape =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartPunchedTapeVert),
|
|
const_cast<sal_uInt16*>(mso_sptFlowChartPunchedTapeSegm), sizeof( mso_sptFlowChartPunchedTapeSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFlowChartPunchedTapeTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartPunchedTapeGluePoints),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptFlowChartSummingJunctionVert[] =
|
|
{
|
|
{ 10800, 10800 }, { 10800, 10800 }, { 0, 360 },
|
|
|
|
{ 3100, 3100 },
|
|
{ 18500, 18500 },
|
|
|
|
{ 3100, 18500 },
|
|
{ 18500, 3100 }
|
|
};
|
|
const sal_uInt16 mso_sptFlowChartSummingJunctionSegm[] =
|
|
{
|
|
0xa203, 0x6000, 0x8000,
|
|
0x4000, 0x0001, 0x8000,
|
|
0x4000, 0x0001, 0x8000
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptFlowChartSummingJunctionTextRect[] =
|
|
{
|
|
{ { 3100, 3100 }, { 18500, 18500 } }
|
|
};
|
|
const mso_CustomShape msoFlowChartSummingJunction =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartSummingJunctionVert),
|
|
const_cast<sal_uInt16*>(mso_sptFlowChartSummingJunctionSegm), sizeof( mso_sptFlowChartSummingJunctionSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFlowChartSummingJunctionTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptEllipseGluePoints),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptFlowChartOrVert[] =
|
|
{
|
|
{ 10800, 10800 }, { 10800, 10800 }, { 0, 360 },
|
|
|
|
{ 0, 10800 }, { 21600, 10800 },
|
|
|
|
{ 10800, 0 }, { 10800, 21600 }
|
|
};
|
|
const sal_uInt16 mso_sptFlowChartOrSegm[] =
|
|
{
|
|
0xa203, 0x6000, 0x8000,
|
|
0x4000, 0x0001, 0x8000,
|
|
0x4000, 0x0001, 0x8000
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptFlowChartOrTextRect[] =
|
|
{
|
|
{ { 3100, 3100 }, { 18500, 18500 } }
|
|
};
|
|
const mso_CustomShape msoFlowChartOr =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartOrVert),
|
|
const_cast<sal_uInt16*>(mso_sptFlowChartOrSegm), sizeof( mso_sptFlowChartOrSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFlowChartOrTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptEllipseGluePoints),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptFlowChartCollateVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 21600 }, { 0, 21600 }, { 21600, 0 }, { 0, 0 }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptFlowChartCollateTextRect[] =
|
|
{
|
|
{ { 5400, 5400 }, { 16200, 16200 } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptFlowChartCollateGluePoints[] =
|
|
{
|
|
{ 10800, 0 }, { 10800, 10800 }, { 10800, 21600 }
|
|
};
|
|
const mso_CustomShape msoFlowChartCollate =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartCollateVert),
|
|
nullptr, 0,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFlowChartCollateTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartCollateGluePoints),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptFlowChartSortVert[] =
|
|
{
|
|
{ 0, 10800 }, { 10800, 0 }, { 21600, 10800 }, { 10800, 21600 },
|
|
|
|
{ 0, 10800 }, { 21600, 10800 }
|
|
};
|
|
const sal_uInt16 mso_sptFlowChartSortSegm[] =
|
|
{
|
|
0x4000, 0x0003, 0x6000, 0x8000,
|
|
0x4000, 0x0001, 0x8000
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptFlowChartSortTextRect[] =
|
|
{
|
|
{ { 5400, 5400 }, { 16200, 16200 } }
|
|
};
|
|
const mso_CustomShape msoFlowChartSort =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartSortVert),
|
|
const_cast<sal_uInt16*>(mso_sptFlowChartSortSegm), sizeof( mso_sptFlowChartSortSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFlowChartSortTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptFlowChartExtractVert[] =
|
|
{
|
|
{ 10800, 0 }, { 21600, 21600 }, { 0, 21600 }, { 10800, 0 }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptFlowChartExtractTextRect[] =
|
|
{
|
|
{ { 5400, 10800 }, { 16200, 21600 } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptFlowChartExtractGluePoints[] =
|
|
{
|
|
{ 10800, 0 }, { 5400, 10800 }, { 10800, 21600 }, { 16200, 10800 }
|
|
};
|
|
const mso_CustomShape msoFlowChartExtract =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartExtractVert),
|
|
nullptr, 0,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFlowChartExtractTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartExtractGluePoints),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptFlowChartMergeVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 0 }, { 10800, 21600 }, { 0, 0 }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptFlowChartMergeTextRect[] =
|
|
{
|
|
{ { 5400, 0 }, { 16200, 10800 } }
|
|
};
|
|
const mso_CustomShape msoFlowChartMerge =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartMergeVert),
|
|
nullptr, 0,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFlowChartMergeTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartExtractGluePoints),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptFlowChartOnlineStorageVert[] =
|
|
{
|
|
{ 3600, 21600 }, { 0, 10800 }, { 3600, 0 }, { 21600, 0 },
|
|
{ 18000, 10800 }, { 21600, 21600 }
|
|
};
|
|
const sal_uInt16 mso_sptFlowChartOnlineStorageSegm[] =
|
|
{
|
|
0x4000, 0xa702, 0x0001, 0xa702, 0x6000, 0x8000
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptFlowChartOnlineStorageTextRect[] =
|
|
{
|
|
{ { 3600, 0 }, { 18000, 21600 } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptFlowChartOnlineStorageGluePoints[] =
|
|
{
|
|
{ 10800, 0 }, { 0, 10800 }, { 10800, 21600 }, { 18000, 10800 }
|
|
};
|
|
const mso_CustomShape msoFlowChartOnlineStorage =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartOnlineStorageVert),
|
|
const_cast<sal_uInt16*>(mso_sptFlowChartOnlineStorageSegm), sizeof( mso_sptFlowChartOnlineStorageSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFlowChartOnlineStorageTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartOnlineStorageGluePoints),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptFlowChartDelayVert[] =
|
|
{
|
|
{ 10800, 0 }, { 21600, 10800 }, { 10800, 21600 }, { 0, 21600 },
|
|
{ 0, 0 }
|
|
};
|
|
const sal_uInt16 mso_sptFlowChartDelaySegm[] =
|
|
{
|
|
0x4000, 0xa702, 0x0002, 0x6000, 0x8000
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptFlowChartDelayTextRect[] =
|
|
{
|
|
{ { 0, 3100 }, { 18500, 18500 } }
|
|
};
|
|
const mso_CustomShape msoFlowChartDelay =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartDelayVert),
|
|
const_cast<sal_uInt16*>(mso_sptFlowChartDelaySegm), sizeof( mso_sptFlowChartDelaySegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFlowChartDelayTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptStandardGluePoints),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptFlowChartMagneticTapeVert[] =
|
|
{
|
|
{ 20980, 18150 }, { 20980, 21600 }, { 10670, 21600 },
|
|
{ 4770, 21540 }, { 0, 16720 }, { 0, 10800 }, // ccp
|
|
{ 0, 4840 }, { 4840, 0 }, { 10800, 0 }, // ccp
|
|
{ 16740, 0 }, { 21600, 4840 }, { 21600, 10800 }, // ccp
|
|
{ 21600, 13520 }, { 20550, 16160 }, { 18670, 18170 } // ccp
|
|
};
|
|
const sal_uInt16 mso_sptFlowChartMagneticTapeSegm[] =
|
|
{
|
|
0x4000, 0x0002, 0x2004, 0x6000, 0x8000
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptFlowChartMagneticTapeTextRect[] =
|
|
{
|
|
{ { 3100, 3100 }, { 18500, 18500 } }
|
|
};
|
|
const mso_CustomShape msoFlowChartMagneticTape =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartMagneticTapeVert),
|
|
const_cast<sal_uInt16*>(mso_sptFlowChartMagneticTapeSegm), sizeof( mso_sptFlowChartMagneticTapeSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFlowChartMagneticTapeTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptStandardGluePoints),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptFlowChartMagneticDiskVert[] =
|
|
{
|
|
{ 0, 3400 }, { 10800, 0 }, { 21600, 3400 }, { 21600, 18200 },
|
|
{ 10800, 21600 }, { 0, 18200 },
|
|
|
|
{ 0, 3400 }, { 10800, 6800 }, { 21600, 3400 }
|
|
};
|
|
const sal_uInt16 mso_sptFlowChartMagneticDiskSegm[] =
|
|
{
|
|
0x4000, 0xa802, 0x0001, 0xa802, 0x6000, 0x8000,
|
|
0x4000, 0xa802, 0x8000
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptFlowChartMagneticDiskTextRect[] =
|
|
{
|
|
{ { 0, 6800 }, { 21600, 18200 } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptFlowChartMagneticDiskGluePoints[] =
|
|
{
|
|
{ 10800, 6800 }, { 10800, 0 }, { 0, 10800 }, { 10800, 21600 }, { 21600, 10800 }
|
|
};
|
|
const mso_CustomShape msoFlowChartMagneticDisk =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartMagneticDiskVert),
|
|
const_cast<sal_uInt16*>(mso_sptFlowChartMagneticDiskSegm), sizeof( mso_sptFlowChartMagneticDiskSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFlowChartMagneticDiskTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartMagneticDiskGluePoints),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptFlowChartMagneticDrumVert[] =
|
|
{
|
|
{ 18200, 0 }, { 21600, 10800 }, { 18200, 21600 }, { 3400, 21600 },
|
|
{ 0, 10800 }, { 3400, 0 },
|
|
|
|
{ 18200, 0 }, { 14800, 10800 }, { 18200, 21600 }
|
|
};
|
|
const sal_uInt16 mso_sptFlowChartMagneticDrumSegm[] =
|
|
{
|
|
0x4000, 0xa702, 0x0001, 0xa702, 0x6000, 0x8000,
|
|
0x4000, 0xa702, 0x8000
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptFlowChartMagneticDrumTextRect[] =
|
|
{
|
|
{ { 3400, 0 }, { 14800, 21600 } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptFlowChartMagneticDrumGluePoints[] =
|
|
{
|
|
{ 10800, 0 }, { 0, 10800 }, { 10800, 21600 }, { 14800, 10800 }, { 21600, 10800 }
|
|
};
|
|
const mso_CustomShape msoFlowChartMagneticDrum =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartMagneticDrumVert),
|
|
const_cast<sal_uInt16*>(mso_sptFlowChartMagneticDrumSegm), sizeof( mso_sptFlowChartMagneticDrumSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFlowChartMagneticDrumTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartMagneticDrumGluePoints),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptFlowChartDisplayVert[] =
|
|
{
|
|
{ 3600, 0 }, { 17800, 0 }, { 21600, 10800 }, { 17800, 21600 },
|
|
{ 3600, 21600 }, { 0, 10800 }
|
|
};
|
|
const sal_uInt16 mso_sptFlowChartDisplaySegm[] =
|
|
{
|
|
0x4000, 0x0001, 0xa702, 0x0002, 0x6000, 0x8000
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptFlowChartDisplayTextRect[] =
|
|
{
|
|
{ { 3600, 0 }, { 17800, 21600 } }
|
|
};
|
|
const mso_CustomShape msoFlowChartDisplay =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptFlowChartDisplayVert),
|
|
const_cast<sal_uInt16*>(mso_sptFlowChartDisplaySegm), sizeof( mso_sptFlowChartDisplaySegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFlowChartDisplayTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptStandardGluePoints),
|
|
std::span<const SvxMSDffHandle>() // handles
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptWedgeRectCalloutVert[] =
|
|
{
|
|
{ 0, 0 },
|
|
{ 0, 3590 }, { 2 MSO_I, 3 MSO_I }, { 0, 8970 },
|
|
{ 0, 12630 },{ 4 MSO_I, 5 MSO_I }, { 0, 18010 },
|
|
{ 0, 21600 },
|
|
{ 3590, 21600 }, { 6 MSO_I, 7 MSO_I }, { 8970, 21600 },
|
|
{ 12630, 21600 }, { 8 MSO_I, 9 MSO_I }, { 18010, 21600 },
|
|
{ 21600, 21600 },
|
|
{ 21600, 18010 }, { 10 MSO_I, 11 MSO_I }, { 21600, 12630 },
|
|
{ 21600, 8970 }, { 12 MSO_I, 13 MSO_I }, { 21600, 3590 },
|
|
{ 21600, 0 },
|
|
{ 18010, 0 }, { 14 MSO_I, 15 MSO_I }, { 12630, 0 },
|
|
{ 8970, 0 }, { 16 MSO_I, 17 MSO_I }, { 3590, 0 },
|
|
{ 0, 0 }
|
|
};
|
|
const SvxMSDffCalculationData mso_sptWedgeRectCalloutCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 10800 } }, //0x400
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0,10800 } },
|
|
{ 0x6006, { 0x412, DFF_Prop_adjustValue, 0 } }, //0x402
|
|
{ 0x6006, { 0x412, DFF_Prop_adjust2Value, 6280 } },
|
|
{ 0x6006, { 0x417, DFF_Prop_adjustValue, 0 } }, //0x404
|
|
{ 0x6006, { 0x417, DFF_Prop_adjust2Value, 15320 } },
|
|
{ 0x6006, { 0x41a, DFF_Prop_adjustValue, 6280 } }, //0x406
|
|
{ 0x6006, { 0x41a, DFF_Prop_adjust2Value, 21600 } },
|
|
{ 0x6006, { 0x41d, DFF_Prop_adjustValue, 15320 } }, //0x408
|
|
{ 0x6006, { 0x41d, DFF_Prop_adjust2Value, 21600 } },
|
|
{ 0x6006, { 0x420, DFF_Prop_adjustValue, 21600 } }, //0x40a
|
|
{ 0x6006, { 0x420, DFF_Prop_adjust2Value, 15320 } },
|
|
{ 0x6006, { 0x422, DFF_Prop_adjustValue, 21600 } }, //0x40c
|
|
{ 0x6006, { 0x422, DFF_Prop_adjust2Value, 6280 } },
|
|
{ 0x6006, { 0x424, DFF_Prop_adjustValue, 15320 } }, //0x40e
|
|
{ 0x6006, { 0x424, DFF_Prop_adjust2Value, 0 } },
|
|
{ 0x6006, { 0x426, DFF_Prop_adjustValue, 6280 } }, //0x410
|
|
{ 0x6006, { 0x426, DFF_Prop_adjust2Value, 0 } },
|
|
{ 0xa006, { DFF_Prop_adjustValue, -1, 0x413 } }, //0x412
|
|
{ 0xa006, { 0x401, -1, 0x416 } },
|
|
{ 0x2003, { 0x400, 0, 0 } }, //0x414
|
|
{ 0x2003, { 0x401, 0, 0 } },
|
|
{ 0xa000, { 0x414, 0, 0x415 } }, //0x416
|
|
{ 0xa006, { DFF_Prop_adjustValue, -1, 0x418 } },
|
|
{ 0x6006, { 0x401, 0x416, -1 } }, //0x418
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0, 21600 } },
|
|
{ 0x6006, { 0x419, 0x41b, -1 } }, //0x41a
|
|
{ 0xa006, { 0x400, -1, 0x41c } },
|
|
{ 0xa000, { 0x415, 0, 0x414 } }, //0x41c
|
|
{ 0x6006, { 0x419, 0x41e, -1 } },
|
|
{ 0x6006, { 0x400, 0x41c, -1 } }, //0x41e
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 21600 } },
|
|
{ 0x6006, { 0x41f, 0x421, -1 } }, //0x420
|
|
{ 0x6006, { 0x401, 0x416, -1 } },
|
|
{ 0x6006, { 0x41f, 0x423, -1 } }, //0x422
|
|
{ 0xa006, { 0x401, -1, 0x416 } },
|
|
{ 0xa006, { DFF_Prop_adjust2Value, -1, 0x425 } }, //0x424
|
|
{ 0x6006, { 0x400, 0x41c, -1 } },
|
|
{ 0xa006, { DFF_Prop_adjust2Value, -1, 0x427 } }, //0x426
|
|
{ 0xa006, { 0x400, -1, 0x41c } },
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, //0x428
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0, 0 } }
|
|
};
|
|
const sal_Int32 mso_sptWedgeRectCalloutDefault[] =
|
|
{
|
|
2, 1400, 25920
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptWedgeRectCalloutTextRect[] =
|
|
{
|
|
{ { 0, 0 }, { 21600, 21600 } }
|
|
};
|
|
const SvxMSDffVertPair mso_sptWedgeRectCalloutGluePoints[] =
|
|
{
|
|
{ 10800, 0 }, { 0, 10800 }, { 10800, 21600 }, { 21600, 10800 }, { 40 MSO_I, 41 MSO_I }
|
|
};
|
|
const SvxMSDffHandle mso_sptCalloutHandle[] =
|
|
{
|
|
{
|
|
SvxMSDffHandleFlags::NONE,
|
|
0x100, 0x101, 10800, 10800, MIN_INT32, 0x7fffffff, MIN_INT32, 0x7fffffff
|
|
}
|
|
};
|
|
const mso_CustomShape msoWedgeRectCallout =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptWedgeRectCalloutVert),
|
|
nullptr, 0,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptWedgeRectCalloutCalc),
|
|
const_cast<sal_Int32*>(mso_sptWedgeRectCalloutDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptWedgeRectCalloutTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptWedgeRectCalloutGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptCalloutHandle),
|
|
};
|
|
const SvxMSDffVertPair mso_sptWedgeRRectCalloutVert[] =
|
|
{
|
|
{ 3590, 0 },
|
|
{ 0, 3590 },
|
|
{ 2 MSO_I, 3 MSO_I }, { 0, 8970 },
|
|
{ 0, 12630 },{ 4 MSO_I, 5 MSO_I }, { 0, 18010 },
|
|
{ 3590, 21600 },
|
|
{ 6 MSO_I, 7 MSO_I }, { 8970, 21600 },
|
|
{ 12630, 21600 }, { 8 MSO_I, 9 MSO_I }, { 18010, 21600 },
|
|
{ 21600, 18010 },
|
|
{ 10 MSO_I, 11 MSO_I }, { 21600, 12630 },
|
|
{ 21600, 8970 }, { 12 MSO_I, 13 MSO_I }, { 21600, 3590 },
|
|
{ 18010, 0 },
|
|
{ 14 MSO_I, 15 MSO_I }, { 12630, 0 },
|
|
{ 8970, 0 }, { 16 MSO_I, 17 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptWedgeRRectCalloutSegm[] =
|
|
{
|
|
0x4000, 0xa701, 0x0005, 0xa801, 0x0005, 0xa701, 0x0005, 0xa801, 0x0004, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptWedgeRRectCalloutTextRect[] =
|
|
{
|
|
{ { 800, 800 }, { 20800, 20800 } }
|
|
};
|
|
const mso_CustomShape msoWedgeRRectCallout =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptWedgeRRectCalloutVert),
|
|
const_cast<sal_uInt16*>(mso_sptWedgeRRectCalloutSegm), sizeof( mso_sptWedgeRRectCalloutSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptWedgeRectCalloutCalc),
|
|
const_cast<sal_Int32*>(mso_sptWedgeRectCalloutDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptWedgeRRectCalloutTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptCalloutHandle),
|
|
};
|
|
const SvxMSDffVertPair mso_sptBalloonVert[] =
|
|
{
|
|
{ 3590, 0 },
|
|
{ 0, 3590 },
|
|
{ 0, 14460 },
|
|
{ 3590, 18050 },
|
|
{ 40 MSO_I, 21600 }, { 5420, 18050 },
|
|
{ 18010, 18050 },
|
|
{ 21600, 14460 },
|
|
{ 21600, 3590 },
|
|
{ 18010, 0 }
|
|
};
|
|
const sal_uInt16 mso_sptBalloonSegm[] =
|
|
{
|
|
0x4000, 0xa701, 0x0001, 0xa801, 0x0003, 0xa701, 0x0001, 0xa801, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffHandle mso_sptBalloonHandle[] =
|
|
{
|
|
{
|
|
SvxMSDffHandleFlags::RANGE,
|
|
0x100, 1, 10800, 10800, 0, 8990, MIN_INT32, 0x7fffffff
|
|
}
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptBalloonTextRect[] =
|
|
{
|
|
{ { 800, 800 }, { 20800, 17250 } }
|
|
};
|
|
const mso_CustomShape msoBalloon =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptBalloonVert),
|
|
const_cast<sal_uInt16*>(mso_sptBalloonSegm), sizeof( mso_sptBalloonSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptWedgeRectCalloutCalc),
|
|
const_cast<sal_Int32*>(mso_sptWedgeRectCalloutDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptBalloonTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptBalloonHandle),
|
|
};
|
|
const SvxMSDffVertPair mso_sptWedgeEllipseCalloutVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 21600 }, { 0x16 MSO_I, 0x17 MSO_I }, { 0x12 MSO_I, 0x13 MSO_I }, { 0xe MSO_I, 0xf MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptWedgeEllipseCalloutSegm[] =
|
|
{
|
|
0xa504, 0x0001, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptWedgeEllipseCalloutCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 10800 } }, // 00 rad x
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0, 10800 } }, // 01 rad y
|
|
{ 0x6001, { 0x400, 0x400, 1 } }, // 02 rad x^2
|
|
{ 0x6001, { 0x401, 0x401, 1 } }, // 03 rad y^2
|
|
{ 0x6000, { 0x402, 0x403, 0 } }, // 04
|
|
{ 0x200d, { 0x404, 0, 0 } }, // 05
|
|
{ 0x2000, { 0x405, 0, 10800 } }, // 06 > 0 ? spur needs to be drawn : 10800
|
|
{ 0x6008, { 0x400, 0x401, 0 } }, // 07 atan2 -> angle
|
|
{ 0x2000, { 0x407, 0, 10 } }, // 08
|
|
{ 0x2000, { 0x407, 10, 0 } }, // 09
|
|
{ 0x400a, { 10800, 0x407, 0 } }, // 0a
|
|
{ 0x4009, { 10800, 0x407, 0 } }, // 0b
|
|
{ 0x2000, { 0x40a, 10800, 0 } }, // 0c
|
|
{ 0x2000, { 0x40b, 10800, 0 } }, // 0d
|
|
{ 0xe006, { 0x406, DFF_Prop_adjustValue, 0x40c } }, // 0e
|
|
{ 0xe006, { 0x406, DFF_Prop_adjust2Value, 0x40d } },// 0f
|
|
{ 0x400a, { 10800, 0x408, 0 } }, // 10
|
|
{ 0x4009, { 10800, 0x408, 0 } }, // 11
|
|
{ 0x2000, { 0x410, 10800, 0 } }, // 12
|
|
{ 0x2000, { 0x411, 10800, 0 } }, // 13
|
|
{ 0x400a, { 10800, 0x409, 0 } }, // 14
|
|
{ 0x4009, { 10800, 0x409, 0 } }, // 15
|
|
{ 0x2000, { 0x414, 10800, 0 } }, // 16
|
|
{ 0x2000, { 0x415, 10800, 0 } } // 17
|
|
};
|
|
const sal_Int32 mso_sptWedgeEllipseCalloutDefault[] =
|
|
{
|
|
2, 1350, 25920
|
|
};
|
|
const SvxMSDffVertPair mso_sptWedgeEllipseCalloutGluePoints[] =
|
|
{
|
|
{ 10800, 0 }, { 3160, 3160 }, { 0, 10800 }, { 3160, 18440 }, { 10800, 21600 }, { 18440, 18440 }, { 21600, 10800 }, { 18440, 3160 }, { 0xe MSO_I, 0xf MSO_I }
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptWedgeEllipseCalloutTextRect[] =
|
|
{
|
|
{ { 3200, 3200 }, { 18400, 18400 } }
|
|
};
|
|
const mso_CustomShape msoWedgeEllipseCallout =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptWedgeEllipseCalloutVert),
|
|
const_cast<sal_uInt16*>(mso_sptWedgeEllipseCalloutSegm), sizeof( mso_sptWedgeEllipseCalloutSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptWedgeEllipseCalloutCalc),
|
|
const_cast<sal_Int32*>(mso_sptWedgeEllipseCalloutDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptWedgeEllipseCalloutTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptWedgeEllipseCalloutGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptCalloutHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptCloudCalloutVert[] =
|
|
{
|
|
{ 1930,7160 }, // p
|
|
{ 1530,4490 }, { 3400,1970 }, { 5270,1970 }, // ccp
|
|
{ 5860,1950 }, { 6470,2210 }, { 6970,2600 }, // ccp
|
|
{ 7450,1390 }, { 8340,650 }, { 9340,650 }, // ccp
|
|
{ 10004,690 }, { 10710,1050 }, { 11210,1700 }, // ccp
|
|
{ 11570,630 }, { 12330,0 }, { 13150,0 }, // ccp
|
|
{ 13840,0 }, { 14470,460 }, { 14870,1160 }, // ccp
|
|
{ 15330,440 }, { 16020,0 }, { 16740,0 }, // ccp
|
|
{ 17910,0 }, { 18900,1130 }, { 19110,2710 }, // ccp
|
|
{ 20240,3150 }, { 21060,4580 }, { 21060,6220 }, // ccp
|
|
{ 21060,6720 }, { 21000,7200 }, { 20830,7660 }, // ccp
|
|
{ 21310,8460 }, { 21600,9450 }, { 21600,10460 }, // ccp
|
|
{ 21600,12750 }, { 20310,14680 }, { 18650,15010 }, // ccp
|
|
{ 18650,17200 }, { 17370,18920 }, { 15770,18920 }, // ccp
|
|
{ 15220,18920 }, { 14700,18710 }, { 14240,18310 }, // ccp
|
|
{ 13820,20240 }, { 12490,21600 }, { 11000,21600 }, // ccp
|
|
{ 9890,21600 }, { 8840,20790 }, { 8210,19510 }, // ccp
|
|
{ 7620,20000 }, { 7930,20290 }, { 6240,20290 }, // ccp
|
|
{ 4850,20290 }, { 3570,19280 }, { 2900,17640 }, // ccp
|
|
{ 1300,17600 }, { 480,16300 }, { 480,14660 }, // ccp
|
|
{ 480,13900 }, { 690,13210 }, { 1070,12640 }, // ccp
|
|
{ 380,12160 }, { 0,11210 }, { 0,10120 }, // ccp
|
|
{ 0,8590 }, { 840,7330 }, { 1930,7160 }, // ccp
|
|
|
|
{ 1930, 7160 }, { 1950, 7410 }, { 2040, 7690 }, { 2090, 7920 }, // pccp
|
|
{ 6970, 2600 }, { 7200, 2790 }, { 7480, 3050 }, { 7670, 3310 }, // pccp
|
|
{ 11210, 1700 }, { 11130, 1910 }, { 11080, 2160 }, { 11030, 2400 }, // pccp
|
|
{ 14870, 1160 }, { 14720, 1400 }, { 14640, 1720 }, { 14540, 2010 }, // pccp
|
|
{ 19110, 2710 }, { 19130, 2890 }, { 19230, 3290 }, { 19190, 3380 }, // pccp
|
|
{ 20830, 7660 }, { 20660, 8170 }, { 20430, 8620 }, { 20110, 8990 }, // pccp
|
|
{ 18660, 15010 }, { 18740, 14200 }, { 18280, 12200 }, { 17000, 11450 }, // pccp
|
|
{ 14240, 18310 }, { 14320, 17980 }, { 14350, 17680 }, { 14370, 17360 }, // pccp
|
|
{ 8220, 19510 }, { 8060, 19250 }, { 7960, 18950 }, { 7860, 18640 }, // pccp
|
|
{ 2900, 17640 }, { 3090, 17600 }, { 3280, 17540 }, { 3460, 17450 }, // pccp
|
|
{ 1070, 12640 }, { 1400, 12900 }, { 1780, 13130 }, { 2330, 13040 }, // pccp
|
|
|
|
{ 0x11 MSO_I, 0x12 MSO_I }, { 1800, 1800 }, { 0, 360 }, // circ1
|
|
{ 0x13 MSO_I, 0x14 MSO_I }, { 1200, 1200 }, { 0, 360 }, // circ2
|
|
{ 0xd MSO_I, 0xe MSO_I }, { 700, 700 }, { 0, 360 } // circ3
|
|
};
|
|
const sal_uInt16 mso_sptCloudCalloutSegm[] =
|
|
{
|
|
0x4000, 0x2016, 0x6001, 0x8000,
|
|
0x4000, 0x2001, 0xaa00, 0x8000,
|
|
0x4000, 0x2001, 0xaa00, 0x8000,
|
|
0x4000, 0x2001, 0xaa00, 0x8000,
|
|
0x4000, 0x2001, 0xaa00, 0x8000,
|
|
0x4000, 0x2001, 0xaa00, 0x8000,
|
|
0x4000, 0x2001, 0xaa00, 0x8000,
|
|
0x4000, 0x2001, 0xaa00, 0x8000,
|
|
0x4000, 0x2001, 0xaa00, 0x8000,
|
|
0x4000, 0x2001, 0xaa00, 0x8000,
|
|
0x4000, 0x2001, 0xaa00, 0x8000,
|
|
0x4000, 0x2001, 0xaa00, 0x8000,
|
|
0xa203, 0x6001, 0x8000,
|
|
0xa203, 0x6001, 0x8000,
|
|
0xa203, 0x6001, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptCloudCalloutCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 10800 } },
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0, 10800 } },
|
|
{ 0x6008, { 0x400, 0x401, 0 } },
|
|
{ 0x400a, { 10800, 0x402, 0 } }, // 3
|
|
{ 0x4009, { 10800, 0x402, 0 } }, // 4
|
|
{ 0x2000, { 0x403, 10800, 0 } }, // 5
|
|
{ 0x2000, { 0x404, 10800, 0 } }, // 6
|
|
{ 0xa000, { DFF_Prop_adjustValue, 0, 0x405 } }, // 7
|
|
{ 0xa000, { DFF_Prop_adjust2Value,0, 0x406 } }, // 8
|
|
{ 0x2001, { 0x407, 1, 3 } }, // 9
|
|
{ 0x2001, { 0x408, 1, 3 } }, // 0xa
|
|
{ 0x2001, { 0x407, 2, 3 } }, // 0xb
|
|
{ 0x2001, { 0x408, 2, 3 } }, // 0xc
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, // 0xd
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0, 0 } }, // 0xe
|
|
{ 0x2001, { 0x403, 1, 10800 / 900 } }, // 0xf taking half x distance of the radius from the first bobble
|
|
{ 0x2001, { 0x404, 1, 10800 / 900 } }, // 0x10
|
|
{ 0xe000, { 0x409, 0x405, 0x40f } }, // 0x11
|
|
{ 0xe000, { 0x40a, 0x406, 0x410 } }, // 0x12
|
|
{ 0x6000, { 0x40b, 0x405, 0 } }, // 0x13
|
|
{ 0x6000, { 0x40c, 0x406, 0 } } // 0x14
|
|
};
|
|
const sal_Int32 mso_sptCloudCalloutDefault[] =
|
|
{
|
|
2, 1350, 25920
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptCloudCalloutTextRect[] =
|
|
{
|
|
{ { 3000, 3320 }, { 17110, 17330 } }
|
|
};
|
|
const mso_CustomShape msoCloudCallout =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptCloudCalloutVert),
|
|
const_cast<sal_uInt16*>(mso_sptCloudCalloutSegm), sizeof( mso_sptCloudCalloutSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptCloudCalloutCalc),
|
|
const_cast<sal_Int32*>(mso_sptCloudCalloutDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptCloudCalloutTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptCalloutHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptWaveVert[] = // adjustment1 : 0 - 4460
|
|
{ // adjustment2 : 8640 - 12960
|
|
{ 7 MSO_I, 0 MSO_I }, { 15 MSO_I, 9 MSO_I }, { 16 MSO_I, 10 MSO_I }, { 12 MSO_I, 0 MSO_I },
|
|
{ 24 MSO_I, 1 MSO_I }, { 25 MSO_I, 26 MSO_I }, { 27 MSO_I, 28 MSO_I }, { 29 MSO_I, 1 MSO_I }
|
|
};
|
|
const SvxMSDffCalculationData mso_sptWaveCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, //400 (vert.adj)
|
|
{ 0x8000, { 21600, 0, 0x400 } }, //401
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },//402 (horz.adj)
|
|
{ 0x2000, { 0x402, 0, 10800 } }, //403 -2160 -> 2160 (horz.adj)
|
|
{ 0x2001, { 0x403, 2, 1 } }, //404 -4320 -> 4320 (horz.adj)
|
|
{ 0x2003, { 0x404, 0, 0 } }, //405 abs( 0x404 ) (horz.adj)
|
|
{ 0x8000, { 4320, 0, 0x405 } }, //406
|
|
{ 0xa006, { 0x403, 0, 0x405 } }, //407
|
|
{ 0x4001, { 15800, 0x400, 4460 } }, //408 0 -> 15800 (vert.adj)
|
|
{ 0xa000, { 0x400, 0, 0x408 } }, //409
|
|
{ 0x6000, { 0x400, 0x408, 0 } }, //40a
|
|
{ 0x8000, { 21600, 0, 0x404 } }, //40b
|
|
{ 0x6006, { 0x403, 0x40b, 21600 } }, //40c
|
|
{ 0xa000, { 0x40c, 0, 0x407 } }, //40d width between p0 and p1
|
|
{ 0x2001, { 0x405, 1, 2 } }, //40e
|
|
{ 0xa000, { 0x407, 7200, 0x40e } }, //40f
|
|
{ 0x6000, { 0x40c, 0x40e, 7200 } }, //410
|
|
{ 0x2001, { 0x40d, 1, 2 } }, //411 1/2 width
|
|
{ 0x6000, { 0x407, 0x411, 0 } }, //412 top center glue xpos
|
|
{ 0x8000, { 21600, 0, 0x412 } }, //413 bottom center glue xpos
|
|
{ 0x2001, { 0x405, 1, 2 } }, //414 left glue x pos
|
|
{ 0x8000, { 21600, 0, 0x414 } }, //415 right glue x pos
|
|
{ 0x2001, { 0x400, 2, 1 } }, //416 y1 (textbox)
|
|
{ 0x8000, { 21600, 0, 0x416 } }, //417 y2 (textbox)
|
|
|
|
{ 0x8000, { 21600, 0, 0x407 } }, //418 p2
|
|
|
|
{ 0x8000, { 21600, 0, 0x40f } }, //419 c
|
|
{ 0x6000, { 0x401, 0x408, 0 } }, //41a
|
|
|
|
{ 0x8000, { 21600, 0, 0x410 } }, //41b c
|
|
{ 0xa000, { 0x401, 0, 0x408 } }, //41c
|
|
|
|
{ 0x8000, { 21600, 0, 0x40c } } //41d p3
|
|
};
|
|
const SvxMSDffVertPair mso_sptWaveGluePoints[] =
|
|
{
|
|
{ 0x12 MSO_I, 0 MSO_I }, { 0x14 MSO_I, 10800 }, { 0x13 MSO_I, 1 MSO_I }, { 0x15 MSO_I, 10800 }
|
|
};
|
|
const sal_uInt16 mso_sptWaveSegm[] =
|
|
{
|
|
0x4000, 0x2001, 0x0001, 0x2001, 0x6000, 0x8000
|
|
};
|
|
const SvxMSDffHandle mso_sptWaveHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 4460 },
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0x101, 21600, 10800, 10800, 8640, 12960, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const sal_Int32 mso_sptWaveDefault[] =
|
|
{
|
|
2, 1400, 10800
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptWaveTextRect[] =
|
|
{
|
|
{ { 5 MSO_I, 22 MSO_I }, { 11 MSO_I, 23 MSO_I } }
|
|
};
|
|
const mso_CustomShape msoWave =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptWaveVert),
|
|
const_cast<sal_uInt16*>(mso_sptWaveSegm), sizeof( mso_sptWaveSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptWaveCalc),
|
|
const_cast<sal_Int32*>(mso_sptWaveDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptWaveTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptWaveGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptWaveHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptDoubleWaveVert[] = // adjustment1 : 0 - 2230
|
|
{ // adjustment2 : 8640 - 12960
|
|
{ 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 },
|
|
{ 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 }
|
|
};
|
|
const SvxMSDffCalculationData mso_sptDoubleWaveCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, //400 (vert.adj)
|
|
{ 0x8000, { 21600, 0, 0x400 } }, //401
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },//402 (horz.adj)
|
|
{ 0x2000, { 0x402, 0, 10800 } }, //403 -2160 -> 2160 (horz.adj)
|
|
{ 0x2001, { 0x403, 2, 1 } }, //404 -4320 -> 4320 (horz.adj)
|
|
{ 0x2003, { 0x404, 0, 0 } }, //405 abs( 0x404 ) (horz.adj)
|
|
{ 0x8000, { 4320, 0, 0x405 } }, //406 -> not used
|
|
{ 0xa006, { 0x403, 0, 0x405 } }, //407
|
|
{ 0x4001, { 7900, 0x400, 2230 } }, //408 0 -> 7900 (vert.adj)
|
|
{ 0xa000, { 0x400, 0, 0x408 } }, //409
|
|
{ 0x6000, { 0x400, 0x408, 0 } }, //40a
|
|
{ 0x8000, { 21600, 0, 0x404 } }, //40b
|
|
{ 0x6006, { 0x403, 0x40b, 21600 } }, //40c
|
|
{ 0xa000, { 0x40c, 0, 0x407 } }, //40d width between p0 and p1
|
|
{ 0x2001, { 0x405, 1, 2 } }, //40e
|
|
{ 0xa000, { 0x407, 3600, 0x40e } }, //40f
|
|
{ 0x6000, { 0x40c, 0x40e, 3600 } }, //410
|
|
{ 0x2001, { 0x40d, 1, 2 } }, //411 1/2 width
|
|
{ 0x6000, { 0x407, 0x411, 0 } }, //412 top center glue xpos
|
|
{ 0x8000, { 21600, 0, 0x412 } }, //413 bottom center glue xpos
|
|
{ 0x2001, { 0x405, 1, 2 } }, //414 left glue x pos
|
|
{ 0x8000, { 21600, 0, 0x414 } }, //415 right glue x pos
|
|
{ 0x2001, { 0x400, 2, 1 } }, //416 y1 (textbox)
|
|
{ 0x8000, { 21600, 0, 0x416 } }, //417 y2 (textbox)
|
|
|
|
{ 0x8000, { 21600, 0, 0x407 } }, //418 p2
|
|
|
|
{ 0x8000, { 21600, 0, 0x40f } }, //419 c
|
|
{ 0x6000, { 0x401, 0x408, 0 } }, //41a
|
|
|
|
{ 0x8000, { 21600, 0, 0x410 } }, //41b c
|
|
{ 0xa000, { 0x401, 0, 0x408 } }, //41c
|
|
|
|
{ 0x8000, { 21600, 0, 0x40c } }, //41d p3
|
|
{ 0xa000, { 0x412, 3600, 0x40e } }, //41e
|
|
{ 0x6000, { 0x412, 0x40e, 3600 } }, //41f
|
|
{ 0xa000, { 0x413, 3600, 0x40e } }, //420
|
|
{ 0x6000, { 0x413, 0x40e, 3600 } } //421
|
|
};
|
|
const SvxMSDffVertPair mso_sptDoubleWaveGluePoints[] =
|
|
{
|
|
{ 0x12 MSO_I, 0 MSO_I }, { 0x14 MSO_I, 10800 }, { 0x13 MSO_I, 1 MSO_I }, { 0x15 MSO_I, 10800 }
|
|
};
|
|
const sal_uInt16 mso_sptDoubleWaveSegm[] =
|
|
{
|
|
0x4000, 0x2002, 0x0001, 0x2002, 0x6000, 0x8000
|
|
};
|
|
const SvxMSDffHandle mso_sptDoubleWaveHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 2230 },
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0x101, 21600, 10800, 10800, 8640, 12960, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const sal_Int32 mso_sptDoubleWaveDefault[] =
|
|
{
|
|
2, 1400, 10800
|
|
};
|
|
const SvxMSDffTextRectangles mso_sptDoubleWaveTextRect[] =
|
|
{
|
|
{ { 5 MSO_I, 22 MSO_I }, { 11 MSO_I, 23 MSO_I } }
|
|
};
|
|
const mso_CustomShape msoDoubleWave =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptDoubleWaveVert),
|
|
const_cast<sal_uInt16*>(mso_sptDoubleWaveSegm), sizeof( mso_sptDoubleWaveSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptDoubleWaveCalc),
|
|
const_cast<sal_Int32*>(mso_sptDoubleWaveDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptDoubleWaveTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptDoubleWaveGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptDoubleWaveHandle),
|
|
};
|
|
|
|
// for each shapetype a bit of 1 is indicating that the shape is NOT filled by default
|
|
const sal_uInt16 mso_DefaultFillingTable[] =
|
|
{
|
|
0x0000, 0x0018, 0x01ff, 0x0000, 0x0c00, 0x01e0, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0600, 0x0000, 0x0000, 0x0000, 0x0000
|
|
};
|
|
bool IsCustomShapeFilledByDefault( MSO_SPT eSpType )
|
|
{
|
|
bool bIsFilledByDefault = true;
|
|
sal_uInt32 i = static_cast<sal_uInt32>(eSpType);
|
|
if ( i < 0x100 )
|
|
bIsFilledByDefault = ( mso_DefaultFillingTable[ i >> 4 ] & ( 1 << ( i & 0xf ) ) ) == 0;
|
|
return bIsFilledByDefault;
|
|
}
|
|
sal_Int16 GetCustomShapeConnectionTypeDefault( MSO_SPT eSpType )
|
|
{
|
|
sal_Int16 nGluePointType = css::drawing::EnhancedCustomShapeGluePointType::SEGMENTS;
|
|
const mso_CustomShape* pDefCustomShape = GetCustomShapeContent( eSpType );
|
|
if (pDefCustomShape && !pDefCustomShape->pGluePoints.empty())
|
|
nGluePointType = css::drawing::EnhancedCustomShapeGluePointType::CUSTOM;
|
|
else
|
|
{
|
|
switch( eSpType )
|
|
{
|
|
case mso_sptRectangle :
|
|
case mso_sptRoundRectangle :
|
|
case mso_sptPictureFrame :
|
|
case mso_sptFlowChartProcess :
|
|
case mso_sptFlowChartPredefinedProcess :
|
|
case mso_sptFlowChartInternalStorage :
|
|
case mso_sptTextPlainText :
|
|
case mso_sptTextBox :
|
|
case mso_sptVerticalScroll :
|
|
case mso_sptHorizontalScroll :
|
|
nGluePointType = css::drawing::EnhancedCustomShapeGluePointType::RECT;
|
|
break;
|
|
default: break;
|
|
}
|
|
}
|
|
return nGluePointType;
|
|
}
|
|
|
|
// for each shapetype a bit of 1 is indicating that the shape is NOT stroked by default
|
|
// #i28269#
|
|
const sal_uInt16 mso_DefaultStrokingTable[] =
|
|
{
|
|
0x0000, 0x0000, 0x0000, 0x0000,
|
|
0x0800, 0x0000, 0x0000, 0x0000, // #i28269# Added shape 75 (mso_sptPictureFrame)
|
|
0x0000, 0x0000, 0x0000, 0x0000,
|
|
0x0000, 0x0000, 0x0000, 0x0000
|
|
};
|
|
// #i28269#
|
|
bool IsCustomShapeStrokedByDefault( MSO_SPT eSpType )
|
|
{
|
|
bool bIsStrokedByDefault = true;
|
|
sal_uInt32 i = static_cast<sal_uInt32>(eSpType);
|
|
if ( i < 0x100 )
|
|
bIsStrokedByDefault = ( mso_DefaultStrokingTable[ i >> 4 ] & ( 1 << ( i & 0xf ) ) ) == 0;
|
|
return bIsStrokedByDefault;
|
|
}
|
|
|
|
const sal_uInt16 msoSortFilledObjectsToBackTable[] =
|
|
{
|
|
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0010, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000
|
|
};
|
|
bool SortFilledObjectsToBackByDefault( MSO_SPT eSpType )
|
|
{
|
|
bool bSortFilledObjectsToBackByDefault = true;
|
|
sal_uInt32 i = static_cast<sal_uInt32>(eSpType);
|
|
if ( i < 0x100 )
|
|
bSortFilledObjectsToBackByDefault = ( msoSortFilledObjectsToBackTable[ i >> 4 ] & ( 1 << ( i & 0xf ) ) ) != 0;
|
|
return bSortFilledObjectsToBackByDefault;
|
|
}
|
|
|
|
const SvxMSDffTextRectangles mso_sptFontWorkTextRect[] =
|
|
{
|
|
{ { 0, 0 }, { 21600, 21600 } }
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextPlainTextVert[] =
|
|
{
|
|
{ 3 MSO_I, 0 }, { 5 MSO_I, 0 }, { 6 MSO_I, 21600 }, { 7 MSO_I, 21600 }
|
|
};
|
|
const SvxMSDffCalculationData mso_sptTextPlainTextCalc[] = // adjustment1 : 6629 - 14971
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 10800 } },
|
|
{ 0x2001, { 0x400, 2, 1 } },
|
|
{ 0x2003, { 0x401, 0, 0 } },
|
|
{ 0xa006, { 0x401, 0, 0x402 } }, // x1(3)
|
|
{ 0x8000, { 21600, 0, 0x402 } },
|
|
{ 0x6006, { 0x401, 0x404, 21600 } }, // x2(5)
|
|
{ 0x6006, { 0x401, 0x402, 0 } }, // x2
|
|
{ 0xa006, { 0x401, 21600, 0x404 } } // x3(7)
|
|
};
|
|
const sal_uInt16 mso_sptTextPlainTextSegm[] =
|
|
{
|
|
0x4000, 0x0001, 0x8000,
|
|
0x4000, 0x0001, 0x8000
|
|
};
|
|
const SvxMSDffHandle mso_sptTextPlainTextHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0x100, 21600, 10800, 10800, 6629, 14971, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoTextPlainText =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextPlainTextVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextPlainTextSegm), sizeof( mso_sptTextPlainTextSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextPlainTextCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault10800),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextPlainTextHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextStopVert[] =
|
|
{
|
|
{ 0, 0 MSO_I }, { 7200, 0 }, { 14400, 0 }, { 21600, 0 MSO_I },
|
|
{ 0, 1 MSO_I }, { 7200, 21600 }, { 14400, 21600 }, { 21600, 1 MSO_I }
|
|
};
|
|
const SvxMSDffCalculationData mso_sptTextStopCalc[] = // adjustment1 : 3080 - 10800
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x8000, { 21600, 0, DFF_Prop_adjustValue } }
|
|
};
|
|
const sal_uInt16 mso_sptTextStopSegm[] =
|
|
{
|
|
0x4000, 0x0003, 0x8000,
|
|
0x4000, 0x0003, 0x8000
|
|
};
|
|
const sal_Int32 mso_sptTextStopDefault[] =
|
|
{
|
|
1, 2700
|
|
};
|
|
const SvxMSDffHandle mso_sptTextStopHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 3080, 10800 }
|
|
};
|
|
const mso_CustomShape msoTextStop =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextStopVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextStopSegm), sizeof( mso_sptTextStopSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextStopCalc),
|
|
const_cast<sal_Int32*>(mso_sptTextStopDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextStopHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextTriangleVert[] =
|
|
{
|
|
{ 0, 0 MSO_I }, { 10800, 0 }, { 21600, 0 MSO_I }, { 0, 21600 }, { 21600, 21600 }
|
|
};
|
|
const SvxMSDffCalculationData mso_sptTextTriangleCalc[] = // adjustment1 : 6629 - 14971
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } }
|
|
};
|
|
const sal_uInt16 mso_sptTextTriangleSegm[] =
|
|
{
|
|
0x4000, 0x0002, 0x8000,
|
|
0x4000, 0x0001, 0x8000
|
|
};
|
|
const SvxMSDffHandle mso_sptTextTriangleHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 21600 }
|
|
};
|
|
const mso_CustomShape msoTextTriangle =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextTriangleVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextTriangleSegm), sizeof( mso_sptTextTriangleSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextTriangleCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault10800),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextTriangleHandle),
|
|
};
|
|
const SvxMSDffVertPair mso_sptTextTriangleInvertedVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 0 }, { 0, 0 MSO_I }, { 10800, 21600 }, { 21600, 0 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptTextTriangleInvertedSegm[] =
|
|
{
|
|
0x4000, 0x0001, 0x8000,
|
|
0x4000, 0x0002, 0x8000
|
|
};
|
|
const mso_CustomShape msoTextTriangleInverted =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextTriangleInvertedVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextTriangleInvertedSegm), sizeof( mso_sptTextTriangleInvertedSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextTriangleCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault10800),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextTriangleHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextChevronVert[] =
|
|
{
|
|
{ 0, 0 MSO_I }, { 10800, 0 }, { 21600, 0 MSO_I }, { 0, 21600 }, { 10800, 1 MSO_I }, { 21600, 21600 }
|
|
};
|
|
const SvxMSDffCalculationData mso_sptTextChevronCalc[] = // adjustment1 : 6629 - 14971
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x8000, { 21600, 0, DFF_Prop_adjustValue } }
|
|
};
|
|
const sal_uInt16 mso_sptTextChevronSegm[] =
|
|
{
|
|
0x4000, 0x0002, 0x8000,
|
|
0x4000, 0x0002, 0x8000
|
|
};
|
|
const SvxMSDffHandle mso_sptTextChevronHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 10800 }
|
|
};
|
|
const mso_CustomShape msoTextChevron =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextChevronVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextChevronSegm), sizeof( mso_sptTextChevronSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextChevronCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault5400),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextChevronHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextChevronInvertedVert[] =
|
|
{
|
|
{ 0, 0 }, { 10800, 1 MSO_I }, { 21600, 0 }, { 0, 0 MSO_I }, { 10800, 21600 }, { 21600, 0 MSO_I }
|
|
};
|
|
const SvxMSDffCalculationData mso_sptTextChevronInvertedCalc[] = // adjustment1 : 6629 - 14971
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x8000, { 21600, 0, DFF_Prop_adjustValue } }
|
|
};
|
|
const sal_uInt16 mso_sptTextChevronInvertedSegm[] =
|
|
{
|
|
0x4000, 0x0002, 0x8000,
|
|
0x4000, 0x0002, 0x8000
|
|
};
|
|
const SvxMSDffHandle mso_sptTextChevronInvertedHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 10800, 21600 }
|
|
};
|
|
const mso_CustomShape msoTextChevronInverted =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextChevronInvertedVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextChevronInvertedSegm), sizeof( mso_sptTextChevronInvertedSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextChevronInvertedCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault16200),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextChevronInvertedHandle),
|
|
};
|
|
//V 0 0 21600 ?f2 0 ?f0 21600 ?f0
|
|
//W 0 0 21600 ?f2 21600 ?f0 0 ?f0 N
|
|
//V 0 ?f3 21600 21600 0 ?f1 21600 ?f1
|
|
//W 0 ?f3 21600 21600 21600 ?f1 0 ?f1 N
|
|
//mso_sptTextRingInside
|
|
const SvxMSDffVertPair mso_sptTextRingInsideVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 2 MSO_I }, { 0, 0 MSO_I },{ 21600, 0 MSO_I },//V
|
|
{ 0, 0 }, { 21600, 2 MSO_I }, { 21600, 0 MSO_I },{ 0, 0 MSO_I },//W
|
|
{ 0, 3 MSO_I }, { 21600, 21600 }, { 0, 1 MSO_I },{ 21600, 1 MSO_I },//V
|
|
{ 0, 3 MSO_I }, { 21600, 21600 }, { 21600, 1 MSO_I },{ 0, 1 MSO_I }//W
|
|
};
|
|
const SvxMSDffCalculationData mso_sptTextRingInsideCalc[] = // adjustment1 : 6629 - 14971
|
|
{
|
|
{ 0x2001, { DFF_Prop_adjustValue, 1, 2 } },
|
|
{ 0x8000, { 21600, 0, 0x400 } },
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, //$0
|
|
{ 0x8000, { 21600, 0, DFF_Prop_adjustValue } }//21600-$0
|
|
};
|
|
const sal_uInt16 mso_sptTextRingInsideSegm[] =
|
|
{
|
|
0xa604, 0xa504,0x8000,
|
|
0xa604, 0xa504,0x8000
|
|
};
|
|
const SvxMSDffHandle mso_sptTextRingInsideHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE| SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL,
|
|
10800, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 10800, 21600 }
|
|
};
|
|
const mso_CustomShape msoTextRingInside =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextRingInsideVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextRingInsideSegm), sizeof( mso_sptTextRingInsideSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextRingInsideCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault13500),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextRingInsideHandle),
|
|
};
|
|
//mso_sptTextRingOutside
|
|
//path = U 10800 ?f0 10800 ?f2 180 539 N U 10800 ?f1 10800 ?f2 180 539 N
|
|
// MSO binary format has swing angle, not end angle, therefore 359 instead of 539.
|
|
const SvxMSDffVertPair mso_sptTextRingOutsideVert[] =
|
|
{
|
|
{ 10800, 0 MSO_I }, { 10800, 0 MSO_I }, { 180, 359 },
|
|
{ 10800, 1 MSO_I }, { 10800, 0 MSO_I }, { 180, 359 }
|
|
};
|
|
const SvxMSDffCalculationData mso_sptTextRingOutsideCalc[] = // adjustment1 : 6629 - 14971
|
|
{
|
|
{ 0x2001, { DFF_Prop_adjustValue, 1, 2 } },
|
|
{ 0x8000, { 21600, 0, 0x400 } }
|
|
};
|
|
const sal_uInt16 mso_sptTextRingOutsideSegm[] =
|
|
{
|
|
0xA203, 0x8000,
|
|
0xA203, 0x8000
|
|
};
|
|
const SvxMSDffHandle mso_sptTextRingOutsideHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
10800, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 10800, 21600 }
|
|
};
|
|
const mso_CustomShape msoTextRingOutside =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextRingOutsideVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextRingOutsideSegm), sizeof( mso_sptTextRingOutsideSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextRingOutsideCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault13500),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextRingOutsideHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextFadeRightVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 0 MSO_I }, { 0, 21600 }, { 21600, 1 MSO_I }
|
|
};
|
|
const SvxMSDffCalculationData mso_sptTextFadeCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x8000, { 21600, 0, DFF_Prop_adjustValue } }
|
|
};
|
|
const sal_uInt16 mso_sptTextFadeSegm[] =
|
|
{
|
|
0x4000, 0x0001, 0x8000,
|
|
0x4000, 0x0001, 0x8000
|
|
};
|
|
const SvxMSDffHandle mso_sptTextFadeRightHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
21600, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 10800 }
|
|
};
|
|
const mso_CustomShape msoTextFadeRight =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextFadeRightVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextFadeSegm), sizeof( mso_sptTextFadeSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextFadeCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault7200),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextFadeRightHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextFadeLeftVert[] =
|
|
{
|
|
{ 0, 0 MSO_I }, { 21600, 0 }, { 0, 1 MSO_I }, { 21600, 21600 }
|
|
};
|
|
const SvxMSDffHandle mso_sptTextFadeLeftHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 10800 }
|
|
};
|
|
const mso_CustomShape msoTextFadeLeft =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextFadeLeftVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextFadeSegm), sizeof( mso_sptTextFadeSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextFadeCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault7200),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextFadeLeftHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextFadeUpVert[] =
|
|
{
|
|
{ 0 MSO_I, 0 }, { 1 MSO_I, 0 }, { 0, 21600 }, { 21600, 21600 }
|
|
};
|
|
const SvxMSDffHandle mso_sptTextFadeUpHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0x100, 0, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoTextFadeUp =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextFadeUpVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextFadeSegm), sizeof( mso_sptTextFadeSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextFadeCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault7200),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextFadeUpHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextFadeDownVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 0 }, { 0 MSO_I, 21600 }, { 1 MSO_I, 21600 }
|
|
};
|
|
const SvxMSDffHandle mso_sptTextFadeDownHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0x100, 21600, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoTextFadeDown =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextFadeDownVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextFadeSegm), sizeof( mso_sptTextFadeSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextFadeCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault7200),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextFadeDownHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextSlantUpVert[] =
|
|
{
|
|
{ 0, 0 MSO_I }, { 21600, 0 }, { 0, 21600 }, { 21600, 1 MSO_I }
|
|
};
|
|
const SvxMSDffHandle mso_sptTextSlantUpHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 15400 }
|
|
};
|
|
const mso_CustomShape msoTextSlantUp =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextSlantUpVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextFadeSegm), sizeof( mso_sptTextFadeSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextFadeCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault12000),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextSlantUpHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextSlantDownVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 1 MSO_I }, { 0, 0 MSO_I }, { 21600, 21600 }
|
|
};
|
|
const SvxMSDffHandle mso_sptTextSlantDownHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 6200, 21600 }
|
|
};
|
|
const mso_CustomShape msoTextSlantDown =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextSlantDownVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextFadeSegm), sizeof( mso_sptTextFadeSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextFadeCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault12000),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextSlantDownHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextCascadeUpVert[] =
|
|
{
|
|
{ 0, 2 MSO_I }, { 21600, 0 }, { 0, 21600 }, { 21600, 0 MSO_I }
|
|
};
|
|
const SvxMSDffCalculationData mso_sptTextCascadeCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x8000, { 21600, 0, DFF_Prop_adjustValue } },
|
|
{ 0x2001, { 0x401, 1, 4 } }
|
|
};
|
|
const SvxMSDffHandle mso_sptTextCascadeUpHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
21600, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 6200, 21600 }
|
|
};
|
|
const mso_CustomShape msoTextCascadeUp =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextCascadeUpVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextFadeSegm), sizeof( mso_sptTextFadeSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextCascadeCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault9600),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextCascadeUpHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextCascadeDownVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 2 MSO_I }, { 0, 0 MSO_I }, { 21600, 21600 }
|
|
};
|
|
const SvxMSDffHandle mso_sptTextCascadeDownHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 6200, 21600 }
|
|
};
|
|
const mso_CustomShape msoTextCascadeDown =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextCascadeDownVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextFadeSegm), sizeof( mso_sptTextFadeSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextCascadeCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault9600),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextCascadeDownHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextArchUpCurveVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 21600 }, { 2 MSO_I, 3 MSO_I }, { 4 MSO_I, 3 MSO_I }
|
|
};
|
|
const SvxMSDffCalculationData mso_sptTextArchCurveCalc[] =
|
|
{
|
|
{ 0x400a, { 10800, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x4009, { 10800, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x2000, { 0x400, 10800, 0 } },
|
|
{ 0x2000, { 0x401, 10800, 0 } },
|
|
{ 0x8000, { 21600, 0, 0x402 } }
|
|
};
|
|
const sal_uInt16 mso_sptTextArchUpCurveSegm[] =
|
|
{
|
|
0xA504, 0x8000 // clockwise arc
|
|
};
|
|
const SvxMSDffHandle mso_sptTextArchUpCurveHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::POLAR,
|
|
10800, 0x100, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const sal_Int32 mso_sptTextArchUpCurveDefault[] =
|
|
{
|
|
1, 180
|
|
};
|
|
const mso_CustomShape msoTextArchUpCurve =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextArchUpCurveVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextArchUpCurveSegm), sizeof( mso_sptTextArchUpCurveSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextArchCurveCalc),
|
|
const_cast<sal_Int32*>(mso_sptTextArchUpCurveDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextArchUpCurveHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextArchDownCurveVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 21600 }, { 4 MSO_I, 3 MSO_I }, { 2 MSO_I, 3 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptTextArchDownCurveSegm[] =
|
|
{
|
|
0xA304, 0x8000 // counter clockwise arc to
|
|
};
|
|
const SvxMSDffHandle mso_sptTextArchDownCurveHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::POLAR,
|
|
10800, 0x100, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const sal_Int32 mso_sptTextArchDownCurveDefault[] =
|
|
{
|
|
1, 0
|
|
};
|
|
const mso_CustomShape msoTextArchDownCurve =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextArchDownCurveVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextArchDownCurveSegm), sizeof( mso_sptTextArchDownCurveSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextArchCurveCalc),
|
|
const_cast<sal_Int32*>(mso_sptTextArchDownCurveDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextArchDownCurveHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextCircleCurveVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 21600 }, { 2 MSO_I, 3 MSO_I }, { 2 MSO_I, 4 MSO_I }
|
|
};
|
|
const SvxMSDffCalculationData mso_sptTextCircleCurveCalc[] =
|
|
{
|
|
{ 0x400a, { 10800, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x4009, { 10800, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x2000, { 0x400, 10800, 0 } },
|
|
{ 0x2000, { 0x401, 10800, 0 } },
|
|
{ 0x8000, { 21600, 0, 0x403 } }
|
|
};
|
|
const sal_uInt16 mso_sptTextCircleCurveSegm[] =
|
|
{
|
|
0xA504, 0x8000 // clockwise arc to
|
|
};
|
|
const SvxMSDffHandle mso_sptTextCircleCurveHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::POLAR,
|
|
10800, 0x100, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const sal_Int32 mso_sptTextCircleCurveDefault[] =
|
|
{
|
|
1, -179
|
|
};
|
|
const mso_CustomShape msoTextCircleCurve =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextCircleCurveVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextCircleCurveSegm), sizeof( mso_sptTextCircleCurveSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextCircleCurveCalc),
|
|
const_cast<sal_Int32*>(mso_sptTextCircleCurveDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextCircleCurveHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextButtonCurveVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 21600 }, { 2 MSO_I, 3 MSO_I }, { 4 MSO_I, 3 MSO_I },
|
|
{ 0, 10800 }, { 21600, 10800 },
|
|
{ 0, 0 }, { 21600, 21600 }, { 2 MSO_I, 5 MSO_I }, { 4 MSO_I, 5 MSO_I }
|
|
};
|
|
const SvxMSDffCalculationData mso_sptTextButtonCurveCalc[] =
|
|
{
|
|
{ 0x400a, { 10800, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x4009, { 10800, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x2000, { 0x400, 10800, 0 } },
|
|
{ 0x2000, { 0x401, 10800, 0 } },
|
|
{ 0x8000, { 21600, 0, 0x402 } },
|
|
{ 0x8000, { 21600, 0, 0x403 } }
|
|
};
|
|
const sal_uInt16 mso_sptTextButtonCurveSegm[] =
|
|
{
|
|
0xA504, 0x8000, // clockwise arc
|
|
0x4000, 0x0001, 0x8000,
|
|
0xA304, 0x8000 // counter clockwise
|
|
};
|
|
const SvxMSDffHandle mso_sptTextButtonCurveHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::POLAR,
|
|
10800, 0x100, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const sal_Int32 mso_sptTextButtonCurveDefault[] =
|
|
{
|
|
1, 180
|
|
};
|
|
const mso_CustomShape msoTextButtonCurve =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextButtonCurveVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextButtonCurveSegm), sizeof( mso_sptTextButtonCurveSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextButtonCurveCalc),
|
|
const_cast<sal_Int32*>(mso_sptTextButtonCurveDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextButtonCurveHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextArchUpPourVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 21600 }, { 2 MSO_I, 3 MSO_I }, { 4 MSO_I, 3 MSO_I },
|
|
{ 5 MSO_I, 5 MSO_I }, { 11 MSO_I, 11 MSO_I }, { 8 MSO_I, 9 MSO_I }, { 0xa MSO_I, 9 MSO_I }
|
|
};
|
|
const SvxMSDffCalculationData mso_sptTextArchPourCalc[] =
|
|
{
|
|
{ 0x400a, { 10800, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x4009, { 10800, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x2000, { 0x400, 10800, 0 } },
|
|
{ 0x2000, { 0x401, 10800, 0 } },
|
|
{ 0x8000, { 21600, 0, 0x402 } },
|
|
{ 0x8000, { 10800, 0, DFF_Prop_adjust2Value } },
|
|
{ 0x600a, { 0x405, DFF_Prop_adjustValue, 0 } }, // 6
|
|
{ 0x6009, { 0x405, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x2000, { 0x406, 10800, 0 } }, // 8
|
|
{ 0x2000, { 0x407, 10800, 0 } },
|
|
{ 0x8000, { 21600, 0, 0x408 } }, // 10
|
|
{ 0x8000, { 21600, 0, 0x405 } }
|
|
};
|
|
const sal_uInt16 mso_sptTextArchUpPourSegm[] =
|
|
{
|
|
0xA504, 0x8000, 0xA504, 0x8000
|
|
};
|
|
const SvxMSDffHandle mso_sptTextArchPourHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::POLAR | SvxMSDffHandleFlags::RADIUS_RANGE,
|
|
0x101, 0x100, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const sal_Int32 mso_sptTextArchUpPourDefault[] =
|
|
{
|
|
2, 180, 5400
|
|
};
|
|
const mso_CustomShape msoTextArchUpPour =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextArchUpPourVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextArchUpPourSegm), sizeof( mso_sptTextArchUpPourSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextArchPourCalc),
|
|
const_cast<sal_Int32*>(mso_sptTextArchUpPourDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextArchPourHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextArchDownPourVert[] =
|
|
{
|
|
{ 5 MSO_I, 5 MSO_I }, { 11 MSO_I, 11 MSO_I }, { 0xa MSO_I, 9 MSO_I }, { 8 MSO_I, 9 MSO_I },
|
|
{ 0, 0 }, { 21600, 21600 }, { 4 MSO_I, 3 MSO_I }, { 2 MSO_I, 3 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptTextArchDownPourSegm[] =
|
|
{
|
|
0xA304, 0x8000, 0xA304, 0x8000
|
|
};
|
|
const sal_Int32 mso_sptTextArchDownPourDefault[] =
|
|
{
|
|
2, 0, 5400
|
|
};
|
|
const mso_CustomShape msoTextArchDownPour =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextArchDownPourVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextArchDownPourSegm), sizeof( mso_sptTextArchDownPourSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextArchPourCalc),
|
|
const_cast<sal_Int32*>(mso_sptTextArchDownPourDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextArchPourHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextCirclePourVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 21600 }, { 2 MSO_I, 3 MSO_I }, { 2 MSO_I, 4 MSO_I },
|
|
{ 5 MSO_I, 5 MSO_I }, { 11 MSO_I, 11 MSO_I }, { 8 MSO_I, 9 MSO_I }, { 8 MSO_I, 0xa MSO_I }
|
|
};
|
|
const SvxMSDffCalculationData mso_sptTextCirclePourCalc[] =
|
|
{
|
|
{ 0x400a, { 10800, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x4009, { 10800, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x2000, { 0x400, 10800, 0 } },
|
|
{ 0x2000, { 0x401, 10800, 0 } },
|
|
{ 0x8000, { 21600, 0, 0x403 } },
|
|
{ 0x8000, { 10800, 0, DFF_Prop_adjust2Value } },
|
|
{ 0x600a, { 0x405, DFF_Prop_adjustValue, 0 } }, // 6
|
|
{ 0x6009, { 0x405, DFF_Prop_adjustValue, 0 } },
|
|
{ 0x2000, { 0x406, 10800, 0 } }, // 8
|
|
{ 0x2000, { 0x407, 10800, 0 } },
|
|
{ 0x8000, { 21600, 0, 0x409 } }, // 10
|
|
{ 0x8000, { 21600, 0, 0x405 } },
|
|
{ 0x000, { 21600, 0, 0 } }
|
|
};
|
|
const sal_uInt16 mso_sptTextCirclePourSegm[] =
|
|
{
|
|
0xA504, 0x8000, 0xA504, 0x8000
|
|
};
|
|
const SvxMSDffHandle mso_sptTextCirclePourHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::POLAR | SvxMSDffHandleFlags::RADIUS_RANGE,
|
|
0x101, 0x100, 10800, 10800, 0, 10800, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const sal_Int32 mso_sptTextCirclePourDefault[] =
|
|
{
|
|
2, -179, 5400
|
|
};
|
|
const mso_CustomShape msoTextCirclePour =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextCirclePourVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextCirclePourSegm), sizeof( mso_sptTextCirclePourSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextCirclePourCalc),
|
|
const_cast<sal_Int32*>(mso_sptTextCirclePourDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextCirclePourHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextButtonPourVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 21600 }, { 2 MSO_I, 3 MSO_I }, { 4 MSO_I, 3 MSO_I },
|
|
{ 6 MSO_I, 6 MSO_I }, { 7 MSO_I, 7 MSO_I }, { 10 MSO_I, 11 MSO_I }, { 12 MSO_I, 11 MSO_I },
|
|
{ 0x16 MSO_I, 16 MSO_I }, { 0x15 MSO_I, 16 MSO_I },
|
|
{ 0x16 MSO_I, 15 MSO_I }, { 0x15 MSO_I, 15 MSO_I },
|
|
{ 6 MSO_I, 6 MSO_I }, { 7 MSO_I, 7 MSO_I }, { 10 MSO_I, 13 MSO_I }, { 12 MSO_I, 13 MSO_I },
|
|
{ 0, 0 }, { 21600, 21600 }, { 2 MSO_I, 5 MSO_I }, { 4 MSO_I, 5 MSO_I }
|
|
};
|
|
const SvxMSDffCalculationData mso_sptTextButtonPourCalc[] =
|
|
{
|
|
{ 0x400a, { 10800, DFF_Prop_adjustValue, 0 } }, // 0x00
|
|
{ 0x4009, { 10800, DFF_Prop_adjustValue, 0 } }, // 0x01
|
|
{ 0x2000, { 0x400, 10800, 0 } }, // 0x02
|
|
{ 0x2000, { 0x401, 10800, 0 } }, // 0x03
|
|
{ 0x8000, { 21600, 0, 0x402 } }, // 0x04
|
|
{ 0x8000, { 21600, 0, 0x403 } }, // 0x05
|
|
|
|
{ 0x8000, { 10800, 0, DFF_Prop_adjust2Value } }, // 0x06
|
|
{ 0x8000, { 21600, 0, 0x406 } }, // 0x07
|
|
|
|
{ 0x600a, { DFF_Prop_adjust2Value, DFF_Prop_adjustValue, 0 } }, // 0x08
|
|
{ 0x6009, { DFF_Prop_adjust2Value, DFF_Prop_adjustValue, 0 } }, // 0x09
|
|
{ 0x2000, { 0x408, 10800, 0 } }, // 0x0a
|
|
{ 0x2000, { 0x409, 10800, 0 } }, // 0x0b
|
|
{ 0x8000, { 21600, 0, 0x40a } }, // 0x0c
|
|
{ 0x8000, { 21600, 0, 0x40b } }, // 0x0d
|
|
{ 0x2001, { 0x406, 1, 2 } }, // 0x0e
|
|
{ 0x4000, { 10800, 0x40e, 0 } }, // 0x0f
|
|
{ 0x8000, { 10800, 0, 0x40e } }, // 0x10
|
|
{ 0x6001, { 0x40e, 0x40e, 1 } }, // 0x11
|
|
{ 0x6001, { DFF_Prop_adjust2Value, DFF_Prop_adjust2Value, 1 } }, // 0x12
|
|
{ 0xA000, { 0x412, 0, 0x411 } }, // 0x13
|
|
{ 0x200d, { 0x413, 0, 0 } }, // 0x14
|
|
{ 0x4000, { 10800, 0x414, 0 } }, // 0x15
|
|
{ 0x8000, { 10800, 0, 0x414 } } // 0x16
|
|
};
|
|
const sal_uInt16 mso_sptTextButtonPourSegm[] =
|
|
{
|
|
0xA504, 0x8000, // clockwise arc
|
|
0xA504, 0x8000, // clockwise arc
|
|
0x4000, 0x0001, 0x8000,
|
|
0x4000, 0x0001, 0x8000,
|
|
0xA304, 0x8000, // counter clockwise
|
|
0xA304, 0x8000 // counter clockwise
|
|
};
|
|
const SvxMSDffHandle mso_sptTextButtonPourHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::POLAR | SvxMSDffHandleFlags::RADIUS_RANGE,
|
|
0x101, 0x100, 10800, 10800, 4320, 10800, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const sal_Int32 mso_sptTextButtonPourDefault[] =
|
|
{
|
|
2, 180, 5400
|
|
};
|
|
const mso_CustomShape msoTextButtonPour =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextButtonPourVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextButtonPourSegm), sizeof( mso_sptTextButtonPourSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextButtonPourCalc),
|
|
const_cast<sal_Int32*>(mso_sptTextButtonPourDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextButtonPourHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextCurveUpVert[] =
|
|
{
|
|
{ 0, 0 MSO_I }, { 4900, 1 MSO_I /*12170->0 14250 ->0*/ }, { 11640, 2 MSO_I /*12170->0 12800 ->0*/ }, { 21600, 0 },
|
|
{ 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*/ }
|
|
};
|
|
const SvxMSDffCalculationData mso_sptTextCurveUpCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, // 400
|
|
{ 0x4001, { 14250, 0x400, 12170 } }, // 401
|
|
{ 0x4001, { 12800, 0x400, 12170 } }, // 402
|
|
{ 0x4001, { 6380, 0x400, 12170 } }, // 403
|
|
{ 0x8000, { 21600, 0, 0x403 } } // 404
|
|
};
|
|
const sal_uInt16 mso_sptTextCurveUpSegm[] =
|
|
{
|
|
0x4000, 0x2001, 0x8000,
|
|
0x4000, 0x2002, 0x8000
|
|
};
|
|
const SvxMSDffHandle mso_sptTextCurveUpHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 12170 }
|
|
};
|
|
const sal_Int32 mso_sptTextCurveUpDefault[] =
|
|
{
|
|
1, 9900
|
|
};
|
|
const mso_CustomShape msoTextCurveUp =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextCurveUpVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextCurveUpSegm), sizeof( mso_sptTextCurveUpSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextCurveUpCalc),
|
|
const_cast<sal_Int32*>(mso_sptTextCurveUpDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextCurveUpHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextCurveDownVert[] =
|
|
{
|
|
// { 0, 0 MSO_I }, { 4900, 1 MSO_I /*12170->0 14250 ->0*/ }, { 11640, 2 MSO_I /*12170->0 12800 ->0*/ }, { 21600, 0 },
|
|
{ 0, 0 }, { 9960, 2 MSO_I }, { 16700, 1 MSO_I }, { 21600, 0 MSO_I },
|
|
|
|
// { 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*/ }
|
|
{ 0, 4 MSO_I }, { 5690, 21600 }, { 7490, 21600 }, { 11500, 21600 }, { 13100, 21600 }, { 17900, 21600 }, { 21600, 4 MSO_I }
|
|
};
|
|
const SvxMSDffHandle mso_sptTextCurveDownHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
21600, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 12170 }
|
|
};
|
|
const mso_CustomShape msoTextCurveDown =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextCurveDownVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextCurveUpSegm), sizeof( mso_sptTextCurveUpSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextCurveUpCalc),
|
|
const_cast<sal_Int32*>(mso_sptTextCurveUpDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextCurveDownHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextCanUpVert[] =
|
|
{
|
|
{ 0, 1 MSO_I }, { 900, 0 }, { 7100, 0 }, { 10800, 0 }, { 14500, 0 }, { 20700, 0 }, { 21600, 1 MSO_I },
|
|
{ 0, 21600 }, { 900, 4 MSO_I }, { 7100, 0 MSO_I }, { 10800, 0 MSO_I }, { 14500, 0 MSO_I }, { 20700, 4 MSO_I }, { 21600, 21600 }
|
|
};
|
|
const SvxMSDffCalculationData mso_sptTextCanUpCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, // 400
|
|
{ 0x8000, { 21600, 0, DFF_Prop_adjustValue } }, // 401
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 14400 } }, // 402
|
|
{ 0x4001, { 5470, 0x402, 7200 } }, // 403
|
|
{ 0x4000, { 16130, 0x403, 0 } } // 404
|
|
};
|
|
const sal_uInt16 mso_sptTextCanUpSegm[] =
|
|
{
|
|
0x4000, 0x2002, 0x8000,
|
|
0x4000, 0x2002, 0x8000
|
|
};
|
|
const SvxMSDffHandle mso_sptTextCanUpHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
10800, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 14400, 21600 }
|
|
};
|
|
const sal_Int32 mso_sptTextCanUpDefault[] =
|
|
{
|
|
1, 18500
|
|
};
|
|
const mso_CustomShape msoTextCanUp =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextCanUpVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextCanUpSegm), sizeof( mso_sptTextCanUpSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextCanUpCalc),
|
|
const_cast<sal_Int32*>(mso_sptTextCanUpDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextCanUpHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextCanDownVert[] =
|
|
{
|
|
{ 0, 0 }, { 900, 2 MSO_I }, { 7100, 0 MSO_I }, { 10800, 0 MSO_I }, { 14500, 0 MSO_I }, { 20700, 2 MSO_I }, { 21600, 0 },
|
|
{ 0, 1 MSO_I }, { 900, 21600 }, { 7100, 21600 }, { 10800, 21600 }, { 14500, 21600 }, { 20700, 21600 }, { 21600, 1 MSO_I }
|
|
};
|
|
const SvxMSDffCalculationData mso_sptTextCanDownCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, // 400
|
|
{ 0x8000, { 21600, 0, DFF_Prop_adjustValue } }, // 401
|
|
{ 0x4001, { 5470, 0x400, 7200 } } // 402
|
|
};
|
|
const SvxMSDffHandle mso_sptTextCanDownHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
10800, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 7200 }
|
|
};
|
|
const sal_Int32 mso_sptTextCanDownDefault[] =
|
|
{
|
|
1, 3100
|
|
};
|
|
const mso_CustomShape msoTextCanDown =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextCanDownVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextCanUpSegm), sizeof( mso_sptTextCanUpSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextCanDownCalc),
|
|
const_cast<sal_Int32*>(mso_sptTextCanDownDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextCanDownHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextInflateVert[] =
|
|
{
|
|
{ 0, 0 MSO_I }, { 4100, 1 MSO_I }, { 7300, 0 }, { 10800, 0 }, { 14300, 0 }, { 17500, 1 MSO_I }, { 21600, 0 MSO_I },
|
|
{ 0, 2 MSO_I }, { 4100, 3 MSO_I }, { 7300, 21600 }, { 10800, 21600 }, { 14300, 21600 }, { 17500, 3 MSO_I }, { 21600, 2 MSO_I }
|
|
};
|
|
const SvxMSDffCalculationData mso_sptTextInflateCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, // 400
|
|
{ 0x4001, { 1530, 0x400, 4650 } }, // 401
|
|
{ 0x8000, { 21600, 0, 0x400 } }, // 402
|
|
{ 0x8000, { 21600, 0, 0x401 } } // 403
|
|
};
|
|
const SvxMSDffHandle mso_sptTextInflateHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 4650 }
|
|
};
|
|
const sal_Int32 mso_sptTextInflateDefault[] =
|
|
{
|
|
1, 2950
|
|
};
|
|
const mso_CustomShape msoTextInflate =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextInflateVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextCanUpSegm), sizeof( mso_sptTextCanUpSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextInflateCalc),
|
|
const_cast<sal_Int32*>(mso_sptTextInflateDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextInflateHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextDeflateVert[] =
|
|
{
|
|
{ 0, 0 }, { 3500, 1 MSO_I }, { 7100, 0 MSO_I }, { 10800, 0 MSO_I }, { 14500, 0 MSO_I }, { 18100, 1 MSO_I }, { 21600, 0 },
|
|
{ 0, 21600 }, { 3500, 3 MSO_I }, { 7100, 2 MSO_I }, { 10800, 2 MSO_I }, { 14500, 2 MSO_I }, { 18100, 3 MSO_I }, { 21600, 21600 }
|
|
};
|
|
const SvxMSDffCalculationData mso_sptTextDeflateCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, // 400
|
|
{ 0x2001, { 0x400, 5320, 7100 } }, // 401
|
|
{ 0x8000, { 21600, 0, 0x400 } }, // 402
|
|
{ 0x8000, { 21600, 0, 0x401 } } // 403
|
|
};
|
|
const SvxMSDffHandle mso_sptTextDeflateHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
10800, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 8100 }
|
|
};
|
|
const mso_CustomShape msoTextDeflate =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextDeflateVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextCanUpSegm), sizeof( mso_sptTextCanUpSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextDeflateCalc),
|
|
const_cast<sal_Int32*>(mso_sptDefault8100),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextDeflateHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextInflateBottomVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 0 },
|
|
{ 0, 0 MSO_I }, { 3500, 3 MSO_I }, { 7300, 21600 }, { 10800, 21600 }, { 14300, 21600 }, { 18100, 3 MSO_I }, { 21600, 0 MSO_I }
|
|
};
|
|
const SvxMSDffCalculationData mso_sptTextInflateBottomCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, // 400
|
|
{ 0x2000, { 0x400, 0, 11150 } }, // 401 0->10450
|
|
{ 0x2001, { 0x401, 3900, 10450 } }, // 402
|
|
{ 0x2000, { 0x402, 17700, 0 } } // 403
|
|
};
|
|
const sal_uInt16 mso_sptTextInflateBottomSegm[] =
|
|
{
|
|
0x4000, 0x0001, 0x8000,
|
|
0x4000, 0x2002, 0x8000
|
|
};
|
|
const SvxMSDffHandle mso_sptTextInflateBottomHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 11150, 21600 }
|
|
};
|
|
const sal_Int32 mso_sptTextInflateBottomDefault[] =
|
|
{
|
|
1, 14700
|
|
};
|
|
const mso_CustomShape msoTextInflateBottom =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextInflateBottomVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextInflateBottomSegm), sizeof( mso_sptTextInflateBottomSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextInflateBottomCalc),
|
|
const_cast<sal_Int32*>(mso_sptTextInflateBottomDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextInflateBottomHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextDeflateBottomVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 0 },
|
|
{ 0, 21600 }, { 2900, 3 MSO_I }, { 7200, 0 MSO_I }, { 10800, 0 MSO_I }, { 14400, 0 MSO_I }, { 18700, 3 MSO_I }, { 21600, 21600 }
|
|
};
|
|
const SvxMSDffCalculationData mso_sptTextDeflateBottomCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, // 400
|
|
{ 0x2000, { 0x400, 0, 1350 } }, // 401 0->20250
|
|
{ 0x2001, { 0x401, 12070, 20250 } }, // 402
|
|
{ 0x2000, { 0x402, 9530, 0 } } // 403
|
|
};
|
|
const sal_uInt16 mso_sptTextDeflateBottomSegm[] =
|
|
{
|
|
0x4000, 0x0001, 0x8000,
|
|
0x4000, 0x2002, 0x8000
|
|
};
|
|
const SvxMSDffHandle mso_sptTextDeflateBottomHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
10800, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 1350, 21600 }
|
|
};
|
|
const sal_Int32 mso_sptTextDeflateBottomDefault[] =
|
|
{
|
|
1, 11500
|
|
};
|
|
const mso_CustomShape msoTextDeflateBottom =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextDeflateBottomVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextDeflateBottomSegm), sizeof( mso_sptTextDeflateBottomSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextDeflateBottomCalc),
|
|
const_cast<sal_Int32*>(mso_sptTextDeflateBottomDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextDeflateBottomHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextInflateTopVert[] =
|
|
{
|
|
{ 0, 0 MSO_I }, { 3500, 1 MSO_I }, { 7300, 0 }, { 10800, 0 }, { 14300, 0 }, { 18100, 1 MSO_I }, { 21600, 0 MSO_I },
|
|
{ 0, 21600 }, { 21600, 21600 }
|
|
};
|
|
const SvxMSDffCalculationData mso_sptTextInflateTopCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, // 400
|
|
{ 0x2001, { 0x400, 3900, 10450 } } // 401
|
|
};
|
|
const sal_uInt16 mso_sptTextInflateTopSegm[] =
|
|
{
|
|
0x4000, 0x2002, 0x8000,
|
|
0x4000, 0x0001, 0x8000
|
|
};
|
|
const SvxMSDffHandle mso_sptTextInflateTopHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 10450 }
|
|
};
|
|
const sal_Int32 mso_sptTextInflateTopDefault[] =
|
|
{
|
|
1, 6900
|
|
};
|
|
const mso_CustomShape msoTextInflateTop =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextInflateTopVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextInflateTopSegm), sizeof( mso_sptTextInflateTopSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextInflateTopCalc),
|
|
const_cast<sal_Int32*>(mso_sptTextInflateTopDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextInflateTopHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextDeflateTopVert[] =
|
|
{
|
|
{ 0, 0 }, { 2900, 1 MSO_I }, { 7200, 0 MSO_I }, { 10800, 0 MSO_I }, { 14400, 0 MSO_I }, { 18700, 1 MSO_I }, { 21600, 0 },
|
|
{ 0, 21600 }, { 21600, 21600 }
|
|
};
|
|
const SvxMSDffCalculationData mso_sptTextDeflateTopCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, // 400
|
|
{ 0x2001, { 0x400, 12070, 20250 } } // 402
|
|
};
|
|
const sal_uInt16 mso_sptTextDeflateTopSegm[] =
|
|
{
|
|
0x4000, 0x2002, 0x8000,
|
|
0x4000, 0x0001, 0x8000
|
|
};
|
|
const SvxMSDffHandle mso_sptTextDeflateTopHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
10800, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 0, 20250 }
|
|
};
|
|
const sal_Int32 mso_sptTextDeflateTopDefault[] =
|
|
{
|
|
1, 10100
|
|
};
|
|
const mso_CustomShape msoTextDeflateTop =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextDeflateTopVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextDeflateTopSegm), sizeof( mso_sptTextDeflateTopSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextDeflateTopCalc),
|
|
const_cast<sal_Int32*>(mso_sptTextDeflateTopDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextDeflateTopHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextDeflateInflateVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 0 },
|
|
{ 0, 10100 }, { 3300, 3 MSO_I }, { 7100, 5 MSO_I }, { 10800, 5 MSO_I }, { 14500, 5 MSO_I }, { 18300, 3 MSO_I }, { 21600, 10100 },
|
|
{ 0, 11500 }, { 3300, 4 MSO_I }, { 7100, 6 MSO_I }, { 10800, 6 MSO_I }, { 14500, 6 MSO_I }, { 18300, 4 MSO_I }, { 21600, 11500 },
|
|
{ 0, 21600 }, { 21600, 21600 }
|
|
};
|
|
const SvxMSDffCalculationData mso_sptTextDeflateInflateCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } }, // 400
|
|
{ 0x8000, { 10800, 0, 0x400 } }, // 401
|
|
{ 0x2001, { 0x401, 5770, 9500 } }, // 402
|
|
{ 0x8000, { 10100, 0, 0x402 } }, // 403
|
|
{ 0x8000, { 11500, 0, 0x402 } }, // 404
|
|
{ 0x2000, { 0x400, 0, 700 } }, // 405
|
|
{ 0x2000, { 0x400, 700, 0 } } // 406
|
|
};
|
|
const sal_uInt16 mso_sptTextDeflateInflateSegm[] =
|
|
{
|
|
0x4000, 0x0001, 0x8000,
|
|
0x4000, 0x2002, 0x8000,
|
|
0x4000, 0x2002, 0x8000,
|
|
0x4000, 0x0001, 0x8000
|
|
};
|
|
const SvxMSDffHandle mso_sptTextDeflateInflateHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
10800, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 1300, 20300 }
|
|
};
|
|
const sal_Int32 mso_sptTextDeflateInflateDefault[] =
|
|
{
|
|
1, 6500
|
|
};
|
|
const mso_CustomShape msoTextDeflateInflate =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextDeflateInflateVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextDeflateInflateSegm), sizeof( mso_sptTextDeflateInflateSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextDeflateInflateCalc),
|
|
const_cast<sal_Int32*>(mso_sptTextDeflateInflateDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextDeflateInflateHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextDeflateInflateDeflateVert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 0 },
|
|
{ 0, 6600 }, { 3600, 3 MSO_I }, { 7250, 4 MSO_I }, { 10800, 4 MSO_I }, { 14350, 4 MSO_I }, { 18000, 3 MSO_I }, { 21600, 6600 },
|
|
{ 0, 7500 }, { 3600, 5 MSO_I }, { 7250, 6 MSO_I }, { 10800, 6 MSO_I }, { 14350, 6 MSO_I }, { 18000, 5 MSO_I }, { 21600, 7500 },
|
|
{ 0, 14100 }, { 3600, 9 MSO_I }, { 7250, 10 MSO_I }, { 10800, 10 MSO_I }, { 14350, 10 MSO_I }, { 18000, 9 MSO_I }, { 21600, 14100 },
|
|
{ 0, 15000 }, { 3600, 7 MSO_I }, { 7250, 8 MSO_I }, { 10800, 8 MSO_I }, { 14350, 8 MSO_I }, { 18000, 7 MSO_I }, { 21600, 15000 },
|
|
{ 0, 21600 }, { 21600, 21600 }
|
|
};
|
|
const SvxMSDffCalculationData mso_sptTextDeflateInflateDeflateCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 850 } }, // 400
|
|
{ 0x2001, { 0x400, 6120, 8700 } },
|
|
{ 0x2000, { 0x401, 0, 4280 } },
|
|
{ 0x4000, { 6600, 0x402, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 450 } }, // 404
|
|
{ 0x2000, { 0x403, 900, 0 } }, // 405
|
|
{ 0x2000, { 0x404, 900, 0 } }, // 406
|
|
{ 0x8000, { 21600, 0, 0x403 } }, // 407
|
|
{ 0x8000, { 21600, 0, 0x404 } }, // 408
|
|
{ 0x8000, { 21600, 0, 0x405 } }, // 409
|
|
{ 0x8000, { 21600, 0, 0x406 } } // 410
|
|
};
|
|
const sal_uInt16 mso_sptTextDeflateInflateDeflateSegm[] =
|
|
{
|
|
0x4000, 0x0001, 0x8000,
|
|
0x4000, 0x2002, 0x8000,
|
|
0x4000, 0x2002, 0x8000,
|
|
0x4000, 0x2002, 0x8000,
|
|
0x4000, 0x2002, 0x8000,
|
|
0x4000, 0x0001, 0x8000
|
|
};
|
|
const SvxMSDffHandle mso_sptTextDeflateInflateDeflateHandle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
10800, 0x100, 10800, 10800, MIN_INT32, 0x7fffffff, 850, 9550 }
|
|
};
|
|
const sal_Int32 mso_sptTextDeflateInflateDeflateDefault[] =
|
|
{
|
|
1, 6050
|
|
};
|
|
const mso_CustomShape msoTextDeflateInflateDeflate =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextDeflateInflateDeflateVert),
|
|
const_cast<sal_uInt16*>(mso_sptTextDeflateInflateDeflateSegm), sizeof( mso_sptTextDeflateInflateDeflateSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTextDeflateInflateDeflateCalc),
|
|
const_cast<sal_Int32*>(mso_sptTextDeflateInflateDeflateDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTextDeflateInflateDeflateHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextWave1Vert[] = // adjustment1 : 0 - 4459
|
|
{ // adjustment2 : 8640 - 12960
|
|
{ 7 MSO_I, 0 MSO_I }, { 15 MSO_I, 9 MSO_I }, { 16 MSO_I, 10 MSO_I }, { 12 MSO_I, 0 MSO_I },
|
|
{ 29 MSO_I, 1 MSO_I }, { 27 MSO_I, 28 MSO_I }, { 25 MSO_I, 26 MSO_I }, { 24 MSO_I, 1 MSO_I }
|
|
};
|
|
const sal_uInt16 mso_sptTextWave1Segm[] =
|
|
{
|
|
0x4000, 0x2001, 0x8000,
|
|
0x4000, 0x2001, 0x8000
|
|
};
|
|
const mso_CustomShape msoTextWave1 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextWave1Vert),
|
|
const_cast<sal_uInt16*>(mso_sptTextWave1Segm), sizeof( mso_sptTextWave1Segm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptWaveCalc),
|
|
const_cast<sal_Int32*>(mso_sptWaveDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptWaveGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptWaveHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextWave2Vert[] = // adjustment1 : 0 - 4459
|
|
{ // adjustment2 : 8640 - 12960
|
|
{ 7 MSO_I, 0 MSO_I }, { 15 MSO_I, 10 MSO_I }, { 16 MSO_I, 9 MSO_I }, { 12 MSO_I, 0 MSO_I },
|
|
{ 29 MSO_I, 1 MSO_I }, { 27 MSO_I, 26 MSO_I }, { 25 MSO_I, 28 MSO_I }, { 24 MSO_I, 1 MSO_I }
|
|
};
|
|
const mso_CustomShape msoTextWave2 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextWave2Vert),
|
|
const_cast<sal_uInt16*>(mso_sptTextWave1Segm), sizeof( mso_sptTextWave1Segm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptWaveCalc),
|
|
const_cast<sal_Int32*>(mso_sptWaveDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptFontWorkTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptWaveGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptWaveHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextWave3Vert[] = // adjustment1 : 0 - 2230
|
|
{ // adjustment2 : 8640 - 12960
|
|
{ 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 },
|
|
{ 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 }
|
|
};
|
|
const sal_uInt16 mso_sptTextWave3Segm[] =
|
|
{
|
|
0x4000, 0x2002, 0x8000,
|
|
0x4000, 0x2002, 0x8000
|
|
};
|
|
const mso_CustomShape msoTextWave3 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextWave3Vert),
|
|
const_cast<sal_uInt16*>(mso_sptTextWave3Segm), sizeof( mso_sptTextWave3Segm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptDoubleWaveCalc),
|
|
const_cast<sal_Int32*>(mso_sptDoubleWaveDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptDoubleWaveTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptDoubleWaveGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptDoubleWaveHandle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptTextWave4Vert[] = // adjustment1 : 0 - 2230
|
|
{ // adjustment2 : 8640 - 12960
|
|
{ 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 },
|
|
{ 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 }
|
|
};
|
|
const mso_CustomShape msoTextWave4 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTextWave4Vert),
|
|
const_cast<sal_uInt16*>(mso_sptTextWave3Segm), sizeof( mso_sptTextWave3Segm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptDoubleWaveCalc),
|
|
const_cast<sal_Int32*>(mso_sptDoubleWaveDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptDoubleWaveTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(mso_sptDoubleWaveGluePoints),
|
|
std::span<const SvxMSDffHandle>(mso_sptDoubleWaveHandle),
|
|
};
|
|
|
|
const sal_Int32 mso_sptCalloutDefault1[] =
|
|
{
|
|
4, -1800, 24500, -1800, 4000
|
|
};
|
|
const sal_Int32 mso_sptCalloutDefault2[] =
|
|
{
|
|
4, -8300, 24500, -1800, 4000
|
|
};
|
|
const sal_Int32 mso_sptCalloutDefault3[] =
|
|
{
|
|
6, -10000, 24500, -3600, 4000, -1800, 4000
|
|
};
|
|
const sal_Int32 mso_sptCalloutDefault4[] =
|
|
{
|
|
8, 23400, 24500, 25200, 21600, 25200, 4000, 23400, 4000
|
|
};
|
|
const SvxMSDffVertPair mso_sptCalloutVert1[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 }, { 0 MSO_I, 1 MSO_I }, { 2 MSO_I, 3 MSO_I }
|
|
};
|
|
const SvxMSDffHandle mso_sptCalloutHandle1[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::NONE,
|
|
0x100, 0x101, 10800, 10800, MIN_INT32, 0x7fffffff, MIN_INT32, 0x7fffffff },
|
|
{ SvxMSDffHandleFlags::NONE,
|
|
0x102, 0x103, 10800, 10800, MIN_INT32, 0x7fffffff, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const sal_uInt16 mso_sptCalloutSegm1a[] =
|
|
{
|
|
0x4000, 0x0003, 0x6000, 0x8000,
|
|
0x4000, 0x0001, 0x8000
|
|
};
|
|
const sal_uInt16 mso_sptCalloutSegm1b[] =
|
|
{
|
|
0x4000, 0xab00, 0x0003, 0x6000, 0x8000, // NO STROKE
|
|
0x4000, 0x0001, 0x8000
|
|
};
|
|
const SvxMSDffVertPair mso_sptCallout1Vert[] =
|
|
{
|
|
{ 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 }
|
|
};
|
|
const sal_uInt16 mso_sptCallout1Segm1a[] =
|
|
{
|
|
0x4000, 0x0003, 0x6000, 0x8000,
|
|
0x4000, 0x0001, 0x8000,
|
|
0x4000, 0x0001, 0x8000
|
|
};
|
|
const sal_uInt16 mso_sptCallout1Segm1b[] =
|
|
{
|
|
0x4000, 0xab00, 0x0003, 0x6000, 0x8000, // NO STROKE
|
|
0x4000, 0x0001, 0x8000,
|
|
0x4000, 0x0001, 0x8000
|
|
};
|
|
const SvxMSDffVertPair mso_sptCallout2Verta[] =
|
|
{
|
|
{ 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 }
|
|
};
|
|
const SvxMSDffVertPair mso_sptCallout2Vertb[] =
|
|
{
|
|
{ 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 }
|
|
};
|
|
const SvxMSDffHandle mso_sptCalloutHandle2[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::NONE,
|
|
0x100, 0x101, 10800, 10800, MIN_INT32, 0x7fffffff, MIN_INT32, 0x7fffffff },
|
|
{ SvxMSDffHandleFlags::NONE,
|
|
0x102, 0x103, 10800, 10800, MIN_INT32, 0x7fffffff, MIN_INT32, 0x7fffffff },
|
|
{ SvxMSDffHandleFlags::NONE,
|
|
0x104, 0x105, 10800, 10800, MIN_INT32, 0x7fffffff, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const sal_uInt16 mso_sptCallout2Segm1a[] =
|
|
{
|
|
0x4000, 0x0003, 0x6000, 0x8000,
|
|
0x4000, 0x0001, 0x8000,
|
|
0x4000, 0x0001, 0x8000,
|
|
0x4000, 0x0001, 0x8000
|
|
};
|
|
const sal_uInt16 mso_sptCallout2Segm1b[] =
|
|
{
|
|
0x4000, 0xab00, 0x0003, 0x6000, 0x8000, // NO STROKE
|
|
0x4000, 0x0001, 0x8000,
|
|
0x4000, 0x0001, 0x8000,
|
|
0x4000, 0x0001, 0x8000
|
|
};
|
|
const sal_uInt16 mso_sptCallout2Segm1c[] =
|
|
{
|
|
0x4000, 0x0003, 0x6000, 0x8000,
|
|
0x4000, 0x0001, 0x8000,
|
|
0x4000, 0x0001, 0x8000,
|
|
0x4000, 0x0001, 0x8000,
|
|
0x4000, 0x0001, 0x8000
|
|
};
|
|
const sal_uInt16 mso_sptCallout2Segm1d[] =
|
|
{
|
|
0x4000, 0xab00, 0x0003, 0x6000, 0x8000, // NO STROKE
|
|
0x4000, 0x0001, 0x8000,
|
|
0x4000, 0x0001, 0x8000,
|
|
0x4000, 0x0001, 0x8000,
|
|
0x4000, 0x0001, 0x8000
|
|
};
|
|
const SvxMSDffVertPair mso_sptCallout3Verta[] =
|
|
{
|
|
{ 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 }
|
|
};
|
|
const SvxMSDffVertPair mso_sptCallout3Vertb[] =
|
|
{
|
|
{ 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 }
|
|
};
|
|
const SvxMSDffHandle mso_sptCalloutHandle3[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::NONE,
|
|
0x100, 0x101, 10800, 10800, MIN_INT32, 0x7fffffff, MIN_INT32, 0x7fffffff },
|
|
{ SvxMSDffHandleFlags::NONE,
|
|
0x102, 0x103, 10800, 10800, MIN_INT32, 0x7fffffff, MIN_INT32, 0x7fffffff },
|
|
{ SvxMSDffHandleFlags::NONE,
|
|
0x104, 0x105, 10800, 10800, MIN_INT32, 0x7fffffff, MIN_INT32, 0x7fffffff },
|
|
{ SvxMSDffHandleFlags::NONE,
|
|
0x106, 0x107, 10800, 10800, MIN_INT32, 0x7fffffff, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const sal_uInt16 mso_sptCallout3Segm1a[] =
|
|
{
|
|
0x4000, 0x0003, 0x6000, 0x8000,
|
|
0x4000, 0xaa00, 0x0003, 0x8000 // NO_FILL
|
|
};
|
|
const sal_uInt16 mso_sptCallout3Segm1b[] =
|
|
{
|
|
0x4000, 0xab00, 0x0003, 0x6000, 0x8000, // NO STROKE
|
|
0x4000, 0xaa00, 0x0003, 0x8000 // NO FILL
|
|
};
|
|
const sal_uInt16 mso_sptCallout3Segm1c[] =
|
|
{
|
|
0x4000, 0x0003, 0x6000, 0x8000,
|
|
0x4000, 0xaa00, 0x0003, 0x8000, // NO FILL
|
|
0x4000, 0x0001, 0x8000
|
|
};
|
|
const sal_uInt16 mso_sptCallout3Segm1d[] =
|
|
{
|
|
0x4000, 0xab00, 0x0003, 0x6000, 0x8000, // NO STROKE
|
|
0x4000, 0xaa00, 0x0003, 0x8000, // NO FILL
|
|
0x4000, 0x0001, 0x8000
|
|
};
|
|
|
|
const SvxMSDffCalculationData mso_sptCalloutCalc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust3Value, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust4Value, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust5Value, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust6Value, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust7Value, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust8Value, 0, 0 } }
|
|
};
|
|
|
|
const mso_CustomShape msoCallout90 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptCalloutVert1),
|
|
const_cast<sal_uInt16*>(mso_sptCalloutSegm1b), sizeof( mso_sptCalloutSegm1b ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptCalloutCalc),
|
|
const_cast<sal_Int32*>(mso_sptCalloutDefault1),
|
|
std::span<const SvxMSDffTextRectangles>(),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptCalloutHandle1),
|
|
};
|
|
const mso_CustomShape msoCallout1 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptCalloutVert1),
|
|
const_cast<sal_uInt16*>(mso_sptCalloutSegm1b), sizeof( mso_sptCalloutSegm1b ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptCalloutCalc),
|
|
const_cast<sal_Int32*>(mso_sptCalloutDefault2),
|
|
std::span<const SvxMSDffTextRectangles>(),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptCalloutHandle1),
|
|
};
|
|
const mso_CustomShape msoCallout2 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptCallout2Verta),
|
|
const_cast<sal_uInt16*>(mso_sptCallout2Segm1b), sizeof( mso_sptCallout2Segm1b ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptCalloutCalc),
|
|
const_cast<sal_Int32*>(mso_sptCalloutDefault3),
|
|
std::span<const SvxMSDffTextRectangles>(),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptCalloutHandle2),
|
|
};
|
|
const mso_CustomShape msoCallout3 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptCallout3Verta),
|
|
const_cast<sal_uInt16*>(mso_sptCallout3Segm1b), sizeof( mso_sptCallout3Segm1b ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptCalloutCalc),
|
|
const_cast<sal_Int32*>(mso_sptCalloutDefault4),
|
|
std::span<const SvxMSDffTextRectangles>(),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptCalloutHandle3),
|
|
};
|
|
const mso_CustomShape msoAccentCallout90 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptCalloutVert1),
|
|
const_cast<sal_uInt16*>(mso_sptCalloutSegm1b), sizeof( mso_sptCalloutSegm1b ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptCalloutCalc),
|
|
const_cast<sal_Int32*>(mso_sptCalloutDefault1),
|
|
std::span<const SvxMSDffTextRectangles>(),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptCalloutHandle1),
|
|
};
|
|
const mso_CustomShape msoAccentCallout1 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptCallout1Vert),
|
|
const_cast<sal_uInt16*>(mso_sptCallout1Segm1b), sizeof( mso_sptCallout1Segm1b ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptCalloutCalc),
|
|
const_cast<sal_Int32*>(mso_sptCalloutDefault2),
|
|
std::span<const SvxMSDffTextRectangles>(),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptCalloutHandle1),
|
|
};
|
|
const mso_CustomShape msoAccentCallout2 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptCallout2Vertb),
|
|
const_cast<sal_uInt16*>(mso_sptCallout2Segm1d), sizeof( mso_sptCallout2Segm1d ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptCalloutCalc),
|
|
const_cast<sal_Int32*>(mso_sptCalloutDefault3),
|
|
std::span<const SvxMSDffTextRectangles>(),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptCalloutHandle2),
|
|
};
|
|
const mso_CustomShape msoAccentCallout3 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptCallout3Vertb),
|
|
const_cast<sal_uInt16*>(mso_sptCallout3Segm1d), sizeof( mso_sptCallout3Segm1d ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptCalloutCalc),
|
|
const_cast<sal_Int32*>(mso_sptCalloutDefault4),
|
|
std::span<const SvxMSDffTextRectangles>(),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptCalloutHandle3),
|
|
};
|
|
const mso_CustomShape msoBorderCallout90 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptCalloutVert1),
|
|
const_cast<sal_uInt16*>(mso_sptCalloutSegm1a), sizeof( mso_sptCalloutSegm1a ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptCalloutCalc),
|
|
const_cast<sal_Int32*>(mso_sptCalloutDefault1),
|
|
std::span<const SvxMSDffTextRectangles>(),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptCalloutHandle1),
|
|
};
|
|
const mso_CustomShape msoBorderCallout1 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptCalloutVert1),
|
|
const_cast<sal_uInt16*>(mso_sptCalloutSegm1a), sizeof( mso_sptCalloutSegm1a ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptCalloutCalc),
|
|
const_cast<sal_Int32*>(mso_sptCalloutDefault2),
|
|
std::span<const SvxMSDffTextRectangles>(),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptCalloutHandle1),
|
|
};
|
|
const mso_CustomShape msoBorderCallout2 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptCallout2Verta),
|
|
const_cast<sal_uInt16*>(mso_sptCallout2Segm1a), sizeof( mso_sptCallout2Segm1a ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptCalloutCalc),
|
|
const_cast<sal_Int32*>(mso_sptCalloutDefault3),
|
|
std::span<const SvxMSDffTextRectangles>(),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptCalloutHandle2),
|
|
};
|
|
const mso_CustomShape msoBorderCallout3 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptCallout3Verta),
|
|
const_cast<sal_uInt16*>(mso_sptCallout3Segm1a), sizeof( mso_sptCallout3Segm1a ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptCalloutCalc),
|
|
const_cast<sal_Int32*>(mso_sptCalloutDefault4),
|
|
std::span<const SvxMSDffTextRectangles>(),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptCalloutHandle3),
|
|
};
|
|
const mso_CustomShape msoAccentBorderCallout90 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptCalloutVert1),
|
|
const_cast<sal_uInt16*>(mso_sptCalloutSegm1a), sizeof( mso_sptCalloutSegm1a ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptCalloutCalc),
|
|
const_cast<sal_Int32*>(mso_sptCalloutDefault1),
|
|
std::span<const SvxMSDffTextRectangles>(),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptCalloutHandle1),
|
|
};
|
|
const mso_CustomShape msoAccentBorderCallout1 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptCallout1Vert),
|
|
const_cast<sal_uInt16*>(mso_sptCallout1Segm1a), sizeof( mso_sptCallout1Segm1a ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptCalloutCalc),
|
|
const_cast<sal_Int32*>(mso_sptCalloutDefault2),
|
|
std::span<const SvxMSDffTextRectangles>(),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptCalloutHandle1),
|
|
};
|
|
const mso_CustomShape msoAccentBorderCallout2 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptCallout2Vertb),
|
|
const_cast<sal_uInt16*>(mso_sptCallout2Segm1c), sizeof( mso_sptCallout2Segm1c ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptCalloutCalc),
|
|
const_cast<sal_Int32*>(mso_sptCalloutDefault3),
|
|
std::span<const SvxMSDffTextRectangles>(),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptCalloutHandle2),
|
|
};
|
|
const mso_CustomShape msoAccentBorderCallout3 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptCallout3Vertb),
|
|
const_cast<sal_uInt16*>(mso_sptCallout3Segm1c), sizeof( mso_sptCallout3Segm1c ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptCalloutCalc),
|
|
const_cast<sal_Int32*>(mso_sptCalloutDefault4),
|
|
std::span<const SvxMSDffTextRectangles>(),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptCalloutHandle3),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptStraightConnector1Vert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 21600 }
|
|
};
|
|
const sal_uInt16 mso_sptStraightConnector1Segm[] =
|
|
{
|
|
0x4000, 0x0001, 0x8000
|
|
};
|
|
const mso_CustomShape msoStraightConnector1 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptStraightConnector1Vert),
|
|
const_cast<sal_uInt16*>(mso_sptStraightConnector1Segm), sizeof( mso_sptStraightConnector1Segm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>()
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptBentConnector2Vert[] =
|
|
{
|
|
{ 0, 0 }, { 21600, 0 }, { 21600, 21600 }
|
|
};
|
|
const sal_uInt16 mso_sptBentConnector2Segm[] =
|
|
{
|
|
0x4000, 0x0002, 0x8000
|
|
};
|
|
const mso_CustomShape msoBentConnector2 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptBentConnector2Vert),
|
|
const_cast<sal_uInt16*>(mso_sptBentConnector2Segm), sizeof( mso_sptBentConnector2Segm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>()
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptBentConnector3Vert[] =
|
|
{
|
|
{ 0, 0 }, { 0 MSO_I, 0 }, { 0 MSO_I, 21600 }, { 21600, 21600 }
|
|
};
|
|
const sal_uInt16 mso_sptBentConnector3Segm[] =
|
|
{
|
|
0x4000, 0x0003, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptBentConnector3Calc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } }
|
|
};
|
|
const sal_Int32 mso_sptBentConnector3Default[] =
|
|
{
|
|
1, 10800
|
|
};
|
|
const SvxMSDffHandle mso_sptBentConnector3Handle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0x100, 10800, 10800, 10800, MIN_INT32, 0x7fffffff, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoBentConnector3 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptBentConnector3Vert),
|
|
const_cast<sal_uInt16*>(mso_sptBentConnector3Segm), sizeof( mso_sptBentConnector3Segm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptBentConnector3Calc),
|
|
const_cast<sal_Int32*>(mso_sptBentConnector3Default),
|
|
std::span<const SvxMSDffTextRectangles>(),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptBentConnector3Handle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptBentConnector4Vert[] =
|
|
{
|
|
{ 0, 0 }, { 0 MSO_I, 0 }, { 0 MSO_I, 1 MSO_I }, { 21600, 1 MSO_I }, { 21600, 21600 }
|
|
};
|
|
const sal_uInt16 mso_sptBentConnector4Segm[] =
|
|
{
|
|
0x4000, 0x0004, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptBentConnector4Calc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
|
|
{ 0x2000, { 0x400, 21600, 0 } },
|
|
{ 0x2001, { 0x402, 1, 2 } },
|
|
{ 0x2001, { 0x401, 1, 2 } }
|
|
};
|
|
const sal_Int32 mso_sptBentConnector4Default[] =
|
|
{
|
|
2, 10800, 10800
|
|
};
|
|
const SvxMSDffHandle mso_sptBentConnector4Handle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
|
|
0x100, 4 + 3, 10800, 10800, MIN_INT32, 0x7fffffff, 4 + 3, 4 + 3 },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
|
|
3 + 3, 0x101, 10800, 10800, 3 + 3, 3 + 3, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoBentConnector4 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptBentConnector4Vert),
|
|
const_cast<sal_uInt16*>(mso_sptBentConnector4Segm), sizeof( mso_sptBentConnector4Segm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptBentConnector4Calc),
|
|
const_cast<sal_Int32*>(mso_sptBentConnector4Default),
|
|
std::span<const SvxMSDffTextRectangles>(),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptBentConnector4Handle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptBentConnector5Vert[] =
|
|
{
|
|
{ 0, 0 }, { 0 MSO_I, 0 }, { 0 MSO_I, 4 MSO_I }, { 1 MSO_I, 4 MSO_I }, { 1 MSO_I, 21600 }, { 21600, 21600 }
|
|
};
|
|
const sal_uInt16 mso_sptBentConnector5Segm[] =
|
|
{
|
|
0x4000, 0x0005, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptBentConnector5Calc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust3Value, 0, 0 } },
|
|
{ 0x6000, { 0x400, 0x401, 0 } },
|
|
{ 0x2001, { 0x402, 1, 2 } },
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
|
|
{ 0x2001, { 0x404, 1, 2 } },
|
|
{ 0x4000, { 21600, 0x404, 0 } },
|
|
{ 0x2001, { 0x406, 1, 2 } }
|
|
};
|
|
const sal_Int32 mso_sptBentConnector5Default[] =
|
|
{
|
|
3, 10800, 10800, 10800
|
|
};
|
|
const SvxMSDffHandle mso_sptBentConnector5Handle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
|
|
0x100, 5 + 3, 10800, 10800, MIN_INT32, 0x7fffffff, 5 + 3, 5 + 3 },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
|
|
3 + 3, 0x101, 10800, 10800, 3 + 3, 3 + 3, MIN_INT32, 0x7fffffff },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
|
|
0x102, 7 + 3, 10800, 10800, MIN_INT32, 0x7fffffff, 7 + 3, 7 + 3 }
|
|
};
|
|
const mso_CustomShape msoBentConnector5 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptBentConnector5Vert),
|
|
const_cast<sal_uInt16*>(mso_sptBentConnector5Segm), sizeof( mso_sptBentConnector5Segm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptBentConnector5Calc),
|
|
const_cast<sal_Int32*>(mso_sptBentConnector5Default),
|
|
std::span<const SvxMSDffTextRectangles>(),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptBentConnector5Handle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptCurvedConnector2Vert[] =
|
|
{
|
|
{ 0, 0 }, { 10800, 0 }, { 21600, 10800 }, { 21600, 21600 }
|
|
};
|
|
const sal_uInt16 mso_sptCurvedConnector2Segm[] =
|
|
{
|
|
0x4000, 0x2001, 0x8000
|
|
};
|
|
const mso_CustomShape msoCurvedConnector2 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptCurvedConnector2Vert),
|
|
const_cast<sal_uInt16*>(mso_sptCurvedConnector2Segm), sizeof( mso_sptCurvedConnector2Segm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(),
|
|
nullptr,
|
|
std::span<const SvxMSDffTextRectangles>(),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>()
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptCurvedConnector3Vert[] =
|
|
{
|
|
{ 0, 0 }, { 1 MSO_I, 0 }, { 0 MSO_I, 5400 }, { 0 MSO_I, 10800 }, { 0 MSO_I, 16200 }, { 3 MSO_I, 21600 }, { 21600, 21600 }
|
|
};
|
|
const sal_uInt16 mso_sptCurvedConnector3Segm[] =
|
|
{
|
|
0x4000, 0x2002, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptCurvedConnector3Calc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x2001, { 0x400, 1, 2 } },
|
|
{ 0x2000, { 0x400, 21600, 0 } },
|
|
{ 0x2001, { 0x402, 1, 2 } }
|
|
};
|
|
const sal_Int32 mso_sptCurvedConnector3Default[] =
|
|
{
|
|
1, 10800
|
|
};
|
|
const SvxMSDffHandle mso_sptCurvedConnector3Handle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE,
|
|
0x100, 10800, 10800, 10800, MIN_INT32, 0x7fffffff, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoCurvedConnector3 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptCurvedConnector3Vert),
|
|
const_cast<sal_uInt16*>(mso_sptCurvedConnector3Segm), sizeof( mso_sptCurvedConnector3Segm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptCurvedConnector3Calc),
|
|
const_cast<sal_Int32*>(mso_sptCurvedConnector3Default),
|
|
std::span<const SvxMSDffTextRectangles>(),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptCurvedConnector3Handle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptCurvedConnector4Vert[] =
|
|
{
|
|
{ 0, 0 }, { 1 MSO_I, 0 }, { 0 MSO_I, 10 MSO_I }, { 0 MSO_I, 9 MSO_I },
|
|
{ 0 MSO_I, 12 MSO_I }, { 5 MSO_I, 8 MSO_I }, { 3 MSO_I, 8 MSO_I },
|
|
{ 7 MSO_I, 8 MSO_I }, { 21600, 14 MSO_I }, { 21600, 21600 }
|
|
|
|
};
|
|
const sal_uInt16 mso_sptCurvedConnector4Segm[] =
|
|
{
|
|
0x4000, 0x2003, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptCurvedConnector4Calc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x2001, { 0x400, 1, 2 } },
|
|
{ 0x4000, { 21600, 0x400, 0 } },
|
|
{ 0x2001, { 0x402, 1, 2 } },
|
|
{ 0x6000, { 0x400, 0x403, 0 } },
|
|
{ 0x2001, { 0x404, 1, 2 } },
|
|
{ 0x2000, { 0x403, 21600, 0 } },
|
|
{ 0x2001, { 0x406, 1, 2 } },
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
|
|
{ 0x2001, { DFF_Prop_adjust2Value, 1, 2 } },
|
|
{ 0x2001, { DFF_Prop_adjust2Value, 1, 4 } },
|
|
{ 0x6000, { 0x408, 0x409, 0 } },
|
|
{ 0x2001, { 0x40b, 1, 2 } },
|
|
{ 0x2000, { 0x408, 21600, 0 } },
|
|
{ 0x2001, { 0x40d, 1, 2 } }
|
|
};
|
|
const sal_Int32 mso_sptCurvedConnector4Default[] =
|
|
{
|
|
2, 10800, 10800
|
|
};
|
|
const SvxMSDffHandle mso_sptCurvedConnector4Handle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
|
|
0x100, 9 + 3, 10800, 10800, MIN_INT32, 0x7fffffff, 9 + 3, 9 + 3 },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
|
|
3 + 3, 0x101, 10800, 10800, 3 + 3, 3 + 3, MIN_INT32, 0x7fffffff }
|
|
};
|
|
const mso_CustomShape msoCurvedConnector4 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptCurvedConnector4Vert),
|
|
const_cast<sal_uInt16*>(mso_sptCurvedConnector4Segm), sizeof( mso_sptCurvedConnector4Segm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptCurvedConnector4Calc),
|
|
const_cast<sal_Int32*>(mso_sptCurvedConnector4Default),
|
|
std::span<const SvxMSDffTextRectangles>(),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptCurvedConnector4Handle),
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptCurvedConnector5Vert[] =
|
|
{
|
|
{ 0, 0 },
|
|
{ 21 MSO_I, 0 }, { 0 MSO_I, 12 MSO_I }, { 0 MSO_I, 11 MSO_I },
|
|
{ 0 MSO_I, 14 MSO_I }, { 6 MSO_I, 4 MSO_I }, { 3 MSO_I, 4 MSO_I },
|
|
{ 8 MSO_I, 4 MSO_I }, { 1 MSO_I, 18 MSO_I }, { 1 MSO_I, 16 MSO_I },
|
|
{ 1 MSO_I, 20 MSO_I }, { 10 MSO_I, 21600 }, { 21600, 21600 }
|
|
};
|
|
const sal_uInt16 mso_sptCurvedConnector5Segm[] =
|
|
{
|
|
0x4000, 0x2004, 0x8000
|
|
};
|
|
const SvxMSDffCalculationData mso_sptCurvedConnector5Calc[] =
|
|
{
|
|
{ 0x2000, { DFF_Prop_adjustValue, 0, 0 } },
|
|
{ 0x2000, { DFF_Prop_adjust3Value, 0, 0 } },
|
|
{ 0x6000, { 0x400, 0x401, 0 } },
|
|
{ 0x2001, { 0x402, 1, 2 } },
|
|
{ 0x2000, { DFF_Prop_adjust2Value, 0, 0 } },
|
|
{ 0x6000, { 0x400, 0x403, 0 } },
|
|
{ 0x2001, { 0x405, 1, 2 } },
|
|
{ 0x6000, { 0x401, 0x403, 0 } },
|
|
{ 0x2001, { 0x407, 1, 2 } },
|
|
{ 0x2000, { 0x401, 21600, 0 } },
|
|
{ 0x2001, { 0x409, 1, 2 } },
|
|
{ 0x2001, { 0x404, 1, 2 } },
|
|
{ 0x2001, { 0x40b, 1, 2 } },
|
|
{ 0x6000, { 0x404, 0x40b, 0 } },
|
|
{ 0x2001, { 0x40d, 1, 2 } },
|
|
{ 0x2000, { 0x404, 21600, 0 } },
|
|
{ 0x2001, { 0x40f, 1, 2 } },
|
|
{ 0x6000, { 0x404, 0x410, 0 } },
|
|
{ 0x2001, { 0x411, 1, 2 } },
|
|
{ 0x2000, { 0x410, 21600, 0 } },
|
|
{ 0x2001, { 0x413, 1, 2 } },
|
|
{ 0x2001, { 0x400, 1, 2 } }
|
|
};
|
|
const sal_Int32 mso_sptCurvedConnector5Default[] =
|
|
{
|
|
3, 10800, 10800, 10800
|
|
};
|
|
const SvxMSDffHandle mso_sptCurvedConnector5Handle[] =
|
|
{
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
|
|
0x100, 11 + 3, 10800, 10800, MIN_INT32, 0x7fffffff, 11 + 3, 11 + 3 },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL,
|
|
3 + 3, 0x101, 10800, 10800, 3 + 3, 3 + 3, MIN_INT32, 0x7fffffff },
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL | SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL,
|
|
0x102, 16 + 3, 10800, 10800, MIN_INT32, 0x7fffffff, 16 + 3, 16 + 3 }
|
|
};
|
|
const mso_CustomShape msoCurvedConnector5 =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptCurvedConnector5Vert),
|
|
const_cast<sal_uInt16*>(mso_sptCurvedConnector5Segm), sizeof( mso_sptCurvedConnector5Segm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptCurvedConnector5Calc),
|
|
const_cast<sal_Int32*>(mso_sptCurvedConnector5Default),
|
|
std::span<const SvxMSDffTextRectangles>(),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptCurvedConnector5Handle),
|
|
};
|
|
|
|
/////////////////////////////teardrop
|
|
const SvxMSDffVertPair mso_sptTearDropVert[] =
|
|
{
|
|
{ 10800, 0 },
|
|
{ 0, 10800 }, // X
|
|
{ 10800, 21600 }, // Y
|
|
{ 21600, 10800 }, // X
|
|
{ 21600, 10800 }, { 21600, 3 MSO_I }, { 0 MSO_I, 1 MSO_I }, // C
|
|
{ 0 MSO_I, 1 MSO_I }, { 4 MSO_I, 0 }, { 10800, 0 }
|
|
};
|
|
|
|
// the last number (0x***n) : 0 = sum, 1 = prod, 2 = mid, 3 = abs, 4 = min, 5 = max, 6 = if, 13 = sqrt, 15 = eclipse ...
|
|
// the first number(0xn***) : 2/4/8 the first/second/third value is not directly value
|
|
const SvxMSDffCalculationData mso_sptTearDropCalc[] =
|
|
{
|
|
{ 0x2000 , { DFF_Prop_adjustValue , 0 , 0 } }, // 0 adjust value #0
|
|
{ 0x8000 , { 21600 , 0 , 0x0400 } }, // 1 21600 - @0 y0
|
|
{ 0x8000 , { 32400 , 0 , 0x0400 } }, // 2 (32400 - @0)
|
|
{ 0x2001 , { 0x0402 , 1 , 2 } }, // 3 (32400 - @0)/2 y1
|
|
{ 0x2002 , { 0x0400 , 10800 , 0 } }, // 4 (@0+10800)/2 x2
|
|
};
|
|
|
|
//m, qx, qy, qx,C,C
|
|
//the last number(0x***n) : repeat number of this current Segm
|
|
const sal_uInt16 mso_sptTearDropSegm[] =
|
|
{
|
|
0x4000, 0xa701, 0xa801, 0xa701, 0x2002, 0x6000, 0x8000
|
|
};
|
|
|
|
const SvxMSDffTextRectangles mso_sptTearDropTextRect[] =
|
|
{
|
|
{ { 2863, 2863 }, { 18737, 18737 } }
|
|
};
|
|
|
|
//the range of adjust values
|
|
const SvxMSDffHandle mso_sptTearDropHandle[] =
|
|
{
|
|
//position="$0,0" xrange="10800,32400"
|
|
{ SvxMSDffHandleFlags::RANGE | SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL| SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL,
|
|
0x100, 0, 10800, 10800, 10800, 32400, MIN_INT32, 0x7fffffff }
|
|
};
|
|
|
|
//the number of adjust values, the default values
|
|
const sal_Int32 mso_sptTearDropDefault[] =
|
|
{
|
|
1, 21600
|
|
};
|
|
|
|
const mso_CustomShape msoTearDrop =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptTearDropVert),
|
|
const_cast<sal_uInt16*>(mso_sptTearDropSegm), sizeof( mso_sptTearDropSegm ) >> 1,
|
|
std::span<const SvxMSDffCalculationData>(mso_sptTearDropCalc),
|
|
const_cast<sal_Int32*>(mso_sptTearDropDefault),
|
|
std::span<const SvxMSDffTextRectangles>(mso_sptTearDropTextRect),
|
|
21600, 21600,
|
|
MIN_INT32, MIN_INT32,
|
|
std::span<const SvxMSDffVertPair>(),
|
|
std::span<const SvxMSDffHandle>(mso_sptTearDropHandle),
|
|
};
|
|
|
|
///////////////////////////// sinusoid
|
|
const SvxMSDffVertPair mso_sptSinusoidVert[] =
|
|
{
|
|
// calculations courtesy of section 6.3.2 of
|
|
// https://documentation.libreoffice.org/assets/Uploads/Documentation/en/Tutorials/CustomShapes7/Custom-Shape-Tutorial.pdf#page=52
|
|
|
|
// taking K = (3pi/2 - 3pi^2/8 - 1/2)
|
|
// transforming points to viewbox of size 21600 x 21600
|
|
|
|
// Start point
|
|
{ 0, 10800 }, // (0, 0)
|
|
// First Bezier
|
|
{ 1757, 5278 }, // (K, K)
|
|
{ 3437, 0 }, // (1, 1)
|
|
{ 5400, 0 }, // (pi/2, 1)
|
|
// Second Bezier
|
|
{ 7362, 0 }, // (pi - 1, 1)
|
|
{ 9042, 5278 }, // (pi - K, K)
|
|
{ 10800, 10800 }, // (pi, 0)
|
|
// Third Bezier
|
|
{ 12557, 16321 }, // (pi + K, -K)
|
|
{ 14237, 21600 }, // (pi + 1, -1)
|
|
{ 16200, 21600 }, // (3pi/2, -1)
|
|
// Fourth Bezier
|
|
{ 18162, 21600 }, // (2pi - 1, -1)
|
|
{ 19842, 16321 }, // (2pi - K, -K)
|
|
{ 21600, 10800 } // (2pi, 0)
|
|
};
|
|
|
|
const sal_uInt16 mso_sptSinusoidSegm[] =
|
|
{
|
|
0x4000, 0x2004, 0x8000
|
|
};
|
|
|
|
const SvxMSDffVertPair mso_sptSinusoidGluePoints[] =
|
|
{
|
|
{ 0, 10800 }, // x = 0.00
|
|
{ 5400, 0 }, // x = 0.25
|
|
{ 10800, 10800 }, // x = 0.50
|
|
{ 16200, 21600 }, // x = 0.75
|
|
{ 21600, 10800 } // x = 1.00
|
|
};
|
|
|
|
const mso_CustomShape msoSinusoid =
|
|
{
|
|
std::span<const SvxMSDffVertPair>(mso_sptSinusoidVert), // vertices
|
|
const_cast<sal_uInt16*>(mso_sptSinusoidSegm), sizeof(mso_sptSinusoidSegm) >> 1, // segments, count
|
|
std::span<const SvxMSDffCalculationData>(), // calculations (none)
|
|
nullptr, // default values (none)
|
|
std::span<const SvxMSDffTextRectangles>(), // text area (default)
|
|
21600, 21600, // viewbox w, h (default)
|
|
MIN_INT32, MIN_INT32, // stretch x, y (unset)
|
|
std::span<const SvxMSDffVertPair>(mso_sptSinusoidGluePoints), // glue points
|
|
std::span<const SvxMSDffHandle>(), // handles (none)
|
|
};
|
|
|
|
|
|
const mso_CustomShape* GetCustomShapeContent( MSO_SPT eSpType )
|
|
{
|
|
const mso_CustomShape* pCustomShape = nullptr;
|
|
switch( eSpType )
|
|
{
|
|
case mso_sptArc : pCustomShape = &msoArc; break;
|
|
case mso_sptLine: pCustomShape = &msoStraightConnector1; break;
|
|
case mso_sptRectangle : pCustomShape = &msoRectangle; break;
|
|
case mso_sptParallelogram : pCustomShape = &msoParallelogram; break;
|
|
case mso_sptTrapezoid : pCustomShape = &msoTrapezoid; break;
|
|
case mso_sptDiamond : pCustomShape = &msoDiamond; break;
|
|
case mso_sptRoundRectangle : pCustomShape = &msoRoundRectangle; break;
|
|
case mso_sptOctagon : pCustomShape = &msoOctagon; break;
|
|
case mso_sptIsocelesTriangle : pCustomShape = &msoIsocelesTriangle; break;
|
|
case mso_sptRightTriangle : pCustomShape = &msoRightTriangle; break;
|
|
case mso_sptEllipse : pCustomShape = &msoEllipse; break;
|
|
case mso_sptHexagon : pCustomShape = &msoHexagon; break;
|
|
case mso_sptPlus : pCustomShape = &msoPlus; break;
|
|
case mso_sptPentagon : pCustomShape = &msoPentagon; break;
|
|
case mso_sptCan : pCustomShape = &msoCan; break;
|
|
case mso_sptCube : pCustomShape = &msoCube; break;
|
|
case mso_sptBalloon : pCustomShape = &msoBalloon; break;
|
|
case mso_sptActionButtonBlank : pCustomShape = &msoActionButtonBlank; break;
|
|
case mso_sptActionButtonHome : pCustomShape = &msoActionButtonHome; break;
|
|
case mso_sptActionButtonHelp : pCustomShape = &msoActionButtonHelp; break;
|
|
case mso_sptActionButtonInformation : pCustomShape = &msoActionButtonInformation; break;
|
|
case mso_sptActionButtonBackPrevious : pCustomShape = &msoActionButtonBackPrevious; break;
|
|
case mso_sptActionButtonForwardNext : pCustomShape = &msoActionButtonForwardNext; break;
|
|
case mso_sptActionButtonBeginning : pCustomShape = &msoActionButtonBeginning; break;
|
|
case mso_sptActionButtonEnd : pCustomShape = &msoActionButtonEnd; break;
|
|
case mso_sptActionButtonReturn : pCustomShape = &msoActionButtonReturn; break;
|
|
case mso_sptActionButtonDocument : pCustomShape = &msoActionButtonDocument; break;
|
|
case mso_sptActionButtonSound : pCustomShape = &msoActionButtonSound; break;
|
|
case mso_sptActionButtonMovie : pCustomShape = &msoActionButtonMovie; break;
|
|
case mso_sptBevel : pCustomShape = &msoBevel; break;
|
|
case mso_sptFoldedCorner : pCustomShape = &msoFoldedCorner; break;
|
|
case mso_sptSmileyFace : pCustomShape = &msoSmileyFace; break;
|
|
case mso_sptDonut : pCustomShape = &msoDonut; break;
|
|
case mso_sptNoSmoking : pCustomShape = &msoNoSmoking; break;
|
|
case mso_sptBlockArc : pCustomShape = &msoBlockArc; break;
|
|
case mso_sptHeart : pCustomShape = &msoHeart; break;
|
|
case mso_sptLightningBolt : pCustomShape = &msoLightningBold; break;
|
|
case mso_sptSun : pCustomShape = &msoSun; break;
|
|
case mso_sptMoon : pCustomShape = &msoMoon; break;
|
|
case mso_sptBracketPair : pCustomShape = &msoBracketPair; break;
|
|
case mso_sptBracePair : pCustomShape = &msoBracePair; break;
|
|
case mso_sptPlaque : pCustomShape = &msoPlaque; break;
|
|
case mso_sptLeftBracket : pCustomShape = &msoLeftBracket; break;
|
|
case mso_sptRightBracket : pCustomShape = &msoRightBracket; break;
|
|
case mso_sptLeftBrace : pCustomShape = &msoLeftBrace; break;
|
|
case mso_sptRightBrace : pCustomShape = &msoRightBrace; break;
|
|
case mso_sptArrow : pCustomShape = &msoArrow; break;
|
|
case mso_sptUpArrow : pCustomShape = &msoUpArrow; break;
|
|
case mso_sptDownArrow : pCustomShape = &msoDownArrow; break;
|
|
case mso_sptLeftArrow : pCustomShape = &msoLeftArrow; break;
|
|
case mso_sptLeftRightArrow : pCustomShape = &msoLeftRightArrow; break;
|
|
case mso_sptUpDownArrow : pCustomShape = &msoUpDownArrow; break;
|
|
case mso_sptQuadArrow : pCustomShape = &msoQuadArrow; break;
|
|
case mso_sptLeftRightUpArrow : pCustomShape = &msoLeftRightUpArrow; break;
|
|
case mso_sptBentArrow : pCustomShape = &msoBentArrow; break;
|
|
case mso_sptUturnArrow : pCustomShape = &msoUturnArrow; break;
|
|
case mso_sptLeftUpArrow : pCustomShape = &msoLeftUpArrow; break;
|
|
case mso_sptBentUpArrow : pCustomShape = &msoBentUpArrow; break;
|
|
case mso_sptCurvedRightArrow : pCustomShape = &msoCurvedRightArrow; break;
|
|
case mso_sptCurvedLeftArrow : pCustomShape = &msoCurvedLeftArrow; break;
|
|
case mso_sptCurvedUpArrow : pCustomShape = &msoCurvedUpArrow; break;
|
|
case mso_sptCurvedDownArrow : pCustomShape = &msoCurvedDownArrow; break;
|
|
case mso_sptStripedRightArrow : pCustomShape = &msoStripedRightArrow; break;
|
|
case mso_sptNotchedRightArrow : pCustomShape = &msoNotchedRightArrow; break;
|
|
case mso_sptHomePlate : pCustomShape = &msoHomePlate; break;
|
|
case mso_sptChevron : pCustomShape = &msoChevron; break;
|
|
case mso_sptRightArrowCallout : pCustomShape = &msoRightArrowCallout; break;
|
|
case mso_sptLeftArrowCallout : pCustomShape = &msoLeftArrowCallout; break;
|
|
case mso_sptUpArrowCallout : pCustomShape = &msoUpArrowCallout; break;
|
|
case mso_sptDownArrowCallout : pCustomShape = &msoDownArrowCallout; break;
|
|
case mso_sptLeftRightArrowCallout : pCustomShape = &msoLeftRightArrowCallout; break;
|
|
case mso_sptUpDownArrowCallout : pCustomShape = &msoUpDownArrowCallout; break;
|
|
case mso_sptQuadArrowCallout : pCustomShape = &msoQuadArrowCallout; break;
|
|
case mso_sptCircularArrow : pCustomShape = &msoCircularArrow; break;
|
|
case mso_sptIrregularSeal1 : pCustomShape = &msoIrregularSeal1; break;
|
|
case mso_sptIrregularSeal2 : pCustomShape = &msoIrregularSeal2; break;
|
|
case mso_sptSeal4 : pCustomShape = &msoSeal4; break;
|
|
case mso_sptStar : pCustomShape = &msoStar; break;
|
|
case mso_sptSeal8 : pCustomShape = &msoSeal8; break;
|
|
case mso_sptSeal :
|
|
case mso_sptSeal16 : pCustomShape = &msoSeal16; break;
|
|
case mso_sptSeal24 : pCustomShape = &msoSeal24; break;
|
|
case mso_sptSeal32 : pCustomShape = &msoSeal32; break;
|
|
case mso_sptRibbon2 : pCustomShape = &msoRibbon2; break;
|
|
case mso_sptRibbon : pCustomShape = &msoRibbon; break;
|
|
case mso_sptEllipseRibbon2 : pCustomShape = &msosptEllipseRibbon2; break; // SJ: TODO
|
|
case mso_sptEllipseRibbon : pCustomShape = &msosptEllipseRibbon; break; // SJ: TODO
|
|
case mso_sptVerticalScroll : pCustomShape = &msoVerticalScroll; break;
|
|
case mso_sptHorizontalScroll : pCustomShape = &msoHorizontalScroll; break;
|
|
case mso_sptFlowChartProcess : pCustomShape = &msoFlowChartProcess; break;
|
|
case mso_sptFlowChartAlternateProcess : pCustomShape = &msoFlowChartAlternateProcess; break;
|
|
case mso_sptFlowChartDecision : pCustomShape = &msoFlowChartDecision; break;
|
|
case mso_sptFlowChartInputOutput : pCustomShape = &msoFlowChartInputOutput; break;
|
|
case mso_sptFlowChartPredefinedProcess :pCustomShape = &msoFlowChartPredefinedProcess; break;
|
|
case mso_sptFlowChartInternalStorage : pCustomShape = &msoFlowChartInternalStorage; break;
|
|
case mso_sptFlowChartDocument : pCustomShape = &msoFlowChartDocument; break;
|
|
case mso_sptFlowChartMultidocument : pCustomShape = &msoFlowChartMultidocument; break;
|
|
case mso_sptFlowChartTerminator : pCustomShape = &msoFlowChartTerminator; break;
|
|
case mso_sptFlowChartPreparation : pCustomShape = &msoFlowChartPreparation; break;
|
|
case mso_sptFlowChartManualInput : pCustomShape = &msoFlowChartManualInput; break;
|
|
case mso_sptFlowChartManualOperation : pCustomShape = &msoFlowChartManualOperation; break;
|
|
case mso_sptFlowChartConnector : pCustomShape = &msoFlowChartConnector; break;
|
|
case mso_sptFlowChartOffpageConnector : pCustomShape = &msoFlowChartOffpageConnector; break;
|
|
case mso_sptFlowChartPunchedCard : pCustomShape = &msoFlowChartPunchedCard; break;
|
|
case mso_sptFlowChartPunchedTape : pCustomShape = &msoFlowChartPunchedTape; break;
|
|
case mso_sptFlowChartSummingJunction : pCustomShape = &msoFlowChartSummingJunction; break;
|
|
case mso_sptFlowChartOr : pCustomShape = &msoFlowChartOr; break;
|
|
case mso_sptFlowChartCollate : pCustomShape = &msoFlowChartCollate; break;
|
|
case mso_sptFlowChartSort : pCustomShape = &msoFlowChartSort; break;
|
|
case mso_sptFlowChartExtract : pCustomShape = &msoFlowChartExtract; break;
|
|
case mso_sptFlowChartMerge : pCustomShape = &msoFlowChartMerge; break;
|
|
case mso_sptFlowChartOnlineStorage : pCustomShape = &msoFlowChartOnlineStorage; break;
|
|
case mso_sptFlowChartDelay : pCustomShape = &msoFlowChartDelay; break;
|
|
case mso_sptFlowChartMagneticTape : pCustomShape = &msoFlowChartMagneticTape; break;
|
|
case mso_sptFlowChartMagneticDisk : pCustomShape = &msoFlowChartMagneticDisk; break;
|
|
case mso_sptFlowChartMagneticDrum : pCustomShape = &msoFlowChartMagneticDrum; break;
|
|
case mso_sptFlowChartDisplay : pCustomShape = &msoFlowChartDisplay; break;
|
|
case mso_sptWedgeRectCallout : pCustomShape = &msoWedgeRectCallout; break;
|
|
case mso_sptWedgeRRectCallout : pCustomShape = &msoWedgeRRectCallout; break;
|
|
case mso_sptWedgeEllipseCallout : pCustomShape = &msoWedgeEllipseCallout; break;
|
|
case mso_sptCloudCallout : pCustomShape = &msoCloudCallout; break;
|
|
case mso_sptWave : pCustomShape = &msoWave; break;
|
|
case mso_sptDoubleWave : pCustomShape = &msoDoubleWave; break;
|
|
case mso_sptSinusoid : pCustomShape = &msoSinusoid; break;
|
|
|
|
// callout
|
|
case mso_sptCallout1 : pCustomShape = &msoCallout1; break;
|
|
case mso_sptCallout2 : pCustomShape = &msoCallout2; break;
|
|
case mso_sptCallout3 : pCustomShape = &msoCallout3; break;
|
|
case mso_sptAccentCallout1 : pCustomShape = &msoAccentCallout1; break;
|
|
case mso_sptAccentCallout2 : pCustomShape = &msoAccentCallout2; break;
|
|
case mso_sptAccentCallout3 : pCustomShape = &msoAccentCallout3; break;
|
|
case mso_sptBorderCallout1 : pCustomShape = &msoBorderCallout1; break;
|
|
case mso_sptBorderCallout2 : pCustomShape = &msoBorderCallout2; break;
|
|
case mso_sptBorderCallout3 : pCustomShape = &msoBorderCallout3; break;
|
|
case mso_sptAccentBorderCallout1 : pCustomShape = &msoAccentBorderCallout1; break;
|
|
case mso_sptAccentBorderCallout2 : pCustomShape = &msoAccentBorderCallout2; break;
|
|
case mso_sptAccentBorderCallout3 : pCustomShape = &msoAccentBorderCallout3; break;
|
|
case mso_sptCallout90 : pCustomShape = &msoCallout90; break;
|
|
case mso_sptAccentCallout90 : pCustomShape = &msoAccentCallout90; break;
|
|
case mso_sptBorderCallout90 : pCustomShape = &msoBorderCallout90; break;
|
|
case mso_sptAccentBorderCallout90 : pCustomShape = &msoAccentBorderCallout90; break;
|
|
|
|
// connectors
|
|
case mso_sptStraightConnector1 : pCustomShape = &msoStraightConnector1; break;
|
|
case mso_sptBentConnector2 : pCustomShape = &msoBentConnector2; break;
|
|
case mso_sptBentConnector3 : pCustomShape = &msoBentConnector3; break;
|
|
case mso_sptBentConnector4 : pCustomShape = &msoBentConnector4; break;
|
|
case mso_sptBentConnector5 : pCustomShape = &msoBentConnector5; break;
|
|
case mso_sptCurvedConnector2 : pCustomShape = &msoCurvedConnector2; break;
|
|
case mso_sptCurvedConnector3 : pCustomShape = &msoCurvedConnector3; break;
|
|
case mso_sptCurvedConnector4 : pCustomShape = &msoCurvedConnector4; break;
|
|
case mso_sptCurvedConnector5 : pCustomShape = &msoCurvedConnector5; break;
|
|
|
|
// Don't know, simply mapping to TextSimple
|
|
case mso_sptTextBox : pCustomShape = &msoTextSimple; break;
|
|
|
|
// FontWork
|
|
case mso_sptTextSimple :
|
|
case mso_sptTextPlainText : pCustomShape = &msoTextPlainText; break;
|
|
case mso_sptTextOctagon :
|
|
case mso_sptTextStop : pCustomShape = &msoTextStop; break;
|
|
case mso_sptTextHexagon :
|
|
case mso_sptTextTriangle : pCustomShape = &msoTextTriangle; break;
|
|
case mso_sptTextTriangleInverted : pCustomShape = &msoTextTriangleInverted; break;
|
|
case mso_sptTextChevron : pCustomShape = &msoTextChevron; break;
|
|
case mso_sptTextChevronInverted : pCustomShape = &msoTextChevronInverted; break;
|
|
case mso_sptTextRingInside : pCustomShape = &msoTextRingInside; break; // SJ: TODO->the orientation of the ellipse needs to be changed
|
|
case mso_sptTextRingOutside : pCustomShape = &msoTextRingOutside; break;
|
|
case mso_sptTextFadeRight : pCustomShape = &msoTextFadeRight; break;
|
|
case mso_sptTextFadeLeft : pCustomShape = &msoTextFadeLeft; break;
|
|
case mso_sptTextFadeUp : pCustomShape = &msoTextFadeUp; break;
|
|
case mso_sptTextFadeDown : pCustomShape = &msoTextFadeDown; break;
|
|
case mso_sptTextSlantUp : pCustomShape = &msoTextSlantUp; break;
|
|
case mso_sptTextSlantDown : pCustomShape = &msoTextSlantDown; break;
|
|
case mso_sptTextCascadeUp : pCustomShape = &msoTextCascadeUp; break;
|
|
case mso_sptTextCascadeDown : pCustomShape = &msoTextCascadeDown; break;
|
|
case mso_sptTextOnRing :
|
|
case mso_sptTextArchUpCurve : pCustomShape = &msoTextArchUpCurve; break;
|
|
case mso_sptTextArchDownCurve : pCustomShape = &msoTextArchDownCurve; break;
|
|
case mso_sptTextCircleCurve : pCustomShape = &msoTextCircleCurve; break;
|
|
case mso_sptTextButtonCurve : pCustomShape = &msoTextButtonCurve; break;
|
|
case mso_sptTextRing :
|
|
case mso_sptTextArchUpPour : pCustomShape = &msoTextArchUpPour; break;
|
|
case mso_sptTextArchDownPour : pCustomShape = &msoTextArchDownPour; break;
|
|
case mso_sptTextCirclePour : pCustomShape = &msoTextCirclePour; break;
|
|
case mso_sptTextButtonPour : pCustomShape = &msoTextButtonPour; break;
|
|
case mso_sptTextCurveUp : pCustomShape = &msoTextCurveUp; break;
|
|
case mso_sptTextCurveDown : pCustomShape = &msoTextCurveDown; break;
|
|
case mso_sptTextCanUp : pCustomShape = &msoTextCanUp; break;
|
|
case mso_sptTextCurve :
|
|
case mso_sptTextOnCurve :
|
|
case mso_sptTextCanDown : pCustomShape = &msoTextCanDown; break;
|
|
case mso_sptTextInflate : pCustomShape = &msoTextInflate; break;
|
|
case mso_sptTextDeflate : pCustomShape = &msoTextDeflate; break;
|
|
case mso_sptTextInflateBottom : pCustomShape = &msoTextInflateBottom; break;
|
|
case mso_sptTextDeflateBottom : pCustomShape = &msoTextDeflateBottom; break;
|
|
case mso_sptTextInflateTop : pCustomShape = &msoTextInflateTop; break;
|
|
case mso_sptTextDeflateTop : pCustomShape = &msoTextDeflateTop; break;
|
|
case mso_sptTextDeflateInflate : pCustomShape = &msoTextDeflateInflate; break;
|
|
case mso_sptTextDeflateInflateDeflate : pCustomShape = &msoTextDeflateInflateDeflate; break;
|
|
case mso_sptTextWave :
|
|
case mso_sptTextWave1 : pCustomShape = &msoTextWave1; break;
|
|
case mso_sptTextWave2 : pCustomShape = &msoTextWave2; break;
|
|
case mso_sptTextWave3 : pCustomShape = &msoTextWave3; break;
|
|
case mso_sptTextWave4 : pCustomShape = &msoTextWave4; break;
|
|
case mso_sptTearDrop : pCustomShape = &msoTearDrop; break;
|
|
default :
|
|
break;
|
|
}
|
|
return pCustomShape;
|
|
}
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|