#!/usr/bin/env perl -w
#**************************************************************
#
#  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
#
#  Unless required by applicable law or agreed to in writing,
#  software distributed under the License is distributed on an
#  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
#  KIND, either express or implied.  See the License for the
#  specific language governing permissions and limitations
#  under the License.
#
#**************************************************************



use warnings;

sub usage() {
    print STDERR <<EOF;
Usage: preset-definitions-to-shape-types.pl <shapes> <text>

Converts presetShapeDefinitions.xml and presetTextWarpDefinitions.xml to a
.cxx that contains VML with the definitions of the shapes.  The result is
written to stdout.

<shapes> presetShapeDefinitions.xml (including the path to it)
<text>   presetTextWarpDefinitions.xml (including the path to it)
EOF
    exit 1;
}

sub show_call_stack
{
    my ( $path, $line, $subr );
    my $max_depth = 30;
    my $i = 1;
    print STDERR "--- Begin stack trace ---\n";
    while ( (my @call_details = (caller($i++))) && ($i<$max_depth) ) {
        print STDERR "$call_details[1] line $call_details[2] in function $call_details[3]\n";
    }
    print STDERR "--- End stack trace ---\n";
}

$src_shapes = shift;
$src_text = shift;

usage() if ( !defined( $src_shapes ) || !defined( $src_text ) ||
             $src_shapes eq "-h" || $src_shapes eq "--help" ||
             !-f $src_shapes || !-f $src_text );

# Global variables
@levels = ();
$shape_name = "";
$state = "";
$path = "";
$adjust = "";
$max_adj_no = 0;
@formulas = ();
%variables = ();
$ignore_this_shape = 0;
$handles = "";
$textboxrect = "";
$last_pos_x = "";
$last_pos_y = "";
$no_stroke = 0;
$no_fill = 0;
$path_w = 1;
$path_h = 1;
@quadratic_bezier = ();

%result_shapes = ();

%shapes_ids = (
    0 => 'notPrimitive',
    1 => 'rectangle',
    2 => 'roundRectangle',
    3 => 'ellipse',
    4 => 'diamond',
    5 => 'triangle',
    6 => 'rtTriangle',
    7 => 'parallelogram',
    8 => 'trapezoid',
    9 => 'hexagon',
    10 => 'octagon',
    11 => 'plus',
    12 => 'star5',
    13 => 'rightArrow',
    14 => 'thickArrow', # should not be used
    15 => 'homePlate',
    16 => 'cube',
    17 => 'wedgeRoundRectCallout', # balloon
    18 => 'star16', # seal
    19 => 'arc',
    20 => 'line',
    21 => 'plaque',
    22 => 'can',
    23 => 'donut',
    24 => 'textPlain', # textSimple - FIXME MS Office 2007 converts these to textboxes with unstyled text, so is it actually correct to map it to a real style?
    25 => 'textStop', # textOctagon FIXME see 24
    26 => 'textTriangle', # textHexagon FIXMME see 24
    27 => 'textCanDown', # textCurve FIXMME see 24
    28 => 'textWave1', # textWave FIXMME see 24
    29 => 'textArchUpPour', # textRing FIXMME see 24
    30 => 'textCanDown', # textOnCurve FIXMME see 24
    31 => 'textArchUp', # textOnRing FIXMME see 24
    32 => 'straightConnector1',
    33 => 'bentConnector2',
    34 => 'bentConnector3',
    35 => 'bentConnector4',
    36 => 'bentConnector5',
    37 => 'curvedConnector2',
    38 => 'curvedConnector3',
    39 => 'curvedConnector4',
    40 => 'curvedConnector5',
    41 => 'callout1',
    42 => 'callout2',
    43 => 'callout3',
    44 => 'accentCallout1',
    45 => 'accentCallout2',
    46 => 'accentCallout3',
    47 => 'borderCallout1',
    48 => 'borderCallout2',
    49 => 'borderCallout3',
    50 => 'accentBorderCallout1',
    51 => 'accentBorderCallout2',
    52 => 'accentBorderCallout3',
    53 => 'ribbon',
    54 => 'ribbon2',
    55 => 'chevron',
    56 => 'pentagon',
    57 => 'noSmoking',
    58 => 'star8', # seal8
    59 => 'star16', # seal16
    60 => 'star32', # seal32
    61 => 'wedgeRectCallout',
    62 => 'wedgeRoundRectCallout', # wedgeRRectCallout
    63 => 'wedgeEllipseCallout',
    64 => 'wave',
    65 => 'foldedCorner',
    66 => 'leftArrow',
    67 => 'downArrow',
    68 => 'upArrow',
    69 => 'leftRightArrow',
    70 => 'upDownArrow',
    71 => 'irregularSeal1',
    72 => 'irregularSeal2',
    73 => 'lightningBolt',
    74 => 'heart',
    75 => 'frame', # pictureFrame
    76 => 'quadArrow',
    77 => 'leftArrowCallout',
    78 => 'rightArrowCallout',
    79 => 'upArrowCallout',
    80 => 'downArrowCallout',
    81 => 'leftRightArrowCallout',
    82 => 'upDownArrowCallout',
    83 => 'quadArrowCallout',
    84 => 'bevel',
    85 => 'leftBracket',
    86 => 'rightBracket',
    87 => 'leftBrace',
    88 => 'rightBrace',
    89 => 'leftUpArrow',
    90 => 'bentUpArrow',
    91 => 'bentArrow',
    92 => 'star24', # seal24
    93 => 'stripedRightArrow',
    94 => 'notchedRightArrow',
    95 => 'blockArc',
    96 => 'smileyFace',
    97 => 'verticalScroll',
    98 => 'horizontalScroll',
    99 => 'circularArrow',
    100 => 'notchedCircularArrow', # should not be used
    101 => 'uturnArrow',
    102 => 'curvedRightArrow',
    103 => 'curvedLeftArrow',
    104 => 'curvedUpArrow',
    105 => 'curvedDownArrow',
    106 => 'cloudCallout',
    107 => 'ellipseRibbon',
    108 => 'ellipseRibbon2',
    109 => 'flowChartProcess',
    110 => 'flowChartDecision',
    111 => 'flowChartInputOutput',
    112 => 'flowChartPredefinedProcess',
    113 => 'flowChartInternalStorage',
    114 => 'flowChartDocument',
    115 => 'flowChartMultidocument',
    116 => 'flowChartTerminator',
    117 => 'flowChartPreparation',
    118 => 'flowChartManualInput',
    119 => 'flowChartManualOperation',
    120 => 'flowChartConnector',
    121 => 'flowChartPunchedCard',
    122 => 'flowChartPunchedTape',
    123 => 'flowChartSummingJunction',
    124 => 'flowChartOr',
    125 => 'flowChartCollate',
    126 => 'flowChartSort',
    127 => 'flowChartExtract',
    128 => 'flowChartMerge',
    129 => 'flowChartOfflineStorage',
    130 => 'flowChartOnlineStorage',
    131 => 'flowChartMagneticTape',
    132 => 'flowChartMagneticDisk',
    133 => 'flowChartMagneticDrum',
    134 => 'flowChartDisplay',
    135 => 'flowChartDelay',
    136 => 'textPlain', # textPlainText
    137 => 'textStop',
    138 => 'textTriangle',
    139 => 'textTriangleInverted',
    140 => 'textChevron',
    141 => 'textChevronInverted',
    142 => 'textRingInside',
    143 => 'textRingOutside',
    144 => 'textArchUp', # textArchUpCurve
    145 => 'textArchDown', # textArchDownCurve
    146 => 'textCircle', # textCircleCurve
    147 => 'textButton', # textButtonCurve
    148 => 'textArchUpPour',
    149 => 'textArchDownPour',
    150 => 'textCirclePour',
    151 => 'textButtonPour',
    152 => 'textCurveUp',
    153 => 'textCurveDown',
    154 => 'textCascadeUp',
    155 => 'textCascadeDown',
    156 => 'textWave1',
    157 => 'textWave2',
    158 => 'textWave3',
    159 => 'textWave4',
    160 => 'textInflate',
    161 => 'textDeflate',
    162 => 'textInflateBottom',
    163 => 'textDeflateBottom',
    164 => 'textInflateTop',
    165 => 'textDeflateTop',
    166 => 'textDeflateInflate',
    167 => 'textDeflateInflateDeflate',
    168 => 'textFadeRight',
    169 => 'textFadeLeft',
    170 => 'textFadeUp',
    171 => 'textFadeDown',
    172 => 'textSlantUp',
    173 => 'textSlantDown',
    174 => 'textCanUp',
    175 => 'textCanDown',
    176 => 'flowChartAlternateProcess',
    177 => 'flowChartOffpageConnector',
    178 => 'callout1', # callout90
    179 => 'accentCallout1', # accentCallout90
    180 => 'borderCallout1', # borderCallout90
    181 => 'accentBorderCallout1', # accentBorderCallout90
    182 => 'leftRightUpArrow',
    183 => 'sun',
    184 => 'moon',
    185 => 'bracketPair',
    186 => 'bracePair',
    187 => 'star4', # seal4
    188 => 'doubleWave',
    189 => 'actionButtonBlank',
    190 => 'actionButtonHome',
    191 => 'actionButtonHelp',
    192 => 'actionButtonInformation',
    193 => 'actionButtonForwardNext',
    194 => 'actionButtonBackPrevious',
    195 => 'actionButtonEnd',
    196 => 'actionButtonBeginning',
    197 => 'actionButtonReturn',
    198 => 'actionButtonDocument',
    199 => 'actionButtonSound',
    200 => 'actionButtonMovie',
    201 => 'hostControl', # should not be used
    202 => 'textBox'
);
# An error occurred, we have to ignore this shape
sub error( $ )
{
    my ( $msg ) = @_;

    $ignore_this_shape = 1;
    print STDERR "ERROR (in $shape_name ): $msg\n";
}

# Check that we are in the correct level
sub is_level( $$ )
{
    my ( $level, $value ) = @_;

    if ( $level > 0 ) {
        error( "Error in is_level(), \$level should be <= 0." );
    }
    return ( $#levels + $level > 0 ) && ( $levels[$#levels + $level] eq $value );
}

# Setup the %variables map with predefined values
sub setup_variables()
{
    %variables = (
        'l'        => 0,
        't'        => 0,
        'r'        => 21600,
        'b'        => 21600,

        'w'        => 21600,
        'h'        => 21600,
        'ss'       => 21600,
        'ls'       => 21600,

        'ssd2'     => 10800, # 1/2
        'ssd4'     => 5400,  # 1/4
        'ssd6'     => 3600,  # 1/6
        'ssd8'     => 2700,  # 1/8
        'ssd16'    => 1350,  # 1/16
        'ssd32'    => 675,   # 1/32

        'hc'       => 10800, # horizontal center
        'vc'       => 10800, # vertical center

        'wd2'      => 10800, # 1/2
        'wd3'      => 7200,  # 1/3
        'wd4'      => 5400,  # 1/4
        'wd5'      => 4320,  # 1/5
        'wd6'      => 3600,  # 1/6
        'wd8'      => 2700,  # 1/8
        'wd10'     => 2160,  # 1/10
        'wd12'     => 1800,  # 1/12
        'wd32'     => 675,   # 1/32

        'hd2'      => 10800, # 1/2
        'hd3'      => 7200,  # 1/3
        'hd4'      => 5400,  # 1/4
        'hd5'      => 4320,  # 1/5
        'hd6'      => 3600,  # 1/6
        'hd8'      => 2700,  # 1/8
        'hd10'     => 2160,  # 1/10
        'hd12'     => 1800,  # 1/12
        'hd32'     => 675,   # 1/32

        '25000'    => 5400,
        '12500'    => 2700,

        'cd4'      => 90,    # 1/4 of a circle
        'cd2'      => 180,   # 1/2 of a circle
        '3cd4'     => 270,   # 3/4 of a circle

        'cd8'      => 45,    # 1/8 of a circle
        '3cd8'     => 135,   # 3/8 of a circle
        '5cd8'     => 225,   # 5/8 of a circle
        '7cd8'     => 315,   # 7/8 of a circle

        '-5400000' => -90,
        '-10800000'=> -180,
        '-16200000'=> -270,
        '-21600000'=> -360,
        '-21599999'=> -360,

        '5400000'  => 90,
        '10800000' => 180,
        '16200000' => 270,
        '21600000' => 360,
        '21599999' => 360
#
#        '21600000' => 360,   # angle conversions
#        '27000000' => 450,
#        '32400000' => 540,
#        '37800000' => 630
    );
}

# Convert the (predefined) value to a number
sub value( $ )
{
    my ( $val ) = @_;

    my $result = $variables{$val};
    return $result if ( defined( $result ) );

    return $val if ( $val =~ /^[0-9-]+$/ );

    error( "Unknown variable '$val'." );

    show_call_stack();
    return $val;
}

# Convert the DrawingML formula to a VML one
%command_variables = (
    'w' => 'width',
    'h' => 'height',
    'r' => 'width',
    'b' => 'height'
);

# The same as value(), but some of the hardcoded values can have a name
sub command_value( $ )
{
    my ( $value ) = @_;

    return "" if ( $value eq "" );

    return $value if ( $value =~ /^@/ );

    my $command_val = $command_variables{$value};
    if ( defined( $command_val ) ) {
        return $command_val;
    }

    return value( $value );
}

# Insert the new formula to the list of formulas
# Creates the name if it's empty...
sub insert_formula( $$ )
{
    my ( $name, $fmla ) = @_;

    my $i = 0;
    foreach $f ( @formulas ) {
        if ( $f eq $fmla ) {
            if ( $name ne "" ) {
                $variables{$name} = "@" . $i;
            }
            return "@" . $i;
        }
        ++$i;
    }

    if ( $name eq "" ) {
        $name = "@" . ( $#formulas + 1 );
    }

    $variables{$name} = "@" . ( $#formulas + 1 );
    push @formulas, $fmla;

    if ( $#formulas > 127 ) {
        error( "Reached the maximum amount of formulas, have to ignore the shape '$shape_name'" );
    }

    return $variables{$name};
}

# The same as insert_formula(), but converts the params
sub insert_formula_params( $$$$$ )
{
    my ( $name, $command, $p1, $p2, $p3 ) = @_;

    my $result = $command;
    if ( $p1 ne "" ) {
        $result .= " " . command_value( $p1 );
        if ( $p2 ne "" ) {
            $result .= " " . command_value( $p2 );
            if ( $p3 ne "" ) {
                $result .= " " . command_value( $p3 );
            }
        }
    }

    return insert_formula( $name, $result );
}

# Convert the formula from DrawingML to VML
sub convert_formula( $$ )
{
    my ( $name, $fmla ) = @_;

    if ( $fmla =~ /^([^ ]+)/ ) {
        my $command = $1;

        # parse the parameters
        ( my $values = $fmla ) =~ s/^([^ ]+) *//;
        my $p1 = "", $p2 = "", $p3 = "";
        if ( $values =~ /^([^ ]+)/ ) {
            $p1 = $1;
            $values =~ s/^([^ ]+) *//;
            if ( $values =~ /^([^ ]+)/ ) {
                $p2 = $1;
                $values =~ s/^([^ ]+) *//;
                if ( $values =~ /^([^ ]+)/ ) {
                    $p3 = $1;
                }
            }
        }

        # now convert the formula
        if ( $command eq "+-" ) {
            if ( $p1 eq "100000" ) {
                $p1 = value( 'w' );
            }
            insert_formula_params( $name, "sum", $p1, $p2, $p3 );
            return;
        }
        elsif ( $command eq "*/" ) {
            if ( ( $p2 =~ /^(w|h|ss|hd2|wd2|vc)$/ ) && defined( $variables{$p1} ) ) {
                # switch it ;-) - presetTextWarpDefinitions.xml has it in other order
                my $tmp = $p1;
                $p1 = $p2;
                $p2 = $tmp;
            }

            if ( ( $p1 =~ /^(w|h|ss|hd2|wd2|vc)$/ ) && defined( $variables{$p2} ) ) {
                my $val3 = $p3;
                if ( $val3 =~ /^[0-9-]+$/ ) {
                    $val3 *= ( value( 'w' ) / value( $p1 ) );

                    # Oh yes, I'm too lazy to implement the full GCD here ;-)
                    if ( ( $val3 % 100000 ) == 0 ) {
                        $p1 = 1;
                        $p3 = sprintf( "%.0f", ( $val3 / 100000 ) );
                    }
                    elsif ( $val3 < 100000 ) {
                        $p3 = 1;
                        while ( ( ( $p3 * 100000 ) % $val3 ) != 0 ) {
                            ++$p3
                        }
                        $p1 = ( $p3 * 100000 ) / $val3;
                    }
                    else {
                        error( "Need to count the greatest common divisor." );
                    }
                }
            }
            elsif ( $p3 eq "100000" && $p2 =~ /^[0-9-]+$/ ) {
                # prevent overflows in some shapes
                $p2 = sprintf( "%.0f", ( $p2 / 10 ) );
                $p3 /= 10;
            }
            elsif ( $p3 eq "32768" && $p2 =~ /^[0-9-]+$/ ) {
                # prevent overflows in some shapes
                $p2 = sprintf( "%.0f", ( $p2 / 8 ) );
                $p3 /= 8;
            }
            elsif ( $p3 eq "50000" ) {
                $p3 = 10800;
            }
            elsif ( $name =~ /^maxAdj/ ) {
                my $val = value( $p1 );
                if ( $val =~ /^[0-9-]+$/ ) {
                    $p1 = sprintf( "%.0f", ( value( 'w' ) * $val / 100000 ) );
                }
            }

            if ( ( value( $p1 ) eq value( $p3 ) ) || ( value( $p2 ) eq value( $p3 ) ) ) {
                my $val = value( ( value( $p1 ) eq value( $p3 ) )? $p2: $p1 );
                if ( $val =~ /^@([0-9]+)$/ ) {
                    insert_formula( $name, $formulas[$1] );
                }
                else {
                    insert_formula( $name, "val $val" );
                }
            }
            else {
                insert_formula_params( $name, "prod", $p1, $p2, $p3 );
            }
            return;
        }
        elsif ( $command eq "+/" ) {
            # we have to split this into 2 formulas - 'sum' and 'prod'
            my $constructed = insert_formula_params( "", "sum", $p1, $p2, "0" );
            insert_formula_params( $name, "prod", 1, $constructed, $p3); # references the 'sum' formula
            return;
        }
        elsif ( $command eq "?:" ) {
            insert_formula_params( $name, "if", $p1, $p2, $p3 );
            return;
        }
        elsif ( $command eq "sin" || $command eq "cos" ) {
            if ( $p2 =~ /^[0-9-]+$/ && ( ( $p2 % 60000 ) == 0 ) ) {
                $p2 /= 60000;
            }
            else {
                $p2 = insert_formula_params( "", "prod", "1", $p2, "60000" );
            }
            # we have to use 'sumangle' even for the case when $p2 is const
            # and theoretically could be written as such; but Word does not
            # accept it :-(
            my $conv = insert_formula_params( "", "sumangle", "0", $p2, "0" );

            $p2 = $conv;

            insert_formula_params( $name, $command, $p1, $p2, "" );
            return;
        }
        elsif ( $command eq "abs" ) {
            insert_formula_params( $name, $command, $p1, "", "" );
            return;
        }
        elsif ( $command eq "max" || $command eq "min" ) {
            insert_formula_params( $name, $command, $p1, $p2, "" );
            return;
        }
        elsif ( $command eq "at2" ) {
            insert_formula_params( $name, "atan2", $p1, $p2, "" );
            return;
        }
        elsif ( $command eq "cat2" ) {
            insert_formula_params( $name, "cosatan2", $p1, $p2, $p3 );
            return;
        }
        elsif ( $command eq "sat2" ) {
            insert_formula_params( $name, "sinatan2", $p1, $p2, $p3 );
            return;
        }
        elsif ( $command eq "sqrt" ) {
            insert_formula_params( $name, "sqrt", $p1, "", "" );
            return;
        }
        elsif ( $command eq "mod" ) {
            insert_formula_params( $name, "mod", $p1, $p2, $p3 );
            return;
        }
        elsif ( $command eq "val" ) {
            insert_formula_params( $name, "val", value( $p1 ), "", "" );
            return;
        }
        else {
            error( "Unknown formula '$name', '$fmla'." );
        }
    }
    else {
        error( "Cannot convert formula's command '$name', '$fmla'." );
    }
}

# There's no exact equivalent of 'arcTo' in VML, we have to do some special casing...
%convert_arcTo = (
    '0' => {
        '90' => {
            'path' => 'qy',
            'op' => [ 'sum 0 __last_x__ __wR__', 'sum __hR__ __last_y__ 0' ],
        },
        '-90' => {
            'path' => 'qy',
            'op' => [ 'sum 0 __last_x__ __wR__', 'sum 0 __last_y__ __hR__' ],
        },
    },
    '90' => {
        '90' => {
            'path' => 'qx',
            'op' => [ 'sum 0 __last_x__ __wR__', 'sum 0 __last_y__ __hR__' ],
        },
        '-90' => {
            'path' => 'qx',
            'op' => [ 'sum __wR__ __last_x__ 0', 'sum 0 __last_y__ __hR__' ],
        },
    },
    '180' => {
        '90' => {
            'path' => 'qy',
            'op' => [ 'sum __wR__ __last_x__ 0', 'sum 0 __last_y__ __hR__' ],
        },
        '-90' => {
            'path' => 'qy',
            'op' => [ 'sum __wR__ __last_x__ 0', 'sum __hR__ __last_y__ 0' ],
        },
    },
    '270' => {
        '90' => {
            'path' => 'qx',
            'op' => [ 'sum __wR__ __last_x__ 0', 'sum __hR__ __last_y__ 0' ],
        },
        '-90' => {
            'path' => 'qx',
            'op' => [ 'sum 0 __last_x__ __wR__', 'sum __hR__ __last_y__ 0' ],
        },
    },
);

# Elliptic quadrant
# FIXME optimize so that we compute the const values when possible
sub elliptic_quadrant( $$$$ )
{
    my ( $wR, $hR, $stAng, $swAng ) = @_;

    if ( defined( $convert_arcTo{$stAng} ) && defined( $convert_arcTo{$stAng}{$swAng} ) ) {
        my $conv_path = $convert_arcTo{$stAng}{$swAng}{'path'};
        my $conv_op_ref = $convert_arcTo{$stAng}{$swAng}{'op'};

        $path .= "$conv_path";

        my $pos_x = $last_pos_x;
        my $pos_y = $last_pos_y;
        for ( my $i = 0; $i <= $#{$conv_op_ref}; ++$i ) {
            my $op = $conv_op_ref->[$i];

            $op =~ s/__last_x__/$last_pos_x/g;
            $op =~ s/__last_y__/$last_pos_y/g;
            $op =~ s/__wR__/$wR/g;
            $op =~ s/__hR__/$hR/g;

            my $fmla = insert_formula( "", $op );

            $path .= $fmla;

            # so far it's sufficient just to rotate the positions
            # FIXME if not ;-)
            $pos_x = $pos_y;
            $pos_y = $fmla;
        }
        $last_pos_x = $pos_x;
        $last_pos_y = $pos_y;
    }
    else {
        error( "Unhandled elliptic_quadrant(), input is ($wR, $hR, $stAng, $swAng)." );
    }
}

# Convert the quadratic bezier to cubic (exact)
# No idea why, but the 'qb' did not work for me :-(
sub quadratic_to_cubic_bezier( $ )
{
    my ( $axis ) = @_;

    my $a0 = $quadratic_bezier[0]->{$axis};
    my $a1 = $quadratic_bezier[1]->{$axis};
    my $a2 = $quadratic_bezier[2]->{$axis};

    my $b0 = $a0;

    # $b1 = $a0 + 2/3 * ( $a1 - $a0 ), but in VML
    # FIXME optimize for constants - compute directly
    my $b1_1 = insert_formula_params( "", "sum", "0", $a1, $a0 );
    my $b1_2 = insert_formula_params( "", "prod", "2", $b1_1, "3" );
    my $b1   = insert_formula_params( "", "sum", $a0, $b1_2, "0" );

    # $b2 = $b1 + 1/3 * ( $a2 - $a0 );
    # FIXME optimize for constants - compute directly
    my $b2_1 = insert_formula_params( "", "sum", "0", $a2, $a0 );
    my $b2_2 = insert_formula_params( "", "prod", "1", $b2_1, "3" );
    my $b2   = insert_formula_params( "", "sum", $b1, $b2_2, "0" );

    my $b3 = $a2;

    return ( $b0, $b1, $b2, $b3 );
}

# Extend $path by one more point
sub add_point_to_path( $$ )
{
    my ( $x, $y ) = @_;

    if ( $path =~ /[0-9]$/ && $x =~ /^[0-9-]/ ) {
        $path .= ",";
    }
    $path .= $x;

    if ( $path =~ /[0-9]$/ && $y =~ /^[0-9-]/ ) {
        $path .= ",";
    }
    $path .= $y;
}

# Start of an element
sub start_element( $% )
{
    my ( $element, %attr ) = @_;

    push @levels, $element;

    #print "element: $element\n";

    if ( is_level( -1, "presetShapeDefinitons" ) || is_level( -1, "presetTextWarpDefinitions" ) ) {
        $shape_name = $element;

        $state = "";
        $ignore_this_shape = 0;
        $path = "";
        $adjust = "";
        $max_adj_no = 0;
        @formulas = ();
        $handles = "";
        $textboxrect = "";
        $last_pos_x = "";
        $last_pos_y = "";
        $no_stroke = 0;
        $no_fill = 0;
        @quadratic_bezier = ();

        setup_variables();

        if ( $shape_name eq "sun" ) {
            # hack for this shape
            $variables{'100000'} = "21600";
            $variables{'50000'} = "10800";
            $variables{'25000'} = "5400";
            $variables{'12500'} = "2700";
            $variables{'3662'} = "791";
        }

        my $found = 0;
        foreach my $name ( values( %shapes_ids ) ) {
            if ( $name eq $shape_name ) {
                $found = 1;
                last;
            }
        }
        if ( !$found ) {
            error( "Unknown shape '$shape_name'." );
        }
    }
    elsif ( $element eq "pathLst" ) {
        $state = "path";
    }
    elsif ( $element eq "avLst" ) {
        $state = "adjust";
    }
    elsif ( $element eq "gdLst" ) {
        $state = "formulas";
    }
    elsif ( $element eq "ahLst" ) {
        $state = "handles";
    }
    elsif ( $element eq "rect" ) {
        $textboxrect = value( $attr{'l'} ) . "," . value( $attr{'t'} ) . "," .
                       value( $attr{'r'} ) . "," . value( $attr{'b'} );
    }
    elsif ( $state eq "path" ) {
        if ( $element eq "path" ) {
            $no_stroke = ( defined( $attr{'stroke'} ) && $attr{'stroke'} eq 'false' );
            $no_fill = ( defined( $attr{'fill'} ) && $attr{'fill'} eq 'none' );
            $path_w = $attr{'w'};
            $path_h = $attr{'h'};
        }
        elsif ( $element eq "moveTo" ) {
            $path .= "m";
        }
        elsif ( $element eq "lnTo" ) {
            $path .= "l";
        }
        elsif ( $element eq "cubicBezTo" ) {
            $path .= "c";
        }
        elsif ( $element eq "quadBezTo" ) {
            my %points = ( 'x' => $last_pos_x, 'y' => $last_pos_y );
            @quadratic_bezier = ( \%points );
        }
        elsif ( $element eq "close" ) {
            $path .= "x";
        }
        elsif ( $element eq "pt" ) {
            # rememeber the last position for the arcTo
            $last_pos_x = value( $attr{'x'} );
            $last_pos_y = value( $attr{'y'} );

            $last_pos_x *= ( value( 'w' ) / $path_w ) if ( defined( $path_w ) );
            $last_pos_y *= ( value( 'h' ) / $path_h ) if ( defined( $path_h ) );

            if ( $#quadratic_bezier >= 0 ) {
                my %points = ( 'x' => $last_pos_x, 'y' => $last_pos_y );
                push( @quadratic_bezier, \%points );
            }
            else {
                add_point_to_path( $last_pos_x, $last_pos_y );
            }
        }
        elsif ( ( $element eq "arcTo" ) && ( $last_pos_x ne "" ) && ( $last_pos_y ne "" ) ) {
            # there's no exact equivalent of arcTo in VML, so we have to
            # compute here a bit...
            my $stAng = value( $attr{'stAng'} );
            my $swAng = value( $attr{'swAng'} );
            my $wR = value( $attr{'wR'} );
            my $hR = value( $attr{'hR'} );

            $wR *= ( value( 'w' ) / $path_w ) if ( defined( $path_w ) );
            $hR *= ( value( 'h' ) / $path_h ) if ( defined( $path_h ) );

            if ( ( $stAng =~ /^[0-9-]+$/ ) && ( $swAng =~ /^[0-9-]+$/ ) ) {
                if ( ( ( $stAng % 90 ) == 0 ) && ( ( $swAng % 90 ) == 0 ) && ( $swAng != 0 ) ) {
                    my $end = $stAng + $swAng;
                    my $step = ( $swAng > 0 )? 90: -90;

                    for ( my $cur = $stAng; $cur != $end; $cur += $step ) {
                        elliptic_quadrant( $wR, $hR, ( $cur % 360 ), $step );
                    }
                }
                else {
                    error( "Unsupported numeric 'arcTo' ($attr{'wR'}, $attr{'hR'}, $stAng, $swAng)." );
                }
            }
            else {
                error( "Unsupported 'arcTo' conversion ($attr{'wR'}, $attr{'hR'}, $stAng, $swAng)." );
            }
        }
        else {
            error( "Unhandled path element '$element'." );
        }
    }
    elsif ( $state eq "adjust" ) {
        if ( $element eq "gd" ) {
            my $adj_no = $attr{'name'};
            my $is_const = 0;

            $adj_no =~ s/^adj//;
            if ( $adj_no eq "" ) {
                $max_adj_no = 0;
            }
            elsif ( !( $adj_no =~ /^[0-9]*$/ ) ) {
                ++$max_adj_no;
                $is_const = 1;
            }
            elsif ( $adj_no != $max_adj_no + 1 ) {
                error( "Wrong order of adj values." );
                ++$max_adj_no;
            }
            else {
                $max_adj_no = $adj_no;
            }

            if ( $attr{'fmla'} =~ /^val ([0-9-]*)$/ ) {
                my $val = sprintf( "%.0f", ( 21600 * $1 ) / 100000 );
                if ( $is_const ) {
                    $variables{$adj_no} = $val;
                }
                elsif ( $adjust eq "" ) {
                    $adjust = $val;
                }
                else {
                    $adjust = "$val,$adjust";
                }
            }
            else {
                error( "Wrong fmla '$attr{'fmla'}'." );
            }
        }
        else {
            error( "Unhandled adjust element '$element'." );
        }
    }
    elsif ( $state eq "formulas" ) {
        if ( $element eq "gd" ) {
            if ( $attr{'fmla'} =~ /^\*\/ (h|w|ss) adj([0-9]+) 100000$/ ) {
                insert_formula( $attr{'name'}, "val #" . ( $max_adj_no - $2 ) );
            }
            elsif ( $attr{'fmla'} =~ /^pin [^ ]+ ([^ ]+) / ) {
                print STDERR "TODO Map 'pin' to VML as xrange for handles.\n";
                my $pin_val = $1;
                if ( $pin_val eq "adj" ) {
                    insert_formula( $attr{'name'}, "val #0" );
                }
                elsif ( $pin_val =~ /^adj([0-9]+)/ ) {
                    insert_formula( $attr{'name'}, "val #" . ( $max_adj_no - $1 ) );
                }
                else {
                    insert_formula( $attr{'name'}, "val " . value( $pin_val ) );
                }
            }
            elsif ( $attr{'fmla'} =~ /adj/ ) {
                error( "Non-standard usage of adj in '$attr{'fmla'}'." );
            }
            else {
                convert_formula( $attr{'name'}, $attr{'fmla'} );
            }
        }
    }
    elsif ( $state eq "handles" ) {
        if ( $element eq "pos" ) {
            $handles .= "<v:h position=\"" . value( $attr{'x'} ) . "," . value( $attr{'y'} ) . "\"/>\n";
        }
    }
}

# End of an element
sub end_element( $ )
{
    my ( $element ) = @_;

    pop @levels;

    if ( $element eq $shape_name ) {
        if ( !$ignore_this_shape ) {
            # we have all the info, generate the shape now
            $state = "";

            # shape path
            my $out = "<v:shapetype id=\"shapetype___ID__\" coordsize=\"21600,21600\" o:spt=\"__ID__\" ";
            if ( $adjust ne "" ) {
                $out .= "adj=\"$adjust\" ";
            }

            # optimize it [yes, we need this twice ;-)]
            $path =~ s/([^0-9-@])0([^0-9-@])/$1$2/g;
            $path =~ s/([^0-9-@])0([^0-9-@])/$1$2/g;

            $out .= "path=\"$path\">\n";

            # stroke
            $out .= "<v:stroke joinstyle=\"miter\"/>\n";

            # formulas
            if ( $#formulas >= 0 )
            {
                $out .= "<v:formulas>\n";
                foreach $fmla ( @formulas ) {
                    $out .= "<v:f eqn=\"$fmla\"/>\n"
                }
                $out .= "</v:formulas>\n";
            }

            # path
            if ( $textboxrect ne "" ) { # TODO connectlocs, connectangles
                $out .= "<v:path gradientshapeok=\"t\" o:connecttype=\"rect\" textboxrect=\"$textboxrect\"/>\n";
            }

            # handles
            if ( $handles ne "" ) {
                $out .= "<v:handles>\n$handles</v:handles>\n";
            }

            $out .="</v:shapetype>";

            # hooray! :-)
            $result_shapes{$shape_name} = $out;
        }
        else {
            print STDERR "Shape '$shape_name' ignored; see the above error(s) for the reason.\n";
        }
        $shape_name = "";
    }
    elsif ( $state eq "path" ) {
        if ( $element eq "path" ) {
            $path .= "ns" if ( $no_stroke );
            $path .= "nf" if ( $no_fill );
            $path .= "e";
        }
        elsif ( $element eq "quadBezTo" ) {
            # we have to convert the quadratic bezier to cubic
            if ( $#quadratic_bezier == 2 ) {
                my @points_x = quadratic_to_cubic_bezier( 'x' );
                my @points_y = quadratic_to_cubic_bezier( 'y' );

                $path .= "c";
                # ignore the starting point
                for ( my $i = 1; $i < 4; ++$i ) {
                    add_point_to_path( $points_x[$i], $points_y[$i] );
                }
            }
            else {
                error( "Wrong number of points of the quadratic bezier." );
            }
            @quadratic_bezier = ();
        }
    }
    elsif ( $element eq "avLst" ) {
        $state = "";
    }
    elsif ( $element eq "gdLst" ) {
        $state = "";
    }
    elsif ( $element eq "ahLst" ) {
        $state = "";
    }
}

# Text inside an element
sub characters( $ )
{
    #my ( $text ) = @_;
}

#################### A trivial XML parser ####################

# Parse the attributes
sub parse_start_element( $ )
{
    # split the string containing both the elements and attributes
    my ( $element_tmp ) = @_;

    $element_tmp =~ s/\s*$//;
    $element_tmp =~ s/^\s*//;

    ( my $element = $element_tmp ) =~ s/\s.*$//;
    if ( $element_tmp =~ /\s/ ) {
        $element_tmp =~ s/^[^\s]*\s//;
    }
    else {
        $element_tmp = "";
    }

    # we have the element, now the attributes
    my %attr;
    my $is_key = 1;
    my $key = "";
    foreach my $tmp ( split( /"/, $element_tmp ) ) {
        if ( $is_key ) {
            $key = $tmp;
            $key =~ s/^\s*//;
            $key =~ s/\s*=\s*$//;
        }
        else {
            $attr{$key} = $tmp;
        }
        $is_key = !$is_key;
    }

    if ( $element ne "" ) {
        start_element( $element, %attr );
    }
}

# Parse the file
sub parse( $ )
{
    my ( $file ) = @_;

    my $in_comment = 0;
    my $line = "";
    while (<$file>) {
        # ignore comments
        s/<\?[^>]*\?>//g;
        s/<!--[^>]*-->//g;
        if ( /<!--/ ) {
            $in_comment = 1;
            s/<!--.*//;
        }
        elsif ( /-->/ && $in_comment ) {
            $in_comment = 0;
            s/.*-->//;
        }
        elsif ( $in_comment ) {
            next;
        }
        # ignore empty lines
        chomp;
        s/^\s*//;
        s/\s*$//;
        next if ( $_ eq "" );

        # take care of lines where element continues
        if ( $line ne "" ) {
            $line .= " " . $_;
        }
        else {
            $line = $_;
        }
        next if ( !/>$/ );

        # the actual parsing
        my @starts = split( /</, $line );
        $line = "";
        foreach $start ( @starts ) {
            next if ( $start eq "" );

            @ends = split( />/, $start );
            my $element = $ends[0];
            my $data = $ends[1];

            # start or end element
            if ( $element =~ /^\/(.*)/ ) {
                end_element( $1 );
            }
            elsif ( $element =~ /^(.*)\/$/ ) {
                parse_start_element( $1 );
                ( my $end = $1 ) =~ s/\s.*$//;
                end_element( $end );
            }
            else {
                parse_start_element( $element );
            }

            # the data
            characters( $data ) if ( defined( $data ) && $data ne "" );
        }
    }
}

# Do the real work
open( IN, "<$src_shapes" ) || die "Cannot open $src_shapes.";
parse( IN );
close( IN );

open( IN, "<$src_text" ) || die "Cannot open $src_text.";
parse( IN );
close( IN );

if ( !defined( $result_shapes{'textBox'} ) ) {
    $result_shapes{'textBox'} =
        "<v:shapetype id=\"shapetype___ID__\" coordsize=\"21600,21600\" " .
        "o:spt=\"__ID__\" path=\"m,l,21600l21600,21600l21600,xe\">\n" .
        "<v:stroke joinstyle=\"miter\"/>\n" .
        "<v:path gradientshapeok=\"t\" o:connecttype=\"rect\"/>\n" .
        "</v:shapetype>";
}

# Generate the code
print <<EOF;
// Shape types generated from
//   '$src_shapes'
// and
//   '$src_text'
// which are part of the OOXML documentation

#include <svx/escherex.hxx>

const char* pShapeTypes[ ESCHER_ShpInst_COUNT ] =
{
EOF

for ( $i = 0; $i < 203; ++$i ) {
    if ( $i < 4 ) {
        print "    /* $i - $shapes_ids{$i} - handled separately */\n    NULL,\n";
    }
    else {
        print "    /* $i - $shapes_ids{$i} */\n";
        my $out = $result_shapes{$shapes_ids{$i}};
        if ( defined( $out ) ) {
            # set the id
            $out =~ s/__ID__/$i/g;

            # escape the '"'s
            $out =~ s/"/\\"/g;

            # output as string
            $out =~ s/^/    "/;
            $out =~ s/\n/"\n    "/g;
            $out =~ s/$/"/;

            print "$out,\n";
        }
        else {
            print "    NULL,\n";
        }
    }
}

print <<EOF;
};
EOF