开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 行业应用 > OA系统 > 查看源码
PieChart.java
资源名称：OA.rar　[点击查看]
上传用户：mingda
上传日期：2017-06-20
资源大小：27691k
文件大小：40k
源码类别：

OA系统

开发平台：

Java

PieChart.java：源码内容
  1. // Decompiled by DJ v2.9.9.60 Copyright 2000 Atanas Neshkov  Date: 2002-12-03 18:43:55
  2. // Home Page : http://members.fortunecity.com/neshkov/dj.html  - Check often for new version!
  3. // Decompiler options: packimports(3) 
  4. // Source File Name:   PieChart.java
  6. package cn.com.fcsoft.chart;
  8. import java.awt.*;
  9. import java.awt.event.MouseEvent;
  10. import java.util.Hashtable;
  11. import java.util.Vector;
  13. // Referenced classes of package com.objectplanet.chart:
  14. //            Chart, ChartSample
  16. public class PieChart extends Chart
  17. {
  19.     public int getSeriesLabelStyle()
  20.     {
  21.         return seriesLabelStyle;
  22.     }
  24.     private void paintPies(Graphics g, Rectangle rectangle)
  25.     {
  26.         int i = getSeriesCount();
  27.         if(i == 1)
  28.         {
  29.             pieBounds[0] = rectangle;
  30.             double ad[] = getSampleValues(0);
  31.             paintPie(g, rectangle, ad, 0);
  32.         } else
  33.         {
  34.             int j = getSampleCount();
  35.             calculatePieBounds(rectangle, j);
  36.             for(int k = 0; k < j; k++)
  37.             {
  38.                 double ad1[] = new double[i];
  39.                 for(int l = 0; l < i; l++)
  40.                     ad1[l] = getSampleValue(l, k);
  42.                 paintPie(g, pieBounds[k], ad1, k);
  43.             }
  45.         }
  46.     }
  48.     public boolean isPercentLabelsOn()
  49.     {
  50.         return percentLabelsOn;
  51.     }
  53.     public boolean isSampleLabelsOn()
  54.     {
  55.         return sampleLabelsOn;
  56.     }
  58.     public boolean isPieLabelsOn()
  59.     {
  60.         return pieLabelsOn;
  61.     }
  63.     private void paintPieSegment(Graphics g, Color color, double d, double d1, int i, 
  64.             int j, int k, int l, boolean flag, double d2, int i1)
  65.     {
  66.         if(d2 > 0.0D && d1 < 360D)
  67.         {
  68.             double d3 = -d + d1 / 2D;
  69.             double d5 = d3 * 0.017453292519943295D;
  70.             k += (int)Math.round(Math.cos(d5) * ((double)i * (d2 / 2D)));
  71.             l += (int)Math.round(Math.sin(d5) * ((double)j * (d2 / 2D)));
  72.         }
  73.         if(i1 == 1 || i1 == 2)
  74.         {
  75.             double d4 = d * 0.017453292519943295D;
  76.             double d6 = (d - d1) * 0.017453292519943295D;
  77.             int l1 = (int)Math.round((double)i * pieDepth * ((double)pieAngle / 90D));
  78.             int i2 = i / 2;
  79.             int j2 = j / 2;
  80.             double d7 = Math.abs(d4 - d6) / 6.2831853071795862D;
  81.             double d8 = 3.1415926535897931D * (double)Math.max(i, j);
  82.             double d9 = d7 * d8;
  83.             double d10 = Math.abs(d4 - d6) / d9;
  84.             if(d10 > 0.0D)
  85.             {
  86.                 double d11 = d4;
  87.                 double d12 = d4;
  88.                 g.setColor(color.darker().darker());
  89.                 while(d11 >= d6) 
  90.                 {
  91.                     d11 -= d10;
  92.                     int k2 = (int)Math.round(Math.cos(d11) * (double)i2);
  93.                     int l2 = (int)Math.round(Math.sin(d11) * (double)j2);
  94.                     if(l2 < 0)
  95.                         g.drawLine(k + k2, l - l2, k + k2, (l - l2) + l1 + 1);
  96.                     else
  97.                         g.drawLine(k + k2, (l - l2) + 1, k + k2, (l - l2) + l1 + 2);
  98.                     double d13 = d11;
  99.                 }
  100.             }
  101.         }
  102.         if(i1 == 0 || i1 == 2)
  103.         {
  104.             int j1 = k - i / 2;
  105.             int k1 = l - j / 2;
  106.             g.setColor(color);
  107.             g.fillArc(j1, k1, i + 1, j + 1, (int)Math.round(d), (int)Math.round(-d1));
  108.             g.setColor(color.darker());
  109.             g.drawArc(j1, k1, i, j, (int)Math.round(d), (int)Math.round(-d1));
  110.         }
  111.         if(flag)
  112.             paintSelectionMarker(g, color, (int)Math.round(-d), (int)Math.round(-d1), i, j, k, l, selectionStyle);
  113.     }
  115.     protected void processEvent(AWTEvent awtevent)
  116.     {
  117.         switch(awtevent.getID())
  118.         {
  119.         case 504: 
  120.         default:
  121.             break;
  123.         case 505: 
  124.             selectedSample = -1;
  125.             selectedSeries = -1;
  126.             repaint();
  127.             break;
  129.         case 503: 
  130.         case 506: 
  131.             MouseEvent mouseevent = (MouseEvent)awtevent;
  132.             if(!seriesLabelsOn && !sampleLabelsOn && !isValueLabelsOn() && !percentLabelsOn)
  133.                 break;
  134.             Point point = new Point(mouseevent.getX(), mouseevent.getY());
  135.             ChartSample chartsample = checkSelection(point);
  136.             boolean flag = false;
  137.             if(chartsample != null)
  138.             {
  139.                 flag = chartsample.getIndex() != selectedSample || chartsample.getSeries() != selectedSeries;
  140.                 selectedSample = chartsample.getIndex();
  141.                 selectedSeries = chartsample.getSeries();
  142.             } else
  143.             {
  144.                 flag = selectedSample != -1 || selectedSeries != -1;
  145.                 selectedSample = -1;
  146.                 selectedSeries = -1;
  147.             }
  148.             if(flag)
  149.                 repaint();
  150.             break;
  151.         }
  152.         super.processEvent(awtevent);
  153.     }
  155.     public void setDepth(double d)
  156.     {
  157.         pieDepth = d;
  158.         super.hasChanged = true;
  159.         autoRepaint();
  160.     }
  162.     public float getDepth()
  163.     {
  164.         return (float)pieDepth;
  165.     }
  167.     public void setPercentLabelStyle(int i)
  168.     {
  169.         percentLabelStyle = 0;
  170.         if(i == 1 || i == 2)
  171.             percentLabelStyle = i;
  172.         super.hasChanged = true;
  173.         autoRepaint();
  174.     }
  176.     public int getPercentLabelStyle()
  177.     {
  178.         return percentLabelStyle;
  179.     }
  181.     public void setSampleLabelStyle(int i)
  182.     {
  183.         sampleLabelStyle = 0;
  184.         if(i == 1 || i == 2)
  185.             sampleLabelStyle = i;
  186.         super.hasChanged = true;
  187.         autoRepaint();
  188.     }
  190.     public int getSampleLabelStyle()
  191.     {
  192.         return sampleLabelStyle;
  193.     }
  195.     public void setDetachedDistance(double d)
  196.     {
  197.         detachedDistance = d;
  198.         super.hasChanged = true;
  199.         autoRepaint();
  200.     }
  202.     public double getDetachedDistance()
  203.     {
  204.         return detachedDistance;
  205.     }
  207.     public void setDetachedSlice(int i, int j, double d)
  208.     {
  209.         Double double1 = new Double(i * 0xf4240 + j);
  210.         if(d != 0.0D)
  211.             detachedSlices.put(double1, new Double(d));
  212.         else
  213.             detachedSlices.remove(double1);
  214.         super.hasChanged = true;
  215.         autoRepaint();
  216.     }
  218.     public double getDetachedSlice(int i, int j)
  219.     {
  220.         Double double1 = new Double(i * 0xf4240 + j);
  221.         Double double2 = (Double)detachedSlices.get(double1);
  222.         if(double2 != null)
  223.             return double2.doubleValue();
  224.         else
  225.             return 0.0D;
  226.     }
  228.     public boolean isSliceSeperatorOn()
  229.     {
  230.         return sliceSeperatorOn;
  231.     }
  233.     protected void calculateChartData(Rectangle rectangle, Rectangle rectangle1)
  234.     {
  235.     }
  237.     public double getPercentValue(int i, int j)
  238.     {
  239.         if(i < 0 || i >= getSeriesCount())
  240.             throw new IllegalArgumentException("Invalid series index: " + i);
  241.         if(j < 0 || j >= getSampleCount())
  242.             throw new IllegalArgumentException("Invalid sample index: " + j);
  243.         int k = getSeriesCount();
  244.         if(k == 1)
  245.         {
  246.             int l = getSampleCount();
  247.             double d1 = 0.0D;
  248.             for(int j1 = 0; j1 < l; j1++)
  249.             {
  250.                 double d5 = getSampleValue(0, j1);
  251.                 if(d5 > 0.0D)
  252.                     d1 += d5;
  253.             }
  255.             double d3 = getSampleValue(0, j);
  256.             if(d3 >= 0.0D)
  257.                 return (d3 / d1) * 100D;
  258.         } else
  259.         {
  260.             double d = 0.0D;
  261.             for(int i1 = 0; i1 < k; i1++)
  262.             {
  263.                 double d4 = getSampleValue(i1, j);
  264.                 if(d4 > 0.0D)
  265.                     d += d4;
  266.             }
  268.             double d2 = getSampleValue(i, j);
  269.             if(d2 > 0.0D)
  270.                 return (d2 / d) * 100D;
  271.         }
  272.         return 0.0D;
  273.     }
  275.     private void paintFloatingLabels(Graphics g, int i, int j)
  276.     {
  277.         int k = getSeriesCount();
  278.         int l = getSampleCount();
  279.         if(g == null || i < 0 || i >= k || j < -1 || j >= l)
  280.             return;
  281.         Font font = getFont("floatingLabelFont");
  282.         g.setFont(font);
  283.         FontMetrics fontmetrics = g.getFontMetrics();
  284.         boolean flag = isValueLabelsOn() && valueLabelStyle == 0;
  285.         boolean flag1 = percentLabelsOn && percentLabelStyle == 0;
  286.         boolean flag2 = sampleLabelsOn && sampleLabelStyle == 0;
  287.         boolean flag3 = seriesLabelsOn && k > 1 && seriesLabelStyle == 0;
  288.         if(j >= 0)
  289.         {
  290.             String s = constructLabel(i, j, flag3, flag2, flag, flag1);
  291.             paintFloatingLabel(g, s, i, j, font, fontmetrics);
  292.         } else
  293.         if(isFloatingOnLegendOn())
  294.         {
  295.             for(int i1 = 0; i1 < l; i1++)
  296.             {
  297.                 String s1 = constructLabel(i, i1, flag3, flag2, flag, flag1);
  298.                 paintFloatingLabel(g, s1, i, i1, font, fontmetrics);
  299.             }
  301.         }
  302.     }
  304.     private void paintSelectionMarker(Graphics g, Color color, double d, double d1, int i, 
  305.             int j, int k, int l, int i1)
  306.     {
  307.         if(i1 == 1)
  308.         {
  309.             double d2 = d - d1 / 2D;
  310.             double d4 = d2 * 0.017453292519943295D;
  311.             int j1 = k + (int)Math.round(Math.cos(d4) * ((double)i * 0.40000000000000002D));
  312.             int l1 = l + (int)Math.round(Math.sin(d4) * ((double)j * 0.40000000000000002D));
  313.             int j2 = Math.max(i / 16, 3);
  314.             int l2 = Math.max(j / 16, 3);
  315.             int j3 = j2 / 2;
  316.             int k3 = l2 / 2;
  317.             g.setColor(color.darker());
  318.             g.fillOval(j1 - j3, l1 - k3, j2, l2);
  319.             g.setColor(color.darker());
  320.             g.drawArc(j1 - j3, l1 - k3, j2, l2, 45, 180);
  321.             g.setColor(color.darker().darker());
  322.             g.drawArc((j1 - j3) + 1, (l1 - k3) + 1, j2 - 2, l2 - 2, 45, 180);
  323.             g.setColor(color);
  324.             g.drawArc((j1 - j3) + 1, (l1 - k3) + 1, j2 - 2, l2 - 2, 45, -180);
  325.             g.setColor(color.brighter());
  326.             g.drawArc(j1 - j3, l1 - k3, j2, l2, 45, -180);
  327.         } else
  328.         if(i1 == 0)
  329.         {
  330.             double d3 = d - d1 / 2D;
  331.             double d5 = d3 * 0.017453292519943295D;
  332.             int k1 = (int)Math.round((double)i * 0.69999999999999996D);
  333.             int i2 = (int)Math.round((double)j * 0.69999999999999996D);
  334.             int k2 = k + (int)Math.round(Math.cos(d5) * ((double)i * 0.10000000000000001D));
  335.             int i3 = l + (int)Math.round(Math.sin(d5) * ((double)j * 0.10000000000000001D));
  336.             k2 -= (int)Math.round((double)k1 / 2D);
  337.             i3 -= (int)Math.round((double)i2 / 2D);
  338.             g.setColor(color.darker());
  339.             g.fillArc(k2, i3, k1 + 1, i2 + 1, (int)(-Math.round(d)), (int)Math.round(d1));
  340.         }
  341.     }
  343.     public void setPercentLabelsOn(boolean flag)
  344.     {
  345.         percentLabelsOn = flag;
  346.         super.hasChanged = true;
  347.         autoRepaint();
  348.     }
  350.     public void setSampleLabelsOn(boolean flag)
  351.     {
  352.         sampleLabelsOn = flag;
  353.         super.hasChanged = true;
  354.         autoRepaint();
  355.     }
  357.     public boolean isSeriesLabelsOn()
  358.     {
  359.         return seriesLabelsOn;
  360.     }
  362.     public void setPieLabelsOn(boolean flag)
  363.     {
  364.         pieLabelsOn = flag;
  365.         super.hasChanged = true;
  366.         autoRepaint();
  367.     }
  369.     private void paintPie(Graphics g, Rectangle rectangle, double ad[], int i)
  370.     {
  371.         if(rectangle == null || rectangle.width <= 0 || rectangle.height <= 0)
  372.             return;
  373.         int j = Math.min(rectangle.width, rectangle.height);
  374.         int k = j;
  375.         int l = k;
  376.         int j1 = rectangle.x + rectangle.width / 2;
  377.         int k1 = rectangle.y + rectangle.height / 2;
  378.         Font font = getFont("pieLabelFont");
  379.         if(font != null)
  380.             g.setFont(font);
  381.         else
  382.             g.setFont(getFont());
  383.         FontMetrics fontmetrics = g.getFontMetrics();
  384.         boolean flag = is3DModeOn();
  385.         if(flag)
  386.         {
  387.             int l1 = (int)Math.round((double)j * ((double)pieAngle / 90D));
  388.             k -= l1;
  389.             int i2 = (int)Math.round((double)j * pieDepth * ((double)pieAngle / 90D));
  390.             int i1 = k + i2;
  391.             k1 -= i2 / 2;
  392.             double d1 = (double)rectangle.width / (double)j;
  393.             int i3 = (int)Math.round((double)j * d1);
  394.             int l3 = (int)Math.round((double)k * d1);
  395.             i2 = (int)Math.round((double)i3 * pieDepth * ((double)pieAngle / 90D));
  396.             i1 = l3 + i2;
  397.             k1 = (rectangle.y + rectangle.height / 2) - i2 / 2;
  398.             if(k1 - l3 / 2 < rectangle.y)
  399.             {
  400.                 double d6 = (double)l3 / (double)i1;
  401.                 i1 = rectangle.height;
  402.                 l3 = (int)Math.round((double)i1 * d6);
  403.                 int j2 = rectangle.height - l3;
  404.                 double d2 = (double)j / (double)k;
  405.                 i3 = (int)Math.round((double)l3 * d2);
  406.                 k1 = (rectangle.y + rectangle.height / 2) - j2 / 2;
  407.             }
  408.             j = i3;
  409.             k = l3;
  410.         }
  411.         if(pieLabelsOn)
  412.         {
  413.             Font font1 = getFont("pieLabelFont");
  414.             String s = getSampleLabel(i);
  415.             Dimension dimension = getLabelSize(s, font1);
  416.             if(flag)
  417.             {
  418.                 int l2 = (int)Math.round((double)j * pieDepth * ((double)pieAngle / 90D));
  419.                 int j3 = ((k1 + k / 2 + dimension.height) - fontmetrics.getDescent()) + 2;
  420.                 j3 += l2;
  421.                 if(j3 > rectangle.y + rectangle.height)
  422.                 {
  423.                     int i4 = j3 - (rectangle.y + rectangle.height);
  424.                     k -= i4;
  425.                     k1 -= i4 / 2;
  426.                 }
  427.             } else
  428.             {
  429.                 k -= dimension.height;
  430.                 j = k;
  431.                 k1 -= dimension.height / 2;
  432.             }
  433.         }
  434.         pieCenter[i].x = j1;
  435.         pieCenter[i].y = k1;
  436.         pieWidth[i] = j;
  437.         double d = 0.0D;
  438.         for(int k2 = 0; k2 < ad.length; k2++)
  439.             if(ad[k2] > 0.0D)
  440.                 d += ad[k2];
  442.         double d3 = 90D;
  443.         int k3 = getSeriesCount();
  444.         for(int j4 = 0; j4 < ad.length; j4++)
  445.         {
  446.             double d7 = (ad[j4] / d) * 360D;
  447.             if(k3 == 1)
  448.                 angles[0][j4] = d3;
  449.             else
  450.                 angles[j4][i] = d3;
  451.             d3 -= d7;
  452.         }
  454.         if(flag)
  455.         {
  456.             int k4 = k1;
  457.             k1 += (int)Math.round((double)j * pieDepth * ((double)pieAngle / 90D));
  458.             for(int j5 = 0; j5 < ad.length; j5++)
  459.             {
  460.                 double d10 = -270D;
  461.                 double d15 = d10;
  462.                 if(k3 == 1)
  463.                 {
  464.                     if(j5 < angles[0].length - 1)
  465.                         d10 = angles[0][j5 + 1];
  466.                     d15 = angles[0][j5];
  467.                 } else
  468.                 {
  469.                     if(j5 < angles.length - 1)
  470.                         d10 = angles[j5 + 1][i];
  471.                     d15 = angles[j5][i];
  472.                 }
  473.                 if(d15 != d10)
  474.                 {
  475.                     boolean flag4 = false;
  476.                     if(k3 == 1)
  477.                         flag4 = isSelected(0, j5);
  478.                     else
  479.                         flag4 = isSelected(j5, i);
  480.                     double d19 = 0.0D;
  481.                     if(flag4 && selectionStyle == 2)
  482.                         d19 = detachedDistance;
  483.                     else
  484.                     if(k3 == 1)
  485.                         d19 = getDetachedSlice(0, j5);
  486.                     else
  487.                         d19 = getDetachedSlice(j5, i);
  488.                     flag4 = false;
  489.                     paintPieSegment(g, getSampleColor(j5).darker(), d15, d15 - d10, j, k, j1, k1, flag4, d19, 0);
  490.                 }
  491.             }
  493.             k1 = k4;
  494.         }
  495.         if(flag)
  496.         {
  497.             double d4 = -270D;
  498.             double d11;
  499.             for(int k5 = ad.length - 1; d4 < -90D && k5 >= 0; d4 = d11)
  500.             {
  501.                 d11 = d4;
  502.                 if(k3 == 1)
  503.                     d11 = angles[0][k5];
  504.                 else
  505.                     d11 = angles[k5][i];
  506.                 boolean flag1 = false;
  507.                 if(k3 == 1)
  508.                     flag1 = isSelected(0, k5);
  509.                 else
  510.                     flag1 = isSelected(k5, i);
  511.                 double d16 = 0.0D;
  512.                 if(flag1 && selectionStyle == 2)
  513.                     d16 = detachedDistance;
  514.                 else
  515.                 if(k3 == 1)
  516.                     d16 = getDetachedSlice(0, k5);
  517.                 else
  518.                     d16 = getDetachedSlice(k5, i);
  519.                 paintPieSegment(g, getSampleColor(k5), d11, d11 - d4, j, k, j1, k1, flag1, d16, 1);
  520.                 k5--;
  521.             }
  523.             for(int l5 = 0; l5 < ad.length; l5++)
  524.             {
  525.                 double d5 = -270D;
  526.                 double d12 = d5;
  527.                 if(k3 == 1)
  528.                 {
  529.                     if(l5 < angles[0].length - 1)
  530.                         d5 = angles[0][l5 + 1];
  531.                     d12 = angles[0][l5];
  532.                 } else
  533.                 {
  534.                     if(l5 < angles.length - 1)
  535.                         d5 = angles[l5 + 1][i];
  536.                     d12 = angles[l5][i];
  537.                 }
  538.                 if(d12 >= -90D)
  539.                 {
  540.                     boolean flag2 = false;
  541.                     if(k3 == 1)
  542.                         flag2 = isSelected(0, l5);
  543.                     else
  544.                         flag2 = isSelected(l5, i);
  545.                     double d17 = 0.0D;
  546.                     if(flag2 && selectionStyle == 2)
  547.                         d17 = detachedDistance;
  548.                     else
  549.                     if(k3 == 1)
  550.                         d17 = getDetachedSlice(0, l5);
  551.                     else
  552.                         d17 = getDetachedSlice(l5, i);
  553.                     paintPieSegment(g, getSampleColor(l5), d12, d12 - d5, j, k, j1, k1, flag2, d17, 1);
  554.                 }
  555.             }
  557.         }
  558.         for(int l4 = 0; l4 < ad.length; l4++)
  559.         {
  560.             double d8 = -270D;
  561.             double d13 = d8;
  562.             if(k3 == 1)
  563.             {
  564.                 if(l4 < angles[0].length - 1)
  565.                     d8 = angles[0][l4 + 1];
  566.                 d13 = angles[0][l4];
  567.             } else
  568.             {
  569.                 if(l4 < angles.length - 1)
  570.                     d8 = angles[l4 + 1][i];
  571.                 d13 = angles[l4][i];
  572.             }
  573.             if(d13 != d8)
  574.             {
  575.                 boolean flag3 = false;
  576.                 if(k3 == 1)
  577.                     flag3 = isSelected(0, l4);
  578.                 else
  579.                     flag3 = isSelected(l4, i);
  580.                 double d18 = 0.0D;
  581.                 if(flag3 && selectionStyle == 2)
  582.                     d18 = detachedDistance;
  583.                 else
  584.                 if(k3 == 1)
  585.                     d18 = getDetachedSlice(0, l4);
  586.                 else
  587.                     d18 = getDetachedSlice(l4, i);
  588.                 paintPieSegment(g, getSampleColor(l4), d13, d13 - d8, j, k, j1, k1, flag3, d18, 0);
  589.             }
  590.         }
  592.         if(sliceSeperatorOn)
  593.         {
  594.             for(int i5 = 0; i5 < ad.length; i5++)
  595.             {
  596.                 double d9 = 0.0D;
  597.                 if(k3 == 1)
  598.                     d9 = angles[0][i5];
  599.                 else
  600.                     d9 = angles[i5][i];
  601.                 double d14 = -d9 * 0.017453292519943295D;
  602.                 int k6 = j1 + (int)Math.round(Math.cos(d14) * ((double)j * 0.5D));
  603.                 int l6 = k1 + (int)Math.round(Math.sin(d14) * ((double)k * 0.5D));
  604.                 if(sliceSeperatorColor != null)
  605.                     g.setColor(sliceSeperatorColor);
  606.                 else
  607.                     g.setColor(getSampleColor(i5).darker());
  608.                 g.drawLine(j1, k1, k6, l6);
  609.             }
  611.         }
  612.         if(pieLabelsOn)
  613.         {
  614.             String s1 = k3 != 1 ? getSampleLabel(i) : getSeriesLabel(i);
  615.             Font font2 = getFont("pieLabelFont");
  616.             if(s1 != null && s1.trim().length() > 0)
  617.             {
  618.                 Dimension dimension1 = getLabelSize(s1, font2);
  619.                 int i6 = j1 - dimension1.width / 2;
  620.                 int j6 = ((k1 + k / 2 + fontmetrics.getHeight()) - fontmetrics.getDescent()) + 2;
  621.                 if(flag)
  622.                     j6 += (int)Math.round((double)j * pieDepth * ((double)pieAngle / 90D));
  623.                 Color color = getSampleLabelColor(i);
  624.                 g.setColor(color == null ? getForeground() : color);
  625.                 paintLabel(g, s1, i6, j6, dimension1, 0, 0);
  626.             }
  627.         }
  628.     }
  630.     private String constructLabel(int i, int j, boolean flag, boolean flag1, boolean flag2, boolean flag3)
  631.     {
  632.         int k = getSeriesCount();
  633.         int l = getSampleCount();
  634.         if(i < 0 || i >= k || j < 0 || j >= l)
  635.             return "";
  636.         String s = getLabel("valueLabelPrefix_" + i);
  637.         if(s == null)
  638.             s = getLabel("valueLabelPrefix");
  639.         String s1 = getLabel("valueLabelPostfix_" + i);
  640.         if(s1 == null)
  641.             s1 = getLabel("valueLabelPostfix");
  642.         String s2 = flag ? getSeriesLabel(i) : null;
  643.         String s3 = flag1 ? getSampleLabel(j) : null;
  644.         String s4 = flag2 ? formatNumber(getSampleValue(i, j), getSampleDecimalCount(i)) : null;
  645.         s4 = s == null || s4 == null ? s4 : s + s4;
  646.         s4 = s1 == null || s4 == null ? s4 : s4 + s1;
  647.         String s5 = flag3 ? formatNumber(getPercentValue(i, j), getPercentDecimalCount()) + "%" : null;
  648.         StringBuffer stringbuffer = new StringBuffer();
  649.         if(s2 != null)
  650.         {
  651.             stringbuffer.append(s2);
  652.             if(!s2.endsWith("n") && (s3 != null || s4 != null || s5 != null))
  653.                 stringbuffer.append(" : ");
  654.         }
  655.         if(s3 != null)
  656.         {
  657.             stringbuffer.append(s3);
  658.             if(!s3.endsWith("n") && (s4 != null || s5 != null))
  659.                 stringbuffer.append(" : ");
  660.         }
  661.         if(s4 != null)
  662.         {
  663.             stringbuffer.append(s4);
  664.             if(!s4.endsWith("n") && s5 != null)
  665.                 stringbuffer.append(" : ");
  666.         }
  667.         if(s5 != null)
  668.             stringbuffer.append(s5);
  669.         return stringbuffer.toString();
  670.     }
  672.     private void paintStaticLabels(Graphics g)
  673.     {
  674.         if(g == null)
  675.             return;
  676.         int i = getSeriesCount();
  677.         boolean flag = percentLabelsOn && percentLabelStyle != 0;
  678.         flag |= isValueLabelsOn() && valueLabelStyle != 0;
  679.         flag |= sampleLabelsOn && sampleLabelStyle != 0;
  680.         flag |= seriesLabelsOn && i > 1 && seriesLabelStyle != 0;
  681.         if(!flag)
  682.             return;
  683.         Font font = getFont("insideLabelFont");
  684.         g.setFont(font);
  685.         FontMetrics fontmetrics = g.getFontMetrics();
  686.         int j = getSampleCount();
  687.         boolean flag1 = percentLabelsOn && percentLabelStyle != 0;
  688.         boolean flag2 = isValueLabelsOn() && valueLabelStyle != 0;
  689.         boolean flag3 = seriesLabelsOn && i > 1 && seriesLabelStyle != 0;
  690.         boolean flag4 = sampleLabelsOn && sampleLabelStyle != 0;
  691.         for(int k = 0; k < i; k++)
  692.         {
  693.             for(int l = 0; l < j; l++)
  694.             {
  695.                 String s = constructLabel(k, l, flag3, flag4, flag2, flag1);
  696.                 paintInsideLabel(g, s, k, l, font, fontmetrics);
  697.             }
  699.         }
  701.     }
  703.     public void setValueLabelStyle(int i)
  704.     {
  705.         valueLabelStyle = 0;
  706.         if(i == 1 || i == 2)
  707.             valueLabelStyle = i;
  708.         super.hasChanged = true;
  709.         autoRepaint();
  710.     }
  712.     public int getValueLabelStyle()
  713.     {
  714.         return valueLabelStyle;
  715.     }
  717.     public void setSliceSeperatorOn(boolean flag)
  718.     {
  719.         sliceSeperatorOn = flag;
  720.         super.hasChanged = true;
  721.         autoRepaint();
  722.     }
  724.     public ChartSample checkSelection(Point point)
  725.     {
  726.         ChartSample chartsample = super.checkSelection(point);
  727.         if(chartsample == null)
  728.         {
  729.             int i = -1;
  730.             Object obj = null;
  731.             for(int j = 0; j < pieBounds.length; j++)
  732.             {
  733.                 Rectangle rectangle = pieBounds[j];
  734.                 if(rectangle == null || !rectangle.contains(point))
  735.                     continue;
  736.                 i = j;
  737.                 break;
  738.             }
  740.             if(i >= 0)
  741.             {
  742.                 point.x -= pieCenter[i].x;
  743.                 point.y -= pieCenter[i].y;
  744.                 if(is3DModeOn())
  745.                 {
  746.                     int k = pieWidth[i];
  747.                     int l = (int)Math.round((double)k * ((double)pieAngle / 90D));
  748.                     double d2 = (double)k / (double)(k - l);
  749.                     point.y = (int)Math.round((double)point.y * d2);
  750.                 }
  751.                 double d = Math.atan2(point.y, point.x);
  752.                 double d3 = -(d * 57.295779513082323D);
  753.                 if(d3 > 90D && d3 <= 180D)
  754.                     d3 = -360D + d3;
  755.                 int i1 = getSeriesCount();
  756.                 double d5 = 0.0D;
  757.                 double d6 = 0.0D;
  758.                 double d7 = 0.0D;
  759.                 if(i1 == 1)
  760.                 {
  761.                     int j1 = getSampleCount();
  762.                     for(int l1 = 0; l1 < j1; l1++)
  763.                     {
  764.                         if(l1 < j1 - 1)
  765.                         {
  766.                             d6 = Math.min(angles[0][l1], angles[0][l1 + 1]);
  767.                             d7 = Math.max(angles[0][l1], angles[0][l1 + 1]);
  768.                         } else
  769.                         {
  770.                             d6 = Math.min(angles[0][l1], -270D);
  771.                             d7 = Math.max(angles[0][l1], -270D);
  772.                         }
  773.                         if(d3 < d6 || d3 >= d7)
  774.                             continue;
  775.                         chartsample = getSample(0, l1);
  776.                         d5 = (d6 + d7) / 2D;
  777.                         break;
  778.                     }
  780.                 } else
  781.                 {
  782.                     for(int k1 = 0; k1 < i1; k1++)
  783.                     {
  784.                         if(k1 < i1 - 1)
  785.                         {
  786.                             d6 = Math.min(angles[k1][i], angles[k1 + 1][i]);
  787.                             d7 = Math.max(angles[k1][i], angles[k1 + 1][i]);
  788.                         } else
  789.                         {
  790.                             d6 = Math.min(angles[k1][i], -270D);
  791.                             d7 = Math.max(angles[k1][i], -270D);
  792.                         }
  793.                         if(d3 < d6 || d3 >= d7)
  794.                             continue;
  795.                         chartsample = getSample(k1, i);
  796.                         d5 = (d6 + d7) / 2D;
  797.                         break;
  798.                     }
  800.                 }
  801.                 if(chartsample != null && chartsample.isSelected() && selectionStyle == 2)
  802.                 {
  803.                     double d8 = d5 * 0.017453292519943295D;
  804.                     point.x -= Math.cos(d8) * (double)pieWidth[i] * 0.5D * detachedDistance;
  805.                     point.y += Math.sin(d8) * (double)pieWidth[i] * 0.5D * detachedDistance;
  806.                     double d1 = Math.atan2(point.y, point.x);
  807.                     double d4 = -(d1 * 57.295779513082323D);
  808.                     if(d4 > 90D && d4 <= 180D)
  809.                         d4 = -360D + d4;
  810.                     if(d4 < d6 || d4 >= d7)
  811.                         return null;
  812.                 }
  813.                 double d9 = Math.sqrt(point.x * point.x + point.y * point.y);
  814.                 if(d9 > (double)(pieWidth[i] / 2))
  815.                     return null;
  816.             }
  817.         }
  818.         return chartsample;
  819.     }
  821.     protected void renderData(Graphics g, Rectangle rectangle, Rectangle rectangle1)
  822.     {
  823.         paintPies(g, rectangle);
  824.         paintStaticLabels(g);
  825.     }
  827.     public void reset()
  828.     {
  829.         super.reset();
  830.         pieAngle = 20;
  831.         pieDepth = 0.40000000596046448D;
  832.         sampleLabelsOn = false;
  833.         percentLabelsOn = false;
  834.         pieLabelsOn = false;
  835.         percentDecimalCount = 0;
  836.         selectionStyle = 0;
  837.         sliceSeperatorOn = true;
  838.         sliceSeperatorColor = null;
  839.         detachedDistance = 0.10000000000000001D;
  840.         if(detachedSlices != null)
  841.             detachedSlices.clear();
  842.         percentLabelStyle = 0;
  843.         valueLabelStyle = 0;
  844.         sampleLabelStyle = 0;
  845.         seriesLabelStyle = 0;
  846.         selectedSample = -1;
  847.         selectedSeries = -1;
  848.     }
  850.     public PieChart()
  851.     {
  852.         this(1);
  853.     }
  855.     public PieChart(int i)
  856.     {
  857.         this(1, i);
  858.     }
  860.     public PieChart(int i, int j)
  861.     {
  862.         super(i, j);
  863.         super.chartType = "pie";
  864.         angles = new double[i][j];
  865.         detachedSlices = new Hashtable();
  866.         pieBounds = new Rectangle[i != 1 ? j : 1];
  867.         pieCenter = new Point[pieBounds.length];
  868.         pieWidth = new int[pieBounds.length];
  869.         for(int k = 0; k < pieBounds.length; k++)
  870.         {
  871.             pieBounds[k] = new Rectangle();
  872.             pieCenter[k] = new Point();
  873.         }
  875.     }
  877.     public void setPercentDecimalCount(int i)
  878.     {
  879.         percentDecimalCount = i;
  880.         super.hasChanged = true;
  881.         autoRepaint();
  882.     }
  884.     public int getPercentDecimalCount()
  885.     {
  886.         return percentDecimalCount;
  887.     }
  889.     public void setSliceSeperatorColor(Color color)
  890.     {
  891.         sliceSeperatorColor = color;
  892.         super.hasChanged = true;
  893.         autoRepaint();
  894.     }
  896.     public Color getSliceSeperatorColor()
  897.     {
  898.         return sliceSeperatorColor;
  899.     }
  901.     public void setFont(String s, Font font)
  902.     {
  903.         super.setFont(s, font);
  904.     }
  906.     public void setAngle(int i)
  907.     {
  908.         pieAngle = i;
  909.         super.hasChanged = true;
  910.         autoRepaint();
  911.     }
  913.     public int getAngle()
  914.     {
  915.         return pieAngle;
  916.     }
  918.     public void setSelectionStyle(int i)
  919.     {
  920.         selectionStyle = i;
  921.         super.hasChanged = true;
  922.         autoRepaint();
  923.     }
  925.     public int getSelectionStyle()
  926.     {
  927.         return selectionStyle;
  928.     }
  930.     public void render(Graphics g)
  931.     {
  932.         render(g, !isServletModeOn());
  933.     }
  935.     public void setSeriesLabelsOn(boolean flag)
  936.     {
  937.         seriesLabelsOn = flag;
  938.         super.hasChanged = true;
  939.         autoRepaint();
  940.     }
  942.     protected void checkDataIntegrity()
  943.     {
  944.         super.checkDataIntegrity();
  945.         int i = getSeriesCount();
  946.         int j = getSampleCount();
  947.         angles = new double[i][j];
  948.         pieBounds = new Rectangle[i != 1 ? j : 1];
  949.         pieCenter = new Point[pieBounds.length];
  950.         pieWidth = new int[pieBounds.length];
  951.         for(int k = 0; k < pieBounds.length; k++)
  952.         {
  953.             pieBounds[k] = new Rectangle();
  954.             pieCenter[k] = new Point();
  955.         }
  957.     }
  959.     void render(Graphics g, boolean flag)
  960.     {
  961.         Rectangle rectangle = getGraphBounds();
  962.         for(int i = 0; i < super.overlayCharts.size(); i++)
  963.         {
  964.             Chart chart = (Chart)super.overlayCharts.elementAt(i);
  965.             if(chart != null)
  966.                 chart.calculateChartData(rectangle, rectangle);
  967.         }
  969.         Dimension dimension = getSize();
  970.         if(flag && super.offscreen == null)
  971.         {
  972.             super.offscreen = createImage(Math.max(1, dimension.width), Math.max(1, dimension.height));
  973.             super.hasChanged = true;
  974.         }
  975.         if(!flag || super.hasChanged || super.offscreen == null)
  976.         {
  977.             if(!super.externalGraphicsOn && !flag)
  978.                 super.og = g;
  979.             else
  980.             if(flag || super.externalGraphicsOn)
  981.             {
  982.                 if(!super.externalGraphicsOn && super.offscreen != null)
  983.                     super.og = super.offscreen.getGraphics();
  984.                 super.og.setColor(getBackground());
  985.                 super.og.fillRect(0, 0, dimension.width, dimension.height);
  986.             }
  987.             paintTitle(super.og, dimension);
  988.             renderData(super.og, rectangle, rectangle);
  989.             for(int j = 0; j < super.overlayCharts.size(); j++)
  990.             {
  991.                 Chart chart1 = (Chart)super.overlayCharts.elementAt(j);
  992.                 if(chart1 != null)
  993.                     chart1.renderData(super.og, rectangle, rectangle);
  994.             }
  996.             if(isLegendOn())
  997.                 paintLegend(super.og, rectangle, getLegendLabels());
  998.             if(!super.externalGraphicsOn && super.og != g)
  999.                 super.og.dispose();
  1000.             super.hasChanged = false;
  1001.         }
  1002.         if((flag || super.externalGraphicsOn) && super.offscreen != null)
  1003.             g.drawImage(super.offscreen, 0, 0, this);
  1004.         if(sampleLabelsOn && sampleLabelStyle == 0 || seriesLabelsOn && seriesLabelStyle == 0 || isValueLabelsOn() && valueLabelStyle == 0 || percentLabelsOn && percentLabelStyle == 0)
  1005.             paintFloatingLabels(g, selectedSeries, selectedSample);
  1006.     }
  1008.     public Rectangle getGraphBounds()
  1009.     {
  1010.         if(!super.hasChanged && super.currentBounds != null)
  1011.             return super.currentBounds;
  1012.         Rectangle rectangle = super.getGraphBounds(getLegendLabels());
  1013.         Insets insets = getGraphInsets();
  1014.         if(insets != null)
  1015.         {
  1016.             Dimension dimension = getSize();
  1017.             if(insets.top != -1)
  1018.             {
  1019.                 int i = rectangle.y + rectangle.height;
  1020.                 rectangle.y = insets.top;
  1021.                 rectangle.height = i - rectangle.y;
  1022.             }
  1023.             if(insets.left != -1)
  1024.             {
  1025.                 int j = rectangle.x + rectangle.width;
  1026.                 rectangle.x = insets.left;
  1027.                 rectangle.width = j - rectangle.x;
  1028.             }
  1029.             if(insets.bottom != -1)
  1030.                 rectangle.height = dimension.height - insets.bottom - rectangle.y;
  1031.             if(insets.right != -1)
  1032.                 rectangle.width = dimension.width - insets.right - rectangle.x;
  1033.         }
  1034.         super.currentBounds = rectangle;
  1035.         return rectangle;
  1036.     }
  1038.     private void calculatePieBounds(Rectangle rectangle, int i)
  1039.     {
  1040.         int j = 0;
  1041.         int k = i;
  1042.         int l = 1;
  1043.         for(int i1 = 1; i1 <= i; i1++)
  1044.         {
  1045.             for(int k1 = 1; k1 <= i; k1++)
  1046.                 if(i1 * k1 >= i)
  1047.                 {
  1048.                     int i2 = Math.min(rectangle.width / i1, rectangle.height / k1);
  1049.                     if(i2 > j)
  1050.                     {
  1051.                         j = i2;
  1052.                         k = i1;
  1053.                         l = k1;
  1054.                     }
  1055.                 }
  1057.         }
  1059.         int j1 = 0;
  1060.         for(int l1 = 0; l1 < l; l1++)
  1061.         {
  1062.             for(int j2 = 0; j2 < k; j2++)
  1063.                 if(j1 < i)
  1064.                 {
  1065.                     Rectangle rectangle1 = pieBounds[j1];
  1066.                     rectangle1.width = rectangle.width / k;
  1067.                     rectangle1.height = rectangle.height / l;
  1068.                     rectangle1.x = rectangle.x + rectangle1.width * j2;
  1069.                     rectangle1.y = rectangle.y + rectangle1.height * l1;
  1070.                     rectangle1.width -= 10;
  1071.                     rectangle1.height -= 10;
  1072.                     rectangle1.x += 5;
  1073.                     rectangle1.y += 5;
  1074.                     j1++;
  1075.                 }
  1077.         }
  1079.     }
  1081.     private void paintFloatingLabel(Graphics g, String s, int i, int j, Font font, FontMetrics fontmetrics)
  1082.     {
  1083.         int k = getSeriesCount();
  1084.         Point point = pieCenter[k <= 1 ? 0 : j];
  1085.         if(point == null)
  1086.             return;
  1087.         double d = 0.0D;
  1088.         if(k == 1)
  1089.         {
  1090.             if(j < angles[0].length - 1)
  1091.                 d = -((angles[0][j] + angles[0][j + 1]) / 2D);
  1092.             else
  1093.                 d = -((angles[0][j] - 270D) / 2D);
  1094.         } else
  1095.         if(i < angles.length - 1)
  1096.             d = -((angles[i][j] + angles[i + 1][j]) / 2D);
  1097.         else
  1098.             d = -((angles[i][j] - 270D) / 2D);
  1099.         double d1 = 1.0D;
  1100.         int l = pieWidth[k != 1 ? j : 0];
  1101.         if(is3DModeOn())
  1102.         {
  1103.             int i1 = (int)Math.round((double)l * ((double)pieAngle / 90D));
  1104.             d1 = (double)(l - i1) / (double)l;
  1105.         }
  1106.         double d2 = d * 0.017453292519943295D;
  1107.         int j1 = point.x + (int)Math.round(Math.cos(d2) * (double)l * 0.29999999999999999D);
  1108.         int k1 = point.y + (int)Math.round(Math.sin(d2) * (double)l * 0.29999999999999999D * d1);
  1109.         Dimension dimension = getLabelSize(s, font);
  1110.         j1 -= dimension.width / 2;
  1111.         k1 -= dimension.height / 2 - fontmetrics.getAscent();
  1112.         Dimension dimension1 = getSize();
  1113.         j1 = Math.max(j1, 3);
  1114.         j1 = Math.min(j1, dimension1.width - dimension.width - 3);
  1115.         k1 = Math.max(k1, fontmetrics.getAscent());
  1116.         k1 = Math.min(k1, ((dimension1.height - dimension.height) + fontmetrics.getAscent()) - 1);
  1117.         int l1 = fontmetrics.getHeight();
  1118.         int i2 = fontmetrics.getDescent();
  1119.         g.setColor(new Color(255, 255, 231));
  1120.         g.fillRect(j1 - 2, ((k1 - l1) + i2 * 2) - 3, dimension.width + 5, dimension.height + 2);
  1121.         g.setColor(getSampleColor(getSeriesCount() != 1 ? i : j).darker());
  1122.         g.drawRect(j1 - 3, ((k1 - l1) + i2 * 2) - 4, dimension.width + 5, dimension.height + 3);
  1123.         g.setColor(Color.black);
  1124.         paintLabel(g, s, j1, k1, dimension, 0, 0);
  1125.     }
  1127.     private void paintInsideLabel(Graphics g, String s, int i, int j, Font font, FontMetrics fontmetrics)
  1128.     {
  1129.         int k = getSeriesCount();
  1130.         Point point = pieCenter[k <= 1 ? 0 : j];
  1131.         if(point == null)
  1132.             return;
  1133.         double d = 0.0D;
  1134.         double d1 = -270D;
  1135.         double d2 = d1;
  1136.         if(k == 1)
  1137.         {
  1138.             if(j < angles[0].length - 1)
  1139.                 d1 = angles[0][j + 1];
  1140.             d2 = angles[0][j];
  1141.         } else
  1142.         {
  1143.             if(i < angles.length - 1)
  1144.                 d1 = angles[i + 1][j];
  1145.             d2 = angles[i][j];
  1146.         }
  1147.         d = -((d2 + d1) / 2D);
  1148.         double d3 = 1.0D;
  1149.         int l = pieWidth[k != 1 ? j : 0];
  1150.         double d4 = 0.0D;
  1151.         if(isSelected(i, j) && d2 - d1 < 360D && selectionStyle == 2)
  1152.             d4 = ((double)l * detachedDistance) / 2D;
  1153.         if(is3DModeOn())
  1154.         {
  1155.             int i1 = (int)Math.round((double)l * ((double)pieAngle / 90D));
  1156.             d3 = (double)(l - i1) / (double)l;
  1157.         }
  1158.         double d5 = d * 0.017453292519943295D;
  1159.         int j1 = point.x + (int)Math.round(Math.cos(d5) * (double)l * 0.34999999999999998D + Math.cos(d5) * d4);
  1160.         int k1 = point.y + (int)Math.round((Math.sin(d5) * (double)l * 0.34999999999999998D + Math.sin(d5) * d4) * d3);
  1161.         Dimension dimension = getLabelSize(s, font);
  1162.         j1 -= dimension.width / 2;
  1163.         k1 -= dimension.height / 2 - fontmetrics.getAscent();
  1164.         Color color = getSampleColor(k != 1 ? i : j);
  1165.         if((color.getRed() + color.getGreen() + color.getBlue()) / 3 > 110)
  1166.             g.setColor(Color.black);
  1167.         else
  1168.             g.setColor(Color.white);
  1169.         paintLabel(g, s, j1, k1, dimension, 0, 0);
  1170.     }
  1172.     public void setSeriesLabelStyle(int i)
  1173.     {
  1174.         seriesLabelStyle = 0;
  1175.         if(i == 1 || i == 2)
  1176.             seriesLabelStyle = i;
  1177.         super.hasChanged = true;
  1178.         autoRepaint();
  1179.     }
  1181.     public static final int SELECTION_STYLE_TRIANGLE = 0;
  1182.     public static final int SELECTION_STYLE_CIRCLE = 1;
  1183.     public static final int SELECTION_STYLE_DETACHED = 2;
  1184.     public static final int FLOATING = 0;
  1185.     public static final int INSIDE = 1;
  1186.     public static final int OUTSIDE = 2;
  1187.     private int pieAngle;
  1188.     private double pieDepth;
  1189.     private boolean seriesLabelsOn;
  1190.     private boolean sampleLabelsOn;
  1191.     private boolean percentLabelsOn;
  1192.     private boolean pieLabelsOn;
  1193.     private int percentDecimalCount;
  1194.     private int selectionStyle;
  1195.     private boolean sliceSeperatorOn;
  1196.     private Color sliceSeperatorColor;
  1197.     private double detachedDistance;
  1198.     private Hashtable detachedSlices;
  1199.     private int percentLabelStyle;
  1200.     private int valueLabelStyle;
  1201.     private int seriesLabelStyle;
  1202.     private int sampleLabelStyle;
  1203.     private int selectedSample;
  1204.     private int selectedSeries;
  1205.     private double angles[][];
  1206.     private Rectangle pieBounds[];
  1207.     private Point pieCenter[];
  1208.     private int pieWidth[];
  1209.     private static final int PAINT_2D = 0;
  1210.     private static final int PAINT_3D = 1;
  1211.     private static final int PAINT_ALL = 2;
  1212. }