// Decompiled by Jad v1.5.7f. Copyright 2000 Pavel Kouznetsov. // Jad home page: http://www.geocities.com/SiliconValley/Bridge/8617/jad.html // Decompiler options: packimports(3) // Source File Name: DataVisualizerJ.java import java.applet.Applet; import java.awt.*; import java.io.*; import java.net.MalformedURLException; import java.net.URL; import java.util.Properties; public class DataVisualizerJ extends Applet implements DIV, LD2 { public void init() { llI1I = true; IIllI1 = "TimesRoman"; String stest[] = getToolkit().getFontList(); for(int ft = 0; ft < stest.length; ft++) { String nom = stest[ft]; if("Times New Roman".equals(nom)) IIllI1 = stest[ft]; } xTitle = new Font(IIllI1, 0, 10); bTitle = new Font(IIllI1, 1, 15); jTitle = new Font(IIllI1, 1, 12); ll1l1l = Color.getHSBColor(0.2F, 0.8F, 0.99F); Il1l11 = Color.getHSBColor(0.3F, 0.8F, 0.8F); lll1I1 = null; I1Ill1 = null; lll11l = null; lIl1I1(); I1 = new LX(); } synchronized boolean l1I11l(String IIlll1) throws Exception { String I11IlI[] = llI1II(IIlll1); if(I11IlI == null) { l11111(); return false; } FontMetrics fm = getFontMetrics(xTitle); int nlen = fm.charWidth('0'); int IIlIII = llllIl; int ll1IIl = II11l1; int l1Il11 = 75 / IIlIII; int I11I = Integer.parseInt(I11IlI[0]); int l1ll = I1lIII; IlllII = I11I; int I1lllI[] = lI11ll(I11I, l1ll, nlen); int l11l1I = I1lllI[0]; int ll1111 = I1lllI[1]; String IllI11 = I11IlI[1]; l1l1II = I11IlI[2]; I1I11I = I11IlI[3]; String I1IlII = I11IlI[4]; I1IlII = llIlll(I1IlII, l1Il11, false); IlI11l = I11IlI[6]; IlI11l = llIlll(IlI11l, l1Il11 + 1, false); II1IIl = I11I * l1ll; int lI1ll1 = 70; String l1I1ll[] = new String[I11I]; String I1l1Il[] = new String[l1ll]; int II1I = l1II1l = l1ll + I11I + 3; II1I += 2; IlIlI = new boolean[II1I]; for(int j = 0; j < II1I; j++) IlIlI[j] = false; lllI1I = II1I; II1I++; lIllll = II1I; String IllIII[] = new String[++II1I]; float lIlIl1[] = new float[l1ll]; int IlII = 0; IllIII[IlII] = "\u53CD\u8EE2"; IlII++; IllIII[IlII] = "\u5E73\u5747\u5024"; IlII++; IllIII[IlII] = "\u6BD4\u7387"; IlII++; int IIlI = 0; int Il1I = 0; int l11l1l[] = new int[II1IIl]; int Il1lIl = 0; int I11Ill = 0; int I1II = 0; lIIIll = "VERTICAL".equals(I11IlI[7]); if(lIIIll) II1lI1 = new DataBall(10, 1, I11I); else II1lI1 = new DataBall(19, 1, I11I); int llIII1 = 8; for(int llll = 0; llll < l1ll; llll++) { String llI11l = I11IlI[llIII1]; llIII1++; IllIII[IlII] = llIlll(llI11l, l1Il11, false); I1l1Il[llll] = llIlll(llI11l, l11l1I, true); int I111l1 = I1l1Il[llll].length(); Il1lIl = I111l1 <= Il1lIl ? Il1lIl : I111l1; IlII++; lIlIl1[llll] = (float)Integer.parseInt(I11IlI[llIII1]) / 100F; llIII1++; String l1111I = I11IlI[llIII1]; llIII1++; int lIIl = 0; for(int j = 0; j < I11I; j++) { l1111I = l1111I.substring(lIIl); int I1lI = l1111I.indexOf(","); if(I1lI == -1) throw new Exception(); int Il11II = Integer.parseInt(l1111I.substring(0, I1lI)); IIlI = IIlI <= Il11II ? Il11II : IIlI; I1II += Il11II; l11l1l[Il1I] = Il11II; Il1I++; lIIl = I1lI + 1; } } I11I1l = lIlIl1; IlIIl1 = I1II; String l1l1lI = I11IlI[5]; int lIll = 0; for(int lI1l = 0; lI1l < I11I; lI1l++) { l1l1lI = l1l1lI.substring(lIll); int l1Il = l1l1lI.indexOf(","); if(l1Il == -1) throw new Exception(); String IlI1ll = l1l1lI.substring(0, l1Il); IllIII[IlII] = llIlll(IlI1ll, l1Il11, false); l1I1ll[lI1l] = llIlll(IlI1ll, ll1111, true); int II11I1 = l1I1ll[lI1l].length(); I11Ill = II11I1 <= I11Ill ? I11Ill : II11I1; IlII++; lIll = l1Il + 1; } IllIII[IlII] = "\u5168\u30B0\u30E9\u30D5"; IlII++; int llII1l; if("auto".equals(IllI11)) llII1l = IIlI; else llII1l = Integer.parseInt(IllI11); Il1Ill = new int[3]; if(llII1l < 100) { Il1Ill[0] = 60; Il1Ill[1] = 10; Il1Ill[2] = 100; } else { String IlII11 = "" + llII1l; int lI1lll = (int)Math.pow(10D, IlII11.length() - 1); Il1Ill[1] = llII1l <= lI1lll * 2 ? lI1lll / 10 : lI1lll / 2; int ll1l = LX.lIll((float)llII1l / (float)Il1Ill[1]); Il1Ill[2] = (ll1l + 1) * Il1Ill[1]; Il1Ill[0] = (ll1l / 2 + 1) * Il1Ill[1]; } IllIII[IlII] = "" + Il1Ill[0]; IlII++; IllIII[IlII] = "plus " + Il1Ill[1]; IlII++; IllIII[IlII] = I1IlII; int I1I1Il = lIIIll ? 445 / l1ll : 445 / I11I; if(I1I1Il > 150) I1I1Il = 150; int Il1I1I = I1I1Il / IIlIII; I1ll1I = I1I1Il; int I1IIl1 = 0; l1lll1 = new III[II1IIl]; int llllI1 = I1I1Il + 80 + 10; int lIIlIl = 31; int l1ll1I = llllI1; int l11I1l = lIIlIl; int IIIIll; int llllII; if(lIIIll) { llllII = 14; IIIIll = 0; } else { llllII = 0; IIIIll = I1I1Il; } for(int l1ll11 = 0; l1ll11 < l1ll; l1ll11++) { for(int jj = 0; jj < I11I; jj++) { int l1Il1l = l11l1l[I1IIl1]; String II11ll; if(l1Il1l == -1) II11ll = "--"; else II11ll = "" + l1Il1l; if(l1Il1l > llII1l || II11ll.length() > Il1I1I) II11ll = "EX"; int II1llI = l1ll1I - II11ll.length() * IIlIII; l1lll1[I1IIl1] = new III(II11ll, l1Il1l, llII1l, lI1ll1, l1ll11, II1llI, l11I1l, ll1IIl); l11I1l += llllII; l1ll1I += IIIIll; I1IIl1++; } if(lIIIll) { l1ll1I += I1I1Il; l11I1l = lIIlIl; } else { l1ll1I = llllI1; l11I1l += 14; } } l1IllI = new short[6][36][II1IIl]; I1lI11 = new int[6][36][3]; lI1lI1 = LX.Ill(lIlll1[1], IllIl1[1], I1lI11, lI1ll1, 800, 230, 105, I11Ill * nlen, Il1lIl * nlen, 20); lIl1I = I1l1Il; II1lI1.Il = l1I1ll; lI11l = IllIII; IlIlIl = new Rectangle[II1I]; for(int i = 0; i < II1I; i++) IlIlIl[i] = new Rectangle(460, 7 + i * 14, 80, 14); if(lIIIll) II1lI1.l1(); return true; } public void start() { llI1I = true; String lI1111 = getDocumentBase().toString(); boolean ll11II = false; for(int Il11l1 = 0; (Il11l1 = lI1111.indexOf(".")) != -1; lI1111 = lI1111.substring(Il11l1 + 1)) { if(!IIIll.equals(lI1111.substring(0, Il11l1))) continue; ll11II = true; break; } if(!ll11II) { Il1III(); return; } l111l = true; II1II = true; l1l1I = true; l1I1Il = -1; Il1IlI = -1; lIIl1I = -1; String targ = getParameter("start"); String targName = getParameter("startName"); if(targ == null) targ = "front"; if(targName == null) targName = "Data Visualizer Demo"; else targName = llIlll(targName, 20, false); try { l1I11l(targ); } catch(Exception _ex) { Il1III(); } IllI1I.setColor(Color.black); IllI1I.fillRect(0, 0, 460, 310); lIlIlI.setColor(Color.black); lIlIlI.fillRect(0, 0, 85, 310); lI1II1.setColor(Color.darkGray); lI1II1.fillRect(0, 0, 545, 120); Ill1lI(IllI1I, Color.green, targName); int IlI1Il = lllI1I; for(int lI = 1; lI < IlI1Il; lI++) IlIlI[lI] = false; try { lll11l = new Starter(this); lll11l.start(); return; } catch(Exception _ex) { Il1III(); } } public void stop() { llI1I = true; if(lll1I1 != null) lll1I1.stop(); if(I1Ill1 != null) I1Ill1.stop(); if(lll11l != null) lll11l.stop(); lll1I1 = null; I1Ill1 = null; lll11l = null; l1lll1 = new III[1]; l1lll1 = null; System.gc(); } String[] llI1II(String targ) { String cheq = getParameter("type"); if("param".equals(cheq)) { String vst = getParameter("v"); int v = Integer.parseInt(vst); I1lIII = v; lIII1l = v + 3; String res[] = new String[8 + v * 3]; res[0] = getParameter("h"); res[1] = getParameter("max"); res[2] = getParameter("upper"); res[3] = getParameter("child"); res[4] = getParameter("upperName"); res[5] = getParameter("hItems"); res[6] = getParameter("title"); res[7] = getParameter("dir"); int c = 8; for(int i = 0; i < v; i++) { res[c] = getParameter("vNam" + i); c++; res[c] = getParameter("vcolor" + i); c++; res[c] = getParameter("vVal" + i); c++; } return res; } Properties prop = null; URL url; try { url = new URL(getCodeBase(), targ + ".txt"); } catch(MalformedURLException _ex) { return null; } try { InputStream is = url.openStream(); prop = new Properties(); prop.load(new BufferedInputStream(is, 2048)); is.close(); } catch(IOException _ex) { return null; } String vst = prop.getProperty("v"); int v = Integer.parseInt(vst); I1lIII = v; lIII1l = v + 3; String res[] = new String[8 + v * 3]; res[0] = prop.getProperty("h"); res[1] = prop.getProperty("max"); res[2] = prop.getProperty("upper"); res[3] = prop.getProperty("child"); res[4] = prop.getProperty("upperName"); res[5] = prop.getProperty("hItems"); res[6] = prop.getProperty("title"); res[7] = prop.getProperty("dir"); int c = 8; for(int i = 0; i < v; i++) { res[c] = prop.getProperty("vNam" + i); c++; res[c] = prop.getProperty("vcolor" + i); c++; res[c] = prop.getProperty("vVal" + i); c++; } return res; } final int IlI1lI(float Ill1Il, int comp) { int l1I1I1 = (int)(Ill1Il * 10000F); int I1l1ll = l1I1I1 % 100; l1I1I1 -= I1l1ll; if(Ill1Il > 0.0F && I1l1ll > comp) l1I1I1 += 100; return l1I1I1 / 100; } final String llIlll(String ss, int m, boolean trm) { String s = ss; int ml = m; for(int ex = -1; (ex = s.indexOf("_")) != -1;) s = s.substring(0, ex) + " " + s.substring(ex + 1); for(int ex = 0; (ex = s.indexOf("{")) != -1;) { if(ex + 2 > ml) { s = s.substring(0, ex); break; } ml--; int ed = s.substring(ex + 1).indexOf("}"); if(ed == -1) return "unknown"; ed += ex + 1; String sx = s.substring(ex + 1, ed); int res; try { res = Integer.parseInt(sx); } catch(Exception _ex) { return "unknown"; } int rH = res >> 8 & 0xff; byte rL[] = { (byte)(res & 0xff) }; String lt = new String(rL, rH); s = s.substring(0, ex) + lt + s.substring(ed + 1); } if(s.length() > ml) s = s.substring(0, ml); if(ml != m && trm) { int countM = m - ml; for(int cxx = 0; cxx < countM; cxx++) s = s + " "; } return s; } int[] lI11ll(int l1lIIl, int II1I1I, int l1IlII) { int l1I111; int I1l1II; if(l1lIIl >= II1I1I) { l1I111 = l1lIIl; I1l1II = II1I1I; } else { l1I111 = II1I1I; I1l1II = l1lIIl; } int Ill1l1 = l1I111 * 2 - 1; int lIl11l = 140 / Ill1l1; if(lIl11l > 12) lIl11l = 12; int ll11lI = lIl11l * Ill1l1; int Il11I1 = lIl11l * 2; int I111ll[][] = new int[2][l1I111]; int IlIIIl = Il11I1 * 2; for(int i = 0; i < l1I111; i++) { int IIlIlI = ll11lI - IlIIIl * i; I111ll[0][i] = IIlIlI; I111ll[1][i] = IIlIlI - Il11I1; } int l11III = 140 - I1l1II * lIl11l; int lI111I = I1l1II != 1 ? l11III / (I1l1II - 1) : 0; if(lI111I > Il11I1) lI111I = Il11I1; int l1llII = lIl11l * I1l1II + lI111I * (I1l1II - 1); int II1lll = lI111I * 2; int llI1Il[][] = new int[2][I1l1II]; int I1II1I = Il11I1 + II1lll; for(int i = 0; i < I1l1II; i++) { int IIlIlI = l1llII - I1II1I * i; llI1Il[0][i] = IIlIlI; llI1Il[1][i] = IIlIlI - Il11I1; } if(IlIIIl > 80) IlIIIl = 80; if(I1II1I > 80) I1II1I = 80; if(l1lIIl >= II1I1I) { lIlll1 = I111ll; IllIl1 = llI1Il; int I1llll[] = { I1II1I / l1IlII - 1, IlIIIl / l1IlII - 1 }; return I1llll; } else { lIlll1 = llI1Il; IllIl1 = I111ll; int I1llll[] = { IlIIIl / l1IlII - 1, I1II1I / l1IlII - 1 }; return I1llll; } } void Il1III() { llII11 = createImage(545, 430); IllI1I = llII11.getGraphics(); IllI1I.setColor(Color.black); IllI1I.fillRect(0, 0, 545, 430); Font tR = new Font("Courier", 1, 15); IllI1I.setFont(tR); IllI1I.setColor(Color.green); IllI1I.drawString("Format Error", 150, 120); IllI1I.drawString("Please submit bug report to nvl", 150, 140); } void l11111() { Font tR = new Font("Courier", 1, 15); IllI1I.setFont(tR); IllI1I.setColor(Color.white); IllI1I.drawString("\u63A5\u7D9A\u5931\u6557", 180, 200); IllI1I.setFont(xTitle); repaint(); } private final synchronized void II111I() { l1I1Il = -1; } private final synchronized void lll1Il() { I111l = false; } private final synchronized void IIIlII() { I111l = true; } private final synchronized void IlIII1(int Il1I) { Graphics nD = lIlIlI; int I11I = (Il1I - 7) / 14; l1I1Il = I11I; nD.setColor(Color.red); if(I11I != -1) nD.drawString(lI11l[I11I], 5, IlIlIl[I11I].y + 12); repaint(); } private final synchronized void l1l11l(int I1III1) { Graphics nD = lI1II1; int lI11I1 = (I1III1 - ll1I1I) / 14; lIIl1I = lI11I1; int yy = 14 * lIIl1I + 31; nD.setColor(Color.red); if(lI11I1 != -1) nD.drawString(lI11l[lI11I1 + lIII1l], 15, yy); repaint(); } void lII1ll(int I1III1, int x, int y) { if(llll1I.inside(x, y) && I1III1 == (y - ll1I1I) / 14) { llI1I = true; if(I1Ill1 != null) I1Ill1.stop(); I1Ill1 = null; lll1I1 = new TD2(this, I1III1, lI11l[I1III1 + lIII1l]); lll1I1.start(); return; } else { Graphics nD = lI1II1; int yy = 14 * I1III1 + 31; nD.setColor(Color.white); nD.drawString(lI11l[I1III1 + lIII1l], 15, yy); repaint(); lIIl1I = -1; return; } } synchronized void lIII11(int I1II, int llll, int lIIl, III I1l1lI[], Rectangle ll1III[], Graphics l1lIlI, Graphics II1II1, String lI11Il[], boolean l1I11I[], int lIl1ll) { if(!ll1III[I1II].inside(llll, lIIl)) { Color ll; if(I1II < 3 || I1II >= lIl1ll) ll = Color.white; else ll = l1I11I[I1II] ? Il1l11 : Color.white; II1II1.setColor(ll); } else { if(I1II > lIl1ll) { llI1I = true; if(I1Ill1 != null) I1Ill1.stop(); I1Ill1 = null; lll1I1 = new TD2(this, -1, lI11Il[I1II]); lll1I1.start(); return; } if(I1II == lIl1ll) { int llIIIl[] = Il1Ill; llIIIl[0] = (llIIIl[0] + llIIIl[1]) % llIIIl[2]; int IlII = I1II - 1; lI11Il[IlII] = "" + llIIIl[0]; II1II1.setColor(I11llI); II1II1.fillRect(0, ll1III[IlII].y, ll1III[IlII].width, ll1III[IlII].height); l1I11I[IlII] = false; II1II1.setColor(Color.white); II1II1.drawString(lI11Il[IlII], 5, ll1III[IlII].y + 12); } else if(I1II == 1) { if(IIll11(l1I11I[1], I1l1lI)) l1I11I[1] = !l1I11I[1]; l1I11I[2] = false; II1II1.setColor(Color.white); } else if(I1II == 2) { if(lllllI(l1I11I[2], I1l1lI)) l1I11I[2] = !l1I11I[2]; l1I11I[1] = false; II1II1.setColor(Color.white); } else if(I1II == 0) { Graphics nB = IllI1I; try { synchronized(II1lI1) { II1lI1.l1(); int I1lI = II1lI1.ll; int IllI = II1lI1.lI; lIIIII(l1IllI[IllI][I1lI], lI1lI1, I1lI11[IllI][I1lI], l1lll1, nB, lIl1I, I1lIII, Il1IlI, II1lI1, I11I1l, llIl1I); } } catch(Exception _ex) { brg(); } l1I11I[2] = false; if(l1I11I[1]) { nB.setColor(Color.white); nB.setFont(jTitle); nB.drawString(I1lIIl, 45, 160); nB.setFont(xTitle); } II1II1.setColor(Color.white); } else { int l1Il = II1IIl; int Ill1I1 = l1II1l; if(I1II < Ill1I1) { if(l1l1I) { l1lIlI.setColor(Color.white); for(int i = 0; i < l1Il; i++) if(I1l1lI[i].IIl) { I1l1lI[i].IIl = false; l1lIlI.drawString(I1l1lI[i].I1I, I1l1lI[i].l1l, I1l1lI[i].II1); } II1II1.setColor(Color.white); II1II1.drawString(lI11Il[Ill1I1], 5, ll1III[Ill1I1].y + 12); l1I11I[Ill1I1] = false; int II1I = Ill1I1 + 1; II1II1.drawString(lI11Il[II1I], 5, ll1III[II1I].y + 12); l1I11I[II1I] = false; Il1IlI = -1; l1l1I = false; } int lI1l = I1II - 3; int ll1l = I1lIII; int Il1I = IlllII; int lIll; int I11I; int l1ll; if(lI1l < ll1l) { lIll = lI1l * Il1I; I11I = 1; l1ll = Il1I; } else { lIll = lI1l - ll1l; I11I = Il1I; l1ll = ll1l; } boolean Il1lII = l1I11I[I1II]; Color IIlI = Il1lII ? Color.white : Il1l11; l1lIlI.setColor(IIlI); for(int i = 0; i < l1ll; i++) { if(I1l1lI[lIll].setSt(Il1lII)) l1lIlI.drawString(I1l1lI[lIll].I1I, I1l1lI[lIll].l1l, I1l1lI[lIll].II1); lIll += I11I; } II1II1.setColor(IIlI); l1I11I[I1II] = !Il1lII; if(Il1IlI != -1 && !I1l1lI[Il1IlI].IIl) Il1IlI = -1; l111l = false; } else if(I1II == Ill1I1) { l1lIlI.setColor(Color.white); for(int i = 0; i < l1Il; i++) { if(I1l1lI[i].IIl) l1lIlI.drawString(I1l1lI[i].I1I, I1l1lI[i].l1l, I1l1lI[i].II1); else I1l1lI[i].IlIl(); if(I1l1lI[i].lll) I1l1lI[i].lll = false; } l111l = true; l1l1I = true; Il1IlI = -1; } else if(I1II == Ill1I1 + 1) { int l11I1I = Il1Ill[0]; for(int i = 0; i < l1Il; i++) { if(I1l1lI[i].lll) I1l1lI[i].lll = false; if(I1l1lI[i].l11 >= l11I1I) { I1l1lI[i].IlIl(); l1lIlI.setColor(Il1l11); l1lIlI.drawString(I1l1lI[i].I1I, I1l1lI[i].l1l, I1l1lI[i].II1); } else if(I1l1lI[i].IIl) { I1l1lI[i].IIl = false; l1lIlI.setColor(Color.white); l1lIlI.drawString(I1l1lI[i].I1I, I1l1lI[i].l1l, I1l1lI[i].II1); } } l1l1I = true; l111l = false; Il1IlI = -1; } if(l1l1I) { II1II1.setColor(Color.white); int l1 = lIl1ll; for(int i = 3; i < l1; i++) { II1II1.drawString(lI11Il[i], 5, ll1III[i].y + 12); l1I11I[i] = false; } l1I11I[I1II] = true; II1II1.setColor(Il1l11); } l1I11I[1] = l1I11I[2] = false; int I1lI = II1lI1.ll; int IllI = II1lI1.lI; try { lIIIII(l1IllI[IllI][I1lI], lI1lI1, I1lI11[IllI][I1lI], l1lll1, IllI1I, lIl1I, I1lIII, Il1IlI, II1lI1, I11I1l, llIl1I); } catch(Exception _ex) { } } } II1II1.drawString(lI11Il[I1II], 5, ll1III[I1II].y + 12); II111I(); repaint(); } void brg() { System.out.println("This must be VM's bug. Please switch your VM to the other one !"); Graphics nD = IllI1I; nD.setColor(Color.black); nD.fillRect(0, 0, 460, 310); nD.setColor(Color.white); nD.drawString("Your current JVM is not capable to use this function", 40, 40); nD.drawString("To restart this Applet, please drag the mouse on this window.", 40, 55); repaint(); } private synchronized void IIl1ll(int IlIIlI, int I1III1) { Graphics llIlII = lI1II1; Graphics l11lll = IllI1I; int lI11I1; int ll11ll; if(lIIIll) { lI11I1 = (IlIIlI - 95) / I1ll1I; ll11ll = (I1III1 - ll1I1I) / 14; } else { lI11I1 = (I1III1 - ll1I1I) / 14; ll11ll = (IlIIlI - 95) / I1ll1I; } int II1I = Il1IlI; int l1I1l1 = lI11I1 * IlllII + ll11ll; III I1l11l = l1lll1[l1I1l1]; if(!I1l11l.IIl) return; Color l1ll = l111l ? Color.white : Il1l11; llIlII.setColor(l1ll); if(II1I == l1I1l1) { llIlII.drawString(I1l11l.I1I, I1l11l.l1l, I1l11l.II1); Il1IlI = -1; } else { if(II1I != -1) { III Ill11I = l1lll1[II1I]; llIlII.drawString(Ill11I.I1I, Ill11I.l1l, Ill11I.II1); } llIlII.setColor(ll1l1l); llIlII.drawString(I1l11l.I1I, I1l11l.l1l, I1l11l.II1); Il1IlI = l1I1l1; } int Il11Il = II1lI1.ll; int I11III = II1lI1.lI; try { lIIIII(l1IllI[I11III][Il11Il], lI1lI1, I1lI11[I11III][Il11Il], l1lll1, l11lll, lIl1I, I1lIII, Il1IlI, II1lI1, I11I1l, llIl1I); } catch(Exception _ex) { } if(IlIlI[1]) { l11lll.setColor(Color.white); l11lll.setFont(jTitle); l11lll.drawString(I1lIIl, 45, 160); l11lll.setFont(xTitle); } IlIlI[2] = false; repaint(); } boolean IIll11(boolean l11II1, III l1I1I1[]) { Graphics IlIllI = IllI1I; int ll1lll = II1lI1.ll; int Il1IIl = II1lI1.lI; try { lIIIII(l1IllI[Il1IIl][ll1lll], lI1lI1, I1lI11[Il1IIl][ll1lll], l1I1I1, IlIllI, lIl1I, I1lIII, Il1IlI, II1lI1, I11I1l, llIl1I); } catch(Exception _ex) { } if(l11II1) return true; int I11I1I = 0; int I1l1ll = 0; int II1l11 = II1IIl; for(int lI = 0; lI < II1l11; lI++) if(l1I1I1[lI].IIl) { I11I1I += l1I1I1[lI].l11; I1l1ll++; } if(I1l1ll == 0) return false; I1l1ll = LX.lIll((float)I11I1I / (float)I1l1ll); int llIIlI = IlI1lI((float)I11I1I / (float)IlIIl1, 45); String Ill1Il = "" + I11I1I; int l1ll1l = Ill1Il.length(); int IIlIl1 = (l1ll1l - 1) / 3; int I1II11 = l1ll1l - IIlIl1 * 3; try { for(int qq = 0; qq < IIlIl1; qq++) { Ill1Il = Ill1Il.substring(0, I1II11) + "," + Ill1Il.substring(I1II11); I1II11 += 4; } } catch(Exception _ex) { } String lIlIII = "" + I1l1ll; l1ll1l = lIlIII.length(); IIlIl1 = (l1ll1l - 1) / 3; I1II11 = l1ll1l - IIlIl1 * 3; try { for(int qq = 0; qq < IIlIl1; qq++) { lIlIII = lIlIII.substring(0, I1II11) + "," + lIlIII.substring(I1II11); I1II11 += 4; } } catch(Exception _ex) { } String lI1lII = "\u9078\u629E\u3055\u308C\u305F\u30C7\u30FC\u30BF\u306E\u5408\u8A08 : " + Ill1Il + " (" + llIIlI + "%)\uFF0F \u5E73\u5747\u5024 : " + lIlIII; IlIllI.setColor(Color.white); IlIllI.setFont(jTitle); IlIllI.drawString(lI1lII, 45, 160); IlIllI.setFont(xTitle); I1lIIl = lI1lII; return true; } boolean lllllI(boolean IlIl11, III Ill1ll[]) { Graphics IIlI11 = IllI1I; float Il1lll[] = I11I1l; int lI1III = II1lI1.ll; int ll1lII = II1lI1.lI; if(IlIl11) { try { lIIIII(l1IllI[ll1lII][lI1III], lI1lI1, I1lI11[ll1lII][lI1III], Ill1ll, IIlI11, lIl1I, I1lIII, Il1IlI, II1lI1, Il1lll, llIl1I); } catch(Exception _ex) { } } else { int llII1I = I1lIII; int l1I1lI[][] = new int[3][llII1I]; for(int j = 0; j < llII1I; j++) l1I1lI[1][j] = j; int I1IllI = II1IIl; int I11IIl = 0; for(int lI = 0; lI < I1IllI; lI++) if(Ill1ll[lI].IIl) { l1I1lI[0][Ill1ll[lI].IlI] += Ill1ll[lI].l11; I11IIl += Ill1ll[lI].l11; } if(I11IIl == 0) return false; try { lIIIII(l1IllI[ll1lII][lI1III], lI1lI1, I1lI11[ll1lII][lI1III], Ill1ll, IIlI11, lIl1I, llII1I, Il1IlI, II1lI1, Il1lll, l11lII); } catch(Exception _ex) { } for(int lI = 0; lI < llII1I; lI++) l1I1lI[2][lI] = IlI1lI((float)(l1I1lI[0][lI] * 10) / (float)I11IIl, 66); try { LX.Il1I(l1I1lI, 0, l1I1lI[0].length - 1); } catch(Exception _ex) { } int l1lII1 = 345; int II1l1l = 130; int l11IlI = 0; String lIl1Il[] = lI11l; IIlI11.setFont(nTitle); for(int lI = 0; lI < llII1I; lI++) if(l1I1lI[0][lI] != 0) { l11IlI = (int)(0.3F * (float)l1I1lI[2][lI]); l1lII1 -= l11IlI; IIlI11.setColor(Color.getHSBColor(Il1lll[l1I1lI[1][lI]], 0.78F, 0.65F)); IIlI11.drawLine(l1lII1, II1l1l, l1lII1, 160); IIlI11.fillRect(l1lII1, 160, l11IlI, 30); IIlI11.fillRect(l1lII1, II1l1l, 115, 14); IIlI11.setColor(Color.white); String I1l1I1 = " " + (float)l1I1lI[2][lI] / 10F; if((l11IlI = I1l1I1.indexOf(".")) != -1) I1l1I1 = I1l1I1.substring(0, l11IlI + 2); IIlI11.drawString(lIl1Il[l1I1lI[1][lI] + 3] + I1l1I1 + " %", l1lII1 + 2, II1l1l + 12); II1l1l -= 15; } IIlI11.setFont(xTitle); } return true; } public boolean handleEvent(Event e) { if(llI1I) return false; int x = e.x; int y = e.y; int et = e.id; switch(et) { case 503: case 504: default: break; case 501: if(IIlI1l.inside(x, y)) { ll111 = x / 12; Il111 = y / 12; synchronized(this) { II1II = false; } } else if(I1IIll.inside(x, y)) IlIII1(y); else if(llll1I.inside(x, y)) l1l11l(y); else if(Ill11.inside(x, y)) IIl1ll(x, y); return true; case 506: ll111 = x / 12; Il111 = y / 12; return true; case 502: case 505: if(II1II) { if(l1I1Il > -1) { lIII11(l1I1Il, x, y, l1lll1, IlIlIl, lI1II1, lIlIlI, lI11l, IlIlI, lllI1I); return true; } if(lIIl1I > -1) { lII1ll(lIIl1I, x, y); return true; } break; } synchronized(this) { II1II = true; } return true; } return false; } public void IIll11() { llI1I = false; do try { I1I1I1(lIl1I, lI1lI1, IllI1I, l1IllI, I1lI11, l1lll1, I11I1l, llIl1I); } catch(InterruptedException _ex) { } while(true); } void I1I1I1(String I1II[], int lIll[], Graphics IIlI, short llll[][][], int lIIl[][][], III l1Il[], float I1lI[], float IllI[]) throws InterruptedException { int I1l111; int Ill1II; do { if(!II1II) { I1l111 = ll111; Ill1II = Il111; break; } Thread.currentThread(); Thread.sleep(100L); } while(true); IIlI.clipRect(0, 0, 460, 310); IlIlI[1] = IlIlI[2] = false; DataBall IlII = II1lI1; int ll1l = Il1IlI; int l1ll = IlII.ll; int II1I = IlII.lI; int lI1l = I1lIII; int Il1I[][] = new int[4][2]; label0: while(!II1II) { Il1I[0][0] = ll111; Il1I[0][1] = Il111; Il1I[1][0] = Il1I[0][0] - I1l111; Il1I[1][1] = Il1I[0][1] - Ill1II; Il1I[2][0] = Math.abs(Il1I[1][0]); Il1I[2][1] = Math.abs(Il1I[1][1]); if(Il1I[2][0] * 2 < Il1I[2][1]) Il1I[2][0] = 0; if(Il1I[2][1] * 2 < Il1I[2][0]) Il1I[2][1] = 0; if(Il1I[2][0] != 0) Il1I[3][0] = (Il1I[1][0] * IlII.II) / Il1I[2][0]; else Il1I[3][0] = 0; if(Il1I[2][1] != 0) Il1I[3][1] = Il1I[1][1] / Il1I[2][1]; else Il1I[3][1] = 0; if(Il1I[3][1] == 0 && Il1I[3][0] == 0) { Thread.currentThread(); Thread.sleep(20L); continue; } do { if(II1I == 0 && Il1I[3][1] < 0 || II1I == 5 && Il1I[3][1] > 0) Il1I[3][1] = 0; if(Il1I[2][1] <= 0) Il1I[3][1] = 0; Il1I[2][1] = Il1I[2][1] - 1; if(II1II) break label0; l1ll = (l1ll + 36 + Il1I[3][0]) % 36; II1I += Il1I[3][1]; lll1Il(); synchronized(IlII) { try { lIIIII(llll[II1I][l1ll], lIll, lIIl[II1I][l1ll], l1Il, IIlI, I1II, lI1l, ll1l, IlII, I1lI, IllI); } catch(Exception _ex) { } IlII.ll = l1ll; IlII.lI = II1I; } repaint(); Thread.currentThread(); Thread.sleep(40L); I1l111 = Il1I[0][1] - Il111; Ill1II = (ll111 - Il1I[0][0]) * IlII.II; } while((I1l111 * Il1I[3][1] > 0 || I1l111 == 0) && (Ill1II * Il1I[3][0] > 0 || Ill1II == 0)); I1l111 = Il1I[0][0]; Ill1II = Il1I[0][1]; } } private final synchronized void lIIIII(short I1IIII[], int I1111l[], int Il11l1[], III l11I1l[], Graphics nD, String l111lI[], int lIll, int lIlI11, DataBall IlII, float ll11II[], float lI1111[]) throws Exception { int ll1ll1 = II1IIl; int l1Il = IlII.II; Color IIIIl1 = IIII11; nD.setColor(Color.black); nD.fillRect(0, 0, 460, 310); int I1lI = Il11l1[IlII.I]; do { int IllI = I1111l[I1lI]; if(IllI == -30) break; String llI11I; if(IllI >= 0) llI11I = IlII.Il[IllI]; else llI11I = l111lI[lIll + IllI]; I1lI++; int I1ll11 = I1111l[I1lI]; I1lI++; int llll = I1111l[I1lI]; I1lI++; int lIIl = I1111l[I1lI]; nD.setColor(Color.getHSBColor(0.3F, ((float)I1ll11 * lI1111[0]) / 160F, (float)I1ll11 / 100F)); nD.drawString(llI11I, llll, lIIl); I1lI++; } while(true); for(int IIlI = 0; IIlI < ll1ll1; IIlI++) { int l1ll1I = I1IIII[IIlI]; float lI1Il1 = l1ll1I != lIlI11 ? 0.0F : 0.2F; III I1II = l11I1l[l1ll1I]; int lI1l = Il11l1[0]; float I11I = ll11II[I1II.IlI]; boolean IlI1Il = I1II.IIl; short Il1lI1[][] = I1II.lI; boolean l1l1I1 = false; int I11lIl[] = new int[4]; int llIIll[] = new int[4]; int Il1I[] = { lI1l + 5, lI1l + 8, lI1l + 11, lI1l + 2 }; for(int l1ll = 0; l1ll < 4; l1ll++) { int II11ll = Il1lI1[0][lI1l]; int II1I = Il1lI1[1][lI1l]; int ll1l = ++lI1l + 1; int IIIl11 = (l1ll + 1) % 4; I11lIl[IIIl11] = Il1lI1[0][ll1l] * l1Il + 230; llIIll[IIIl11] = Il1lI1[1][ll1l]; if(II11ll == 0 && IlI1Il) lI1l += 2; else if(II11ll == -1 && IlI1Il) { l1l1I1 = true; lI1l += 2; } else { int IIllII[] = { Il1lI1[0][lI1l] * l1Il + 230, Il1lI1[0][ll1l] * l1Il + 230, Il1lI1[0][Il1I[l1ll]] * l1Il + 230, Il1lI1[0][Il1I[l1ll] - 1] * l1Il + 230 }; int llllll[] = { Il1lI1[1][lI1l], Il1lI1[1][ll1l], Il1lI1[1][Il1I[l1ll]], Il1lI1[1][Il1I[l1ll] - 1] }; if(IlI1Il) { Color l1Il1l = Color.getHSBColor(I11I, lI1111[1], (float)II1I / 100F + lI1Il1); nD.setColor(l1Il1l); nD.fillPolygon(IIllII, llllll, 4); nD.setColor(IIIIl1); nD.drawPolygon(IIllII, llllll, 4); } else { Color l1Il1l = Color.getHSBColor(I11I, lI1111[2], 0.5F); nD.setColor(l1Il1l); nD.drawPolygon(IIllII, llllll, 4); } lI1l += 2; } } if(l1l1I1) { Color IllllI = Color.getHSBColor(I11I, lI1111[2], 0.78F + lI1Il1); nD.setColor(IllllI); nD.fillPolygon(I11lIl, llIIll, 4); nD.setColor(IIIIl1); nD.drawPolygon(I11lIl, llIIll, 4); } } IIIlII(); } public void update(Graphics g) { boolean painted = false; synchronized(this) { painted = I111l; } if(painted) paint(g); } public void paint(Graphics g) { if(llII11 != null) g.drawImage(llII11, 0, 0, this); } public void l111l1(int IIlIl1, String lI1lII) { boolean l1ll1l = IIlIl1 != -1; boolean II1l11 = I1I11I.equals("non") && l1ll1l || l1l1II.equals("non") && !l1ll1l; IIIlII(); try { if(II1l11) { Graphics nD = IllI1I; nD.setColor(Color.white); nD.setFont(bTitle); nD.drawString("\u767B\u9332\u3055\u308C\u3066\u307E\u305B\u3093", 150, 130); nD.setFont(xTitle); if(l1ll1l) { int I1II11 = 14 * lIIl1I + 31; lI1II1.setColor(Color.white); lI1II1.drawString(lI11l[lIIl1I + lIII1l], 15, I1II11); } else { lIlIlI.setColor(Color.white); lIlIlI.drawString(lI11l[l1I1Il], 5, IlIlIl[l1I1Il].y + 12); } repaint(); Thread.currentThread(); Thread.sleep(250L); } else { if(IlIlI[1] || IlIlI[2]) { int IlIllI = II1lI1.ll; int I1II11 = II1lI1.lI; lIIIII(l1IllI[I1II11][IlIllI], lI1lI1, I1lI11[I1II11][IlIllI], l1lll1, IllI1I, lIl1I, I1lIII, Il1IlI, II1lI1, I11I1l, llIl1I); } Ill1lI(IllI1I, Color.white, lI1lII); repaint(); Thread.currentThread(); Thread.sleep(50L); String tarSt = l1ll1l ? I1I11I + lIIl1I : l1l1II; if(l1I11l(tarSt)) { IllI1I.setColor(Color.white); I1l11I(I1lIII, IlllII, IllIl1, lIlll1, l1lll1, l1IllI, I1lI11, IllI1I); IllI1I.fillRect(180, 160, 120, 15); lIlIlI.setColor(Color.black); lIlIlI.fillRect(0, 0, 85, 310); lI1II1.setColor(Color.darkGray); lI1II1.fillRect(0, 0, 545, 120); repaint(); Thread.currentThread(); Thread.sleep(50L); l111l = true; II1II = true; l1l1I = true; Il1IlI = -1; ll11Il(l1lll1, lI1II1, lIlIlI, I11I1l, I1ll1I); } else { if(l1ll1l) { int I1II11 = 14 * lIIl1I + 31; lI1II1.setColor(Color.white); lI1II1.drawString(lI11l[lIIl1I + lIII1l], 15, I1II11); } else { lIlIlI.setColor(Color.white); lIlIlI.drawString(lI11l[l1I1Il], 5, IlIlIl[l1I1Il].y + 12); } Thread.currentThread(); Thread.sleep(500L); } } IlIlI[1] = IlIlI[2] = false; int ll1lll = II1lI1.ll; int Il1IIl = II1lI1.lI; l1I1Il = -1; lIIl1I = -1; lIIIII(l1IllI[Il1IIl][ll1lll], lI1lI1, I1lI11[Il1IIl][ll1lll], l1lll1, IllI1I, lIl1I, I1lIII, Il1IlI, II1lI1, I11I1l, llIl1I); repaint(); Thread.currentThread(); Thread.sleep(100L); I1Ill1 = new SD(this); I1Ill1.start(); return; } catch(Exception _ex) { l11111(); } } public void I1Il1l() { IIIlII(); try { int ll1lll = II1lI1.ll; int Il1IIl = II1lI1.lI; repaint(); Thread.currentThread(); Thread.sleep(50L); IllI1I.setColor(Color.green); I1l11I(I1lIII, IlllII, IllIl1, lIlll1, l1lll1, l1IllI, I1lI11, IllI1I); ll11Il(l1lll1, lI1II1, lIlIlI, I11I1l, I1ll1I); lIIIII(l1IllI[Il1IIl][ll1lll], lI1lI1, I1lI11[Il1IIl][ll1lll], l1lll1, IllI1I, lIl1I, I1lIII, Il1IlI, II1lI1, I11I1l, llIl1I); repaint(); Thread.currentThread(); Thread.sleep(100L); } catch(Exception _ex) { } I1Ill1 = new SD(this); I1Ill1.start(); } private synchronized void lIl1I1() { resize(545, 430); llII11 = createImage(545, 430); IllI1I = llII11.getGraphics(); nTitle = new Font(IIllI1, 0, 12); FontMetrics fm = getFontMetrics(nTitle); llllIl = fm.charWidth('0'); II11l1 = fm.charWidth(','); lIlIlI = IllI1I.create(460, 0, 85, 310); lIlIlI.clipRect(0, 0, 85, 310); lIlIlI.setFont(nTitle); ll1I1I = 329; int cff = 120; lI1II1 = IllI1I.create(0, 310, 545, cff); lI1II1.clipRect(0, 0, 545, cff); lI1II1.setFont(nTitle); IllI1I.clipRect(0, 0, 460, 310); IllI1I.setFont(xTitle); ll1I1I++; } void Ill1lI(Graphics nD, Color cl, String tarT) { Font tR = new Font(IIllI1, 1, 15); FontMetrics ftR = getFontMetrics(tR); int ftLen = ftR.charWidth('0'); String ttS = "\u30C7\u30FC\u30BF\u540D : " + tarT; int fstt = 240 - (ttS.length() / 2 + 3) * ftLen; nD.setFont(tR); nD.setColor(cl); nD.drawString(ttS, fstt, 120); nD.drawString(" - Formating -", 190, 140); nD.drawRect(180, 160, 120, 15); nD.setFont(xTitle); } void ll11Il(III ll1Ill[], Graphics nD, Graphics nL, float lI1lIl[], int Il1I1l) throws Exception { int lIllI1 = I1lIII; int Illll1 = IlllII; String I1lIl1[] = lI11l; Rectangle l1II11[] = IlIlIl; int I1lI = 0; int lI1l = 42; nL.setColor(Color.getHSBColor(0.6F, 0.4F, 0.5F)); nL.fillRect(0, 7, 80, lI1l); nL.setColor(Color.white); for(int i = 0; i < 3; i++) { nL.drawString(I1lIl1[I1lI], 5, l1II11[I1lI].y + 12); I1lI++; } repaint(); Thread.currentThread(); Thread.sleep(50L); int IllI = 14 * lIllI1; lI1l += 7; nL.setColor(Color.getHSBColor(0.1F, 0.4F, 0.5F)); nL.fillRect(0, lI1l, 80, IllI); nL.setColor(Color.white); for(int i = 0; i < lIllI1; i++) { nL.drawString(I1lIl1[I1lI], 5, l1II11[I1lI].y + 12); I1lI++; } repaint(); Thread.currentThread(); Thread.sleep(50L); lI1l += IllI; IllI = 14 * Illll1; nL.setColor(Color.getHSBColor(0.8F, 0.4F, 0.5F)); nL.fillRect(0, lI1l, 80, IllI); nL.setColor(Color.white); for(int i = 0; i < Illll1; i++) { nL.drawString(I1lIl1[I1lI], 5, l1II11[I1lI].y + 12); I1lI++; } repaint(); Thread.currentThread(); Thread.sleep(50L); lI1l += IllI; IllI = 42; I11llI = Color.getHSBColor(0.4F, 0.4F, 0.5F); nL.setColor(I11llI); nL.fillRect(0, lI1l, 80, IllI); nL.setColor(Color.white); for(int i = 0; i < 3; i++) { nL.drawString(I1lIl1[I1lI], 5, l1II11[I1lI].y + 12); I1lI++; } repaint(); Thread.currentThread(); Thread.sleep(50L); lI1l += IllI; if(l1l1II.equals("non")) nL.setColor(Color.getHSBColor(0.8F, 0.0F, 0.5F)); else nL.setColor(Color.getHSBColor(0.0F, 0.6F, 0.5F)); nL.fillRect(0, lI1l, 80, 14); nL.setColor(Color.white); nL.drawString(I1lIl1[I1lI], 5, l1II11[I1lI].y + 12); repaint(); Thread.currentThread(); Thread.sleep(50L); nD.setColor(Color.white); nD.drawString(IlI11l, 5, 12); int Il1I; int l1IIl1; if(lIIIll) { Il1I = 3; l1IIl1 = lIllI1; } else { Il1I = lIII1l; l1IIl1 = Illll1; } int lIll = 95; int I11I = 17; int lengTemp = 115; for(int i = 0; i < l1IIl1; i++) { if(lIIIll) { nD.setColor(Color.getHSBColor(lI1lIl[i], 0.6F, 0.5F)); nD.fillRect(lIll, 5, Il1I1l, 14); nD.setColor(Color.white); } nD.drawString(I1lIl1[Il1I], lIll + 5, I11I); nD.drawLine(lIll, 5, lIll, lengTemp); lIll += Il1I1l; Il1I++; } int I11l1I; if(!lIIIll) { Il1I = 3; I11l1I = lIllI1; } else { Il1I = lIII1l; I11l1I = Illll1; } I11I = 31; int l1ll = 19; for(int i = 0; i < I11l1I; i++) { if(!lIIIll) { nD.setColor(Color.getHSBColor(lI1lIl[i], 0.6F, 0.5F)); nD.fillRect(10, l1ll, 80, 14); nD.setColor(Color.white); } String nSt = I1lIl1[Il1I]; nD.drawString(nSt, 15, I11I); I11I += 14; l1ll += 14; Il1I++; } int t = II1IIl; for(int i = 0; i < t; i++) { nD.drawString(ll1Ill[i].I1I, ll1Ill[i].l1l, ll1Ill[i].II1); if(ll1Ill[i].IlI1) ll1Ill[i].I1I = ""; } repaint(); Thread.currentThread(); Thread.sleep(50L); IIlI1l = new Rectangle(0, 0, 460, 310); I1IIll = new Rectangle(460, 7, 80, 14 * (lIllll + 1)); Ill11 = new Rectangle(95, ll1I1I, Il1I1l * l1IIl1, 14 * I11l1I); llll1I = new Rectangle(10, ll1I1I, 80, 14 * I11l1I); lIII1l = lIIIll ? lIII1l : 3; } void I1l11I(int lIIll, int lllII, int II11Il[][], int IlIIII[][], III llII1l[], short l1I1ll[][][], int lllIIl[][][], Graphics nD) throws InterruptedException { int Il1I1I = -3; int II1llI = lllII; int IlII11 = lIIll; int I11Ill = 105; int lI1ll1 = 70; int lIl111 = 0; int lIll = II1IIl - 1; for(int l1Il = 0; l1Il < 6; l1Il++) { nD.fillRect(180, 160, l1Il * 20, 15); repaint(); Thread.currentThread(); Thread.sleep(50L); int ll1IIl = 0; int I1lI = 0; float Il111l = LX.lI1l(Il1I1I); float I1111I = LX.ll1l(Il1I1I); float I1l1Il = (float)lI1ll1 * I1111I; float IllIII = (float)lI1ll1 * Il111l; float IIlll1 = 800F * -Il111l; for(int IllI = 0; IllI < 10; IllI++) { float llI1lI = LX.lI1l(ll1IIl); float l111I1 = LX.ll1l(ll1IIl); boolean l1Il11[][] = new boolean[II1llI][2]; short I1IlII[] = new short[4]; short I1lllI[][] = new short[3][IlII11 * II1llI]; for(int lI1l = 0; lI1l < 4; lI1l++) { I1IlII[lI1l] = l1llll[I1lI]; I1lI = (I1lI + 9) % 36; } float l11l1I[][][] = new float[II1llI][2][3]; int ll1l = II1llI - 1; int IllI11 = LX.lIll(800F * I1111I * -llI1lI); for(int Il1I = 0; Il1I < II1llI; Il1I++) { int ll1lI1 = IlIIII[0][Il1I]; l11l1I[Il1I][0][1] = (float)ll1lI1 * Il111l * -llI1lI; l11l1I[Il1I][0][2] = (float)ll1lI1 * l111I1; l11l1I[Il1I][0][0] = (float)ll1lI1 * I1111I * -llI1lI; l1Il11[Il1I][0] = ll1lI1 < IllI11; l11l1I[ll1l][1][0] = -l11l1I[Il1I][0][0]; l11l1I[ll1l][1][1] = -l11l1I[Il1I][0][1]; l11l1I[ll1l][1][2] = -l11l1I[Il1I][0][2]; l1Il11[ll1l][1] = -ll1lI1 > IllI11; ll1l--; } int l1ll = 0; boolean IIllll = IllI == 0 || IllI == 9; int l1l1ll = lIl111 + (432 - IllI * 24); IllI11 = LX.lIll(800F * I1111I * l111I1); float lIlIl1[][] = new float[2][3]; for(int IlII = 0; IlII < IlII11; IlII++) { int Il1lIl = II11Il[0][IlII]; lIlIl1[0][1] = (float)Il1lIl * Il111l * l111I1; lIlIl1[0][2] = (float)Il1lIl * llI1lI; lIlIl1[0][0] = (float)Il1lIl * I1111I * l111I1; boolean lIllII = Il1lIl < IllI11; Il1lIl = II11Il[1][IlII]; lIlIl1[1][1] = (float)Il1lIl * Il111l * l111I1; lIlIl1[1][2] = (float)Il1lIl * llI1lI; lIlIl1[1][0] = (float)Il1lIl * I1111I * l111I1; boolean lI1lll = Il1lIl > IllI11; int II1I = l1ll + II1llI; for(int I1II = 0; I1II < II1llI; I1II++) { II1I--; III I11IlI = llII1l[l1ll]; III llIII1 = llII1l[lIll - l1ll]; III l11l1l = llII1l[II1I]; III l1ll11 = llII1l[lIll - II1I]; boolean I1IIl1[] = { lIllII, l1Il11[I1II][0], lI1lll, l1Il11[I1II][1] }; if(IIllll) LX.I1l(lIlIl1, l11l1I[I1II], I11IlI, llIII1, Il111l, I1111I, IllIII, I1l1Il, I11Ill, 800, lIl111, I1IIl1, I1IlII, IIlll1); else LX.l1Il(lIlIl1, l11l1I[I1II], I11IlI, llIII1, l11l1l, l1ll11, Il111l, I1111I, IllIII, I1l1Il, I11Ill, 800, lIl111, l1l1ll, I1IIl1, I1IlII, IIlll1); float lI11II = lIlIl1[0][2] + l11l1I[I1II][0][2]; float ll11l1 = lIlIl1[0][0] + l11l1I[I1II][0][0]; ll11l1 = 800F - ll11l1; I1lllI[0][l1ll] = (short)(int)Math.sqrt(lI11II * lI11II + ll11l1 * ll11l1); I1lllI[1][l1ll] = (short)l1ll; I1lllI[2][l1ll] = (short)II1I; l1ll++; } } try { II1IlI(I1lllI, 0, I1lllI[0].length - 1); } catch(Exception _ex) { } l1I1ll[l1Il][IllI] = I1lllI[1]; l1I1ll[l1Il][IllI + 18] = l1lI1I(I1lllI[1]); lllIIl[l1Il][IllI][0] = lIl111; lllIIl[l1Il][IllI + 18][0] = lIl111 + 216; if(!IIllll) { int I11I = 36 - IllI; l1I1ll[l1Il][I11I] = I1lllI[2]; l1I1ll[l1Il][I11I - 18] = l1lI1I(I1lllI[2]); lllIIl[l1Il][I11I][0] = l1l1ll; lllIIl[l1Il][I11I - 18][0] = l1l1ll - 216; } lIl111 += 12; ll1IIl += 10; I1lI++; } lIl111 += 312; Il1I1I += 10; } l1IllI = l1I1ll; I1lI11 = lllIIl; System.gc(); } final short[] l1lI1I(short II1I[]) { int IIlI = II1I.length; short IlII[] = new short[IIlI]; int I1II = IIlI - 1; for(int i = 0; i < IIlI; i++) { IlII[i] = II1I[I1II]; I1II--; } return IlII; } final void II1IlI(short ll1l[][], int I1lI, int l1Il) throws Exception { int lI1l = I1lI; int lIll = l1Il; if(l1Il > I1lI) { int IllI = ll1l[0][(I1lI + l1Il) / 2]; while(lI1l <= lIll) { while(lI1l < l1Il && ll1l[0][lI1l] > IllI) lI1l++; for(; lIll > I1lI && ll1l[0][lIll] < IllI; lIll--); if(lI1l <= lIll) { short Il1I = ll1l[0][lI1l]; short I11I = ll1l[1][lI1l]; short l1ll = ll1l[2][lI1l]; ll1l[0][lI1l] = ll1l[0][lIll]; ll1l[1][lI1l] = ll1l[1][lIll]; ll1l[2][lI1l] = ll1l[2][lIll]; ll1l[0][lIll] = Il1I; ll1l[1][lIll] = I11I; ll1l[2][lIll] = l1ll; lI1l++; lIll--; } } if(I1lI < lIll) II1IlI(ll1l, I1lI, lIll); if(lI1l < l1Il) II1IlI(ll1l, lI1l, l1Il); } } public DataVisualizerJ() { IIIll = "win"; } private short l1IllI[][][]; private int I1lI11[][][]; private int IllIl1[][]; private int lIlll1[][]; private int lI1lI1[]; private int Il1Ill[]; private float I11I1l[]; private float llIl1I[] = { 1.0F, 0.76F, 0.45F }; private float l11lII[] = { 0.0F, 0.0F, 0.0F }; private byte l1llll[] = { 67, 67, 66, 65, 64, 62, 60, 58, 55, 52, 49, 46, 44, 42, 40, 38, 38, 37, 37, 37, 38, 38, 40, 42, 44, 46, 49, 52, 55, 58, 60, 62, 64, 65, 66, 67 }; private int II1IIl; private int l1I1Il; private int I1lIII; private int IlllII; private int lIllll; private int ll1I1I; private int Il1IlI; private int I1ll1I; private int l1II1l; private int llllIl; private int II11l1; private int lIIl1I; private int lllI1I; private int lIII1l; double IlIIl1; LX I1; private SD I1Ill1; private TD2 lll1I1; private Starter lll11l; private String IIllI1; private String I1lIIl; private String l1l1II; private String I1I11I; private String IlI11l; private String IIIll; private Graphics IllI1I; private Graphics lIlIlI; private Graphics lI1II1; private Color ll1l1l; private Color Il1l11; private Color I11llI; private final Color IIII11 = Color.getHSBColor(0.8F, 0.1F, 0.4F); private Image llII11; private static final float l11Il1 = 0.78F; private III l1lll1[]; private DataBall II1lI1; private Rectangle IlIlIl[]; private Rectangle I1IIll; private Rectangle IIlI1l; private Rectangle Ill11; private Rectangle llll1I; private String lIl1I[]; private String lI11l[]; private Font xTitle; private Font bTitle; private Font jTitle; private Font nTitle; private volatile int ll111; private volatile int Il111; private boolean I111l; private boolean llI1I; private boolean l111l; private boolean l1l1I; private boolean lIIIll; private volatile boolean II1II; private boolean IlIlI[]; private final int I1Ill = 460; private final int IIlII = 230; private final int l1Ill1 = 800; private final int I1llI1 = 545; private final int lIlIll = 7; private final int lI1I1l = 80; private final int ll1l1I = 14; private final int IIII1l = 12; private final int III1lI = 140; private final int IIl1lI = 95; private final int IIlII1 = 70; private final int I1IIlI = 105; private final int IlII1I = 310; private final int lI1IIl = 430; }