home *** CD-ROM | disk | FTP | other *** search
/ Symantec Visual Cafe for Java 2.5 / symantec-visual-cafe-2.5-database-dev-edition.iso / VCafe / JCLASS.BIN / KLG.JAR / jclass / chart / ChartDataView.class (.txt) < prev    next >
Encoding:
Java Class File  |  1997-12-05  |  15.8 KB  |  1,071 lines
  1. package jclass.chart;
  2.  
  3. import java.awt.Graphics;
  4. import java.awt.Point;
  5. import java.awt.Rectangle;
  6. import java.io.IOException;
  7. import java.io.ObjectInputStream;
  8. import java.util.Observable;
  9. import java.util.Observer;
  10. import java.util.Vector;
  11. import jclass.bwt.JCSerializable;
  12. import jclass.util.JCVector;
  13.  
  14. public class ChartDataView implements Observer, Changeable, JCSerializable {
  15.    protected JCVector series = new JCVector();
  16.    public static final int PICK_FOCUS_LOCAL = -1;
  17.    public static final int PICK_FOCUS_XY = 0;
  18.    public static final int PICK_FOCUS_X = 1;
  19.    public static final int PICK_FOCUS_Y = 2;
  20.    private double[] xvalues;
  21.    boolean isBatched = false;
  22.    double holeValue = Double.MAX_VALUE;
  23.    int chartType = 0;
  24.    String name;
  25.    int drawingOrder = -1;
  26.    Chartable dataSource;
  27.    DataInterpretation dataInterpretation;
  28.    JCAxis xaxis;
  29.    JCAxis yaxis;
  30.    JCVector pointLabels = new JCVector();
  31.    JCBarChartFormat barChartFormat;
  32.    JCPieChartFormat pieChartFormat;
  33.    private transient Object transientData;
  34.    boolean isInverted = false;
  35.    int pickFocus = 0;
  36.    boolean isShowingInLegend = true;
  37.    int previousXAxisAnnotationMethod;
  38.    private JCVector styles = new JCVector();
  39.    boolean changed = true;
  40.    boolean allowPick = true;
  41.    JCChart chart;
  42.    MinMax xLimits;
  43.    MinMax yLimits;
  44.    static int dataViewNum;
  45.  
  46.    ChartDataView(JCChart var1) {
  47.       this.setChartType(0);
  48.       this.setParent(var1);
  49.       this.name = "DataView #" + ++dataViewNum;
  50.    }
  51.  
  52.    public ChartDataView() {
  53.       this.setChartType(0);
  54.       this.name = "DataView #" + ++dataViewNum;
  55.    }
  56.  
  57.    void setParent(JCChart var1) {
  58.       this.chart = var1;
  59.       if (this.chart != null && this.chart.chartArea != null) {
  60.          if (this.xaxis == null || !this.chart.chartArea.xaxes.contains(this.xaxis)) {
  61.             this.xaxis = this.chart.chartArea.getXAxis(0);
  62.          }
  63.  
  64.          if (this.yaxis == null || !this.chart.chartArea.yaxes.contains(this.yaxis)) {
  65.             this.yaxis = this.chart.chartArea.getYAxis(0);
  66.          }
  67.       }
  68.  
  69.       this.setChanged(true, false);
  70.    }
  71.  
  72.    void draw(Graphics var1) {
  73.    }
  74.  
  75.    boolean editPoint(ChartDataViewSeries var1, int var2, double var3) {
  76.       if (this.dataSource == null) {
  77.          return true;
  78.       } else if (!(this.dataSource instanceof EditableChartable)) {
  79.          return false;
  80.       } else {
  81.          int var5 = -1;
  82.          var5 = this.series.indexOf(var1);
  83.          if (var5 == -1) {
  84.             throw new RuntimeException("Bad row in editPoint!");
  85.          } else {
  86.             return this.dataInterpretation.editPoint(var5, var2, var3);
  87.          }
  88.       }
  89.    }
  90.  
  91.    public void update(Observable var1, Object var2) {
  92.       if (var2 instanceof ChartDataModelUpdate) {
  93.          ChartDataModelUpdate var3 = (ChartDataModelUpdate)var2;
  94.          switch (var3.message) {
  95.             case 0:
  96.                this.dataInterpretation.changeValue(var3.row, var3.column);
  97.                break;
  98.             case 1:
  99.                this.dataInterpretation.addValue(var3.row, var3.column);
  100.                break;
  101.             case 2:
  102.                this.dataInterpretation.removeValue(var3.row, var3.column);
  103.                break;
  104.             case 3:
  105.                this.dataInterpretation.changeRow(var3.row, var3.column);
  106.                break;
  107.             case 4:
  108.                this.dataInterpretation.addRow(var3.row, var3.column);
  109.                break;
  110.             case 5:
  111.                this.dataInterpretation.removeRow(var3.row, var3.column);
  112.                break;
  113.             case 6:
  114.                this.dataInterpretation.changeColumn(var3.row, var3.column);
  115.                break;
  116.             case 7:
  117.                this.dataInterpretation.addColumn(var3.row, var3.column);
  118.                break;
  119.             case 8:
  120.                this.dataInterpretation.removeColumn(var3.row, var3.column);
  121.                break;
  122.             case 9:
  123.                this.dataInterpretation.changePointLabel(var3.row, var3.column);
  124.                break;
  125.             case 10:
  126.                this.dataInterpretation.changeSeriesName(var3.row, var3.column);
  127.                break;
  128.             case 11:
  129.                this.dataInterpretation.changeSeriesLabel(var3.row, var3.column);
  130.                break;
  131.             case 12:
  132.                boolean var4 = this.getIsBatched();
  133.                this.setIsBatched(true);
  134.                this.dataInterpretation.reset(var3.row, var3.column);
  135.                this.setIsBatched(var4);
  136.                return;
  137.          }
  138.  
  139.          this.setChanged(true);
  140.       }
  141.    }
  142.  
  143.    public double getHoleValue() {
  144.       return this.holeValue;
  145.    }
  146.  
  147.    public synchronized void setHoleValue(double var1) {
  148.       this.holeValue = var1;
  149.    }
  150.  
  151.    public boolean getIsBatched() {
  152.       return this.isBatched;
  153.    }
  154.  
  155.    public synchronized void setIsBatched(boolean var1) {
  156.       if (this.isBatched != var1) {
  157.          this.isBatched = var1;
  158.          if (!this.isBatched) {
  159.             this.propagateChange();
  160.          }
  161.  
  162.       }
  163.    }
  164.  
  165.    public int getChartType() {
  166.       return this.chartType;
  167.    }
  168.  
  169.    public synchronized void setChartType(int var1) {
  170.       if (this.chartType != var1) {
  171.          if (this.xaxis != null) {
  172.             this.xaxis.annotationMethod = this.previousXAxisAnnotationMethod;
  173.          }
  174.  
  175.          switch (var1) {
  176.             case 0:
  177.             case 1:
  178.             case 9:
  179.             case 10:
  180.             case 11:
  181.                switch (this.chartType) {
  182.                   case 9:
  183.                   case 10:
  184.                      if (this.xaxis != null) {
  185.                         this.previousXAxisAnnotationMethod = this.xaxis.annotationMethod;
  186.                         this.xaxis.annotationMethod = 0;
  187.                         this.xaxis.setChanged(true, false);
  188.                      }
  189.                      break;
  190.                   case 11:
  191.                      if (this.yaxis != null) {
  192.                         this.yaxis.isShowing = true;
  193.                         this.yaxis.setChanged(true, false);
  194.                      }
  195.  
  196.                      if (this.xaxis != null) {
  197.                         this.xaxis.isShowing = true;
  198.                         this.xaxis.setChanged(true, false);
  199.                      }
  200.                }
  201.  
  202.                this.chartType = var1;
  203.                if (this.chartType == 11 && this.pieChartFormat == null) {
  204.                   this.pieChartFormat = new JCPieChartFormat(this);
  205.                }
  206.  
  207.                if ((this.chartType == 9 || this.chartType == 10) && this.barChartFormat == null) {
  208.                   this.barChartFormat = new JCBarChartFormat(this);
  209.                }
  210.  
  211.                switch (this.chartType) {
  212.                   case 0:
  213.                   case 1:
  214.                   default:
  215.                      break;
  216.                   case 8:
  217.                      if (this.yaxis != null && this.xaxis != null) {
  218.                         if (this.yaxis.getOriginPlacementIsDefault()) {
  219.                            this.yaxis.originPlacement.value = 3;
  220.                            this.yaxis.setChanged(true, false);
  221.                         }
  222.  
  223.                         if (this.xaxis.getPlacementIsDefault()) {
  224.                            this.xaxis.placement.value = 5;
  225.                         }
  226.  
  227.                         this.xaxis.placementAxis = this.yaxis;
  228.                         this.xaxis.setChanged(true, false);
  229.                      }
  230.                      break;
  231.                   case 9:
  232.                   case 10:
  233.                      if (this.yaxis != null && this.xaxis != null) {
  234.                         this.previousXAxisAnnotationMethod = this.xaxis.annotationMethod;
  235.                         this.xaxis.placementAxis = this.yaxis;
  236.                         this.xaxis.annotationMethod = 3;
  237.                         if (this.xaxis.getPlacementIsDefault()) {
  238.                            this.xaxis.setPlacement(5);
  239.                         } else {
  240.                            this.xaxis.setChanged(true, false);
  241.                         }
  242.  
  243.                         if (this.yaxis.getOriginPlacementIsDefault()) {
  244.                            this.yaxis.setOriginPlacement(3);
  245.                         }
  246.                      }
  247.                      break;
  248.                   case 11:
  249.                      if (this.yaxis != null) {
  250.                         this.yaxis.isShowing = false;
  251.                         this.yaxis.setChanged(true, false);
  252.                      }
  253.  
  254.                      if (this.xaxis != null) {
  255.                         this.xaxis.isShowing = false;
  256.                         this.xaxis.setChanged(true, false);
  257.                      }
  258.                }
  259.  
  260.                if (this.chart != null) {
  261.                   this.chart.chartArea.removeDrawable(this);
  262.                }
  263.  
  264.                this.setChanged(true);
  265.                return;
  266.             case 2:
  267.             case 3:
  268.             case 4:
  269.             case 5:
  270.             case 6:
  271.             case 7:
  272.             case 8:
  273.                throw new IllegalArgumentException("Currently unsupported chart type");
  274.             default:
  275.                throw new IllegalArgumentException("Invalid chart type");
  276.          }
  277.       }
  278.    }
  279.  
  280.    public String getName() {
  281.       return this.name;
  282.    }
  283.  
  284.    public synchronized void setName(String var1) {
  285.       if (this.name == null || !this.name.equals(var1)) {
  286.          this.name = var1;
  287.          this.setChanged(true);
  288.       }
  289.    }
  290.  
  291.    public int getDrawingOrder() {
  292.       return this.drawingOrder;
  293.    }
  294.  
  295.    public synchronized void setDrawingOrder(int var1) {
  296.       if (var1 >= 0 && (this.chart == null || var1 < this.chart.data.size())) {
  297.          this.drawingOrder = var1;
  298.          this.setChanged(true);
  299.       } else {
  300.          throw new IllegalArgumentException("DrawingOrder property for ChartDataView is out of range");
  301.       }
  302.    }
  303.  
  304.    public Chartable getDataSource() {
  305.       return this.dataSource;
  306.    }
  307.  
  308.    public synchronized void setDataSource(Chartable var1) {
  309.       this.dataSource = var1;
  310.       if (this.dataSource != null) {
  311.          this.dataInterpretation = DataInterpretation.getData(this, var1);
  312.          String[] var2 = var1.getPointLabels();
  313.          if (var2 != null) {
  314.             for(int var3 = 0; var3 < var2.length; ++var3) {
  315.                this.pointLabels.addElement(var2[var3]);
  316.             }
  317.          }
  318.  
  319.          for(int var5 = 0; var5 < this.series.size(); ++var5) {
  320.             ChartDataViewSeries var4 = (ChartDataViewSeries)this.series.elementAt(var5);
  321.             var4.name = var1.getSeriesName(var5);
  322.             var4.label = var1.getSeriesLabel(var5);
  323.          }
  324.  
  325.          this.name = var1.getName();
  326.          if (var1 instanceof Observable) {
  327.             ((Observable)var1).addObserver(this);
  328.          }
  329.  
  330.          if (!(this.dataSource instanceof EditableChartable) && !(this.dataSource instanceof Observable)) {
  331.             this.dataSource = null;
  332.          }
  333.  
  334.          this.setChanged(true);
  335.       }
  336.    }
  337.  
  338.    public String getPointLabel(int var1) {
  339.       if (var1 >= 0 && var1 < this.pointLabels.size()) {
  340.          return (String)this.pointLabels.elementAt(var1);
  341.       } else {
  342.          throw new IllegalArgumentException("Invalid point label index");
  343.       }
  344.    }
  345.  
  346.    public synchronized void setPointLabel(int var1, String var2) {
  347.       if (var1 >= 0 && var1 < this.pointLabels.size()) {
  348.          this.pointLabels.setElementAt(var1, var2);
  349.          this.setChanged(true);
  350.       } else {
  351.          throw new IllegalArgumentException("Invalid point label index");
  352.       }
  353.    }
  354.  
  355.    public String[] getPointLabels() {
  356.       if (this.pointLabels != null && this.pointLabels.size() != 0) {
  357.          String[] var1 = new String[this.pointLabels.size()];
  358.  
  359.          for(int var2 = 0; var2 < var1.length; ++var2) {
  360.             var1[var2] = (String)this.pointLabels.elementAt(var2);
  361.          }
  362.  
  363.          return var1;
  364.       } else {
  365.          return null;
  366.       }
  367.    }
  368.  
  369.    public int getNumPointLabels() {
  370.       return this.pointLabels.size();
  371.    }
  372.  
  373.    public synchronized void setPointLabels(String[] var1) {
  374.       this.pointLabels = new JCVector(var1);
  375.       this.setChanged(true);
  376.    }
  377.  
  378.    public ChartDataViewSeries[] getSeries() {
  379.       ChartDataViewSeries[] var1 = new ChartDataViewSeries[this.series.size()];
  380.  
  381.       for(int var2 = 0; var2 < this.series.size(); ++var2) {
  382.          var1[var2] = (ChartDataViewSeries)this.series.elementAt(var2);
  383.       }
  384.  
  385.       return var1;
  386.    }
  387.  
  388.    public ChartDataViewSeries getSeries(int var1) {
  389.       if (var1 >= 0 && var1 < this.series.size()) {
  390.          return (ChartDataViewSeries)this.series.elementAt(var1);
  391.       } else {
  392.          throw new IllegalArgumentException("Invalid ChartDataViewSeries index.");
  393.       }
  394.    }
  395.  
  396.    public synchronized void setSeries(ChartDataViewSeries[] var1) {
  397.       this.series = new JCVector(var1);
  398.       this.setChanged(true);
  399.    }
  400.  
  401.    public synchronized void setSeries(int var1, ChartDataViewSeries var2) {
  402.       if (var1 >= 0 && var1 < this.series.size()) {
  403.          this.series.setElementAt(var1, var2);
  404.          this.setChanged(true);
  405.       } else {
  406.          throw new IllegalArgumentException("Invalid ChartDataViewSeries index.");
  407.       }
  408.    }
  409.  
  410.    public ChartDataViewSeries addSeries(int var1) {
  411.       Object var2 = null;
  412.       if (var1 < 0) {
  413.          var1 = 0;
  414.       }
  415.  
  416.       if (var1 > this.series.size()) {
  417.          var1 = this.series.size();
  418.       }
  419.  
  420.       ChartDataViewSeries var3 = new ChartDataViewSeries();
  421.       var3.init((double[])null, (double[])null, this);
  422.       var3.setDrawingOrder(var1);
  423.       this.series.insertElementAt(var3, var1);
  424.       this.setChanged(true);
  425.       return var3;
  426.    }
  427.  
  428.    public synchronized void addSeries(ChartDataViewSeries var1) {
  429.       var1.setDrawingOrder(this.series.size());
  430.       this.series.addElement(var1);
  431.       this.setChanged(true);
  432.    }
  433.  
  434.    public synchronized void removeSeries(int var1) {
  435.       if (var1 >= 0 && var1 < this.series.size()) {
  436.          this.series.removeElementAt(var1);
  437.          this.setChanged(true);
  438.       } else {
  439.          throw new IllegalArgumentException("Invalid ChartDataViewSeries index");
  440.       }
  441.    }
  442.  
  443.    public int getSeriesIndex(String var1) {
  444.       try {
  445.          for(int var2 = 0; var2 < this.series.size(); ++var2) {
  446.             ChartDataViewSeries var3 = (ChartDataViewSeries)this.series.elementAt(var2);
  447.             if (var1.equals(var3.getName())) {
  448.                return var2;
  449.             }
  450.          }
  451.       } catch (Exception var4) {
  452.       }
  453.  
  454.       return -1;
  455.    }
  456.  
  457.    public int getSeriesIndex(ChartDataViewSeries var1) {
  458.       return this.series.indexOf(var1);
  459.    }
  460.  
  461.    public JCPieChartFormat getPieChartFormat() {
  462.       if (this.pieChartFormat == null) {
  463.          this.pieChartFormat = new JCPieChartFormat(this);
  464.       }
  465.  
  466.       return this.pieChartFormat;
  467.    }
  468.  
  469.    public JCBarChartFormat getBarChartFormat() {
  470.       if (this.barChartFormat == null) {
  471.          this.barChartFormat = new JCBarChartFormat(this);
  472.       }
  473.  
  474.       return this.barChartFormat;
  475.    }
  476.  
  477.    public JCAxis getXAxis() {
  478.       return this.xaxis;
  479.    }
  480.  
  481.    public synchronized void setXAxis(JCAxis var1) {
  482.       this.xaxis = var1;
  483.    }
  484.  
  485.    public JCAxis getYAxis() {
  486.       return this.yaxis;
  487.    }
  488.  
  489.    public synchronized void setYAxis(JCAxis var1) {
  490.       this.yaxis = var1;
  491.    }
  492.  
  493.    public JCDataCoord map(int var1, int var2) {
  494.       Point var3 = this.chart.chartArea.location();
  495.       Rectangle var4 = this.chart.chartArea.getDrawingArea();
  496.       var1 = var1 - var3.x - var4.x;
  497.       var2 = var2 - var3.y - var4.y;
  498.       JCDataCoord var5 = new JCDataCoord(this.holeValue, this.holeValue);
  499.       if (this.xaxis != null) {
  500.          var5.x = this.xaxis.toData(var1);
  501.       }
  502.  
  503.       if (this.yaxis != null) {
  504.          var5.y = this.yaxis.toData(var2);
  505.       }
  506.  
  507.       return var5;
  508.    }
  509.  
  510.    public Point unmap(double var1, double var3) {
  511.       Point var5 = this.chart.chartArea.location();
  512.       Rectangle var6 = this.chart.chartArea.getDrawingArea();
  513.       Point var7 = new Point(var5.x + var6.x, var5.y + var6.y);
  514.       if (this.xaxis != null) {
  515.          var7.x += this.xaxis.toPixel(var1);
  516.       }
  517.  
  518.       if (this.yaxis != null) {
  519.          var7.y += this.yaxis.toPixel(var3);
  520.       }
  521.  
  522.       return var7;
  523.    }
  524.  
  525.    public JCDataCoord coordToDataCoord(int var1, int var2) {
  526.       return this.map(var1, var2);
  527.    }
  528.  
  529.    public Point dataCoordToCoord(double var1, double var3) {
  530.       return this.unmap(var1, var3);
  531.    }
  532.  
  533.    public Point dataIndexToCoord(JCDataIndex var1) {
  534.       Point var2 = this.chart.unpick(this, var1.point, var1.seriesIndex);
  535.       if (var2 != null) {
  536.          Point var3 = this.chart.chartArea.location();
  537.          var2.x += var3.x;
  538.          var2.y += var3.y;
  539.       }
  540.  
  541.       return var2;
  542.    }
  543.  
  544.    public JCDataIndex coordToDataIndex(int var1, int var2, int var3) {
  545.       Point var4 = this.chart.chartArea.location();
  546.       return this.chart.chartArea.pick(new Point(var1 - var4.x, var2 - var4.y), this, var3);
  547.    }
  548.  
  549.    public int getNumSeries() {
  550.       return this.series == null ? 0 : this.series.size();
  551.    }
  552.  
  553.    double[] toDoubleArray(Vector var1) {
  554.       if (var1 != null && var1.size() > 0) {
  555.          double[] var2 = new double[var1.size()];
  556.  
  557.          for(int var3 = 0; var3 < var2.length; ++var3) {
  558.             Object var4 = var1.elementAt(var3);
  559.             if (var4 == null) {
  560.                var2[var3] = this.holeValue;
  561.             } else if (var4 instanceof Number) {
  562.                var2[var3] = ((Number)var4).doubleValue();
  563.             } else if (var4 instanceof String) {
  564.                var2[var3] = Double.valueOf((String)var4);
  565.             } else {
  566.                var2[var3] = this.holeValue;
  567.             }
  568.          }
  569.  
  570.          return var2;
  571.       } else {
  572.          return null;
  573.       }
  574.    }
  575.  
  576.    public String toString() {
  577.       String var1 = this.getName();
  578.       return var1 == null ? "Unnamed DataView" : var1;
  579.    }
  580.  
  581.    void calcXMinMax(MinMax var1) {
  582.       double var2 = this.xaxis.step;
  583.       this.xaxis.step = Double.MAX_VALUE;
  584.  
  585.       for(int var4 = 0; var4 < this.series.size(); ++var4) {
  586.          ChartDataViewSeries var5 = (ChartDataViewSeries)this.series.elementAt(var4);
  587.          if (var5.isIncluded) {
  588.             var5.getXMinMax(var1);
  589.             var5.calcStep(this.xaxis);
  590.          }
  591.       }
  592.  
  593.       if (this.xaxis.step == Double.MAX_VALUE) {
  594.          this.xaxis.step = var2;
  595.       }
  596.  
  597.    }
  598.  
  599.    void calcYMinMax(MinMax var1) {
  600.       for(int var2 = 0; var2 < this.series.size(); ++var2) {
  601.          ChartDataViewSeries var3 = (ChartDataViewSeries)this.series.elementAt(var2);
  602.          if (var3.isIncluded) {
  603.             var3.getYMinMax(var1);
  604.          }
  605.       }
  606.  
  607.    }
  608.  
  609.    private void calcYMinMaxOfTotals(MinMax var1) {
  610.       Point var2 = this.getFirstLast();
  611.       if (var2 != null) {
  612.          int var3 = this.series.size();
  613.          MinMax var4 = new MinMax();
  614.  
  615.          for(int var5 = var2.x; var5 <= var2.y; ++var5) {
  616.             MinMax var6 = new MinMax((double)0.0F, (double)0.0F);
  617.  
  618.             for(int var7 = 0; var7 < var3; ++var7) {
  619.                ChartDataViewSeries var8 = (ChartDataViewSeries)this.series.elementAt(var7);
  620.                if (var8.isIncluded) {
  621.                   double var9 = var8.getY(var5);
  622.                   if (var9 != this.holeValue) {
  623.                      if (var9 >= (double)0.0F) {
  624.                         var6.max += var9;
  625.                      } else {
  626.                         var6.min += var9;
  627.                      }
  628.                   }
  629.                }
  630.             }
  631.  
  632.             var4.union(var6);
  633.          }
  634.  
  635.          var1.union(var4);
  636.       }
  637.    }
  638.  
  639.    void getDataBounds(MinMax var1, MinMax var2) {
  640.       boolean var3 = this.chartType == 2;
  641.       boolean var4 = this.chartType == 3 || this.chartType == 4;
  642.       boolean var5 = var3 || var4;
  643.       this.calcXMinMax(var1);
  644.       this.calcYMinMax(var2);
  645.       if (!this.xaxis.min.isDefault && this.xaxis.min.value > var1.min || var5) {
  646.          var1.min = this.xaxis.min.value;
  647.       }
  648.  
  649.       if (!this.xaxis.max.isDefault && this.xaxis.max.value < var1.max || var5) {
  650.          var1.max = this.xaxis.max.value;
  651.       }
  652.  
  653.       if (!this.yaxis.min.isDefault && this.yaxis.min.value > var2.min || var5) {
  654.          var2.min = this.yaxis.min.value;
  655.       }
  656.  
  657.       if (var3 && var2.min < (double)0.0F) {
  658.          double var6 = var2.min;
  659.          if ((var6 > (double)0.0F ? var6 : -var6) > var2.max) {
  660.             var6 = var2.min;
  661.             var2.max = var6 > (double)0.0F ? var6 : -var6;
  662.          }
  663.  
  664.          var2.min = (double)0.0F;
  665.       }
  666.  
  667.       if (!this.yaxis.max.isDefault && this.yaxis.max.value < var2.max || var5) {
  668.          var2.max = this.yaxis.max.value;
  669.       }
  670.  
  671.    }
  672.  
  673.    DoubleCoord getOrigin(MinMax var1, MinMax var2, boolean var3) {
  674.       DoubleCoord var4 = new DoubleCoord(var1.min, var2.min);
  675.       if (!var3) {
  676.          return var4;
  677.       } else {
  678.          int var5 = this.chart.getChartArea().angleUnit;
  679.          if (this.xaxis.origin.isDefault) {
  680.             if (this.chartType != 2 && this.chartType != 3 && this.chartType != 4) {
  681.                switch (this.xaxis.originPlacement.value) {
  682.                   case 0:
  683.                      if (var1.min <= (double)0.0F && var1.max >= (double)0.0F) {
  684.                         var4.x = (double)0.0F;
  685.                      } else {
  686.                         var4.x = var1.min;
  687.                      }
  688.                      break;
  689.                   case 1:
  690.                      var4.x = var1.min;
  691.                      break;
  692.                   case 2:
  693.                      var4.x = var1.max;
  694.                      break;
  695.                   case 3:
  696.                      var4.x = (double)0.0F;
  697.                }
  698.             } else {
  699.                switch (var5) {
  700.                   case 1:
  701.                      var4.x = (double)90.0F;
  702.                      break;
  703.                   case 2:
  704.                      var4.x = (Math.PI / 2D);
  705.                      break;
  706.                   case 3:
  707.                      var4.x = (double)100.0F;
  708.                }
  709.             }
  710.          } else {
  711.             var4.x = JCChartUtil.boundAngle(var5, this.xaxis.origin.value);
  712.          }
  713.  
  714.          if (this.chartType == 10) {
  715.             if (this.yaxis.isLogarithmic) {
  716.                double var6 = var2.min;
  717.                var4.y = var6 > (double)0.0F ? var6 : (double)0.0F;
  718.             } else {
  719.                var4.y = (double)0.0F;
  720.             }
  721.          } else if (this.chartType != 2 && this.chartType != 3 && this.chartType != 4) {
  722.             if (this.yaxis.origin.isDefault) {
  723.                switch (this.yaxis.originPlacement.value) {
  724.                   case 0:
  725.                      if ((this.chartType == 9 || this.chartType == 8) && !this.yaxis.isLogarithmic) {
  726.                         var4.y = (double)0.0F;
  727.                      } else if (var2.min <= (double)0.0F && var2.max >= (double)0.0F) {
  728.                         var4.y = (double)0.0F;
  729.                      } else {
  730.                         var4.y = var2.min;
  731.                      }
  732.                      break;
  733.                   case 1:
  734.                      var4.y = var2.min;
  735.                      break;
  736.                   case 2:
  737.                      var4.y = var2.max;
  738.                      break;
  739.                   case 3:
  740.                      var4.y = (double)0.0F;
  741.                }
  742.             } else {
  743.                var4.y = this.yaxis.origin.value;
  744.             }
  745.          } else if (this.yaxis.isReversed) {
  746.             var4.y = var2.min;
  747.          } else {
  748.             var4.y = var2.max;
  749.          }
  750.  
  751.          return var4;
  752.       }
  753.    }
  754.  
  755.    void clearLimits() {
  756.       if (this.xaxis != null) {
  757.          this.xaxis.clearLimits();
  758.       }
  759.  
  760.       if (this.yaxis != null) {
  761.          this.yaxis.clearLimits();
  762.       }
  763.  
  764.       this.xLimits = null;
  765.       this.yLimits = null;
  766.    }
  767.  
  768.    void calcLimits() {
  769.       if (this.xaxis != null) {
  770.          this.xLimits = new MinMax();
  771.          this.calcXMinMax(this.xLimits);
  772.          this.xaxis.setLimits(this.xLimits);
  773.       }
  774.  
  775.       if (this.yaxis != null) {
  776.          this.yLimits = new MinMax();
  777.          if (this.chartType == 10) {
  778.             if (this.barChartFormat.get100Percent()) {
  779.                this.yLimits.max = (double)100.0F;
  780.                this.yLimits.min = (double)-100.0F;
  781.             } else {
  782.                this.calcYMinMaxOfTotals(this.yLimits);
  783.             }
  784.          } else {
  785.             this.calcYMinMax(this.yLimits);
  786.          }
  787.  
  788.          this.yaxis.setLimits(this.yLimits);
  789.       }
  790.  
  791.    }
  792.  
  793.    public MinMax getXLimits() {
  794.       return this.xLimits;
  795.    }
  796.  
  797.    public MinMax getYLimits() {
  798.       return this.yLimits;
  799.    }
  800.  
  801.    void getDataBoundValues(MinMax var1, MinMax var2) {
  802.       if (this.xLimits != null) {
  803.          var1.reset(this.xLimits);
  804.       }
  805.  
  806.       if (this.yLimits != null) {
  807.          var2.reset(this.yLimits);
  808.       }
  809.  
  810.    }
  811.  
  812.    public boolean isChanged() {
  813.       return this.getChanged();
  814.    }
  815.  
  816.    public boolean getChanged() {
  817.       return this.changed;
  818.    }
  819.  
  820.    public synchronized void setChanged(boolean var1) {
  821.       if (this.changed != var1) {
  822.          this.changed = var1;
  823.          if (this.changed) {
  824.             this.markAsChanged();
  825.             this.propagateChange();
  826.          }
  827.       }
  828.    }
  829.  
  830.    private void propagateChange() {
  831.       if (this.changed) {
  832.          if (!this.getIsBatched()) {
  833.             if (this.chart != null) {
  834.                if (!this.chart.getIsBatched()) {
  835.                   this.chart.update();
  836.                }
  837.             }
  838.          }
  839.       }
  840.    }
  841.  
  842.    private void markAsChanged() {
  843.       if (this.xaxis != null) {
  844.          this.xaxis.setChanged(true, false);
  845.       }
  846.  
  847.       if (this.yaxis != null) {
  848.          this.yaxis.setChanged(true, false);
  849.       }
  850.  
  851.       if (this.chart != null && this.chart.chartArea != null) {
  852.          this.chart.chartArea.setChanged(true, false);
  853.       }
  854.  
  855.       if (this.chart != null && this.chart.legend != null) {
  856.          this.chart.legend.setChanged(true, false);
  857.       }
  858.  
  859.    }
  860.  
  861.    public void setChanged(boolean var1, boolean var2) {
  862.       if (this.changed != var1) {
  863.          if (var2) {
  864.             this.setChanged(var1);
  865.          } else {
  866.             this.changed = var1;
  867.             if (this.changed) {
  868.                this.markAsChanged();
  869.             }
  870.  
  871.          }
  872.       }
  873.    }
  874.  
  875.    public Point getFirstLast() {
  876.       if (this.series == null) {
  877.          return null;
  878.       } else {
  879.          int var1 = -1;
  880.          int var2 = Integer.MAX_VALUE;
  881.          int var3 = Integer.MAX_VALUE;
  882.  
  883.          for(int var4 = 0; var4 < this.series.size(); ++var4) {
  884.             ChartDataViewSeries var5 = (ChartDataViewSeries)this.series.elementAt(var4);
  885.             if (var5.isShowing) {
  886.                if (var1 < var5.getFirstPoint()) {
  887.                   var1 = var5.getFirstPoint();
  888.                }
  889.  
  890.                if (var2 > var5.getLastPoint()) {
  891.                   var2 = var5.getLastPoint();
  892.                }
  893.  
  894.                int var6 = var5.maxIndex();
  895.                if (var3 > var6) {
  896.                   var3 = var6;
  897.                }
  898.             }
  899.          }
  900.  
  901.          if (var3 == Integer.MAX_VALUE) {
  902.             return null;
  903.          } else if (var1 > var3) {
  904.             return null;
  905.          } else {
  906.             if (var2 > var3) {
  907.                var2 = var3;
  908.             }
  909.  
  910.             if (var1 > var2) {
  911.                return null;
  912.             } else {
  913.                return new Point(var1, var2);
  914.             }
  915.          }
  916.       }
  917.    }
  918.  
  919.    public int getVisibleDataSeries() {
  920.       int var1 = 0;
  921.  
  922.       for(int var2 = 0; var2 < this.series.size(); ++var2) {
  923.          ChartDataViewSeries var3 = (ChartDataViewSeries)this.series.elementAt(var2);
  924.          if (var3.isShowing) {
  925.             ++var1;
  926.          }
  927.       }
  928.  
  929.       return var1;
  930.    }
  931.  
  932.    public synchronized void calcTransientData() {
  933.       if (this.getChartType() == 11) {
  934.          PieChartDraw var1 = (PieChartDraw)this.chart.chartArea.getDrawable(this);
  935.          if (var1 != null) {
  936.             var1.calcTransientData();
  937.          }
  938.       }
  939.  
  940.    }
  941.  
  942.    public synchronized void setIsInverted(boolean var1) {
  943.       if (this.isInverted != var1) {
  944.          this.isInverted = var1;
  945.          if (this.xaxis != null) {
  946.             this.xaxis.isVertical = var1;
  947.          }
  948.  
  949.          if (this.yaxis != null) {
  950.             this.yaxis.isVertical = !var1;
  951.          }
  952.  
  953.          this.setChanged(true);
  954.       }
  955.    }
  956.  
  957.    public boolean getIsInverted() {
  958.       return this.isInverted;
  959.    }
  960.  
  961.    public synchronized void setPickFocus(int var1) {
  962.       this.pickFocus = var1;
  963.    }
  964.  
  965.    public int getPickFocus() {
  966.       return this.pickFocus;
  967.    }
  968.  
  969.    public boolean getIsShowingInLegend() {
  970.       return this.isShowingInLegend;
  971.    }
  972.  
  973.    public synchronized void setIsShowingInLegend(boolean var1) {
  974.       if (var1 != this.isShowingInLegend) {
  975.          this.isShowingInLegend = var1;
  976.          this.setChanged(true);
  977.       }
  978.    }
  979.  
  980.    public synchronized void setChartStyle(int var1, JCChartStyle var2) {
  981.       if (var1 >= 0 && var1 <= this.styles.size()) {
  982.          if (var1 < this.styles.size()) {
  983.             this.styles.setElementAt(var2, var1);
  984.          } else {
  985.             this.styles.insertElementAt(var2, var1);
  986.          }
  987.  
  988.          this.setChanged(true);
  989.       } else {
  990.          throw new IllegalArgumentException("Invalid ChartStyle index in ChartDataView.");
  991.       }
  992.    }
  993.  
  994.    public JCChartStyle getChartStyle(int var1) {
  995.       if (var1 < 0) {
  996.          throw new IllegalArgumentException("ChartStyle index must be positive");
  997.       } else {
  998.          if (var1 >= this.styles.size()) {
  999.             while(var1 >= this.styles.size()) {
  1000.                this.styles.addElement((Object)null);
  1001.             }
  1002.          }
  1003.  
  1004.          Object var2 = this.styles.elementAt(var1);
  1005.          if (var2 == null) {
  1006.             var2 = JCChartStyle.makeDefault(this.chart);
  1007.             this.styles.setElementAt(var2, var1);
  1008.          }
  1009.  
  1010.          return (JCChartStyle)var2;
  1011.       }
  1012.    }
  1013.  
  1014.    public JCChartStyle[] getChartStyle() {
  1015.       if (this.styles != null && this.styles.size() != 0) {
  1016.          JCChartStyle[] var1 = new JCChartStyle[this.styles.size()];
  1017.  
  1018.          for(int var2 = 0; var2 < var1.length; ++var2) {
  1019.             var1[var2] = (JCChartStyle)this.styles.elementAt(var2);
  1020.          }
  1021.  
  1022.          return var1;
  1023.       } else {
  1024.          return null;
  1025.       }
  1026.    }
  1027.  
  1028.    public synchronized void setChartStyle(JCChartStyle[] var1) {
  1029.       this.styles = new JCVector();
  1030.       if (var1 != null) {
  1031.          for(int var2 = 0; var2 < var1.length; ++var2) {
  1032.             this.styles.setElementAt(var2, var1[var2]);
  1033.          }
  1034.  
  1035.       }
  1036.    }
  1037.  
  1038.    double[] getX() {
  1039.       return this.xvalues;
  1040.    }
  1041.  
  1042.    void setX(double[] var1) {
  1043.       this.xvalues = var1;
  1044.    }
  1045.  
  1046.    private void readObject(ObjectInputStream var1) throws IOException {
  1047.       try {
  1048.          var1.defaultReadObject();
  1049.          if (this.dataSource != null && this.dataSource instanceof Observable) {
  1050.             ((Observable)this.dataSource).addObserver(this);
  1051.             return;
  1052.          }
  1053.       } catch (Exception var3) {
  1054.          ((Throwable)var3).printStackTrace(System.out);
  1055.       }
  1056.  
  1057.    }
  1058.  
  1059.    Object getTransientData() {
  1060.       return this.transientData;
  1061.    }
  1062.  
  1063.    void setTransientData(Object var1) {
  1064.       this.transientData = var1;
  1065.       if (this.chart != null && this.chart.legend != null) {
  1066.          this.chart.legend.setChanged(true, false);
  1067.       }
  1068.  
  1069.    }
  1070. }
  1071.