mirror of
https://github.com/johndoe6345789/tustu.git
synced 2026-05-03 10:04:56 +00:00
2864 lines
106 KiB
Java
2864 lines
106 KiB
Java
package com.efiAnalytics.apps.ts.dashboard;
|
|
|
|
import C.ExceptionInVPackage;
|
|
import G.R;
|
|
import G.T;
|
|
import G.GInterfaceAf;
|
|
import G.GInterfaceAg;
|
|
import G.GInterfaceAh;
|
|
import G.Exceptionprintstacktrace;
|
|
import G.AeInterfaceMikeTostring;
|
|
import G.GComponentCq;
|
|
import G.ManagerUsingArrayList;
|
|
import G.RInterfaceIndia;
|
|
import I.ArrayListInIPackage;
|
|
import I.IInterfaceDelta;
|
|
import K.ArrayListInIPackage;
|
|
import V.ExceptionInVPackage;
|
|
import V.ExceptionPrintstacktrace;
|
|
import W.WInterfaceAp;
|
|
import aE.ExceptionInVPackage;
|
|
import bH.A;
|
|
import bH.D;
|
|
import bH.J;
|
|
import bH.K;
|
|
import bH.S;
|
|
import bH.X;
|
|
import bH.aa;
|
|
import bH.RInterfacePapa;
|
|
import bz.ManagerPreferredlayoutsize;
|
|
import com.efiAnalytics.apps.ts.dashboard.renderers.GaugePainter;
|
|
import com.efiAnalytics.apps.ts.dashboard.renderers.IndicatorPainter;
|
|
import com.efiAnalytics.apps.ts.dashboard.renderers.e;
|
|
import com.efiAnalytics.ui.ExceptionInVPackage;
|
|
import com.efiAnalytics.ui.bV;
|
|
import com.efiAnalytics.ui.ba;
|
|
import com.efiAnalytics.ui.bc;
|
|
import com.efiAnalytics.ui.bq;
|
|
import com.efiAnalytics.ui.br;
|
|
import com.efiAnalytics.ui.ct;
|
|
import com.efiAnalytics.ui.dQ;
|
|
import com.efiAnalytics.ui.dR;
|
|
import com.efiAnalytics.ui.dn;
|
|
import com.efiAnalytics.ui.eJ;
|
|
import com.efiAnalytics.ui.et;
|
|
import IInterfaceDelta.IInterfaceDelta;
|
|
import IInterfaceDelta.e;
|
|
import IInterfaceDelta.ExceptionPrintstacktrace;
|
|
import RInterfaceIndia.ExceptionInVPackage;
|
|
import RInterfaceIndia.ArrayListInIPackage;
|
|
import RInterfaceIndia.IComponentJuliet;
|
|
import java.awt.AlphaComposite;
|
|
import java.awt.BasicStroke;
|
|
import java.awt.BorderLayout;
|
|
import java.awt.Color;
|
|
import java.awt.Component;
|
|
import java.awt.Container;
|
|
import java.awt.Dimension;
|
|
import java.awt.Font;
|
|
import java.awt.FontMetrics;
|
|
import java.awt.GradientPaint;
|
|
import java.awt.Graphics;
|
|
import java.awt.Graphics2D;
|
|
import java.awt.GraphicsConfiguration;
|
|
import java.awt.GraphicsDevice;
|
|
import java.awt.GraphicsEnvironment;
|
|
import java.awt.Image;
|
|
import java.awt.LayoutManager;
|
|
import java.awt.MouseInfo;
|
|
import java.awt.Point;
|
|
import java.awt.Rectangle;
|
|
import java.awt.RenderingHints;
|
|
import java.awt.Stroke;
|
|
import java.awt.Toolkit;
|
|
import java.awt.Window;
|
|
import java.awt.geom.AffineTransform;
|
|
import java.awt.geom.Area;
|
|
import java.awt.geom.Point2D;
|
|
import java.io.File;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Vector;
|
|
import java.util.logging.Level;
|
|
import java.util.logging.Logger;
|
|
import javax.swing.JCheckBoxMenuItem;
|
|
import javax.swing.JComponent;
|
|
import javax.swing.JDialog;
|
|
import javax.swing.JMenu;
|
|
import javax.swing.JMenuItem;
|
|
import javax.swing.JOptionPane;
|
|
import javax.swing.JPanel;
|
|
import javax.swing.JPopupMenu;
|
|
import r.ExceptionInVPackage;
|
|
import r.ManagerPreferredlayoutsize;
|
|
import r.RInterfaceIndia;
|
|
import r.IComponentJuliet;
|
|
import r.RComponentMike;
|
|
import r.RInterfaceOscar;
|
|
import r.RInterfacePapa;
|
|
import s.ExceptionPrintstacktrace;
|
|
import t.ThreadedInTPackage;
|
|
import t.w;
|
|
import v.ArrayListInIPackage;
|
|
|
|
public class x extends JComponent implements GInterfaceAf, GInterfaceAg, ac, bc {
|
|
private Image ThreadedInTPackage = null;
|
|
|
|
private Image Exceptionprintstacktrace = null;
|
|
|
|
private Image al = null;
|
|
|
|
Color ExceptionInVPackage = new Color(0, 255, 0, 0);
|
|
|
|
Vector ManagerPreferredlayoutsize = new Vector();
|
|
|
|
long ArrayListInIPackage = System.currentTimeMillis();
|
|
|
|
double IInterfaceDelta = 0.0D;
|
|
|
|
float e = 1.0F;
|
|
|
|
X f = null;
|
|
|
|
W ExceptionPrintstacktrace = new W(this);
|
|
|
|
Q h = new Q(this);
|
|
|
|
private int am = eJ.ExceptionInVPackage(7);
|
|
|
|
private Window an = null;
|
|
|
|
private Container ao = null;
|
|
|
|
boolean RInterfaceIndia = false;
|
|
|
|
private String WInterfaceAp = "";
|
|
|
|
private Image aq = null;
|
|
|
|
private String ar = null;
|
|
|
|
private Dimension as = null;
|
|
|
|
private boolean at = false;
|
|
|
|
private T au = null;
|
|
|
|
private boolean av = true;
|
|
|
|
private boolean aw = false;
|
|
|
|
WInterfaceAp IComponentJuliet = null;
|
|
|
|
private boolean ax = false;
|
|
|
|
private boolean ay = false;
|
|
|
|
R k = null;
|
|
|
|
private boolean az = false;
|
|
|
|
S l = null;
|
|
|
|
private boolean aA = false;
|
|
|
|
private Z aB = null;
|
|
|
|
private Z aC = null;
|
|
|
|
private String aD = null;
|
|
|
|
private w aE = null;
|
|
|
|
private ArrayList GInterfaceAf = new ArrayList();
|
|
|
|
private boolean GInterfaceAg = true;
|
|
|
|
private String aH = null;
|
|
|
|
private String aI = null;
|
|
|
|
private Color aJ = Color.gray;
|
|
|
|
boolean RComponentMike = RInterfaceIndia.ExceptionInVPackage().ExceptionInVPackage("sesrhsfghyuf754");
|
|
|
|
public static final String n = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Stretch");
|
|
|
|
public static final String RInterfaceOscar = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Tile");
|
|
|
|
public static final String RInterfacePapa = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Center");
|
|
|
|
private String aK = RInterfaceOscar;
|
|
|
|
public static final String q = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Bring Forward");
|
|
|
|
public static final String r = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Send Backward");
|
|
|
|
public static final String s = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Bring to Front");
|
|
|
|
public static final String t = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Send to Back");
|
|
|
|
public static final String u = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Gauge Properties");
|
|
|
|
public static final String v = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Add Gauge");
|
|
|
|
public static final String w = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Add Indicator");
|
|
|
|
public static final String x = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Add Label");
|
|
|
|
public static final String y = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Add Settings Panel");
|
|
|
|
public static final String z = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Add Tuning Table");
|
|
|
|
public static final String A = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Remove From Dash");
|
|
|
|
public static final String B = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Start Gauge Demo");
|
|
|
|
public static final String C = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Stop Gauge Demo");
|
|
|
|
public static final String D = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Set Background Color");
|
|
|
|
public static final String E = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Set Background Dither Color");
|
|
|
|
public static final String F = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Set Background Image");
|
|
|
|
public static final String G = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Clear Background Image");
|
|
|
|
public static final String H = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Export / Save As");
|
|
|
|
public static final String I = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Save Dashboard");
|
|
|
|
public static final String J = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Load Dashboard");
|
|
|
|
public static final String K = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Reload Default Gauges");
|
|
|
|
public static final String L = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Load ExceptionInVPackage Saved Gauge");
|
|
|
|
public static final String M = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Save this Gauge");
|
|
|
|
public static final String N = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Designer Mode");
|
|
|
|
public static final String O = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Copy");
|
|
|
|
public static final String P = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Paste");
|
|
|
|
public static final String Q = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Paste Other");
|
|
|
|
public static final String R = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Paste Gauge Theme");
|
|
|
|
public static final String S = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Paste Gauge Size");
|
|
|
|
public static final String T = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Antialiasing Enabled");
|
|
|
|
public static final String U = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Group Selected Gauges");
|
|
|
|
public static final String V = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Un-Group Gauges");
|
|
|
|
public static final String W = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Show Grid");
|
|
|
|
public static final String X = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Force Aspect Ratio");
|
|
|
|
private static String aL = "fullScreenIndex";
|
|
|
|
public static final String Y = N;
|
|
|
|
private static String aM = IComponentJuliet.y() + File.separator + ".tempGauge";
|
|
|
|
private boolean aN = false;
|
|
|
|
private boolean aO = false;
|
|
|
|
private boolean aP = false;
|
|
|
|
private boolean aQ = true;
|
|
|
|
private boolean aR = false;
|
|
|
|
N Z = new N(this);
|
|
|
|
private boolean aS = false;
|
|
|
|
private boolean aT = true;
|
|
|
|
private final ArrayList aU = new ArrayList();
|
|
|
|
private final ArrayList aV = new ArrayList();
|
|
|
|
private final ArrayList aW = new ArrayList();
|
|
|
|
private final List aX = new ArrayList();
|
|
|
|
private float aY = 0.32F;
|
|
|
|
private float aZ = 24.0F;
|
|
|
|
private boolean ba = false;
|
|
|
|
private double bb = 16.0D;
|
|
|
|
private double bc = 9.0D;
|
|
|
|
long aa = -1L;
|
|
|
|
public static int ab = 3500;
|
|
|
|
private boolean bd = true;
|
|
|
|
HashMap ac = new HashMap<>();
|
|
|
|
List ad = new ArrayList();
|
|
|
|
ExceptionInVPackage ae = new y(this);
|
|
|
|
IComponentJuliet af = new F(this);
|
|
|
|
int ag = eJ.ExceptionInVPackage(2);
|
|
|
|
Stroke GInterfaceAh = new BasicStroke(this.ag);
|
|
|
|
static int ai = 0;
|
|
|
|
public x(R paramR) {
|
|
this();
|
|
ExceptionInVPackage(paramR);
|
|
}
|
|
|
|
public x() {
|
|
setFocusable(true);
|
|
if (A.RInterfaceIndia().ManagerPreferredlayoutsize()) {
|
|
setLayout(new Y());
|
|
addMouseListener(this.h);
|
|
addMouseMotionListener(this.h);
|
|
setDoubleBuffered(true);
|
|
setFocusable(true);
|
|
this.aN = ExceptionInVPackage.ExceptionInVPackage().ExceptionInVPackage(ExceptionInVPackage.ck, "false").equals("true");
|
|
this.aZ = ExceptionInVPackage.ExceptionInVPackage().ExceptionInVPackage(ExceptionInVPackage.GInterfaceAf, this.aZ);
|
|
this.aY = ExceptionInVPackage.ExceptionInVPackage().ExceptionInVPackage(ExceptionInVPackage.GInterfaceAg, this.aY);
|
|
this.f = new X(this);
|
|
this.f.start();
|
|
}
|
|
setDoubleBuffered(false);
|
|
setOpaque(false);
|
|
}
|
|
|
|
public void ExceptionInVPackage(R paramR) {
|
|
if (this.k != null) {
|
|
this.k.C().ArrayListInIPackage(this);
|
|
this.k.C().ManagerPreferredlayoutsize(this);
|
|
}
|
|
this.k = paramR;
|
|
if (this.k != null) {
|
|
paramR.C().ExceptionInVPackage(this);
|
|
paramR.C().ExceptionInVPackage(this);
|
|
}
|
|
if (RInterfaceIndia.ExceptionInVPackage().ExceptionInVPackage(" a09kmfds098432lkg89vlk")) {
|
|
ArrayListInIPackage.ExceptionInVPackage().ExceptionInVPackage(this.ae);
|
|
ArrayListInIPackage.ExceptionInVPackage().ExceptionInVPackage(this.af);
|
|
}
|
|
if (paramR.C().q()) {
|
|
ab();
|
|
} else {
|
|
k(ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Off Line"));
|
|
}
|
|
}
|
|
|
|
public void ExceptionInVPackage(s params) {
|
|
if (this.f != null && (this.k == null || this.ax || this.ay))
|
|
this.f.ArrayListInIPackage();
|
|
if (!this.az)
|
|
repaint();
|
|
}
|
|
|
|
public void ManagerPreferredlayoutsize(s params) {
|
|
if (this.f == null || !this.f.isAlive()) {
|
|
this.f = new X(this);
|
|
this.f.start();
|
|
}
|
|
add(params);
|
|
if (RInterfaceIndia.ExceptionInVPackage().ExceptionInVPackage("09BDPO;L,;l;ldpo;l5 ") && params instanceof IInterfaceDelta)
|
|
params.addMouseListener(this.Z);
|
|
params.setGaugeContainer(this);
|
|
if (isEnabled()) {
|
|
if (params instanceof Gauge) {
|
|
Gauge gauge = (Gauge)params;
|
|
gauge.setValue(gauge.max());
|
|
}
|
|
if (!(params instanceof t)) {
|
|
params.addMouseListener(this.ExceptionPrintstacktrace);
|
|
params.addMouseMotionListener(this.ExceptionPrintstacktrace);
|
|
params.setFocusable(false);
|
|
} else {
|
|
params.setFocusable(true);
|
|
params.enableInputMethods(true);
|
|
}
|
|
if (this.bd)
|
|
params.subscribeToOutput();
|
|
}
|
|
params.setAntialiasingOn(M());
|
|
}
|
|
|
|
public void ExceptionInVPackage() {
|
|
for (s s : r())
|
|
ArrayListInIPackage(s);
|
|
this.Exceptionprintstacktrace = null;
|
|
repaint();
|
|
}
|
|
|
|
public void ArrayListInIPackage(s params) {
|
|
params.removeMouseListener(this.ExceptionPrintstacktrace);
|
|
params.removeMouseMotionListener(this.ExceptionPrintstacktrace);
|
|
remove(params);
|
|
if (params instanceof GComponentCq) {
|
|
ManagerUsingArrayList ManagerUsingArrayList = ManagerUsingArrayList.ExceptionInVPackage();
|
|
ManagerUsingArrayList.ExceptionInVPackage((GComponentCq)params);
|
|
}
|
|
}
|
|
|
|
public void removeAll() {
|
|
Component[] arrayOfComponent = getComponents();
|
|
int RInterfaceIndia = getComponentCount();
|
|
for (byte ManagerPreferredlayoutsize = 0; ManagerPreferredlayoutsize < RInterfaceIndia; ManagerPreferredlayoutsize++) {
|
|
if (arrayOfComponent[ManagerPreferredlayoutsize] instanceof s)
|
|
ArrayListInIPackage((s)arrayOfComponent[ManagerPreferredlayoutsize]);
|
|
}
|
|
super.removeAll();
|
|
}
|
|
|
|
public void setBackground(Color paramColor) {
|
|
super.setBackground(paramColor);
|
|
this.ThreadedInTPackage = null;
|
|
this.aq = null;
|
|
if (getParent() != null)
|
|
getParent().setBackground(paramColor);
|
|
}
|
|
|
|
private boolean GInterfaceAh() {
|
|
return (getComponentCount() > 0 && !(getComponent(0) instanceof HtmlDisplay));
|
|
}
|
|
|
|
private void ai() {
|
|
for (aQ aQ : this.ad)
|
|
aQ.ExceptionInVPackage();
|
|
}
|
|
|
|
public void paint(Graphics paramGraphics) {
|
|
long l1 = System.nanoTime();
|
|
boolean bool = (D() && GInterfaceAh()) ? true : false;
|
|
if (bool) {
|
|
ExceptionInVPackage(paramGraphics, D(), bool);
|
|
} else {
|
|
Image image = aC();
|
|
if (image == null)
|
|
return;
|
|
Graphics graphics = image.getGraphics();
|
|
ExceptionInVPackage(graphics, D(), bool);
|
|
paramGraphics.drawImage(image, 0, 0, null);
|
|
}
|
|
ManagerPreferredlayoutsize(paramGraphics);
|
|
if (L()) {
|
|
String str = "Width: " + getWidth() + ", Height: " + getHeight();
|
|
int RInterfaceIndia = getFontMetrics(paramGraphics.getFont()).stringWidth(str) + 8;
|
|
int k = getWidth() - RInterfaceIndia - 10;
|
|
int RComponentMike = getFont().getSize();
|
|
paramGraphics.setColor(Color.DARK_GRAY);
|
|
paramGraphics.fillRect(k, 0, RInterfaceIndia, RComponentMike);
|
|
paramGraphics.setColor(Color.WHITE);
|
|
paramGraphics.drawString(str, k + 4, RComponentMike);
|
|
}
|
|
ExceptionInVPackage(paramGraphics);
|
|
long l2 = System.nanoTime() - this.ArrayListInIPackage;
|
|
double d1 = (System.nanoTime() - l1) / 1000000.0D;
|
|
double d2 = d1 * 1000000.0D / l2;
|
|
if (getComponentCount() > 0) {
|
|
if (getComponent(0) instanceof Gauge || getComponent(0) instanceof Indicator) {
|
|
float f = (float)Math.round(1.0E9D / l2) * 5.0F;
|
|
this.IInterfaceDelta = (f * this.IInterfaceDelta + 1.0E9D / l2) / (f + 1.0F);
|
|
this.e = (f * this.e + (float)d2 * 100.0F) / (f + 1.0F);
|
|
}
|
|
float f1 = this.at ? 0.12F : (s() ? 0.9F : this.aY);
|
|
float f2 = s() ? 95.0F : this.aZ;
|
|
if (ArrayListInIPackage.ExceptionInVPackage().ManagerPreferredlayoutsize() > 5.0D && f2 > 1.05D / ArrayListInIPackage.ExceptionInVPackage().ManagerPreferredlayoutsize())
|
|
f2 = (float)(1.05D * ArrayListInIPackage.ExceptionInVPackage().ManagerPreferredlayoutsize());
|
|
if (d2 > f1 || this.IInterfaceDelta > (f2 + 5.0F)) {
|
|
this.f.ManagerPreferredlayoutsize();
|
|
} else if (this.IInterfaceDelta <= f2) {
|
|
this.f.ExceptionInVPackage();
|
|
}
|
|
}
|
|
if (this.aN) {
|
|
paramGraphics.setFont(new Font("Arial Unicode MS", 1, eJ.ExceptionInVPackage(13)));
|
|
paramGraphics.setColor(Color.CYAN);
|
|
paramGraphics.drawString(X.ManagerPreferredlayoutsize(this.IInterfaceDelta, 1) + " fps, Core%: " + X.ManagerPreferredlayoutsize(this.e, 1), 5, 15);
|
|
}
|
|
this.ArrayListInIPackage = System.nanoTime();
|
|
}
|
|
|
|
private void ExceptionInVPackage(Graphics paramGraphics, boolean paramBoolean) {
|
|
if ((paramBoolean || L()) && (this.aK.equals(RInterfacePapa) || this.aq == null || this.WInterfaceAp == null || this.WInterfaceAp.equals(""))) {
|
|
Color color = getBackground();
|
|
if (this.aJ != null && this.RComponentMike && this.aJ.getAlpha() > 0) {
|
|
Point2D.Float float_1 = new Point2D.Float((getWidth() / 3), (getHeight() * 5 / 6));
|
|
Point2D.Float float_2 = new Point2D.Float((getWidth() / 3), (getHeight() / 6));
|
|
GradientPaint gradientPaint = new GradientPaint(float_1, color, float_2, this.aJ, true);
|
|
((Graphics2D)paramGraphics).setPaint(gradientPaint);
|
|
} else {
|
|
paramGraphics.setColor(getBackground());
|
|
}
|
|
paramGraphics.fillRect(0, 0, getWidth(), getHeight());
|
|
}
|
|
if (this.WInterfaceAp != null && !this.WInterfaceAp.equals("") && this.aq == null)
|
|
this.aq = Toolkit.getDefaultToolkit().getImage(this.WInterfaceAp);
|
|
if ((paramBoolean || L()) && this.aq != null && this.aq.getWidth(null) > 0)
|
|
if (this.aK.equals(n)) {
|
|
paramGraphics.drawImage(this.aq, 0, 0, getWidth(), getHeight(), null);
|
|
} else if (this.aK.equals(RInterfacePapa)) {
|
|
if (getWidth() > this.aq.getWidth(null)) {
|
|
paramGraphics.drawImage(this.aq, (getWidth() - this.aq.getWidth(null)) / 2, (getHeight() - this.aq.getHeight(null)) / 2, null);
|
|
} else {
|
|
double IInterfaceDelta = getWidth() / this.aq.getWidth(null);
|
|
paramGraphics.drawImage(this.aq, 0, (getHeight() - (int)(this.aq.getHeight(null) * IInterfaceDelta)) / 2, (int)(this.aq.getWidth(null) * IInterfaceDelta), (int)(this.aq.getHeight(null) * IInterfaceDelta), null);
|
|
}
|
|
} else if (this.aK.equals(RInterfaceOscar) && this.aq.getWidth(null) > 0) {
|
|
int RInterfaceIndia = this.aq.getWidth(null);
|
|
int k = this.aq.getHeight(null);
|
|
for (byte ManagerPreferredlayoutsize = 0; ManagerPreferredlayoutsize * RInterfaceIndia < getWidth(); ManagerPreferredlayoutsize++) {
|
|
for (byte b1 = 0; b1 * k < getHeight(); b1++)
|
|
paramGraphics.drawImage(this.aq, ManagerPreferredlayoutsize * RInterfaceIndia, b1 * k, null);
|
|
}
|
|
} else {
|
|
D.ArrayListInIPackage("Shouldn't be here. backgroundImage.getWidth(null)=" + this.aq.getWidth(null) + "\n\tbackgroundImageStyle=" + this.aK + "\n");
|
|
}
|
|
if (this.aQ && L()) {
|
|
int RInterfaceIndia = eJ.ExceptionInVPackage(10);
|
|
Color color1 = getBackground();
|
|
Color color2 = new Color(255 - color1.getRed(), 255 - color1.getGreen(), 255 - color1.getBlue(), 64);
|
|
paramGraphics.setColor(color2);
|
|
byte ManagerPreferredlayoutsize;
|
|
for (ManagerPreferredlayoutsize = 1; ManagerPreferredlayoutsize * RInterfaceIndia < getWidth(); ManagerPreferredlayoutsize++)
|
|
paramGraphics.drawLine(ManagerPreferredlayoutsize * RInterfaceIndia, 0, ManagerPreferredlayoutsize * RInterfaceIndia, getHeight());
|
|
for (ManagerPreferredlayoutsize = 1; ManagerPreferredlayoutsize * RInterfaceIndia < getHeight(); ManagerPreferredlayoutsize++)
|
|
paramGraphics.drawLine(0, ManagerPreferredlayoutsize * RInterfaceIndia, getWidth(), ManagerPreferredlayoutsize * RInterfaceIndia);
|
|
}
|
|
}
|
|
|
|
private void ExceptionInVPackage(Graphics paramGraphics, boolean paramBoolean1, boolean paramBoolean2) {
|
|
try {
|
|
if (paramBoolean2) {
|
|
Image image = aD();
|
|
Graphics2D graphics2D1 = (Graphics2D)image.getGraphics();
|
|
if (ThreadedInTPackage()) {
|
|
Graphics2D graphics2D = (Graphics2D)paramGraphics;
|
|
graphics2D1.setColor(this.ExceptionInVPackage);
|
|
graphics2D1.setComposite(AlphaComposite.getInstance(2));
|
|
graphics2D1.fillRect(0, 0, image.getWidth(null), image.getHeight(null));
|
|
graphics2D1.setComposite(AlphaComposite.getInstance(3));
|
|
if (image.getWidth(null) < 0)
|
|
System.out.print("break 214312");
|
|
ExceptionInVPackage(graphics2D1, true);
|
|
ArrayListInIPackage(graphics2D1);
|
|
this.aT = false;
|
|
}
|
|
Graphics2D graphics2D2 = (Graphics2D)paramGraphics;
|
|
paramGraphics.drawImage(image, 0, 0, null);
|
|
IInterfaceDelta(paramGraphics);
|
|
} else {
|
|
ExceptionInVPackage(paramGraphics, paramBoolean1);
|
|
ManagerPreferredlayoutsize(paramGraphics, paramBoolean1);
|
|
}
|
|
} catch (Exception exception) {
|
|
D.ArrayListInIPackage("Exception in GaugeCluster paint");
|
|
exception.printStackTrace();
|
|
}
|
|
}
|
|
|
|
public void paintChildren(Graphics paramGraphics) {
|
|
ManagerPreferredlayoutsize(paramGraphics, !this.az);
|
|
if (!this.az)
|
|
super.paintChildren(paramGraphics);
|
|
ai();
|
|
}
|
|
|
|
private void ExceptionInVPackage(Graphics paramGraphics) {
|
|
if (this.h.ExceptionInVPackage() != null) {
|
|
Rectangle rectangle = this.h.ExceptionInVPackage();
|
|
paramGraphics.setColor(getBackground());
|
|
paramGraphics.setXORMode(Color.YELLOW);
|
|
int RInterfaceIndia = Math.abs(rectangle.width);
|
|
int k = Math.abs(rectangle.height);
|
|
int RComponentMike = (rectangle.width < 0) ? (rectangle.x + rectangle.width) : rectangle.x;
|
|
int n = (rectangle.height < 0) ? (rectangle.y + rectangle.height) : rectangle.y;
|
|
BasicStroke basicStroke = new BasicStroke(eJ.ExceptionInVPackage(1), 0, 2, 0.0F, new float[] { 2.0F, 1.0F }, 0.0F);
|
|
((Graphics2D)paramGraphics).setStroke(basicStroke);
|
|
paramGraphics.drawRect(RComponentMike, n, RInterfaceIndia, k);
|
|
}
|
|
}
|
|
|
|
private void ManagerPreferredlayoutsize(Graphics paramGraphics) {
|
|
String str1;
|
|
String str2;
|
|
if (L())
|
|
return;
|
|
boolean bool = false;
|
|
if (this.k != null && !this.k.C().q() && (this.aa > System.currentTimeMillis() || RComponentMike.ExceptionInVPackage().ManagerPreferredlayoutsize())) {
|
|
str1 = null;
|
|
str2 = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Log Playback");
|
|
bool = true;
|
|
} else {
|
|
str1 = aa();
|
|
str2 = this.aI;
|
|
}
|
|
if (((str1 == null || str1.equals("")) && (str2 == null || str2.equals(""))) || (getComponentCount() > 0 && this.ax))
|
|
return;
|
|
if (this.al == null || this.al.getWidth(null) != getWidth() || this.al.getHeight(null) != getHeight()) {
|
|
GraphicsEnvironment graphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
|
|
GraphicsDevice graphicsDevice = graphicsEnvironment.getDefaultScreenDevice();
|
|
GraphicsConfiguration graphicsConfiguration = graphicsDevice.getDefaultConfiguration();
|
|
this.al = graphicsConfiguration.createCompatibleImage(getWidth(), getHeight(), 3);
|
|
Graphics2D graphics2D = (Graphics2D)this.al.getGraphics();
|
|
graphics2D.setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_SPEED);
|
|
graphics2D.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
|
|
if (str1 != null && !str1.equals("")) {
|
|
Color color = new Color(64, 64, 64, 160);
|
|
graphics2D.setColor(color);
|
|
graphics2D.fillRect(0, 0, getWidth(), getHeight());
|
|
}
|
|
graphics2D.setColor(new Color(210, 210, 210, 239));
|
|
int RInterfaceIndia = bool ? eJ.ExceptionInVPackage(16) : eJ.ExceptionInVPackage(28);
|
|
Font font = null;
|
|
FontMetrics fontMetrics = null;
|
|
if (str1 == null || str1.equals(""))
|
|
str1 = str2;
|
|
String[] arrayOfString = str1.split("\n");
|
|
while (true) {
|
|
font = new Font("Times", 1, RInterfaceIndia);
|
|
graphics2D.setFont(font);
|
|
fontMetrics = getFontMetrics(font);
|
|
if (fontMetrics.stringWidth(arrayOfString[0]) <= getWidth() - 4 && --RInterfaceIndia != 0) {
|
|
int k = RInterfaceIndia / 2;
|
|
int RComponentMike = bool ? 2 : (getHeight() / 12);
|
|
int n = fontMetrics.stringWidth(arrayOfString[0]) + k;
|
|
Font font1 = new Font(font.getFamily(), 0, (int)(font.getSize() * 0.6D));
|
|
if (arrayOfString.length > 1)
|
|
for (byte b1 = 1; b1 < arrayOfString.length; b1++) {
|
|
int i3 = getFontMetrics(font1).stringWidth(arrayOfString[b1]) + k;
|
|
if (i3 > n)
|
|
n = i3;
|
|
}
|
|
int i1 = (getWidth() - n + k) / 2;
|
|
int i2 = (int)((fontMetrics.getHeight() + k / 2) + fontMetrics.getHeight() * 0.6D * (arrayOfString.length - 0.5D));
|
|
graphics2D.fillRect(i1 - k / 2, RComponentMike, n, i2);
|
|
graphics2D.setColor(new Color(16, 16, 32));
|
|
for (byte ManagerPreferredlayoutsize = 0; ManagerPreferredlayoutsize < arrayOfString.length; ManagerPreferredlayoutsize++) {
|
|
if (ManagerPreferredlayoutsize == 1)
|
|
graphics2D.setFont(font1);
|
|
i1 = (getWidth() - graphics2D.getFontMetrics().stringWidth(arrayOfString[ManagerPreferredlayoutsize])) / 2;
|
|
graphics2D.drawString(arrayOfString[ManagerPreferredlayoutsize], i1, RComponentMike + fontMetrics.getHeight());
|
|
RComponentMike += graphics2D.getFontMetrics().getHeight();
|
|
}
|
|
} else {
|
|
continue;
|
|
}
|
|
paramGraphics.drawImage(this.al, 0, 0, null);
|
|
return;
|
|
}
|
|
}
|
|
paramGraphics.drawImage(this.al, 0, 0, null);
|
|
}
|
|
|
|
public boolean ExceptionInVPackage(String paramString, AeInterfaceMikeTostring parambT) {
|
|
if (ExceptionInVPackage.A().E().ArrayListInIPackage().equals(paramString)) {
|
|
this.IInterfaceDelta = 6.0D;
|
|
ab();
|
|
S s = this.l;
|
|
if (s != null)
|
|
S.ExceptionInVPackage(s);
|
|
this.az = true;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public void ExceptionInVPackage(String paramString) {
|
|
if (ExceptionInVPackage.A().E() != null && ExceptionInVPackage.A().E().ArrayListInIPackage().equals(paramString)) {
|
|
ManagerPreferredlayoutsize();
|
|
this.az = false;
|
|
}
|
|
R r = T.ExceptionInVPackage().ArrayListInIPackage(paramString);
|
|
if (r != null && !r.C().O()) {
|
|
k(ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Connected to Dash Echo server that is Off Line"));
|
|
} else {
|
|
k(ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Off Line"));
|
|
}
|
|
}
|
|
|
|
public void ManagerPreferredlayoutsize() {
|
|
if (ExceptionInVPackage.ExceptionInVPackage().ExceptionInVPackage(ExceptionInVPackage.P, ExceptionInVPackage.Q) && ArrayListInIPackage.ExceptionInVPackage().IInterfaceDelta())
|
|
return;
|
|
this.ax = false;
|
|
s[] arrayOfS = IComponentJuliet();
|
|
if (!B()) {
|
|
this.ay = false;
|
|
for (s s : arrayOfS) {
|
|
if (s instanceof Gauge) {
|
|
Gauge gauge = (Gauge)s;
|
|
if (gauge.min() < 0.0D && gauge.max() > 0.0D) {
|
|
gauge.setValue(0.0D);
|
|
} else {
|
|
gauge.setValue(gauge.min());
|
|
}
|
|
gauge.invalidate();
|
|
} else if (s instanceof Indicator) {
|
|
Indicator indicator = (Indicator)s;
|
|
if (indicator.getEcuConfigurationName() != null && !indicator.getEcuConfigurationName().equals(ManagerUsingArrayList.ExceptionInVPackage))
|
|
indicator.setValue(0.0D);
|
|
indicator.setRunDemo(false);
|
|
}
|
|
}
|
|
} else {
|
|
for (s s : arrayOfS) {
|
|
if (s instanceof Gauge) {
|
|
Gauge gauge = (Gauge)s;
|
|
gauge.invalidate();
|
|
} else if (s instanceof Indicator) {
|
|
Indicator indicator = (Indicator)s;
|
|
if (indicator.getEcuConfigurationName() != null && !indicator.getEcuConfigurationName().equals(ManagerUsingArrayList.ExceptionInVPackage)) {
|
|
indicator.goDead();
|
|
} else if (indicator.isRunDemo()) {
|
|
indicator.setRunDemo(false);
|
|
}
|
|
}
|
|
}
|
|
this.ay = true;
|
|
if (this.l != null)
|
|
this.l.ManagerPreferredlayoutsize = true;
|
|
this.l = new S(this);
|
|
this.l.ExceptionInVPackage = false;
|
|
this.l.start();
|
|
}
|
|
}
|
|
|
|
public void update(Graphics paramGraphics) {
|
|
D.ArrayListInIPackage("Update Called");
|
|
paint(paramGraphics);
|
|
}
|
|
|
|
private boolean ExceptionInVPackage(Component paramComponent, int paramInt) {
|
|
Component[] arrayOfComponent = getComponents();
|
|
for (int RInterfaceIndia = paramInt; RInterfaceIndia < arrayOfComponent.length; RInterfaceIndia++) {
|
|
if (!arrayOfComponent[RInterfaceIndia].equals(paramComponent) && ExceptionInVPackage(arrayOfComponent[RInterfaceIndia], paramComponent))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private boolean ExceptionInVPackage(Component paramComponent1, Component paramComponent2) {
|
|
int RInterfaceIndia = paramComponent1.getX();
|
|
int k = paramComponent1.getY();
|
|
int RComponentMike = paramComponent1.getWidth();
|
|
int n = paramComponent1.getHeight();
|
|
Rectangle rectangle1 = new Rectangle(RInterfaceIndia, k, RComponentMike, n);
|
|
RInterfaceIndia = paramComponent2.getX();
|
|
k = paramComponent2.getY();
|
|
RComponentMike = paramComponent2.getWidth();
|
|
n = paramComponent2.getHeight();
|
|
Rectangle rectangle2 = new Rectangle(RInterfaceIndia, k, RComponentMike, n);
|
|
return (rectangle1.intersects(rectangle2) && !paramComponent2.equals(paramComponent1));
|
|
}
|
|
|
|
private void ManagerPreferredlayoutsize(Graphics paramGraphics, boolean paramBoolean) {
|
|
Component[] arrayOfComponent = getComponents();
|
|
for (byte ManagerPreferredlayoutsize = 0; ManagerPreferredlayoutsize < arrayOfComponent.length; ManagerPreferredlayoutsize++) {
|
|
if (arrayOfComponent[ManagerPreferredlayoutsize] instanceof s) {
|
|
s s = (s)arrayOfComponent[ManagerPreferredlayoutsize];
|
|
if (!D() && s.isMustPaint()) {
|
|
e(true);
|
|
D.ArrayListInIPackage("Deactivated fast paint " + getName());
|
|
}
|
|
if (s.isDirty() || paramBoolean || L() || s.isRunDemo() || s.requiresBackgroundRepaint()) {
|
|
Graphics graphics = paramGraphics.create(s.getX(), s.getY(), s.getWidth(), s.getHeight());
|
|
Area area = f(s);
|
|
graphics.setClip(area);
|
|
s.paint(graphics);
|
|
graphics.dispose();
|
|
s.setDirty(false);
|
|
}
|
|
if (this.GInterfaceAf.contains(s))
|
|
ExceptionInVPackage(paramGraphics, s);
|
|
}
|
|
}
|
|
}
|
|
|
|
private boolean ThreadedInTPackage() {
|
|
if (this.aT)
|
|
return true;
|
|
Component[] arrayOfComponent = getComponents();
|
|
if (arrayOfComponent.length == 0)
|
|
return true;
|
|
boolean bool = false;
|
|
for (byte ManagerPreferredlayoutsize = 0; ManagerPreferredlayoutsize < arrayOfComponent.length; ManagerPreferredlayoutsize++) {
|
|
if (arrayOfComponent[ManagerPreferredlayoutsize] instanceof s) {
|
|
s s = (s)arrayOfComponent[ManagerPreferredlayoutsize];
|
|
if (!bool && s.requiresBackgroundRepaint()) {
|
|
bool = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return bool;
|
|
}
|
|
|
|
private void ArrayListInIPackage(Graphics paramGraphics) {
|
|
Component[] arrayOfComponent = getComponents();
|
|
for (byte ManagerPreferredlayoutsize = 0; ManagerPreferredlayoutsize < arrayOfComponent.length; ManagerPreferredlayoutsize++) {
|
|
if (arrayOfComponent[ManagerPreferredlayoutsize] instanceof s) {
|
|
s s = (s)arrayOfComponent[ManagerPreferredlayoutsize];
|
|
Graphics graphics = paramGraphics.create(s.getX(), s.getY(), s.getWidth(), s.getHeight());
|
|
s.paintBackground(graphics);
|
|
graphics.dispose();
|
|
s.validate();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void IInterfaceDelta(Graphics paramGraphics) {
|
|
Component[] arrayOfComponent = getComponents();
|
|
for (byte ManagerPreferredlayoutsize = 0; ManagerPreferredlayoutsize < arrayOfComponent.length; ManagerPreferredlayoutsize++) {
|
|
if (arrayOfComponent[ManagerPreferredlayoutsize] instanceof s) {
|
|
s s = (s)arrayOfComponent[ManagerPreferredlayoutsize];
|
|
if (s.getWidth() > 0 && s.getHeight() > 0) {
|
|
Graphics2D graphics2D = (Graphics2D)paramGraphics.create(s.getX(), s.getY(), s.getWidth(), s.getHeight());
|
|
Area area = f(s);
|
|
graphics2D.setClip(area);
|
|
s.updateGauge(graphics2D);
|
|
graphics2D.dispose();
|
|
s.setDirty(false);
|
|
}
|
|
if (this.GInterfaceAf.contains(s))
|
|
ExceptionInVPackage(paramGraphics, s);
|
|
}
|
|
}
|
|
ai();
|
|
}
|
|
|
|
private Area f(s params) {
|
|
Area area = (Area)this.ac.get(params);
|
|
if (area == null || L()) {
|
|
area = new Area(new Rectangle(0, 0, params.getWidth(), params.getHeight()));
|
|
boolean bool = false;
|
|
for (s s1 : IComponentJuliet()) {
|
|
if (bool) {
|
|
Area area1 = s1.areaPainted();
|
|
int RInterfaceIndia = s1.getX() - params.getX();
|
|
int k = s1.getY() - params.getY();
|
|
AffineTransform affineTransform = new AffineTransform();
|
|
affineTransform.translate(RInterfaceIndia, k);
|
|
area1.transform(affineTransform);
|
|
area.subtract(area1);
|
|
} else if (s1.equals(params)) {
|
|
bool = true;
|
|
}
|
|
}
|
|
this.ac.put(params, area);
|
|
}
|
|
return area;
|
|
}
|
|
|
|
public void setBounds(int paramInt1, int paramInt2, int paramInt3, int paramInt4) {
|
|
super.setBounds(paramInt1, paramInt2, paramInt3, paramInt4);
|
|
this.ac.clear();
|
|
}
|
|
|
|
public void ArrayListInIPackage() {
|
|
for (Component component : getComponents()) {
|
|
if (component instanceof bc)
|
|
((bc)component).close();
|
|
}
|
|
removeAll();
|
|
String str = ExceptionInVPackage.ExceptionInVPackage().ExceptionInVPackage(ExceptionInVPackage.aX, G);
|
|
RInterfaceIndia(str);
|
|
IComponentJuliet(RInterfacePapa);
|
|
this.aq = eJ.ExceptionInVPackage(this.aq);
|
|
this.ar = "";
|
|
if (this.k != null) {
|
|
this.k.C().ArrayListInIPackage(this);
|
|
this.k.C().ManagerPreferredlayoutsize(this);
|
|
}
|
|
if (this.f != null) {
|
|
X.ExceptionInVPackage(this.f);
|
|
this.f = null;
|
|
}
|
|
e(false);
|
|
ArrayListInIPackage.ExceptionInVPackage().ManagerPreferredlayoutsize(this.ae);
|
|
ArrayListInIPackage.ExceptionInVPackage().ManagerPreferredlayoutsize(this.af);
|
|
}
|
|
|
|
private void ExceptionInVPackage(Graphics paramGraphics, s params) {
|
|
if (!L())
|
|
return;
|
|
int RInterfaceIndia = params.getX();
|
|
int k = params.getY();
|
|
int RComponentMike = params.getWidth();
|
|
int n = params.getHeight();
|
|
int i1 = this.am - this.ag / 2;
|
|
if (RComponentMike > 0 && n > 0) {
|
|
if (M()) {
|
|
Graphics2D graphics2D = (Graphics2D)paramGraphics;
|
|
graphics2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
|
|
graphics2D.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
|
|
graphics2D.setStroke(this.GInterfaceAh);
|
|
}
|
|
paramGraphics.setFont(getFont());
|
|
Color color = Color.yellow;
|
|
paramGraphics.setColor(color);
|
|
paramGraphics.drawLine(RInterfaceIndia + i1, k + i1, RInterfaceIndia + RComponentMike - i1, k + n - i1);
|
|
paramGraphics.drawLine(RInterfaceIndia + i1, k + n - i1, RInterfaceIndia + RComponentMike - i1, k + i1);
|
|
paramGraphics.fillRect(RInterfaceIndia, k, this.am, this.am);
|
|
paramGraphics.fillRect(RInterfaceIndia, k + n - this.am, this.am, this.am);
|
|
paramGraphics.fillRect(RInterfaceIndia + RComponentMike - this.am, k, this.am, this.am);
|
|
paramGraphics.setColor(Color.red);
|
|
paramGraphics.fillRect(RInterfaceIndia + RComponentMike - this.am, k + n - this.am, this.am, this.am);
|
|
String str = "X: " + RInterfaceIndia + ", Y:" + k + ", Width: " + RComponentMike + ", Height: " + n;
|
|
paramGraphics.setColor(Color.DARK_GRAY);
|
|
paramGraphics.fillRect(RInterfaceIndia + 10, k, paramGraphics.getFontMetrics().stringWidth(str) + 10, paramGraphics.getFont().getSize() + 2);
|
|
paramGraphics.setColor(Color.WHITE);
|
|
paramGraphics.drawString(str, RInterfaceIndia + eJ.ExceptionInVPackage(15), k + paramGraphics.getFont().getSize() - 1);
|
|
}
|
|
}
|
|
|
|
public void ExceptionInVPackage(Component paramComponent, int paramInt1, int paramInt2) {
|
|
boolean bool = ExceptionInVPackage.ExceptionInVPackage().ExceptionInVPackage(ExceptionInVPackage.da, ExceptionInVPackage.db);
|
|
if (bool)
|
|
return;
|
|
boolean bool1 = false;
|
|
if (!bool1) {
|
|
JPopupMenu jPopupMenu = IInterfaceDelta();
|
|
add(jPopupMenu);
|
|
if (paramComponent != null) {
|
|
jPopupMenu.show(paramComponent, paramInt1, paramInt2);
|
|
} else {
|
|
jPopupMenu.show(this, paramInt1, paramInt2);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void ExceptionInVPackage(boolean paramBoolean) {
|
|
this.aT = paramBoolean;
|
|
}
|
|
|
|
public JPopupMenu IInterfaceDelta() {
|
|
br br = new br();
|
|
ExceptionInVPackage((bq)br);
|
|
return (JPopupMenu)br;
|
|
}
|
|
|
|
public bq ExceptionInVPackage(bq parambq) {
|
|
V v = new V(this);
|
|
JMenu jMenu1 = null;
|
|
if (RInterfaceIndia.ExceptionInVPackage().ExceptionInVPackage("43wunjt58j7tjtht")) {
|
|
JMenu jMenu = new JMenu(ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Load / Save"));
|
|
parambq.add(jMenu);
|
|
jMenu.add(J).addActionListener(v);
|
|
jMenu.add(I).addActionListener(v);
|
|
jMenu.add(H).addActionListener(v);
|
|
if (L()) {
|
|
jMenu.addSeparator();
|
|
jMenu.add(L).addActionListener(v);
|
|
JMenuItem jMenuItem1 = parambq.add(O);
|
|
jMenuItem1.addActionListener(v);
|
|
if (this.GInterfaceAf.size() > 0) {
|
|
jMenu.add(M).addActionListener(v);
|
|
} else {
|
|
jMenuItem1.setEnabled(false);
|
|
}
|
|
File file = new File(aM);
|
|
JMenuItem jMenuItem2 = parambq.add(P);
|
|
jMenuItem2.setEnabled(file.exists());
|
|
jMenuItem2.addActionListener(v);
|
|
if (r().size() > 0) {
|
|
JMenu jMenu4 = new JMenu(Q);
|
|
parambq.add(jMenu4);
|
|
jMenuItem2 = jMenu4.add(R);
|
|
jMenuItem2.setEnabled(file.exists());
|
|
jMenuItem2.addActionListener(v);
|
|
jMenuItem2 = jMenu4.add(S);
|
|
jMenuItem2.setEnabled(file.exists());
|
|
jMenuItem2.addActionListener(v);
|
|
}
|
|
}
|
|
} else {
|
|
parambq.add(K).addActionListener(v);
|
|
}
|
|
if (L()) {
|
|
JMenu jMenu;
|
|
byte ManagerPreferredlayoutsize = 0;
|
|
if (r().size() > 0) {
|
|
w w1 = O();
|
|
O().ManagerPreferredlayoutsize(r());
|
|
w1.setText(ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Dashboard Designer"));
|
|
} else {
|
|
jMenu = new JMenu(ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Dashboard Designer"));
|
|
}
|
|
jMenu1 = new JMenu(ExceptionPrintstacktrace.ManagerPreferredlayoutsize("New"));
|
|
jMenu1.add(v).addActionListener(v);
|
|
jMenu1.add(w).addActionListener(v);
|
|
jMenu1.add(x).addActionListener(v);
|
|
if (RInterfaceIndia.ExceptionInVPackage().ExceptionInVPackage("LKMFSLKFDSLK;LKM09")) {
|
|
jMenu1.add(y).addActionListener(v);
|
|
jMenu1.add(z).addActionListener(v);
|
|
}
|
|
jMenu.insert(jMenu1, ManagerPreferredlayoutsize++);
|
|
if (this.GInterfaceAf.size() > 0) {
|
|
JMenuItem jMenuItem = new JMenuItem(A);
|
|
jMenuItem.addActionListener(v);
|
|
jMenu.insert(jMenuItem, ManagerPreferredlayoutsize++);
|
|
}
|
|
if (am()) {
|
|
parambq.addSeparator();
|
|
if (this.GInterfaceAf.size() > 1) {
|
|
JMenuItem jMenuItem = new JMenuItem(U);
|
|
jMenuItem.addActionListener(v);
|
|
jMenu.insert(jMenuItem, ManagerPreferredlayoutsize++);
|
|
if (this.GInterfaceAf.get(0) instanceof Gauge) {
|
|
Gauge gauge = this.GInterfaceAf.get(0);
|
|
if (gauge.getGroupId() != 0) {
|
|
jMenuItem = new JMenuItem(V);
|
|
jMenuItem.addActionListener(v);
|
|
jMenu.insert(jMenuItem, ManagerPreferredlayoutsize++);
|
|
}
|
|
}
|
|
}
|
|
GaugePainter[] arrayOfGaugePainter = e.ExceptionInVPackage();
|
|
jMenu1 = new JMenu(ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Gauge Style"));
|
|
if (arrayOfGaugePainter != null)
|
|
for (byte b1 = 0; b1 < arrayOfGaugePainter.length; b1++) {
|
|
GaugePainter gaugePainter = arrayOfGaugePainter[b1];
|
|
JMenuItem jMenuItem = new JMenuItem(ExceptionPrintstacktrace.ManagerPreferredlayoutsize(gaugePainter.getName()));
|
|
jMenuItem.setActionCommand(gaugePainter.getClass().getName());
|
|
jMenuItem.addActionListener(new G(this));
|
|
jMenu1.add(jMenuItem);
|
|
}
|
|
jMenu.insert(jMenu1, ManagerPreferredlayoutsize++);
|
|
}
|
|
if (al()) {
|
|
parambq.addSeparator();
|
|
IndicatorPainter[] arrayOfIndicatorPainter = e.ManagerPreferredlayoutsize();
|
|
jMenu1 = new JMenu(ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Indicator Style"));
|
|
for (byte b1 = 0; b1 < arrayOfIndicatorPainter.length; b1++) {
|
|
IndicatorPainter indicatorPainter = arrayOfIndicatorPainter[b1];
|
|
JMenuItem jMenuItem = new JMenuItem(indicatorPainter.getName());
|
|
jMenuItem.setActionCommand(indicatorPainter.getClass().getName());
|
|
jMenuItem.addActionListener(new H(this));
|
|
jMenu1.add(jMenuItem);
|
|
}
|
|
jMenu.insert(jMenu1, ManagerPreferredlayoutsize++);
|
|
}
|
|
if (r().size() > 0) {
|
|
jMenu1 = new JMenu(ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Order"));
|
|
jMenu1.add(q).addActionListener(v);
|
|
jMenu1.add(r).addActionListener(v);
|
|
jMenu1.add(s).addActionListener(v);
|
|
jMenu1.add(t).addActionListener(v);
|
|
jMenu.insert(jMenu1, ManagerPreferredlayoutsize++);
|
|
}
|
|
jMenu.insertSeparator(ManagerPreferredlayoutsize++);
|
|
JCheckBoxMenuItem jCheckBoxMenuItem1 = new JCheckBoxMenuItem(W);
|
|
jCheckBoxMenuItem1.setState(this.aQ);
|
|
jCheckBoxMenuItem1.addActionListener(new I(this));
|
|
jMenu.add(jCheckBoxMenuItem1);
|
|
jCheckBoxMenuItem1 = new JCheckBoxMenuItem(X);
|
|
jCheckBoxMenuItem1.setState(this.ba);
|
|
x x1 = this;
|
|
jCheckBoxMenuItem1.addActionListener(new J(this, x1));
|
|
jMenu.add(jCheckBoxMenuItem1);
|
|
parambq.add(jMenu);
|
|
}
|
|
if (am()) {
|
|
if (RInterfaceIndia.ExceptionInVPackage().ExceptionInVPackage("43wunjt58j7tjtht"))
|
|
parambq.addSeparator();
|
|
jMenu1 = new JMenu(ExceptionInVPackage.ManagerPreferredlayoutsize + " " + ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Gauges"));
|
|
parambq.add(jMenu1);
|
|
ArrayList arrayList = new ArrayList();
|
|
Iterator iterator = ArrayListInIPackage.ExceptionInVPackage().ManagerPreferredlayoutsize();
|
|
while (iterator.hasNext())
|
|
arrayList.add(iterator.next());
|
|
List list = S.ExceptionInVPackage(arrayList);
|
|
O RInterfaceOscar = new O(this, ManagerUsingArrayList.ExceptionInVPackage);
|
|
HashMap<Object, Object> hashMap = new HashMap<>();
|
|
for (GInterfaceAh GInterfaceAh : list) {
|
|
String str = "";
|
|
try {
|
|
str = ExceptionPrintstacktrace.ManagerPreferredlayoutsize(GInterfaceAh.k().ExceptionInVPackage());
|
|
} catch (ExceptionPrintstacktrace ExceptionPrintstacktrace) {
|
|
Logger.getLogger(x.class.getName()).log(Level.SEVERE, (String)null, (Throwable)ExceptionPrintstacktrace);
|
|
}
|
|
JMenuItem jMenuItem = new JMenuItem(str + " - " + GInterfaceAh.aL());
|
|
jMenuItem.setActionCommand(GInterfaceAh.aL());
|
|
jMenuItem.addActionListener(RInterfaceOscar);
|
|
if (GInterfaceAh.RInterfacePapa() == null || GInterfaceAh.RInterfacePapa().equals("")) {
|
|
jMenu1.add(jMenuItem);
|
|
continue;
|
|
}
|
|
if (hashMap.containsKey(GInterfaceAh.RInterfacePapa())) {
|
|
((ArrayList<JMenuItem>)hashMap.get(GInterfaceAh.RInterfacePapa())).add(jMenuItem);
|
|
continue;
|
|
}
|
|
ArrayList<JMenuItem> arrayList1 = new ArrayList();
|
|
arrayList1.add(jMenuItem);
|
|
hashMap.put(GInterfaceAh.RInterfacePapa(), arrayList1);
|
|
}
|
|
for (String str : hashMap.keySet()) {
|
|
jMenu1 = new JMenu(ExceptionPrintstacktrace.ManagerPreferredlayoutsize(str));
|
|
parambq.add(jMenu1);
|
|
for (JMenuItem jMenuItem : hashMap.get(str))
|
|
jMenu1.add(jMenuItem);
|
|
}
|
|
byte b1 = 0;
|
|
int RInterfaceIndia = (Toolkit.getDefaultToolkit().getScreenSize()).height;
|
|
JMenu jMenu = null;
|
|
T t = T.ExceptionInVPackage();
|
|
String[] arrayOfString = t.IInterfaceDelta();
|
|
for (byte b2 = 0; b2 < arrayOfString.length; b2++) {
|
|
R r = t.ArrayListInIPackage(arrayOfString[b2]);
|
|
if (r.S()) {
|
|
RInterfaceOscar = new O(this, arrayOfString[b2]);
|
|
if (r != null && r.B() != null) {
|
|
byte b3 = 0;
|
|
byte b4 = 25;
|
|
ArrayList<GInterfaceAh> arrayList1 = new ArrayList();
|
|
Iterator<GInterfaceAh> iterator1 = r.B();
|
|
while (iterator1.hasNext()) {
|
|
GInterfaceAh GInterfaceAh = iterator1.next();
|
|
boolean bool = true;
|
|
try {
|
|
bool = RInterfacePapa.ExceptionInVPackage(GInterfaceAh.aJ(), r);
|
|
} catch (ExceptionPrintstacktrace ExceptionPrintstacktrace) {
|
|
Logger.getLogger(x.class.getName()).log(Level.SEVERE, (String)null, (Throwable)ExceptionPrintstacktrace);
|
|
}
|
|
if (bool)
|
|
arrayList1.add(GInterfaceAh);
|
|
}
|
|
List list1 = S.ExceptionInVPackage(arrayList1);
|
|
iterator1 = null;
|
|
String str = null;
|
|
for (GInterfaceAh GInterfaceAh : list1) {
|
|
if (b3++ % b4 == 0 || !X.ExceptionInVPackage(GInterfaceAh.RInterfacePapa(), str)) {
|
|
if (!X.ExceptionInVPackage(GInterfaceAh.RInterfacePapa(), str)) {
|
|
b3 = 1;
|
|
str = GInterfaceAh.RInterfacePapa();
|
|
}
|
|
String str2 = (GInterfaceAh.RInterfacePapa() == null) ? (ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Gauge Templates") + " ") : ExceptionPrintstacktrace.ManagerPreferredlayoutsize(GInterfaceAh.RInterfacePapa());
|
|
String str3 = (b3 > b4) ? ((b3 / b4 + 1) + "") : "";
|
|
if (arrayOfString.length == 1) {
|
|
jMenu1 = new JMenu(str2 + " " + str3);
|
|
} else {
|
|
jMenu1 = new JMenu(str2 + " " + str3 + " (" + r.ArrayListInIPackage() + ")");
|
|
}
|
|
if (RInterfaceIndia < 1024 && b1++ > 12) {
|
|
if (jMenu == null) {
|
|
jMenu = new JMenu(ExceptionPrintstacktrace.ManagerPreferredlayoutsize("More Gauges"));
|
|
parambq.add(jMenu);
|
|
}
|
|
jMenu.add(jMenu1);
|
|
} else {
|
|
parambq.add(jMenu1);
|
|
}
|
|
}
|
|
String str1 = "";
|
|
try {
|
|
str1 = ExceptionPrintstacktrace.ManagerPreferredlayoutsize(GInterfaceAh.k().ExceptionInVPackage());
|
|
} catch (ExceptionPrintstacktrace ExceptionPrintstacktrace) {
|
|
Logger.getLogger(x.class.getName()).log(Level.SEVERE, (String)null, (Throwable)ExceptionPrintstacktrace);
|
|
}
|
|
JMenuItem jMenuItem = new JMenuItem(str1 + " - " + GInterfaceAh.aL());
|
|
jMenuItem.setActionCommand(GInterfaceAh.aL());
|
|
jMenuItem.addActionListener(RInterfaceOscar);
|
|
jMenu1.add(jMenuItem);
|
|
}
|
|
}
|
|
parambq.addSeparator();
|
|
}
|
|
}
|
|
}
|
|
if (al()) {
|
|
parambq.addSeparator();
|
|
jMenu1 = new JMenu(ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Application Indicators"));
|
|
parambq.add(jMenu1);
|
|
ArrayList arrayList = new ArrayList();
|
|
Iterator iterator = IInterfaceDelta.ExceptionInVPackage().ArrayListInIPackage();
|
|
while (iterator.hasNext())
|
|
arrayList.add(iterator.next());
|
|
List list = S.ExceptionInVPackage(arrayList);
|
|
P RInterfacePapa = new P(this, ManagerUsingArrayList.ExceptionInVPackage);
|
|
for (Exceptionprintstacktrace Exceptionprintstacktrace : list) {
|
|
JMenuItem jMenuItem = new JMenuItem(ExceptionPrintstacktrace.ManagerPreferredlayoutsize("On") + ": " + Exceptionprintstacktrace.ManagerPreferredlayoutsize() + " - " + ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Off") + ": " + Exceptionprintstacktrace.e());
|
|
jMenuItem.setActionCommand(Exceptionprintstacktrace.aL());
|
|
jMenuItem.addActionListener(RInterfacePapa);
|
|
jMenu1.add(jMenuItem);
|
|
}
|
|
T t = T.ExceptionInVPackage();
|
|
String[] arrayOfString = t.IInterfaceDelta();
|
|
for (byte ManagerPreferredlayoutsize = 0; ManagerPreferredlayoutsize < arrayOfString.length; ManagerPreferredlayoutsize++) {
|
|
if (arrayOfString.length > 1) {
|
|
jMenu1 = new JMenu(ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Predefined Indicators") + " (" + arrayOfString[ManagerPreferredlayoutsize] + ")");
|
|
} else {
|
|
jMenu1 = new JMenu(ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Predefined Indicators"));
|
|
}
|
|
parambq.add(jMenu1);
|
|
R r = t.ArrayListInIPackage(arrayOfString[ManagerPreferredlayoutsize]);
|
|
RInterfacePapa = new P(this, arrayOfString[ManagerPreferredlayoutsize]);
|
|
if (r != null && r.A() != null) {
|
|
byte b1 = 1;
|
|
byte b2 = 25;
|
|
list = new ArrayList();
|
|
Iterator<Exceptionprintstacktrace> iterator1 = r.A();
|
|
while (iterator1.hasNext())
|
|
list.add(iterator1.next());
|
|
list = S.ExceptionInVPackage(list);
|
|
iterator1 = list.iterator();
|
|
while (iterator1.hasNext()) {
|
|
if (b1++ % b2 == 0) {
|
|
jMenu1 = new JMenu(ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Predefined Indicators") + " " + (b1 / b2 + 1));
|
|
parambq.add(jMenu1);
|
|
}
|
|
Exceptionprintstacktrace Exceptionprintstacktrace = iterator1.next();
|
|
JMenuItem jMenuItem = new JMenuItem(ExceptionPrintstacktrace.ManagerPreferredlayoutsize("On") + ": " + ExceptionPrintstacktrace.ManagerPreferredlayoutsize(Exceptionprintstacktrace.ManagerPreferredlayoutsize()) + " - " + ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Off") + ": " + ExceptionPrintstacktrace.ManagerPreferredlayoutsize(Exceptionprintstacktrace.e()));
|
|
jMenuItem.setActionCommand(Exceptionprintstacktrace.aL());
|
|
jMenuItem.addActionListener(RInterfacePapa);
|
|
jMenu1.add(jMenuItem);
|
|
}
|
|
}
|
|
}
|
|
parambq.addSeparator();
|
|
}
|
|
if (al() || am()) {
|
|
JMenuItem jMenuItem = new JMenuItem(ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Reset Value"));
|
|
jMenuItem.addActionListener(new K(this));
|
|
parambq.add(jMenuItem);
|
|
}
|
|
JMenu jMenu2 = new JMenu(ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Background"));
|
|
parambq.add(jMenu2);
|
|
jMenu2.add(D).addActionListener(v);
|
|
jMenu2.add(E).addActionListener(v);
|
|
jMenu2.add(F).addActionListener(v);
|
|
JMenu jMenu3 = new JMenu(ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Image Position"));
|
|
L l = new L(this);
|
|
jMenu3.add(n).addActionListener(l);
|
|
jMenu3.add(RInterfaceOscar).addActionListener(l);
|
|
jMenu3.add(RInterfacePapa).addActionListener(l);
|
|
jMenu2.add(jMenu3);
|
|
if (this.aq != null)
|
|
jMenu2.add(G).addActionListener(v);
|
|
JCheckBoxMenuItem jCheckBoxMenuItem = new JCheckBoxMenuItem(T);
|
|
ExceptionInVPackage((dR)new ba(jCheckBoxMenuItem, "antiAliasingOn"));
|
|
jCheckBoxMenuItem.setState(M());
|
|
jCheckBoxMenuItem.addActionListener(new M(this));
|
|
parambq.add(jCheckBoxMenuItem);
|
|
if (af())
|
|
if (J.ManagerPreferredlayoutsize() || !bV.h() || s()) {
|
|
JMenuItem jMenuItem = new JMenuItem(ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Full Screen"));
|
|
jMenuItem.setSelected(s());
|
|
jMenuItem.addActionListener(new z(this));
|
|
parambq.add(jMenuItem);
|
|
} else {
|
|
JMenu jMenu = new JMenu(ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Full Screen"));
|
|
jMenu.setSelected(s());
|
|
jMenu.addActionListener(new A(this));
|
|
String[] arrayOfString = dn.ExceptionInVPackage();
|
|
for (byte ManagerPreferredlayoutsize = 0; ManagerPreferredlayoutsize < arrayOfString.length; ManagerPreferredlayoutsize++) {
|
|
JMenuItem jMenuItem = new JMenuItem(ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Full Screen on ") + arrayOfString[ManagerPreferredlayoutsize]);
|
|
jMenuItem.setActionCommand(ManagerPreferredlayoutsize + "");
|
|
jMenu.add(jMenuItem);
|
|
jMenuItem.addActionListener(new B(this));
|
|
}
|
|
parambq.add(jMenu);
|
|
}
|
|
if (!ExceptionInVPackage.ExceptionInVPackage().ManagerPreferredlayoutsize(ExceptionInVPackage.cQ, ExceptionInVPackage.cR)) {
|
|
jCheckBoxMenuItem = new JCheckBoxMenuItem(N);
|
|
jCheckBoxMenuItem.setState(L());
|
|
jCheckBoxMenuItem.addActionListener(new C(this));
|
|
parambq.add(jCheckBoxMenuItem);
|
|
if (!RInterfaceIndia.ExceptionInVPackage().ExceptionInVPackage("sesrhsfghyuf754"))
|
|
jCheckBoxMenuItem.setEnabled(false);
|
|
}
|
|
jMenu1 = new JMenu(ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Gauge Demo"));
|
|
jMenu1.add(B).addActionListener(v);
|
|
jMenu1.add(C).addActionListener(v);
|
|
parambq.add(jMenu1);
|
|
return parambq;
|
|
}
|
|
|
|
private void Exceptionprintstacktrace() {
|
|
for (s s : this.GInterfaceAf) {
|
|
if (s instanceof SingleChannelDashComponent) {
|
|
SingleChannelDashComponent singleChannelDashComponent = (SingleChannelDashComponent)s;
|
|
String str1 = singleChannelDashComponent.getOutputChannel();
|
|
String str2 = singleChannelDashComponent.getEcuConfigurationName();
|
|
try {
|
|
RInterfaceIndia.ExceptionInVPackage(str2, str1);
|
|
} catch (ExceptionPrintstacktrace ExceptionPrintstacktrace) {
|
|
Logger.getLogger(x.class.getName()).log(Level.SEVERE, (String)null, (Throwable)ExceptionPrintstacktrace);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private boolean al() {
|
|
Iterator iterator = this.GInterfaceAf.iterator();
|
|
while (iterator.hasNext()) {
|
|
if (iterator.next() instanceof Indicator)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private boolean am() {
|
|
Iterator iterator = this.GInterfaceAf.iterator();
|
|
while (iterator.hasNext()) {
|
|
if (iterator.next() instanceof Gauge)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void ManagerPreferredlayoutsize(boolean paramBoolean) {
|
|
Component component = null;
|
|
for (byte ManagerPreferredlayoutsize = 0; ManagerPreferredlayoutsize < getComponentCount(); ManagerPreferredlayoutsize++) {
|
|
component = getComponent(ManagerPreferredlayoutsize);
|
|
if (component instanceof s) {
|
|
s s = (s)component;
|
|
s.setRunDemo(paramBoolean);
|
|
}
|
|
if (component instanceof Gauge && paramBoolean) {
|
|
Gauge gauge = (Gauge)component;
|
|
gauge.setValue(gauge.min());
|
|
}
|
|
}
|
|
if (paramBoolean && !this.ax) {
|
|
this.ax = paramBoolean;
|
|
if (this.ax) {
|
|
if (this.l != null)
|
|
S.ExceptionInVPackage(this.l);
|
|
this.ay = false;
|
|
this.l = new S(this);
|
|
this.l.start();
|
|
}
|
|
} else if (!paramBoolean) {
|
|
this.ax = false;
|
|
ManagerPreferredlayoutsize();
|
|
}
|
|
}
|
|
|
|
public void e() {
|
|
Component component = null;
|
|
for (byte ManagerPreferredlayoutsize = 0; ManagerPreferredlayoutsize < getComponentCount(); ManagerPreferredlayoutsize++) {
|
|
component = getComponent(ManagerPreferredlayoutsize);
|
|
if (!(component instanceof Gauge) && component instanceof Indicator) {
|
|
Indicator indicator = (Indicator)component;
|
|
indicator.setOffText(ExceptionPrintstacktrace.ManagerPreferredlayoutsize(indicator.getOffText().toString()));
|
|
indicator.setOnText(ExceptionPrintstacktrace.ManagerPreferredlayoutsize(indicator.getOnText().toString()));
|
|
}
|
|
}
|
|
}
|
|
|
|
public void f() {
|
|
Component component = null;
|
|
for (byte ManagerPreferredlayoutsize = 0; ManagerPreferredlayoutsize < getComponentCount(); ManagerPreferredlayoutsize++) {
|
|
component = getComponent(ManagerPreferredlayoutsize);
|
|
if (!(component instanceof Gauge) && component instanceof Indicator);
|
|
}
|
|
}
|
|
|
|
public Component ExceptionPrintstacktrace() {
|
|
return (this.GInterfaceAf.size() > 0) ? this.GInterfaceAf.get(0) : null;
|
|
}
|
|
|
|
public void ManagerPreferredlayoutsize(String paramString) {
|
|
if (paramString.equals(v)) {
|
|
RComponentMike();
|
|
} else if (paramString.equals(w)) {
|
|
RInterfacePapa();
|
|
} else if (paramString.equals(x)) {
|
|
q();
|
|
} else if (paramString.equals(y)) {
|
|
n();
|
|
} else if (paramString.equals(z)) {
|
|
RInterfaceOscar();
|
|
} else if (paramString.equals(D)) {
|
|
ay();
|
|
} else if (paramString.equals(E)) {
|
|
az();
|
|
} else if (paramString.equals(F)) {
|
|
aA();
|
|
} else if (paramString.equals(H)) {
|
|
at();
|
|
} else if (paramString.equals(I)) {
|
|
h();
|
|
} else if (paramString.equals(J)) {
|
|
k();
|
|
} else if (paramString.equals(L)) {
|
|
ax();
|
|
} else if (paramString.equals(G)) {
|
|
l();
|
|
} else if (paramString.equals(B)) {
|
|
ManagerPreferredlayoutsize(true);
|
|
} else if (paramString.equals(C)) {
|
|
ManagerPreferredlayoutsize(false);
|
|
} else if (paramString.equals(O)) {
|
|
WInterfaceAp();
|
|
} else if (paramString.equals(P)) {
|
|
aq();
|
|
} else if (paramString.equals(R)) {
|
|
as();
|
|
} else if (paramString.equals(S)) {
|
|
ar();
|
|
} else if (paramString.equals(K)) {
|
|
GInterfaceAf();
|
|
}
|
|
Component component = ExceptionPrintstacktrace();
|
|
if (component == null) {
|
|
repaint();
|
|
return;
|
|
}
|
|
if (paramString.equals(q)) {
|
|
ExceptionInVPackage(component);
|
|
} else if (paramString.equals(r)) {
|
|
ManagerPreferredlayoutsize(component);
|
|
} else if (paramString.equals(s)) {
|
|
IInterfaceDelta(component);
|
|
} else if (paramString.equals(t)) {
|
|
ArrayListInIPackage(component);
|
|
} else if (paramString.equals(U)) {
|
|
ao();
|
|
} else if (paramString.equals(V)) {
|
|
an();
|
|
} else if (component instanceof s) {
|
|
if (paramString.equals(A)) {
|
|
ExceptionInVPackage();
|
|
} else if (paramString.equals(M)) {
|
|
ExceptionInVPackage(r());
|
|
} else if (component instanceof Gauge) {
|
|
Gauge gauge = (Gauge)component;
|
|
if (paramString.equals(u))
|
|
IInterfaceDelta(gauge);
|
|
}
|
|
}
|
|
this.Exceptionprintstacktrace = null;
|
|
repaint();
|
|
}
|
|
|
|
private void an() {
|
|
for (s s : this.GInterfaceAf) {
|
|
if (s instanceof Gauge)
|
|
((Gauge)s).setGroupId(0);
|
|
}
|
|
}
|
|
|
|
private void ao() {
|
|
int RInterfaceIndia = (int)(Math.random() * 2.147483647E9D);
|
|
for (s s : this.GInterfaceAf) {
|
|
if (s instanceof Gauge)
|
|
((Gauge)s).setGroupId(RInterfaceIndia);
|
|
}
|
|
}
|
|
|
|
private void WInterfaceAp() {
|
|
ExceptionInVPackage(r(), aM);
|
|
}
|
|
|
|
private void aq() {
|
|
try {
|
|
ExceptionInVPackage(aM, 0.06D, 0.06D);
|
|
} catch (ExceptionInVPackage a1) {
|
|
D.IInterfaceDelta("no valid DashboardComponent");
|
|
}
|
|
}
|
|
|
|
private void ar() {
|
|
try {
|
|
File file = new File(aM);
|
|
ArrayList<s> arrayList = (new ArrayListInIPackage(IComponentJuliet.G())).ManagerPreferredlayoutsize(file.getAbsolutePath());
|
|
if (arrayList.isEmpty()) {
|
|
bV.IInterfaceDelta("No Component Copied", this);
|
|
return;
|
|
}
|
|
s s = arrayList.get(0);
|
|
for (s s1 : r()) {
|
|
s1.setRelativeHeight(s.getRelativeHeight());
|
|
s1.setRelativeWidth(s.getRelativeWidth());
|
|
}
|
|
doLayout();
|
|
ExceptionInVPackage(true);
|
|
repaint();
|
|
} catch (ExceptionInVPackage a1) {
|
|
D.IInterfaceDelta("no valid DashboardComponent");
|
|
}
|
|
}
|
|
|
|
private void as() {
|
|
try {
|
|
File file = new File(aM);
|
|
Gauge gauge = aa.ExceptionInVPackage(file);
|
|
if (gauge != null) {
|
|
for (s s : r()) {
|
|
if (s instanceof Gauge) {
|
|
Gauge gauge1 = (Gauge)s;
|
|
aa.ExceptionInVPackage(gauge, gauge1);
|
|
}
|
|
}
|
|
} else {
|
|
bV.IInterfaceDelta(ExceptionPrintstacktrace.ManagerPreferredlayoutsize("You must copy ExceptionInVPackage Gauge before applying the Theme."), this);
|
|
}
|
|
} catch (ExceptionInVPackage a1) {
|
|
D.IInterfaceDelta("no valid DashboardComponent");
|
|
}
|
|
}
|
|
|
|
private void at() {
|
|
String[] arrayOfString = { ExceptionInVPackage.co };
|
|
String str = (ad() == null) ? ("*." + ExceptionInVPackage.co) : ad();
|
|
str = bV.ExceptionInVPackage(this, ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Save Dashboard Layout"), arrayOfString, "*." + ExceptionInVPackage.co, IComponentJuliet.IComponentJuliet().getAbsolutePath(), false);
|
|
if (str == null)
|
|
return;
|
|
if (!str.toLowerCase().endsWith("." + ExceptionInVPackage.co))
|
|
str = str + "." + ExceptionInVPackage.co;
|
|
IInterfaceDelta(str);
|
|
IComponentJuliet.e(new File(str));
|
|
}
|
|
|
|
public void ArrayListInIPackage(String paramString) {
|
|
if (ad() != null) {
|
|
ExceptionInVPackage(ad(), paramString);
|
|
this.GInterfaceAg = true;
|
|
} else {
|
|
at();
|
|
}
|
|
}
|
|
|
|
public void h() {
|
|
if (ad() != null) {
|
|
ExceptionInVPackage(ad(), (String)null);
|
|
this.GInterfaceAg = true;
|
|
} else {
|
|
at();
|
|
}
|
|
}
|
|
|
|
public void IInterfaceDelta(String paramString) {
|
|
ExceptionInVPackage(paramString, (String)null);
|
|
}
|
|
|
|
public void ExceptionInVPackage(String paramString1, String paramString2) {
|
|
if (paramString1 == null || paramString1.trim().equals(""))
|
|
return;
|
|
aa aa = new aa();
|
|
aa.ExceptionInVPackage();
|
|
ArrayListInIPackage ArrayListInIPackage = new ArrayListInIPackage(IComponentJuliet.G());
|
|
try {
|
|
boolean bool = this.ax;
|
|
ManagerPreferredlayoutsize(false);
|
|
if (bool)
|
|
try {
|
|
Thread.sleep(100L);
|
|
} catch (InterruptedException interruptedException) {
|
|
Logger.getLogger(x.class.getName()).log(Level.SEVERE, (String)null, interruptedException);
|
|
}
|
|
Z z = RInterfaceIndia();
|
|
if (paramString2 != null)
|
|
z.ManagerPreferredlayoutsize(paramString2);
|
|
synchronized (this) {
|
|
ArrayListInIPackage.ExceptionInVPackage(paramString1, z);
|
|
}
|
|
D.ArrayListInIPackage("Time to save dashboard: " + aa.IInterfaceDelta() + "ms. file: " + paramString1);
|
|
} catch (ExceptionInVPackage a1) {
|
|
bV.IInterfaceDelta("Error saving Dashboard.\n" + a1.getMessage() + "\nCheck Log for more details", this);
|
|
}
|
|
}
|
|
|
|
private void ExceptionInVPackage(ArrayList paramArrayList) {
|
|
String[] arrayOfString = { ExceptionInVPackage.GComponentCq };
|
|
ExceptionInVPackage a1 = ExceptionInVPackage.A();
|
|
if (a1 == null)
|
|
bV.IInterfaceDelta("There is no project open.\nPlease open ExceptionInVPackage project first.", this);
|
|
String str = bV.ExceptionInVPackage(this, "Save Gauge", arrayOfString, "*." + ExceptionInVPackage.GComponentCq, IComponentJuliet.IComponentJuliet().getAbsolutePath(), false);
|
|
if (str == null)
|
|
return;
|
|
if (!str.toLowerCase().endsWith("." + ExceptionInVPackage.GComponentCq))
|
|
str = str + "." + ExceptionInVPackage.GComponentCq;
|
|
IComponentJuliet.e((new File(str)).getParentFile());
|
|
ExceptionInVPackage(paramArrayList, str);
|
|
}
|
|
|
|
private void ExceptionInVPackage(ArrayList paramArrayList, String paramString) {
|
|
ArrayListInIPackage ArrayListInIPackage = new ArrayListInIPackage(IComponentJuliet.G());
|
|
try {
|
|
ArrayListInIPackage.ExceptionInVPackage(paramString, paramArrayList);
|
|
} catch (ExceptionInVPackage a1) {
|
|
bV.IInterfaceDelta("Error saving Gauge.\n" + a1.getMessage() + "\nCheck Log for more details", this);
|
|
}
|
|
}
|
|
|
|
public Z RInterfaceIndia() {
|
|
ManagerPreferredlayoutsize(false);
|
|
Z z = new Z();
|
|
z.ExceptionInVPackage(getBackground());
|
|
String str = J();
|
|
if (str != null && !str.equals(""))
|
|
str = IComponentJuliet.ArrayListInIPackage(str);
|
|
z.ExceptionInVPackage(str);
|
|
z.ArrayListInIPackage(K());
|
|
z.ManagerPreferredlayoutsize(C());
|
|
z.ManagerPreferredlayoutsize(au());
|
|
z.ManagerPreferredlayoutsize(this.ba);
|
|
z.ManagerPreferredlayoutsize(I());
|
|
z.ExceptionInVPackage(H());
|
|
Component[] arrayOfComponent = getComponents();
|
|
z.ExceptionInVPackage(arrayOfComponent);
|
|
z.ExceptionInVPackage(this.aP);
|
|
return z;
|
|
}
|
|
|
|
public s[] IComponentJuliet() {
|
|
ArrayList<Component> arrayList = new ArrayList();
|
|
for (byte b1 = 0; b1 < getComponentCount(); b1++) {
|
|
if (getComponent(b1) instanceof s)
|
|
arrayList.add(getComponent(b1));
|
|
}
|
|
s[] arrayOfS = new s[arrayList.size()];
|
|
for (byte b2 = 0; b2 < arrayList.size(); b2++)
|
|
arrayOfS[b2] = (s)arrayList.get(b2);
|
|
return arrayOfS;
|
|
}
|
|
|
|
private String au() {
|
|
try {
|
|
return this.k.RInterfaceIndia();
|
|
} catch (Exception exception) {
|
|
D.ManagerPreferredlayoutsize("Could not get Firmware signature");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public boolean e(String paramString) {
|
|
if (!this.GInterfaceAg) {
|
|
String str = null;
|
|
if (getName() == null || getName().equals("") || !ExceptionInVPackage.ExceptionInVPackage().ArrayListInIPackage().getLanguage().equals(ExceptionPrintstacktrace.ArrayListInIPackage().getLanguage())) {
|
|
str = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("This Project's dashboard layout has been modified.") + "\n" + ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Would you like to save the changes to this project?");
|
|
} else {
|
|
str = "The dashboard layout for " + getName() + " has been modified.\nWould you like to save the changes to this project?";
|
|
}
|
|
int RInterfaceIndia = JOptionPane.showConfirmDialog(this, str, ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Save Dashboard?"), 1, 3);
|
|
if (RInterfaceIndia == 2)
|
|
return false;
|
|
if (RInterfaceIndia == 0) {
|
|
f();
|
|
if (paramString != null && !paramString.equals("")) {
|
|
IInterfaceDelta(paramString);
|
|
} else {
|
|
h();
|
|
}
|
|
return true;
|
|
}
|
|
if (RInterfaceIndia == 1)
|
|
return true;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
protected void k() {
|
|
ExceptionInVPackage((ExceptionInVPackage)null);
|
|
}
|
|
|
|
public void ExceptionInVPackage(ExceptionInVPackage parama) {
|
|
ManagerPreferredlayoutsize ManagerPreferredlayoutsize = new ManagerPreferredlayoutsize();
|
|
aa aa = new aa();
|
|
String[] arrayOfString1 = T.ExceptionInVPackage().IInterfaceDelta();
|
|
String str = this.k.ArrayListInIPackage();
|
|
String[] arrayOfString2 = new String[arrayOfString1.length];
|
|
if (this.aB != null)
|
|
ManagerPreferredlayoutsize.ExceptionInVPackage(ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Default"), this.aB);
|
|
for (byte b1 = 0; b1 < arrayOfString1.length; b1++) {
|
|
R r1 = T.ExceptionInVPackage().ArrayListInIPackage(arrayOfString1[b1]);
|
|
if (r1.S()) {
|
|
Z z = ManagerPreferredlayoutsize(r1);
|
|
if (this.aB == null) {
|
|
if (ag() != null) {
|
|
ManagerPreferredlayoutsize.ExceptionInVPackage(ag());
|
|
} else {
|
|
ManagerPreferredlayoutsize.ExceptionInVPackage();
|
|
}
|
|
if (!str.equals(r1.ArrayListInIPackage()))
|
|
z.IInterfaceDelta(r1.ArrayListInIPackage());
|
|
ManagerPreferredlayoutsize.ExceptionInVPackage(r1.ArrayListInIPackage(), z);
|
|
}
|
|
}
|
|
arrayOfString2[b1] = r1.RInterfaceIndia();
|
|
}
|
|
RInterfaceOscar RInterfaceOscar = RInterfacePapa.ExceptionInVPackage().ManagerPreferredlayoutsize();
|
|
ManagerPreferredlayoutsize.ExceptionInVPackage(arrayOfString2, RInterfaceOscar);
|
|
R r = new R(this, ManagerPreferredlayoutsize, arrayOfString2);
|
|
Window window1 = bV.ManagerPreferredlayoutsize(this);
|
|
Window window2 = window1;
|
|
if (!(window2 instanceof java.awt.Dialog) && !(window2 instanceof java.awt.Frame))
|
|
window2 = null;
|
|
ct ct = new ct(window2, (JComponent)ManagerPreferredlayoutsize, "Select Dashboard", r, 7);
|
|
if (parama != null)
|
|
ct.ExceptionInVPackage(parama);
|
|
bV.ExceptionInVPackage(window1, (Component)ct);
|
|
ct.setVisible(true);
|
|
}
|
|
|
|
public void f(String paramString) {
|
|
ArrayListInIPackage ArrayListInIPackage = new ArrayListInIPackage(IComponentJuliet.G());
|
|
Z z = null;
|
|
try {
|
|
z = ArrayListInIPackage.ExceptionInVPackage(paramString);
|
|
} catch (Exception exception) {
|
|
exception.printStackTrace();
|
|
bV.IInterfaceDelta("Error Loading Dashboard file.\n" + paramString + "\nloading default gauge cluster.", this);
|
|
z = (new aa()).ExceptionInVPackage(this.k, "FrontPage", 1);
|
|
ArrayListInIPackage.ExceptionInVPackage(paramString, z);
|
|
}
|
|
String str = this.k.RInterfaceIndia();
|
|
RInterfaceOscar RInterfaceOscar = RInterfacePapa.ExceptionInVPackage().ManagerPreferredlayoutsize();
|
|
if (!RInterfaceIndia.ExceptionInVPackage().ExceptionInVPackage("GD;';'RE;'GD;'DG") && str != null && !RInterfaceOscar.ExceptionInVPackage(str, z.IInterfaceDelta()) && !aa.ExceptionInVPackage(this.k, z)) {
|
|
boolean bool = bV.ExceptionInVPackage("Warning: Gauge Cluster firmware signature '" + z.IInterfaceDelta() + "'\ndoes not match current firmware '" + str + "'.\nYou may need to reset gauge output channels.\n \nContinue Loading?", this, true);
|
|
if (!bool) {
|
|
k();
|
|
this.ar = paramString;
|
|
h();
|
|
return;
|
|
}
|
|
k(false);
|
|
} else {
|
|
this.GInterfaceAg = true;
|
|
}
|
|
this.ar = paramString;
|
|
ExceptionInVPackage(z);
|
|
validate();
|
|
}
|
|
|
|
public void ExceptionInVPackage(Z paramZ) {
|
|
if (RInterfaceIndia.ExceptionInVPackage().ExceptionInVPackage("0rewporewo430932")) {
|
|
T t = T.ExceptionInVPackage();
|
|
R r = t.ArrayListInIPackage();
|
|
if (r != null)
|
|
(new aa()).ManagerPreferredlayoutsize(r, paramZ);
|
|
}
|
|
ExceptionPrintstacktrace(false);
|
|
ExceptionPrintstacktrace(paramZ.h());
|
|
ExceptionInVPackage(paramZ.RInterfaceIndia());
|
|
ManagerPreferredlayoutsize(paramZ.IComponentJuliet());
|
|
if (getParent() != null)
|
|
getParent().doLayout();
|
|
Component[] arrayOfComponent1 = getComponents();
|
|
for (byte b1 = 0; b1 < arrayOfComponent1.length; b1++) {
|
|
if (arrayOfComponent1[b1] instanceof s)
|
|
ArrayListInIPackage((s)arrayOfComponent1[b1]);
|
|
}
|
|
Component[] arrayOfComponent2 = paramZ.ArrayListInIPackage();
|
|
IComponentJuliet(paramZ.f());
|
|
String str = "";
|
|
byte b2 = 0;
|
|
for (byte b3 = 0; b3 < arrayOfComponent2.length; b3++) {
|
|
try {
|
|
if (arrayOfComponent2[b3] != null) {
|
|
ManagerPreferredlayoutsize((s)arrayOfComponent2[b3]);
|
|
} else {
|
|
D.ManagerPreferredlayoutsize("A null gauge was tried to be added?\nThis is wierd.");
|
|
}
|
|
} catch (ExceptionInVPackage a1) {
|
|
if (b2++ < 5)
|
|
str = str + a1.getMessage() + "\n";
|
|
}
|
|
}
|
|
setBackground(paramZ.ExceptionInVPackage());
|
|
RInterfaceIndia(paramZ.ManagerPreferredlayoutsize());
|
|
IComponentJuliet(paramZ.e());
|
|
ExceptionInVPackage(paramZ.ExceptionPrintstacktrace());
|
|
ManagerPreferredlayoutsize();
|
|
invalidate();
|
|
validate();
|
|
this.Exceptionprintstacktrace = null;
|
|
repaint();
|
|
if (!str.equals(""))
|
|
str = str + "\n\n" + ExceptionPrintstacktrace.ManagerPreferredlayoutsize("To correct this:") + "\n" + ExceptionPrintstacktrace.ManagerPreferredlayoutsize("- right click on any Gauge or indicator with ExceptionInVPackage red line through it.") + "\n" + ExceptionPrintstacktrace.ManagerPreferredlayoutsize("- Select ExceptionInVPackage valid Gauge or Indicator Template from the menu.");
|
|
e();
|
|
av();
|
|
}
|
|
|
|
private void av() {
|
|
e(aw());
|
|
D.ArrayListInIPackage("High Speed Paint: " + (!D() ? 1 : 0));
|
|
}
|
|
|
|
private boolean aw() {
|
|
Component[] arrayOfComponent = getComponents();
|
|
for (byte ManagerPreferredlayoutsize = 0; ManagerPreferredlayoutsize < arrayOfComponent.length; ManagerPreferredlayoutsize++) {
|
|
if (ExceptionInVPackage(arrayOfComponent[ManagerPreferredlayoutsize], ManagerPreferredlayoutsize))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean imageUpdate(Image paramImage, int paramInt1, int paramInt2, int paramInt3, int paramInt4, int paramInt5) {
|
|
if (paramInt1 == 32) {
|
|
this.ThreadedInTPackage = null;
|
|
aC().getGraphics();
|
|
return true;
|
|
}
|
|
return super.imageUpdate(paramImage, paramInt1, paramInt2, paramInt3, paramInt4, paramInt5);
|
|
}
|
|
|
|
private void ax() {
|
|
String[] arrayOfString = { ExceptionInVPackage.GComponentCq };
|
|
String str = bV.ExceptionInVPackage(this, ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Open Gauge Layout"), arrayOfString, "*." + ExceptionInVPackage.co, IComponentJuliet.h().getAbsolutePath(), true);
|
|
if (str == null)
|
|
return;
|
|
try {
|
|
RInterfaceOscar(str);
|
|
} catch (ExceptionInVPackage a1) {
|
|
bV.IInterfaceDelta("Error loading Gauge.\n" + a1.getMessage() + "\nCheck Log for more details", this);
|
|
}
|
|
}
|
|
|
|
private void RInterfaceOscar(String paramString) {
|
|
ExceptionInVPackage(paramString, 0.0D, 0.0D);
|
|
}
|
|
|
|
private void ExceptionInVPackage(String paramString, double paramDouble1, double paramDouble2) {
|
|
ArrayListInIPackage ArrayListInIPackage = new ArrayListInIPackage(IComponentJuliet.G());
|
|
ArrayList<s> arrayList = null;
|
|
arrayList = ArrayListInIPackage.ManagerPreferredlayoutsize(paramString);
|
|
try {
|
|
for (byte ManagerPreferredlayoutsize = 0; ManagerPreferredlayoutsize < arrayList.size(); ManagerPreferredlayoutsize++) {
|
|
if (paramDouble1 != 0.0D && ((s)arrayList.get(ManagerPreferredlayoutsize)).getRelativeX() + paramDouble1 < 0.97D) {
|
|
((s)arrayList.get(ManagerPreferredlayoutsize)).setRelativeX(((s)arrayList.get(ManagerPreferredlayoutsize)).getRelativeX() + paramDouble1);
|
|
} else if (paramDouble1 != 0.0D) {
|
|
((s)arrayList.get(ManagerPreferredlayoutsize)).setRelativeX(((s)arrayList.get(ManagerPreferredlayoutsize)).getRelativeX() - paramDouble1);
|
|
}
|
|
if (paramDouble2 != 0.0D && ((s)arrayList.get(ManagerPreferredlayoutsize)).getRelativeY() + paramDouble2 < 0.97D) {
|
|
((s)arrayList.get(ManagerPreferredlayoutsize)).setRelativeY(((s)arrayList.get(ManagerPreferredlayoutsize)).getRelativeY() + paramDouble2);
|
|
} else if (paramDouble2 != 0.0D) {
|
|
((s)arrayList.get(ManagerPreferredlayoutsize)).setRelativeY(((s)arrayList.get(ManagerPreferredlayoutsize)).getRelativeY() - paramDouble2);
|
|
}
|
|
if (arrayList.get(ManagerPreferredlayoutsize) instanceof Gauge) {
|
|
Gauge gauge = (Gauge)arrayList.get(ManagerPreferredlayoutsize);
|
|
if (gauge.getGroupId() > 0)
|
|
gauge.setGroupId(gauge.getGroupId() + 1);
|
|
}
|
|
ManagerPreferredlayoutsize(arrayList.get(ManagerPreferredlayoutsize));
|
|
((s)arrayList.get(ManagerPreferredlayoutsize)).goDead();
|
|
}
|
|
} catch (ExceptionInVPackage a1) {
|
|
bV.IInterfaceDelta(a1.getMessage(), this);
|
|
}
|
|
this.GInterfaceAf.clear();
|
|
for (s s : arrayList)
|
|
this.GInterfaceAf.add(s);
|
|
GInterfaceAg();
|
|
repaint();
|
|
validate();
|
|
}
|
|
|
|
private void ay() {
|
|
Color color = bV.ExceptionInVPackage(this, ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Choose Background Color"), getBackground());
|
|
setBackground(color);
|
|
k(false);
|
|
}
|
|
|
|
private void az() {
|
|
Color color = bV.ExceptionInVPackage(this, ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Choose Background Dither Color"), C());
|
|
ExceptionInVPackage(color);
|
|
k(false);
|
|
this.ThreadedInTPackage = null;
|
|
}
|
|
|
|
public void l() {
|
|
this.aq = null;
|
|
this.WInterfaceAp = null;
|
|
this.ThreadedInTPackage = null;
|
|
repaint();
|
|
k(false);
|
|
}
|
|
|
|
private void aA() {
|
|
String str = "Select Indicator Off Image";
|
|
ThreadedInTPackage ThreadedInTPackage = new ThreadedInTPackage(bV.ManagerPreferredlayoutsize(this), IComponentJuliet.G(), str);
|
|
bV.ExceptionInVPackage(this, (Component)ThreadedInTPackage);
|
|
ThreadedInTPackage.ExceptionInVPackage(new D(this));
|
|
ThreadedInTPackage.setVisible(true);
|
|
}
|
|
|
|
public void IInterfaceDelta(s params) {
|
|
if (params instanceof Gauge) {
|
|
ad ad = new ad((Gauge)params);
|
|
ad.ExceptionInVPackage(this);
|
|
}
|
|
}
|
|
|
|
public void RComponentMike() {
|
|
String str = ExceptionPrintstacktrace.ManagerPreferredlayoutsize("Add Gauges");
|
|
ArrayList<File> arrayList = new ArrayList();
|
|
arrayList.add(IComponentJuliet.IComponentJuliet());
|
|
arrayList.add(IComponentJuliet.h());
|
|
ExceptionPrintstacktrace ExceptionPrintstacktrace = new ExceptionPrintstacktrace(bV.ExceptionInVPackage(this), arrayList, str);
|
|
ExceptionPrintstacktrace.ExceptionInVPackage((et)new dQ((ExceptionInVPackage.ExceptionInVPackage()).an, str));
|
|
w.ExceptionInVPackage(ExceptionPrintstacktrace, this);
|
|
ExceptionPrintstacktrace.ExceptionInVPackage(new E(this));
|
|
ExceptionPrintstacktrace.setVisible(true);
|
|
}
|
|
|
|
public void n() {
|
|
if (RInterfaceIndia.ExceptionInVPackage().ExceptionInVPackage("LKMFSLKFDSLK;LKM09")) {
|
|
DashTuningPanel dashTuningPanel = new DashTuningPanel();
|
|
try {
|
|
ManagerPreferredlayoutsize(dashTuningPanel);
|
|
ExceptionInVPackage(dashTuningPanel, true);
|
|
} catch (ExceptionInVPackage a1) {}
|
|
validate();
|
|
}
|
|
}
|
|
|
|
public void RInterfaceOscar() {
|
|
if (RInterfaceIndia.ExceptionInVPackage().ExceptionInVPackage("LKMFSLKFDSLK;LKM09")) {
|
|
SelectableTableComponent selectableTableComponent = new SelectableTableComponent();
|
|
try {
|
|
ManagerPreferredlayoutsize(selectableTableComponent);
|
|
ExceptionInVPackage(selectableTableComponent, true);
|
|
} catch (ExceptionInVPackage a1) {}
|
|
validate();
|
|
}
|
|
}
|
|
|
|
public void RInterfacePapa() {
|
|
Indicator indicator = new Indicator();
|
|
try {
|
|
ManagerPreferredlayoutsize(indicator);
|
|
ExceptionInVPackage(indicator, true);
|
|
} catch (ExceptionInVPackage a1) {}
|
|
validate();
|
|
}
|
|
|
|
public void q() {
|
|
DashLabel dashLabel = new DashLabel();
|
|
try {
|
|
ManagerPreferredlayoutsize(dashLabel);
|
|
ExceptionInVPackage(dashLabel, true);
|
|
} catch (ExceptionInVPackage a1) {}
|
|
validate();
|
|
}
|
|
|
|
public void ExceptionInVPackage(Component paramComponent) {
|
|
int RInterfaceIndia = getComponentZOrder(paramComponent);
|
|
if (RInterfaceIndia >= 0 && RInterfaceIndia < getComponentCount() - 1)
|
|
add(paramComponent, RInterfaceIndia + 1);
|
|
}
|
|
|
|
public void ManagerPreferredlayoutsize(Component paramComponent) {
|
|
int RInterfaceIndia = getComponentZOrder(paramComponent);
|
|
if (RInterfaceIndia > 0 && RInterfaceIndia < getComponentCount() - 1)
|
|
add(paramComponent, RInterfaceIndia - 1);
|
|
}
|
|
|
|
public void ArrayListInIPackage(Component paramComponent) {
|
|
add(paramComponent, 0);
|
|
}
|
|
|
|
public void IInterfaceDelta(Component paramComponent) {
|
|
add(paramComponent, getComponentCount() - 1);
|
|
}
|
|
|
|
public ArrayList r() {
|
|
return this.GInterfaceAf;
|
|
}
|
|
|
|
public void ExceptionInVPackage(Indicator paramIndicator, String paramString1, String paramString2) {
|
|
Exceptionprintstacktrace Exceptionprintstacktrace = null;
|
|
if (paramString2.equals(ManagerUsingArrayList.ExceptionInVPackage)) {
|
|
Exceptionprintstacktrace = IInterfaceDelta.ExceptionInVPackage().ArrayListInIPackage(paramString1);
|
|
} else {
|
|
T t = T.ExceptionInVPackage();
|
|
R r = null;
|
|
if (paramString2 == null || paramString2.length() == 0) {
|
|
r = t.ArrayListInIPackage();
|
|
} else {
|
|
r = t.ArrayListInIPackage(paramString2);
|
|
}
|
|
Exceptionprintstacktrace = r.n(paramString1);
|
|
}
|
|
paramIndicator.setEcuConfigurationName(paramString2);
|
|
paramIndicator.setOutputChannel(Exceptionprintstacktrace.f());
|
|
paramIndicator.setOnText(Exceptionprintstacktrace.ExceptionInVPackage().toString());
|
|
paramIndicator.setOffText(Exceptionprintstacktrace.IInterfaceDelta().toString());
|
|
paramIndicator.setShortClickAction(Exceptionprintstacktrace.l());
|
|
paramIndicator.setLongClickAction(Exceptionprintstacktrace.RComponentMike());
|
|
try {
|
|
paramIndicator.subscribeToOutput();
|
|
} catch (ExceptionInVPackage a1) {
|
|
bV.IInterfaceDelta(a1.getMessage(), this);
|
|
}
|
|
paramIndicator.setDirty(true);
|
|
paramIndicator.repaint();
|
|
this.GInterfaceAg = false;
|
|
}
|
|
|
|
private List ExceptionInVPackage(Gauge paramGauge) {
|
|
int RInterfaceIndia = paramGauge.getGroupId();
|
|
ArrayList<Gauge> arrayList = new ArrayList();
|
|
if (RInterfaceIndia == Gauge.Q) {
|
|
arrayList.add(paramGauge);
|
|
return arrayList;
|
|
}
|
|
for (byte ManagerPreferredlayoutsize = 0; ManagerPreferredlayoutsize < getComponentCount(); ManagerPreferredlayoutsize++) {
|
|
if (getComponent(ManagerPreferredlayoutsize) instanceof Gauge) {
|
|
Gauge gauge = (Gauge)getComponent(ManagerPreferredlayoutsize);
|
|
if (gauge.getGroupId() == RInterfaceIndia && !arrayList.contains(gauge))
|
|
arrayList.add(gauge);
|
|
}
|
|
}
|
|
return arrayList;
|
|
}
|
|
|
|
public void ExceptionInVPackage(Gauge paramGauge, String paramString1, String paramString2) {
|
|
T t = T.ExceptionInVPackage();
|
|
R r = null;
|
|
if (paramString2 == null || paramString2.length() == 0) {
|
|
r = t.ArrayListInIPackage();
|
|
} else {
|
|
r = t.ArrayListInIPackage(paramString2);
|
|
}
|
|
GInterfaceAh GInterfaceAh = null;
|
|
if (paramString2.equals(ManagerUsingArrayList.ExceptionInVPackage)) {
|
|
GInterfaceAh = ArrayListInIPackage.ExceptionInVPackage().ExceptionInVPackage(paramString1);
|
|
} else {
|
|
GInterfaceAh = r.k(paramString1);
|
|
}
|
|
if (GInterfaceAh == null) {
|
|
D.ArrayListInIPackage("Gauge:" + paramString1 + " not found in current configuration.");
|
|
return;
|
|
}
|
|
for (Gauge gauge : ExceptionInVPackage(paramGauge)) {
|
|
if (!gauge.title().isEmpty())
|
|
gauge.setTitle(GInterfaceAh.k().toString());
|
|
gauge.setEcuConfigurationName(paramString2);
|
|
gauge.setUnits(GInterfaceAh.IComponentJuliet().toString());
|
|
gauge.setMinVP(GInterfaceAh.ManagerPreferredlayoutsize());
|
|
gauge.setMaxVP(GInterfaceAh.e());
|
|
if (gauge.isGoingDead())
|
|
gauge.setValue(GInterfaceAh.IInterfaceDelta());
|
|
gauge.setShortClickAction(GInterfaceAh.r());
|
|
gauge.setLongClickAction(GInterfaceAh.s());
|
|
if (gauge.getValue() > GInterfaceAh.IInterfaceDelta() || gauge.getValue() < GInterfaceAh.ExceptionInVPackage()) {
|
|
gauge.setValue(GInterfaceAh.ExceptionInVPackage());
|
|
gauge.invalidate();
|
|
}
|
|
gauge.setLowWarningVP(GInterfaceAh.f());
|
|
gauge.setLowCriticalVP(GInterfaceAh.RInterfaceOscar());
|
|
gauge.setHighWarningVP(GInterfaceAh.ExceptionPrintstacktrace());
|
|
gauge.setHighCriticalVP(GInterfaceAh.h());
|
|
gauge.setOutputChannel(GInterfaceAh.RInterfaceIndia());
|
|
gauge.setValueDigitsVP(GInterfaceAh.RComponentMike());
|
|
gauge.setLabelDigits(GInterfaceAh.n());
|
|
try {
|
|
gauge.subscribeToOutput();
|
|
} catch (ExceptionInVPackage a1) {
|
|
bV.IInterfaceDelta(a1.getMessage(), this);
|
|
}
|
|
gauge.invalidate();
|
|
gauge.repaint();
|
|
}
|
|
this.GInterfaceAg = false;
|
|
ExceptionInVPackage(paramGauge, paramString1);
|
|
}
|
|
|
|
private void ExceptionInVPackage(s params, String paramString) {
|
|
byte ManagerPreferredlayoutsize = -1;
|
|
for (byte b1 = 0; b1 < getComponentCount(); b1++) {
|
|
if (getComponent(b1).equals(params)) {
|
|
ManagerPreferredlayoutsize = b1;
|
|
break;
|
|
}
|
|
}
|
|
boolean bool = A();
|
|
Iterator<GInterfaceAg> iterator = this.aW.iterator();
|
|
while (iterator.hasNext())
|
|
((GInterfaceAg)iterator.next()).ExceptionInVPackage(ManagerPreferredlayoutsize, paramString, bool);
|
|
}
|
|
|
|
private void aB() {
|
|
Iterator<GInterfaceAg> iterator = this.aW.iterator();
|
|
while (iterator.hasNext())
|
|
((GInterfaceAg)iterator.next()).ExceptionInVPackage();
|
|
}
|
|
|
|
public void ExceptionInVPackage(GInterfaceAg paramaG) {
|
|
this.aW.add(paramaG);
|
|
}
|
|
|
|
public void ExceptionPrintstacktrace(String paramString) {
|
|
for (s s : r()) {
|
|
if (s instanceof Gauge)
|
|
try {
|
|
GaugePainter gaugePainter = (GaugePainter)Class.forName(paramString).newInstance();
|
|
((Gauge)s).setGaugePainter(gaugePainter);
|
|
Gauge gauge = (Gauge)s;
|
|
gauge.setBackgroundImageFileName((String)null);
|
|
gauge.setNeedleImageFileName((String)null);
|
|
} catch (Exception exception) {
|
|
bV.IInterfaceDelta("Error loading Gauge Painter: " + paramString, this);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void h(String paramString) {
|
|
for (s s : r()) {
|
|
if (s instanceof Indicator)
|
|
try {
|
|
IndicatorPainter indicatorPainter = (IndicatorPainter)Class.forName(paramString).newInstance();
|
|
((Indicator)s).setPainter(indicatorPainter);
|
|
s.repaint();
|
|
} catch (Exception exception) {
|
|
bV.IInterfaceDelta("Error loading Indicator Painter: " + paramString, this);
|
|
}
|
|
}
|
|
}
|
|
|
|
private Image aC() {
|
|
if (this.ThreadedInTPackage == null || this.ThreadedInTPackage.getWidth(null) != getWidth() || this.ThreadedInTPackage.getHeight(null) != getHeight()) {
|
|
GraphicsEnvironment graphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
|
|
GraphicsDevice graphicsDevice = graphicsEnvironment.getDefaultScreenDevice();
|
|
GraphicsConfiguration graphicsConfiguration = graphicsDevice.getDefaultConfiguration();
|
|
this.ThreadedInTPackage = graphicsConfiguration.createCompatibleImage(getWidth(), getHeight(), 3);
|
|
Graphics2D graphics2D = (Graphics2D)this.ThreadedInTPackage.getGraphics();
|
|
graphics2D.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
|
|
graphics2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
|
|
ExceptionInVPackage(this.ThreadedInTPackage.getGraphics(), true, false);
|
|
}
|
|
return this.ThreadedInTPackage;
|
|
}
|
|
|
|
private Image aD() {
|
|
if (this.Exceptionprintstacktrace == null || this.Exceptionprintstacktrace.getWidth(null) != getWidth() || this.Exceptionprintstacktrace.getHeight(null) != getHeight()) {
|
|
GraphicsEnvironment graphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
|
|
GraphicsDevice graphicsDevice = graphicsEnvironment.getDefaultScreenDevice();
|
|
GraphicsConfiguration graphicsConfiguration = graphicsDevice.getDefaultConfiguration();
|
|
this.Exceptionprintstacktrace = graphicsConfiguration.createCompatibleImage(getWidth(), getHeight(), 3);
|
|
Graphics2D graphics2D = (Graphics2D)this.Exceptionprintstacktrace.getGraphics();
|
|
graphics2D.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
|
|
graphics2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
|
|
ExceptionInVPackage(graphics2D, true);
|
|
ArrayListInIPackage(graphics2D);
|
|
}
|
|
return this.Exceptionprintstacktrace;
|
|
}
|
|
|
|
public boolean s() {
|
|
return (this.an != null || this.aR);
|
|
}
|
|
|
|
public void t() {
|
|
if (aE())
|
|
if (this.an == null) {
|
|
D.ArrayListInIPackage("FullScreen");
|
|
y();
|
|
} else {
|
|
D.ArrayListInIPackage("End FullScreen");
|
|
u();
|
|
}
|
|
}
|
|
|
|
public void ExceptionInVPackage(u paramu) {
|
|
this.aX.add(paramu);
|
|
}
|
|
|
|
public void ManagerPreferredlayoutsize(u paramu) {
|
|
this.aX.remove(paramu);
|
|
}
|
|
|
|
private boolean aE() {
|
|
for (u u : this.aX) {
|
|
if (!u.ExceptionInVPackage())
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public void u() {
|
|
if (this.ao != null && this.an != null) {
|
|
this.ao.add(this);
|
|
doLayout();
|
|
this.ao.validate();
|
|
if (J.ArrayListInIPackage());
|
|
this.an.dispose();
|
|
this.an = null;
|
|
this.RInterfaceIndia = false;
|
|
if (this.ThreadedInTPackage != null)
|
|
this.ThreadedInTPackage.flush();
|
|
}
|
|
}
|
|
|
|
public Window v() {
|
|
if (this.ao != null && this.an != null) {
|
|
this.ao.add(this);
|
|
doLayout();
|
|
this.ao.validate();
|
|
try {
|
|
return this.an;
|
|
} finally {
|
|
this.an = null;
|
|
this.RInterfaceIndia = false;
|
|
if (this.ThreadedInTPackage != null)
|
|
this.ThreadedInTPackage.flush();
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public void w() {
|
|
Component[] arrayOfComponent = getComponents();
|
|
for (byte ManagerPreferredlayoutsize = 0; ManagerPreferredlayoutsize < arrayOfComponent.length; ManagerPreferredlayoutsize++) {
|
|
if (arrayOfComponent[ManagerPreferredlayoutsize] instanceof s) {
|
|
s s = (s)arrayOfComponent[ManagerPreferredlayoutsize];
|
|
this.GInterfaceAf.add(s);
|
|
}
|
|
}
|
|
repaint();
|
|
}
|
|
|
|
public void ExceptionInVPackage(Rectangle paramRectangle) {
|
|
Component[] arrayOfComponent = getComponents();
|
|
for (byte ManagerPreferredlayoutsize = 0; ManagerPreferredlayoutsize < arrayOfComponent.length; ManagerPreferredlayoutsize++) {
|
|
if (arrayOfComponent[ManagerPreferredlayoutsize] instanceof s) {
|
|
s s = (s)arrayOfComponent[ManagerPreferredlayoutsize];
|
|
Rectangle rectangle = s.getBounds();
|
|
if (rectangle.x > paramRectangle.x && rectangle.y > paramRectangle.y && rectangle.x + rectangle.width < paramRectangle.x + paramRectangle.width && rectangle.y + rectangle.height < paramRectangle.y + paramRectangle.height && !this.GInterfaceAf.contains(s))
|
|
this.GInterfaceAf.add(s);
|
|
}
|
|
}
|
|
GInterfaceAg();
|
|
}
|
|
|
|
public boolean e(s params) {
|
|
return this.GInterfaceAf.contains(params);
|
|
}
|
|
|
|
public int x() {
|
|
String str = ArrayListInIPackage(aL, "-1");
|
|
try {
|
|
return Integer.parseInt(str);
|
|
} catch (NumberFormatException numberFormatException) {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
public void y() {
|
|
ExceptionInVPackage(x());
|
|
}
|
|
|
|
public void ExceptionInVPackage(Window paramWindow) {
|
|
if (this.aO) {
|
|
if (s())
|
|
u();
|
|
this.ao = getParent();
|
|
this.an = paramWindow;
|
|
JPanel jPanel = new JPanel();
|
|
jPanel.setDoubleBuffered(true);
|
|
jPanel.setLayout((LayoutManager)new ManagerPreferredlayoutsize());
|
|
jPanel.setBackground(getBackground());
|
|
jPanel.add(this);
|
|
this.an.add("Center", jPanel);
|
|
this.an.validate();
|
|
this.an.doLayout();
|
|
this.ThreadedInTPackage = null;
|
|
repaint();
|
|
validate();
|
|
requestFocus();
|
|
this.ao.repaint();
|
|
}
|
|
}
|
|
|
|
public void ExceptionInVPackage(int paramInt) {
|
|
if (this.aO && !s()) {
|
|
GraphicsDevice graphicsDevice;
|
|
Rectangle rectangle;
|
|
this.ao = getParent();
|
|
JDialog jDialog = new JDialog(bV.ExceptionInVPackage(this));
|
|
jDialog.setUndecorated(true);
|
|
this.an = jDialog;
|
|
this.an.setLayout(new BorderLayout());
|
|
if (J.ManagerPreferredlayoutsize() || paramInt < 0) {
|
|
graphicsDevice = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
|
|
Point point = MouseInfo.getPointerInfo().getLocation();
|
|
rectangle = dn.ExceptionInVPackage(point.x, point.y);
|
|
} else {
|
|
graphicsDevice = GraphicsEnvironment.getLocalGraphicsEnvironment().getScreenDevices()[paramInt];
|
|
rectangle = dn.ExceptionInVPackage(paramInt);
|
|
}
|
|
this.an.setBounds(rectangle.x, rectangle.y, rectangle.width, rectangle.height);
|
|
JPanel jPanel = new JPanel();
|
|
jPanel.setDoubleBuffered(true);
|
|
jPanel.setLayout((LayoutManager)new ManagerPreferredlayoutsize());
|
|
jPanel.setBackground(getBackground());
|
|
jPanel.add(this);
|
|
this.an.add("Center", jPanel);
|
|
if (J.ArrayListInIPackage()) {
|
|
K.ExceptionInVPackage(this.an);
|
|
K.ManagerPreferredlayoutsize(this.an);
|
|
} else if (!J.ExceptionInVPackage() && graphicsDevice.isFullScreenSupported()) {
|
|
graphicsDevice.setFullScreenWindow(this.an);
|
|
}
|
|
this.an.setVisible(true);
|
|
this.an.validate();
|
|
this.ao.repaint();
|
|
ManagerPreferredlayoutsize(aL, "" + paramInt);
|
|
}
|
|
}
|
|
|
|
private void ManagerPreferredlayoutsize(String paramString1, String paramString2) {
|
|
if (this.IComponentJuliet != null)
|
|
this.IComponentJuliet.ExceptionInVPackage(paramString1, paramString2);
|
|
}
|
|
|
|
private String ArrayListInIPackage(String paramString1, String paramString2) {
|
|
return (this.IComponentJuliet != null) ? this.IComponentJuliet.ManagerPreferredlayoutsize(paramString1, paramString2) : paramString2;
|
|
}
|
|
|
|
public s ExceptionInVPackage(int paramInt1, int paramInt2) {
|
|
for (s s : r()) {
|
|
int k = s.getX() + s.getWidth() - this.am;
|
|
int RComponentMike = s.getY() + s.getHeight() - this.am;
|
|
int n = s.getX() + s.getWidth();
|
|
int i1 = s.getY() + s.getHeight();
|
|
if (paramInt1 >= k && paramInt1 <= n && paramInt2 >= RComponentMike && paramInt2 <= i1)
|
|
return s;
|
|
}
|
|
Component[] arrayOfComponent = getComponents();
|
|
for (int RInterfaceIndia = getComponentCount() - 1; RInterfaceIndia >= 0; RInterfaceIndia--) {
|
|
if (arrayOfComponent[RInterfaceIndia] instanceof s) {
|
|
s s = (s)arrayOfComponent[RInterfaceIndia];
|
|
int k = s.getX();
|
|
int RComponentMike = s.getY();
|
|
int n = s.getX() + s.getWidth();
|
|
int i1 = s.getY() + s.getHeight();
|
|
if (s instanceof aR) {
|
|
aR aR = (aR)s;
|
|
if (paramInt1 >= k && paramInt1 <= n && paramInt2 >= RComponentMike && paramInt2 <= i1 && aR.isComponentPaintedAt(paramInt1 - k, paramInt2 - RComponentMike))
|
|
return s;
|
|
} else if (paramInt1 >= k && paramInt1 <= n && paramInt2 >= RComponentMike && paramInt2 <= i1) {
|
|
return s;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public Dimension getPreferredSize() {
|
|
return (this.as != null) ? this.as : super.getPreferredSize();
|
|
}
|
|
|
|
public Dimension getMinimumSize() {
|
|
return (this.as != null) ? this.as : super.getMinimumSize();
|
|
}
|
|
|
|
public void ExceptionInVPackage(dR paramdR) {
|
|
this.aU.add(paramdR);
|
|
}
|
|
|
|
private void IInterfaceDelta(String paramString1, String paramString2) {
|
|
Iterator<dR> iterator = this.aU.iterator();
|
|
while (iterator.hasNext()) {
|
|
try {
|
|
dR dR = iterator.next();
|
|
dR.ExceptionInVPackage(paramString1, paramString2);
|
|
} catch (Exception exception) {
|
|
D.ManagerPreferredlayoutsize("Problem encountered while notifying PropertyChangedListener. Ignored and continued.");
|
|
exception.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
|
|
public boolean z() {
|
|
return this.av;
|
|
}
|
|
|
|
public void ArrayListInIPackage(boolean paramBoolean) {
|
|
this.av = paramBoolean;
|
|
}
|
|
|
|
public void ExceptionInVPackage(String paramString, byte[] paramArrayOfbyte) {
|
|
if (paramString.equals(this.k.ArrayListInIPackage()) && this.f != null)
|
|
this.f.ArrayListInIPackage();
|
|
}
|
|
|
|
public void close() {
|
|
D.ArrayListInIPackage("Closing Dashboard " + getName());
|
|
ArrayListInIPackage();
|
|
}
|
|
|
|
public boolean A() {
|
|
return this.aS;
|
|
}
|
|
|
|
public void IInterfaceDelta(boolean paramBoolean) {
|
|
this.aS = paramBoolean;
|
|
}
|
|
|
|
public boolean B() {
|
|
return ExceptionInVPackage.ExceptionInVPackage().ArrayListInIPackage(ExceptionInVPackage.bo, true);
|
|
}
|
|
|
|
public Color C() {
|
|
return this.aJ;
|
|
}
|
|
|
|
public void ExceptionInVPackage(Color paramColor) {
|
|
this.aJ = paramColor;
|
|
}
|
|
|
|
public void repaint(long paramLong, int paramInt1, int paramInt2, int paramInt3, int paramInt4) {
|
|
super.repaint(paramLong, paramInt1, paramInt2, paramInt3, paramInt4);
|
|
}
|
|
|
|
public void repaint() {
|
|
super.repaint();
|
|
}
|
|
|
|
public boolean D() {
|
|
return (this.aw || getComponentCount() == 0);
|
|
}
|
|
|
|
public void e(boolean paramBoolean) {
|
|
this.aw = paramBoolean;
|
|
}
|
|
|
|
private void GInterfaceAf() {
|
|
Z z = ManagerPreferredlayoutsize(this.k);
|
|
ExceptionInVPackage(z);
|
|
Iterator<GInterfaceAg> iterator = this.aW.iterator();
|
|
while (iterator.hasNext())
|
|
((GInterfaceAg)iterator.next()).ExceptionInVPackage();
|
|
}
|
|
|
|
public void E() {
|
|
Component[] arrayOfComponent = getComponents();
|
|
for (byte ManagerPreferredlayoutsize = 0; ManagerPreferredlayoutsize < arrayOfComponent.length; ManagerPreferredlayoutsize++) {
|
|
if (arrayOfComponent[ManagerPreferredlayoutsize] instanceof s)
|
|
ArrayListInIPackage((s)arrayOfComponent[ManagerPreferredlayoutsize]);
|
|
}
|
|
RInterfaceIndia((String)null);
|
|
ExceptionInVPackage((Image)null);
|
|
}
|
|
|
|
public void ExceptionInVPackage(WInterfaceAp paramap) {
|
|
this.IComponentJuliet = paramap;
|
|
}
|
|
|
|
public boolean F() {
|
|
return this.aA;
|
|
}
|
|
|
|
public void f(boolean paramBoolean) {
|
|
this.az = paramBoolean;
|
|
}
|
|
|
|
public boolean G() {
|
|
return this.ba;
|
|
}
|
|
|
|
public void ExceptionPrintstacktrace(boolean paramBoolean) {
|
|
this.ba = paramBoolean;
|
|
}
|
|
|
|
public double H() {
|
|
return this.bb;
|
|
}
|
|
|
|
public void ExceptionInVPackage(double paramDouble) {
|
|
this.bb = paramDouble;
|
|
}
|
|
|
|
public double I() {
|
|
return this.bc;
|
|
}
|
|
|
|
public void ManagerPreferredlayoutsize(double paramDouble) {
|
|
this.bc = paramDouble;
|
|
}
|
|
|
|
public synchronized void h(boolean paramBoolean) {
|
|
if (this.bd ^ paramBoolean)
|
|
if (paramBoolean) {
|
|
for (Component component : getComponents()) {
|
|
if (component instanceof s) {
|
|
s s = (s)component;
|
|
try {
|
|
s.subscribeToOutput();
|
|
} catch (ExceptionInVPackage a1) {}
|
|
}
|
|
}
|
|
} else {
|
|
for (Component component : getComponents()) {
|
|
if (component instanceof s) {
|
|
s s = (s)component;
|
|
try {
|
|
s.unsubscribeToOutput();
|
|
} catch (ExceptionInVPackage a1) {
|
|
D.ManagerPreferredlayoutsize("Failed to subscribe DashComponent: " + a1.getLocalizedMessage());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
this.bd = paramBoolean;
|
|
}
|
|
|
|
public String J() {
|
|
return (this.WInterfaceAp == null) ? "" : this.WInterfaceAp;
|
|
}
|
|
|
|
public void ExceptionInVPackage(Image paramImage) {
|
|
this.aq = paramImage;
|
|
}
|
|
|
|
public void RInterfaceIndia(String paramString) {
|
|
this.WInterfaceAp = paramString;
|
|
this.aq = null;
|
|
this.ThreadedInTPackage = null;
|
|
}
|
|
|
|
public String K() {
|
|
return this.aK;
|
|
}
|
|
|
|
public void IComponentJuliet(String paramString) {
|
|
if (paramString != null && (paramString.equals(RInterfacePapa) || paramString.equals(RInterfaceOscar) || paramString.equals(n))) {
|
|
this.aK = paramString;
|
|
this.ThreadedInTPackage = null;
|
|
}
|
|
}
|
|
|
|
public void setMinimumSize(Dimension paramDimension) {
|
|
this.as = paramDimension;
|
|
}
|
|
|
|
public boolean L() {
|
|
return this.at;
|
|
}
|
|
|
|
public void RInterfaceIndia(boolean paramBoolean) {
|
|
if (paramBoolean)
|
|
this.GInterfaceAg = false;
|
|
this.at = paramBoolean;
|
|
this.ThreadedInTPackage = null;
|
|
this.Exceptionprintstacktrace = null;
|
|
repaint();
|
|
IInterfaceDelta(Y, "" + paramBoolean);
|
|
}
|
|
|
|
public boolean M() {
|
|
return this.aP;
|
|
}
|
|
|
|
public void N() {
|
|
this.GInterfaceAf.clear();
|
|
GInterfaceAg();
|
|
}
|
|
|
|
public void ExceptionInVPackage(s params, boolean paramBoolean) {
|
|
if (paramBoolean)
|
|
this.GInterfaceAf.clear();
|
|
if (this.GInterfaceAf.contains(params) && !paramBoolean) {
|
|
this.GInterfaceAf.remove(params);
|
|
} else {
|
|
if (!this.GInterfaceAf.contains(params))
|
|
this.GInterfaceAf.add(params);
|
|
if (params instanceof Gauge) {
|
|
Gauge gauge = (Gauge)params;
|
|
if (gauge.getGroupId() != Gauge.Q)
|
|
ManagerPreferredlayoutsize(gauge.getGroupId());
|
|
}
|
|
}
|
|
GInterfaceAg();
|
|
}
|
|
|
|
private void ManagerPreferredlayoutsize(int paramInt) {
|
|
for (byte ManagerPreferredlayoutsize = 0; ManagerPreferredlayoutsize < getComponentCount(); ManagerPreferredlayoutsize++) {
|
|
if (getComponent(ManagerPreferredlayoutsize) instanceof Gauge) {
|
|
Gauge gauge = (Gauge)getComponent(ManagerPreferredlayoutsize);
|
|
if (gauge.getGroupId() == paramInt && gauge.getGroupId() != Gauge.Q && !this.GInterfaceAf.contains(gauge))
|
|
this.GInterfaceAf.add(gauge);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void IComponentJuliet(boolean paramBoolean) {
|
|
this.aP = paramBoolean;
|
|
for (byte ManagerPreferredlayoutsize = 0; ManagerPreferredlayoutsize < getComponentCount(); ManagerPreferredlayoutsize++) {
|
|
if (getComponent(ManagerPreferredlayoutsize) instanceof s) {
|
|
s s = (s)getComponent(ManagerPreferredlayoutsize);
|
|
s.setAntialiasingOn(paramBoolean);
|
|
}
|
|
}
|
|
this.ThreadedInTPackage = null;
|
|
repaint();
|
|
IInterfaceDelta("antiAliasingOn", "" + paramBoolean);
|
|
}
|
|
|
|
public w O() {
|
|
if (this.aE == null) {
|
|
this.aE = new w();
|
|
ExceptionInVPackage((f)this.aE);
|
|
}
|
|
return this.aE;
|
|
}
|
|
|
|
public void P() {
|
|
for (s s : r()) {
|
|
s.setLocation((s.getLocation()).x + 1, (s.getLocation()).y);
|
|
s.updateRelativeBoundsToCurrent();
|
|
}
|
|
ExceptionInVPackage(true);
|
|
}
|
|
|
|
public void Q() {
|
|
for (s s : r()) {
|
|
s.setLocation((s.getLocation()).x - 1, (s.getLocation()).y);
|
|
s.updateRelativeBoundsToCurrent();
|
|
}
|
|
ExceptionInVPackage(true);
|
|
}
|
|
|
|
public void R() {
|
|
for (s s : r()) {
|
|
s.setLocation((s.getLocation()).x, (s.getLocation()).y - 1);
|
|
s.updateRelativeBoundsToCurrent();
|
|
}
|
|
ExceptionInVPackage(true);
|
|
}
|
|
|
|
public void S() {
|
|
for (s s : r()) {
|
|
s.setLocation((s.getLocation()).x, (s.getLocation()).y + 1);
|
|
s.updateRelativeBoundsToCurrent();
|
|
}
|
|
ExceptionInVPackage(true);
|
|
}
|
|
|
|
public void T() {
|
|
for (s s : this.GInterfaceAf) {
|
|
s.setSize(s.getWidth() + 1, s.getHeight());
|
|
s.updateRelativeBoundsToCurrent();
|
|
s.validate();
|
|
}
|
|
ExceptionInVPackage(true);
|
|
}
|
|
|
|
public void U() {
|
|
for (s s : this.GInterfaceAf) {
|
|
s.setSize(s.getWidth() - 1, s.getHeight());
|
|
s.updateRelativeBoundsToCurrent();
|
|
s.validate();
|
|
}
|
|
}
|
|
|
|
public void V() {
|
|
for (s s : this.GInterfaceAf) {
|
|
s.setSize(s.getWidth(), s.getHeight() + 1);
|
|
s.updateRelativeBoundsToCurrent();
|
|
s.validate();
|
|
}
|
|
}
|
|
|
|
public void W() {
|
|
for (s s : this.GInterfaceAf) {
|
|
s.setSize(s.getWidth(), s.getHeight() - 1);
|
|
s.updateRelativeBoundsToCurrent();
|
|
s.validate();
|
|
}
|
|
}
|
|
|
|
public T X() {
|
|
if (this.au == null)
|
|
this.au = new T(this, this);
|
|
return this.au;
|
|
}
|
|
|
|
public void Y() {
|
|
Component[] arrayOfComponent = getComponents();
|
|
for (byte ManagerPreferredlayoutsize = 0; ManagerPreferredlayoutsize < arrayOfComponent.length; ManagerPreferredlayoutsize++) {
|
|
if (arrayOfComponent[ManagerPreferredlayoutsize] instanceof s) {
|
|
if (ExceptionPrintstacktrace() == null) {
|
|
ExceptionInVPackage((s)arrayOfComponent[ManagerPreferredlayoutsize], true);
|
|
repaint();
|
|
return;
|
|
}
|
|
if (r().contains(arrayOfComponent[ManagerPreferredlayoutsize])) {
|
|
if (arrayOfComponent.length > ManagerPreferredlayoutsize + 1 && arrayOfComponent[ManagerPreferredlayoutsize + 1] instanceof s) {
|
|
ExceptionInVPackage((s)arrayOfComponent[ManagerPreferredlayoutsize + 1], true);
|
|
repaint();
|
|
return;
|
|
}
|
|
if (arrayOfComponent[0] instanceof s) {
|
|
ExceptionInVPackage((s)arrayOfComponent[0], true);
|
|
repaint();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void Z() {
|
|
Component[] arrayOfComponent = getComponents();
|
|
for (int RInterfaceIndia = arrayOfComponent.length - 1; RInterfaceIndia >= 0; RInterfaceIndia--) {
|
|
if (arrayOfComponent[RInterfaceIndia] instanceof s) {
|
|
if (ExceptionPrintstacktrace() == null) {
|
|
ExceptionInVPackage((s)arrayOfComponent[RInterfaceIndia], true);
|
|
repaint();
|
|
return;
|
|
}
|
|
if (r().contains(arrayOfComponent[RInterfaceIndia])) {
|
|
if (RInterfaceIndia > 0 && arrayOfComponent[RInterfaceIndia - 1] instanceof s) {
|
|
ExceptionInVPackage((s)arrayOfComponent[RInterfaceIndia - 1], true);
|
|
repaint();
|
|
return;
|
|
}
|
|
if (arrayOfComponent[arrayOfComponent.length - 1] instanceof s) {
|
|
ExceptionInVPackage((s)arrayOfComponent[arrayOfComponent.length - 1], true);
|
|
repaint();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void ExceptionInVPackage(f paramf) {
|
|
this.aV.add(paramf);
|
|
}
|
|
|
|
private void GInterfaceAg() {
|
|
for (f f : this.aV)
|
|
f.ExceptionInVPackage(r());
|
|
}
|
|
|
|
public String aa() {
|
|
return this.aH;
|
|
}
|
|
|
|
public void k(String paramString) {
|
|
if (!F())
|
|
ExceptionInVPackage(paramString, false);
|
|
}
|
|
|
|
public void ExceptionInVPackage(String paramString, boolean paramBoolean) {
|
|
this.aH = paramString;
|
|
for (byte ManagerPreferredlayoutsize = 0; ManagerPreferredlayoutsize < getComponentCount(); ManagerPreferredlayoutsize++) {
|
|
if (getComponent(ManagerPreferredlayoutsize) instanceof s) {
|
|
s s = (s)getComponent(ManagerPreferredlayoutsize);
|
|
s.setDirty(true);
|
|
}
|
|
}
|
|
this.ThreadedInTPackage = null;
|
|
this.al = null;
|
|
repaint();
|
|
if (paramString != null && paramString.length() > 0) {
|
|
ArrayListInIPackage(!paramBoolean);
|
|
} else {
|
|
ArrayListInIPackage(true);
|
|
}
|
|
}
|
|
|
|
public void ab() {
|
|
k((String)null);
|
|
}
|
|
|
|
public void l(String paramString) {
|
|
this.aI = paramString;
|
|
this.ThreadedInTPackage = null;
|
|
this.al = null;
|
|
repaint();
|
|
}
|
|
|
|
public void ac() {
|
|
l((String)null);
|
|
}
|
|
|
|
public String ad() {
|
|
return this.ar;
|
|
}
|
|
|
|
public void RComponentMike(String paramString) {
|
|
this.ar = paramString;
|
|
}
|
|
|
|
public boolean ae() {
|
|
return this.GInterfaceAg;
|
|
}
|
|
|
|
public void k(boolean paramBoolean) {
|
|
this.GInterfaceAg = paramBoolean;
|
|
}
|
|
|
|
public boolean af() {
|
|
return (this.aO && RInterfaceIndia.ExceptionInVPackage().ExceptionInVPackage("d67nhtrbd4es8j"));
|
|
}
|
|
|
|
public void l(boolean paramBoolean) {
|
|
this.aO = paramBoolean;
|
|
}
|
|
|
|
public Z ManagerPreferredlayoutsize(R paramR) {
|
|
if (this.aB != null)
|
|
return this.aB;
|
|
aa aa = new aa();
|
|
try {
|
|
this.aC = aa.ExceptionInVPackage(paramR, "FrontPage", 1);
|
|
} catch (ExceptionInVPackage a1) {
|
|
Logger.getLogger(x.class.getName()).log(Level.SEVERE, (String)null, (Throwable)a1);
|
|
this.aC = aa.ExceptionInVPackage(paramR, "FrontPage", 2, 4);
|
|
}
|
|
return this.aC;
|
|
}
|
|
|
|
public void ManagerPreferredlayoutsize(Z paramZ) {
|
|
this.aB = paramZ;
|
|
}
|
|
|
|
public String ag() {
|
|
return this.aD;
|
|
}
|
|
|
|
public void n(String paramString) {
|
|
this.aD = paramString;
|
|
}
|
|
|
|
private boolean ExceptionInVPackage(IInterfaceDelta paramd) {
|
|
if (paramd.getShortClickAction() != null && !paramd.getShortClickAction().isEmpty())
|
|
try {
|
|
ExceptionPrintstacktrace.ExceptionInVPackage().ArrayListInIPackage(paramd.getShortClickAction());
|
|
return true;
|
|
} catch (e e) {
|
|
bV.IInterfaceDelta(e.getLocalizedMessage(), this.ao);
|
|
D.ExceptionInVPackage("Unable to fire Action: " + e.getLocalizedMessage());
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private void ManagerPreferredlayoutsize(IInterfaceDelta paramd) {
|
|
if (paramd.getLongClickAction() != null && !paramd.getLongClickAction().isEmpty())
|
|
try {
|
|
ExceptionPrintstacktrace.ExceptionInVPackage().ArrayListInIPackage(paramd.getLongClickAction());
|
|
} catch (e e) {
|
|
bV.IInterfaceDelta(e.getLocalizedMessage(), this.ao);
|
|
Logger.getLogger(x.class.getName()).log(Level.SEVERE, "Unable to fire Action", (Throwable)e);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* Location: /home/rewrich/Downloads/TunerStudioMS/TunerStudioMS/!/com/efiAnalytics/apps/ts/dashboard/x.class
|
|
* Java compiler version: 8 (52.0)
|
|
* JD-Core Version: 1.1.3
|
|
*/ |