// Decompiled by DJ v2.6.6.51 Copyright 2000 Atanas Neshkov  Date: 6/15/2001 17:06:36
// Home Page : http://members.fortunecity.com/neshkov/dj.html  - Check often for new version!
// Decompiler options: packimports(3) 
// Source File Name:   com/macromedia/generator/commands/StockChartCommand

package com.macromedia.generator.commands;

import com.macromedia.generator.api.*;
import com.macromedia.generator.app.*;
import com.macromedia.generator.utils.Chart;
import com.macromedia.generator.utils.PropertyParser;
import java.util.Properties;

public class StockChartCommand extends GenericCommand
{

    public StockChartCommand()
    {
        _fld010A = 0;
        _fld010C = 20;
        _fld0133 = -1;
        _fld0153 = 0;
        _fld0114 = null;
        _fld0115 = null;
        _fld0116 = null;
        _fld0117 = null;
        _fld011A = 0;
        _fld011B = null;
        _fld011C = null;
        _fld011D = 0.0F;
        _fld011E = 0.0F;
        _fld011F = 0.0F;
        _fld0120 = 0.0F;
        _fld0121 = true;
        _fld0122 = false;
        _fld0125 = 0.0F;
        _fld0126 = 0.0F;
        _fld012B = true;
        _fld015D = 5;
        _fld015E = 2;
        _fld012E = true;
        _fld012F = 1;
        _fld0130 = true;
        _fld0131 = 0.0F;
        _fld0132 = 0.0F;
        _fld0134 = 2;
        _fld0135 = 1;
        _fld0136 = 1.0F;
        _fld015F = 1;
        _fld0137 = 0;
        _fld0138 = 2;
        _fld0139 = 1.0F;
        _fld013A = 20;
        _fld013B = 7;
        _fld013C = 0;
        _fld013D = 0;
        _fld013E = 20;
        _fld013F = 0.0F;
        _fld0140 = false;
    }

    private void _mth010A(int i, int j, int k, int ai[])
    {
        if(j != -1 && _fld0117 != null)
        {
            Context context = (Context)_fld0109.add(new Context());
            context.setParent(_fld0119);
            context.setValue("label", _fld0113[i][j]);
            _mth0112(context, i, ai);
            Script script = (Script)_fld0109.add(_fld0117.copyScript());
            _fld0115.processScript(script, context);
            _fld0114.addHorizontalLabelScript(k, script);
            _fld0109.release(context);
        }
    }

    boolean _mth014B(FlashEnvironment flashenvironment, int i)
    {
        int j = -1;
        int k = -1;
        int l = -1;
        int i1 = -1;
        int j1 = -1;
        for(int k1 = 0; k1 < _fld0113[0].length; k1++)
            if(_fld0113[0][k1].equalsIgnoreCase(_fld0159))
                j = k1;
            else
            if(_fld0113[0][k1].equalsIgnoreCase(_fld015A))
                k = k1;
            else
            if(_fld0113[0][k1].equalsIgnoreCase(_fld015B))
                l = k1;
            else
            if(_fld0113[0][k1].equalsIgnoreCase(_fld015C))
                i1 = k1;
            else
            if(_fld0113[0][k1].equalsIgnoreCase("color"))
                j1 = k1;

        int l1 = findColumn(_fld0113, "url");
        int i2 = findColumn(_fld0113, "window");
        int j2 = findColumn(_fld0113, "goto");
        int k2 = findColumn(_fld0113, "gotolabel");
        int l2 = findColumn(_fld0113, "hlabel");
        int ai[] = {
            j, k, l, i1, j1, l1, i2, j2, k2, l2
        };
        if(_fld0134 != 0)
        {
            int i3 = -1;
            switch(_fld015F)
            {
            case 0: // '\0'
                i3 = j;
                break;

            case 1: // '\001'
                i3 = k;
                break;

            case 2: // '\002'
                i3 = l;
                break;

            case 3: // '\003'
                i3 = i1;
                break;
            }
            if(i3 < 0)
            {
                logError(_fld0115, "valueDisplayErr", "");
                _fld0134 = 0;
                try
                {
                    _fld0114.setValueDisplay(_fld0134, _fld0135, _fld0136);
                }
                catch(GeneratorApiException _ex) { }
            }
        }
        boolean flag = false;
        if(j == -1 && (i != 2 || _fld0134 != 0 && _fld015F == 0))
            flag = true;
        if(k == -1 || l == -1 || i1 == -1)
            flag = true;
        if(flag)
        {
            logError(flashenvironment, "stockColNF", _fld010E);
            _fld0109.release();
            return false;
        }
        if(_fld0133 == -1)
        {
            if((_fld0113.length - 1) + _fld0153 > _fld014F)
            {
                logError(flashenvironment, "toobig", _fld010E);
                _fld0109.release();
                return false;
            }
        } else
        if(_fld0133 > 0)
        {
            if(_fld0133 + _fld0153 > _fld014F)
            {
                logError(flashenvironment, "toobig", _fld010E);
                _fld0109.release();
                return false;
            }
        } else
        {
            logError(flashenvironment, "toosmall", _fld010E);
            _fld0109.release();
            return false;
        }
        if(_fld010A > 0 && 2 * _fld0133 + 1 > _fld014F)
        {
            logError(flashenvironment, "toobig", _fld010E);
            _fld0109.release();
            return false;
        }
        _fld0133 = _fld0133 != -1 ? _fld0133 : _fld0113.length - 1;
        int j3 = _fld0113.length - 1;
        if(j3 > _fld0133)
            j3 = _fld0133;
        int k3 = _fld0113.length - _fld0133;
        if(k3 < 1)
            k3 = 1;
        int l3 = 0;
        _fld0114.setMultiDimenDataCount(j3, 4);
        for(int i4 = k3; i4 < _fld0113.length; i4++)
        {
            int j4 = _fld013C;
            try
            {
                if(j1 != -1)
                    j4 = Color.getRGBValue(_fld0113[i4][j1]);
            }
            catch(GeneratorApiException _ex) { }
            float f;
            float f1;
            float f2;
            float f3;
            try
            {
                f1 = Float.valueOf(_fld0113[i4][k]).floatValue();
                f2 = Float.valueOf(_fld0113[i4][l]).floatValue();
                f3 = Float.valueOf(_fld0113[i4][i1]).floatValue();
                if(j != -1)
                    f = Float.valueOf(_fld0113[i4][j]).floatValue();
                else
                    f = f3;
                if(f > f2)
                {
                    logError(flashenvironment, "openhigh", null);
                    f = f2;
                } else
                if(f < f3)
                {
                    logError(flashenvironment, "openlow", null);
                    f = f3;
                }
                if(f1 > f2)
                {
                    logError(flashenvironment, "closehigh", null);
                    f1 = f2;
                } else
                if(f1 < f3)
                {
                    logError(flashenvironment, "closelow", null);
                    f1 = f3;
                }
                float af[] = {
                    f, f2, f3, f1
                };
                _fld0114.setMultiDimenValue(l3, af, j4);
            }
            catch(NumberFormatException _ex)
            {
                logError(_fld0115, "invalidDataValue", "");
                f = 0.0F;
                f1 = 0.0F;
                f2 = 0.0F;
                f3 = 0.0F;
            }
            _mth0117(l3, i4, l1, i2, j2, k2);
            _mth010A(i4, l2, l3, ai);
            if(_fld0134 != 0 && _fld0116 != null)
            {
                float f4 = 0.0F;
                switch(_fld015F)
                {
                case 1: // '\001'
                    f4 = f1;
                    break;

                case 0: // '\0'
                    f4 = f;
                    break;

                case 2: // '\002'
                    f4 = f2;
                    break;

                case 3: // '\003'
                    f4 = f3;
                    break;
                }
                Context context = (Context)_fld0109.add(new Context());
                context.setParent(_fld0119);
                String s = _fld0114.MakeFloatLabel(f4);
                context.setValue("value", s);
                _mth0112(context, i4, ai);
                Script script = (Script)_fld0109.add(_fld0116.copyScript());
                _fld0115.processScript(script, context);
                _fld0114.addValueScript(l3, script);
                _fld0109.release(context);
            }
            l3++;
        }

        _fld0114.computeChartSize();
        if(_fld0130)
            _fld0114.RenderLabels(_fld0115, _fld0109, _fld0117);
        try
        {
            _fld0114.processStock(i);
        }
        catch(GeneratorApiException _ex) { }
        return true;
    }

    private void _mth0112(Context context, int i, int ai[])
    {
        if(_fld0113 == null)
            return;
        int j = _fld0113[i].length;
        for(int k = 0; k < j; k++)
            if(!_mth0115(k, ai))
                context.setValue(_fld0113[0][k], _fld0113[i][k]);

    }

    public void doCommand(FlashEnvironment flashenvironment, Script script, Context context, int i, Properties properties)
        throws FlashCommandException
    {
        _fld0109 = new GenVector(512);
        _fld0119 = context;
        _fld0115 = flashenvironment;
        _fld011B = script;
        _fld0110 = (Script)_fld0109.add(script.getCommandScript(i));
        _fld011C = _fld0110;
        _fld011A = script.getCommandFrameCount(i);
        _fld0110 = (Script)_fld0109.add(script.getCommandScript(i));
        if(_fld0110 == null)
            throw new FlashCommandException("movie clip missing");
        _fld010E = context.apply(properties.getProperty("datasource", ""));
        _fld0111 = context.apply(properties.getProperty("type", getResourceString(flashenvironment, "strHLC")));
        _fld0154 = context.apply(properties.getProperty("border", "true"));
        _fld010F = context.apply(properties.getProperty("color", "black"));
        _fld0155 = context.apply(properties.getProperty("ymin", ""));
        _fld0156 = context.apply(properties.getProperty("ymax", ""));
        _fld0157 = context.apply(properties.getProperty("major", ""));
        _fld0158 = context.apply(properties.getProperty("minor", ""));
        _fld0159 = context.apply(properties.getProperty("open", "open"));
        _fld015A = context.apply(properties.getProperty("close", "close"));
        _fld015B = context.apply(properties.getProperty("high", "high"));
        _fld015C = context.apply(properties.getProperty("low", "low"));
        String s = properties.getProperty("instancename", null);
        try
        {
            if(s != null)
                script.setCommandLabel(i, s);
        }
        catch(GeneratorApiException _ex)
        {
            logError(flashenvironment, "UnableToSetInstanceName", s);
        }
        try
        {
            _fld010A = Float.valueOf(context.apply(properties.getProperty("gap", "0"))).intValue();
            if(_fld010A < 0)
            {
                logWarning(flashenvironment, "badgap", null);
                _fld010A = 0;
            }
        }
        catch(NumberFormatException _ex)
        {
            logError(flashenvironment, "badgap", null);
            _fld010A = 0;
        }
        try
        {
            String s1 = properties.getProperty("start", "Default");
            s1 = context.apply(s1);
            if(!s1.equalsIgnoreCase("Default"))
                _fld0153 = Float.valueOf(s1).intValue();
            else
                _fld0153 = 0;
        }
        catch(NumberFormatException _ex)
        {
            logError(flashenvironment, "badstart", null);
            _fld0153 = 0;
        }
        if(_fld0153 < 0)
            _fld0153 = 0;
        try
        {
            Color color = (Color)_fld0109.add(new Color());
            color.setRGBValue(_fld010F);
        }
        catch(GeneratorApiException _ex)
        {
            logError(flashenvironment, "UseDefColor", null);
            _fld010F = "black";
        }
        try
        {
            _fld0151 = Float.valueOf(_fld0155).intValue();
        }
        catch(NumberFormatException _ex)
        {
            logWarning(flashenvironment, "MinMaxMustBeNumbers", null);
            _fld0151 = 0;
        }
        try
        {
            _fld0152 = Float.valueOf(_fld0156).intValue();
        }
        catch(NumberFormatException _ex)
        {
            logWarning(flashenvironment, "MinMaxMustBeNumbers", null);
            _fld0152 = 100;
        }
        try
        {
            UrlDataSource urldatasource = new UrlDataSource();
            urldatasource.setEnvironment(flashenvironment);
            try
            {
                _fld0113 = urldatasource.getData(_fld010E);
            }
            catch(Exception _ex)
            {
                logError(flashenvironment, "DataLoadError", _fld010E);
                _fld0109.release();
                return;
            }
            if(_fld0113 == null)
            {
                logError(flashenvironment, "DataSourceError", _fld010E);
                _fld0109.release();
                return;
            }
            if(_fld0113.length <= 1)
            {
                logError(flashenvironment, "invalidrows", _fld010E);
                _fld0109.release();
                return;
            }
            Rect rect = (Rect)_fld0109.add(script.getCommandRect(i));
            _fld014B = rect.getXMin();
            _fld014D = rect.getYMin();
            _fld014C = rect.getXMax();
            _fld014E = rect.getYMax();
            _fld014F = _fld014C - _fld014B;
            _fld0150 = _fld014E - _fld014D;
            if(!_mth014C(properties))
            {
                _fld0109.release();
                return;
            }
            _fld0114.setChartRect(rect);
            _fld0114.setSpacing(_fld0153, _fld010A);
            if(_fld0111.equalsIgnoreCase(getResourceString(flashenvironment, "strHLC")))
            {
                if(!_mth014B(flashenvironment, 2))
                    logError(flashenvironment, "createStockChart", null);
            } else
            if(_fld0111.equalsIgnoreCase(getResourceString(flashenvironment, "strHLCO")))
            {
                if(!_mth014B(flashenvironment, 0))
                    logError(flashenvironment, "createStockChart", null);
            } else
            if(_fld0111.equalsIgnoreCase(getResourceString(flashenvironment, "strVHLC")))
            {
                if(!_mth014B(flashenvironment, 2))
                    logError(flashenvironment, "createStockChart", null);
            } else
            if(_fld0111.equalsIgnoreCase(getResourceString(flashenvironment, "strVHLCO")))
            {
                if(!_mth014B(flashenvironment, 0))
                    logError(flashenvironment, "createStockChart", null);
            } else
            if(_fld0111.equalsIgnoreCase(getResourceString(flashenvironment, "strCandleSticks")) && !_mth014B(flashenvironment, 1))
                logError(flashenvironment, "createStockChart", null);
        }
        catch(GeneratorApiException _ex)
        {
            logError(flashenvironment, "UnableToOpenFile", _fld010E);
        }
        _fld0109.release();
    }

    private int _mth0113(int i, int j)
    {
        if(j == -1)
            return -1;
        int k = -1;
        try
        {
            k = Integer.valueOf(_fld0113[i][j]).intValue();
        }
        catch(NumberFormatException _ex) { }
        return k;
    }

    private String _mth0114(int i, int j)
    {
        if(j == -1)
            return null;
        else
            return _fld0113[i][j];
    }

    private boolean _mth0115(int i, int ai[])
    {
        return false;
    }

    private boolean _mth0116(int i, int j)
    {
        if(j == -1)
            return false;
        return _fld0113[i][j] != null && _fld0113[i][j] != "";
    }

    private void _mth0117(int i, int j, int k, int l, int i1, int j1)
    {
        if(_mth0116(j, k))
        {
            try
            {
                String s = null;
                if(l != -1)
                    s = _fld0113[j][l];
                if(s == null || s.length() == 0)
                    s = "_self";
                _fld0114.setURL(i, _fld0113[j][k], s);
            }
            catch(GeneratorApiException _ex) { }
        } else
        {
            int k1 = _mth0113(j, i1);
            if(k1 == -1 && i1 != -1)
                logWarning(_fld0115, "invalidgoto", "");
            if(k1 != -1)
            {
                try
                {
                    _fld0114.setGoTo(i, k1, "../");
                }
                catch(GeneratorApiException _ex)
                {
                    logWarning(_fld0115, "invalidgoto", "");
                }
            } else
            {
                String s1 = _mth0114(j, j1);
                if(s1 != null && s1 != "")
                    try
                    {
                        _fld0114.setGoToLabel(i, "../", s1);
                    }
                    catch(GeneratorApiException _ex)
                    {
                        logWarning(_fld0115, "invalidgotolabel", "");
                    }
            }
        }
    }

    private boolean _mth014C(Properties properties)
    {
        PropertyParser propertyparser = new PropertyParser(getClass().getName(), _fld0115, _fld0119, properties);
        _fld012B = propertyparser.ParamEquals("gridscale", "auto");
        _fld015D = propertyparser.GetIntParam("majordiv", 5);
        if(!propertyparser.Suceeded() && propertyparser.HasParam("majorDiv"))
            logError(_fld0115, "majorDivErr", propertyparser.GetStringParam("majordiv"));
        _fld015E = propertyparser.GetIntParam("minordiv", 2);
        if(!propertyparser.Suceeded() && propertyparser.HasParam("minordiv"))
            logError(_fld0115, "minorDivErr", propertyparser.GetStringParam("minordiv"));
        if(_fld015D < 2)
        {
            logError(_fld0115, "invaliddivisions", "");
            _fld015D = 2;
        }
        if(_fld015E < 0)
        {
            logError(_fld0115, "invaliddivisions", "");
            _fld015E = 1;
        }
        _fld0122 = propertyparser.ParamEquals("minytype", "relative");
        if(propertyparser.HasParam("minytype") && !_fld0122)
        {
            if(!propertyparser.ParamEquals("minytype", "Absolute"))
                logError(_fld0115, "minTypeErr", propertyparser.GetStringParam("minytype"));
            _fld0122 = false;
        }
        _fld0121 = propertyparser.ParamEquals("maxytype", "relative");
        if(propertyparser.HasParam("maxytype") && !_fld0121)
        {
            if(!propertyparser.ParamEquals("maxytype", "Absolute"))
                logError(_fld0115, "maxTypeErr", propertyparser.GetStringParam("maxytype"));
            _fld0121 = false;
        }
        _fld0125 = propertyparser.GetFloatParam("ymin", 0.0F);
        if(!propertyparser.Suceeded() && propertyparser.HasParam("ymin"))
            logError(_fld0115, "MinMaxMustBeNumbers", null);
        _fld0126 = propertyparser.GetFloatParam("ymax", 0.0F);
        if(!propertyparser.Suceeded() && propertyparser.HasParam("ymax"))
            logError(_fld0115, "MinMaxMustBeNumbers", null);
        _fld0132 = propertyparser.GetFloatParam("origin", 0.0F);
        if(!_fld0122 && !_fld0121 && _fld0125 > _fld0126)
        {
            logError(_fld0115, "YMinGreaterThanYMax", "");
            return false;
        }
        if(_fld0122 && (double)_fld0125 < 0.0D)
        {
            logError(_fld0115, "minmaxSign", "");
            _fld0125 = 0.0F;
        }
        if(_fld0121 && (double)_fld0126 < 0.0D)
        {
            logError(_fld0115, "minmaxSign", "");
            _fld0126 = 0.0F;
        }
        _fld0130 = true;
        if(propertyparser.HasParam("labels"))
        {
            _fld0130 = propertyparser.ParamEquals("labels", "on");
            if(!_fld0130 && !propertyparser.ParamEquals("labels", "off"))
            {
                logError(_fld0115, "labelParamErr", properties.getProperty("labels"));
                _fld0130 = true;
            }
        }
        _fld012F = 1;
        if(propertyparser.HasParam("gridlines"))
            if(propertyparser.ParamEquals("gridlines", "on"))
                _fld012F = 1;
            else
            if(propertyparser.ParamEquals("gridlines", "off"))
                _fld012F = 0;
            else
            if(propertyparser.ParamEquals("gridlines", "tick") || propertyparser.ParamEquals("gridlines", "tic"))
            {
                _fld012F = 2;
            } else
            {
                logError(_fld0115, "gridlinesParamErr", propertyparser.GetStringParam("gridlines"));
                _fld012F = 1;
            }
        _fld0137 = 0;
        if(propertyparser.HasParam("hlabelorient"))
            if(propertyparser.ParamEquals("hlabelorient", "horizontal"))
                _fld0137 = 1;
            else
            if(propertyparser.ParamEquals("hlabelorient", "vertical"))
                _fld0137 = 0;
            else
                logError(_fld0115, "hlabelorientErr", propertyparser.GetStringParam("hlabelorient"));
        _fld0138 = 2;
        _fld0139 = 1.0F;
        if(propertyparser.HasParam("hlabelscale"))
            if(propertyparser.ParamEquals("hlabelscale", "scaleToFit"))
                _fld0138 = 1;
            else
            if(propertyparser.ParamEquals("hlabelscale", "fixed"))
            {
                _fld0138 = 2;
                _fld0139 = 1.0F;
            } else
            if(propertyparser.ParamEquals("hlabelscale", "double"))
            {
                _fld0138 = 3;
                _fld0139 = 2.0F;
            } else
            if(propertyparser.ParamEquals("hlabelscale", "half"))
            {
                _fld0138 = 3;
                _fld0139 = 0.5F;
            } else
            {
                _fld0139 = propertyparser.GetFloatParam("hlabelscale", 1.0F);
                _fld0138 = 3;
                if(!propertyparser.Suceeded())
                {
                    logError(_fld0115, "hlabelScaleErr", propertyparser.GetStringParam("hlabelscale"));
                    _fld0138 = 2;
                }
            }
        _fld0134 = 2;
        if(propertyparser.ParamEquals("valuedisplay", "never"))
            _fld0134 = 0;
        else
        if(propertyparser.ParamEquals("valuedisplay", "always"))
            _fld0134 = 1;
        else
        if(propertyparser.ParamEquals("valuedisplay", "rollover"))
            _fld0134 = 2;
        else
        if(propertyparser.HasParam("valuedisplay"))
            logError(_fld0115, "valueDisplayErr", properties.getProperty("valuedisplay"));
        _fld0135 = 1;
        _fld0136 = 1.0F;
        if(propertyparser.HasParam("valuescale") && !propertyparser.ParamEquals("valuescale", "scaleToFit"))
            if(propertyparser.ParamEquals("valuescale", "fixed"))
            {
                _fld0135 = 2;
                _fld0136 = 1.0F;
            } else
            if(propertyparser.ParamEquals("valuescale", "double"))
            {
                _fld0135 = 3;
                _fld0136 = 2.0F;
            } else
            if(propertyparser.ParamEquals("valuescale", "half"))
            {
                _fld0135 = 3;
                _fld0136 = 0.5F;
            } else
            {
                _fld0136 = propertyparser.GetFloatParam("valuescale", 1.0F);
                _fld0135 = 3;
                if(!propertyparser.Suceeded() && propertyparser.HasParam("valuescale"))
                {
                    logError(_fld0115, "valueScaleParamErr", propertyparser.GetStringParam("valuescale"));
                    _fld0135 = 1;
                }
            }
        _fld015F = 1;
        if(propertyparser.ParamEquals("valuetodisplay", "open"))
            _fld015F = 0;
        else
        if(propertyparser.ParamEquals("valuetodisplay", "high"))
            _fld015F = 2;
        else
        if(propertyparser.ParamEquals("valuetodisplay", "low"))
            _fld015F = 3;
        else
        if(propertyparser.ParamEquals("valuetodisplay", "close"))
            _fld015F = 1;
        else
        if(propertyparser.HasParam("valuetodisplay"))
            logError(_fld0115, "valueToDisplayErr", properties.getProperty("valuetodisplay"));
        _fld013A = propertyparser.GetIntParam("lineSize", 20);
        if(_fld013A < 1 || _fld013A > 100 || !propertyparser.Suceeded())
        {
            if(propertyparser.HasParam("lineSize"))
                logError(_fld0115, "borderThickErr", properties.getProperty("lineSize"));
            _fld013A = 20;
        }
        _fld013B = _fld013A / 4;
        if(_fld013B < 1)
            _fld013B = 1;
        try
        {
            _fld013C = Color.getRGBValue(propertyparser.GetStringParam("color", "black"));
        }
        catch(GeneratorApiException _ex)
        {
            if(propertyparser.HasParam("color"))
                logError(_fld0115, "UseDefColor", propertyparser.GetStringParam("color"));
        }
        int i = Color.getRedValue(_fld013C) / 2;
        int j = Color.getGreenValue(_fld013C) / 2;
        int k = Color.getBlueValue(_fld013C) / 2;
        _fld013D = Color.getRGBValue(i, j, k);
        _fld013E = 20;
        if(propertyparser.HasParam("chartlinethickness"))
        {
            _fld013E = propertyparser.GetIntParam("chartlinethickness", 20);
            if(_fld013E < 1 || _fld013E > 100 || !propertyparser.Suceeded())
            {
                logError(_fld0115, "lineThickErr", propertyparser.GetStringParam("chartlinethickness"));
                _fld013E = 20;
            }
        }
        _fld013F = propertyparser.GetFloatParam("depth", 0.0F);
        if(_fld013F < 0.0F || !propertyparser.Suceeded())
        {
            if(propertyparser.HasParam("depth"))
                logError(_fld0115, "depthErr", properties.getProperty("depth"));
            _fld013F = -_fld013F;
        }
        _fld0140 = _fld013F > 1E-005F;
        _fld012E = true;
        if(propertyparser.HasParam("border"))
        {
            _fld012E = propertyparser.ParamEquals("border", "true");
            if(!_fld012E && !propertyparser.ParamEquals("border", "false"))
            {
                logError(_fld0115, "borderErr", properties.getProperty("border"));
                _fld012E = true;
            }
        }
        byte byte0 = 0;
        if(propertyparser.ParamEquals("valueplace", "onbar"))
            byte0 = 0;
        else
        if(propertyparser.ParamEquals("valueplace", "overbar"))
            byte0 = 1;
        else
        if(propertyparser.ParamEquals("valueplace", "overchart"))
            byte0 = 2;
        else
        if(propertyparser.ParamEquals("valueplace", "underchart"))
            byte0 = 3;
        else
        if(propertyparser.HasParam("valueplace"))
            logError(_fld0115, "valuePlaceErr", properties.getProperty("valueplace"));
        _fld0133 = -1;
        if(propertyparser.HasParam("itemcount"))
            if(propertyparser.ParamEquals("itemcount", "default"))
            {
                _fld0133 = -1;
            } else
            {
                _fld0133 = propertyparser.GetIntParam("itemcount", -1);
                if(!propertyparser.Suceeded())
                    logWarning(_fld0115, "maxEntriesErr", propertyparser.GetStringParam("itemcount"));
            }
        try
        {
            _fld0114 = (Chart)_fld0109.add(new Chart(getClass().getName(), _fld0115, _fld0119, _fld011C));
            _fld0114.setLabels(_fld0130);
            _fld0114.setBorder(_fld012E);
            _fld0114.setGridLines(_fld012F);
            _fld0114.setUserLimits(_fld0125, _fld0122, _fld0126, _fld0121);
            _fld0114.setDivisions(_fld015E + 1, _fld015D - 1);
            _fld0114.setOrigin(_fld0132);
            _fld0114.setMaxDataEntries(_fld0133);
            try
            {
                _fld0114.setValueDisplay(_fld0134, _fld0135, _fld0136);
            }
            catch(GeneratorApiException _ex) { }
            _fld0114.setClip(_fld011C, _fld011A);
            _fld0114.setAutoScale(_fld012B);
            _fld0114.setLineStyle(_fld013A, _fld013C, _fld013B, _fld013D);
            _fld0114.setChartLineThickness(_fld013E);
            _fld0114.setEffect3D(_fld0140);
            _fld0114.setDepth3D(_fld013F);
            _fld0114.setValuePlacement(byte0);
            _fld0114.setHorizontalLabelDisplay(_fld0137, _fld0138, _fld0139);
            String s = propertyparser.GetStringParam("symbolfile");
            Script script = (Script)_fld0109.add(_fld0114.getSymbolScript(s));
            if(script != null)
            {
                _fld0116 = (Script)_fld0109.add(_fld0114.getValueScript(script, propertyparser));
                _fld0117 = (Script)_fld0109.add(_fld0114.getLabelScript(script, propertyparser));
                if(_fld0130 && _fld0117 == null)
                    logError(_fld0115, "labelSymbolMissing", "");
            }
        }
        catch(GeneratorApiException _ex)
        {
            logError(_fld0115, "chartclasserror", "");
            return false;
        }
        return true;
    }

    int _fld014B;
    int _fld014C;
    int _fld014D;
    int _fld014E;
    int _fld014F;
    int _fld0150;
    int _fld0151;
    int _fld0152;
    int _fld010A;
    int _fld010C;
    int _fld0133;
    int _fld0153;
    String _fld010E;
    String _fld0111;
    String _fld0154;
    String _fld010F;
    String _fld0155;
    String _fld0156;
    String _fld0157;
    String _fld0158;
    String _fld0159;
    String _fld015A;
    String _fld015B;
    String _fld015C;
    Script _fld0110;
    String _fld0113[][];
    GenVector _fld0109;
    private Chart _fld0114;
    private FlashEnvironment _fld0115;
    private Script _fld0116;
    private Script _fld0117;
    private Context _fld0119;
    private int _fld011A;
    private Script _fld011B;
    private Script _fld011C;
    private float _fld011D;
    private float _fld011E;
    private float _fld011F;
    private float _fld0120;
    private boolean _fld0121;
    private boolean _fld0122;
    private float _fld0125;
    private float _fld0126;
    private final float _fld0129 = 1E-005F;
    private final int _fld012A = 75;
    private boolean _fld012B;
    private int _fld015D;
    private int _fld015E;
    private boolean _fld012E;
    private int _fld012F;
    private boolean _fld0130;
    private float _fld0131;
    private float _fld0132;
    private int _fld0134;
    private int _fld0135;
    private float _fld0136;
    private int _fld015F;
    private int _fld0137;
    private int _fld0138;
    private float _fld0139;
    int _fld013A;
    int _fld013B;
    int _fld013C;
    int _fld013D;
    int _fld013E;
    float _fld013F;
    boolean _fld0140;
}