lät jag klassen Graph att utöka från klassen JComponent som
är en lättviktigare komponent.
Det fungerar alldeles förträffligt bra att nu dra i en slider för att
justera en marker. Sedan kan jag finjustera med en spinner.
När jag drar i slidern så ändras värdet i spinnern och tvärt om.
Det är spinnern som har händelsehanteraren och ritar om de
buffrade bilderna med uppdaterade värden för markeringslinjerna
och tillhörande värden som syns, och följer med, linjerna.
På något sätt tänkte jag inkludera en graf i NTC-interfacet så jag måste
då också lösa hur jag ska få axlarna att graderas riktigt beroende på
vilken kurva jag får. Max y-värde ges ju av kurvans formel och max x-värde
av mellan vilka motståndsvärden kurvan ritas.
Kod: Markera allt
import java.awt.AlphaComposite;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.geom.Point2D;
import javax.swing.JComponent;
public class Graph extends JComponent {
private static final long serialVersionUID = 1L;
public static final int AXIS_MARGIN = 68; // totala marginalen ovan+under och vänster+höger
public static final int HALF_AXIS_MARGIN = AXIS_MARGIN/2;
public static final int X_MARKERS_SPACE = 20; // antal pixlar mellan varje markör på x-axeln
public static final int Y_MARKERS_SPACE = 10; // sätter steglängden hos markörer
public static final int MARKER_LENGTH = 1; // markörernas halva längd
public static final double SCALEFACTOR_Y = 100.0; // y-axeln ska visa 100ggr mindre värden än dess längd i pixlar
private int jComponentWidth;
private int jComponentHeight;
private ImageA imgA;
private ImageB imgB;
private static Point2D origo;
private Graphics2D g;
private int markerLineX1pos;
private int markerLineY1pos;
private int markerLineX2pos;
private int markerLineY2pos;
private AlphaComposite compA;
private AlphaComposite compB;
private int yAxisStart;
private int xAxisStart;
private int xAxisEnd;
private int yAxisEnd;
private String sY1;
private String sY2;
private String sX1;
private String sX2;
private Font f;
/*
* Konstruktor. Skapar en JComponent med höjd, bredd och placeras
* med offset i x- och y-led i den behållare där den ingår.
* Buffrade bilder placeras sedan på denna JComponent.
*/
public Graph(int offsetX, int offsetY,int width, int height) {
jComponentWidth = width;
jComponentHeight = height;
setBackground(Color.WHITE);
setBounds(offsetX, offsetY, width, height);
imgA = new ImageA(jComponentWidth,jComponentHeight,Color.WHITE); // skapa en buffrad bild med x-y-axel
imgB = new ImageB(jComponentWidth-AXIS_MARGIN,jComponentHeight-AXIS_MARGIN,Color.WHITE); // skapa en buffrad bild med plottad funktion
markerLineX1pos = markerLineX2pos = (int) origo.getX();
markerLineY1pos = markerLineY2pos = (int) origo.getY();
compA = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1.0f); // genomskinlighetsgrad
compB = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.5f);
yAxisStart = (int) origo.getY();
xAxisStart = (int) origo.getX();
xAxisEnd = jComponentWidth - HALF_AXIS_MARGIN;
yAxisEnd = HALF_AXIS_MARGIN;
sY1 = sX1 = sY2 = sX2 = Double.toString(0.0); // utgångsläge för markörer X1,Y1,X2,Y2
f = new Font("SansSerif",Font.BOLD,12); // text/font markörvärde label
}
public void paint(Graphics gr) {
super.paint(gr);
g = (Graphics2D) gr;
g.setFont(f);
g.setComposite(compA);
g.drawImage(imgA, null, 0, 0); // rita den buffrade bilden
g.setComposite(compB);
g.drawImage(imgB, null, xAxisStart ,HALF_AXIS_MARGIN); // rita den buffrade bilden
drawMarkerLineX1(markerLineX1pos); // rita en flyttbar x-markering i JComponent
drawMarkerLineY1(markerLineY1pos); // rita en flyttbar y-markering i JComponent
drawMarkerLineX2(markerLineX2pos); // rita en flyttbar x-markering i JComponent
drawMarkerLineY2(markerLineY2pos); // rita en flyttbar y-markering i JComponent
g.dispose();
}
/*
* Ritar en lodrät markeringslinje i grafen på angiven X1-koordinat.
*/
private void drawMarkerLineX1(int x) {
g.setPaint(Color.BLUE);
sX1 = Double.toString(x-Graph.HALF_AXIS_MARGIN);
g.drawString(sX1, x+3, yAxisEnd+10); // rita en label med aktuellt X1-värde
g.drawLine(x, HALF_AXIS_MARGIN, x, yAxisStart);
}
/*
* Ritar en lodrät markeringslinje i grafen på angiven X2-koordinat.
*/
private void drawMarkerLineX2(int x) {
g.setPaint(Color.ORANGE);
sX2 = Double.toString(x-Graph.HALF_AXIS_MARGIN);
g.drawString(sX2, x+3, yAxisEnd+21); // rita en label med aktuellt X2-värde
g.drawLine(x, HALF_AXIS_MARGIN, x, yAxisStart);
}
/*
* Ritar en vågrät markeringslinje i grafen på angiven Y1-koordinat.
*/
private void drawMarkerLineY1(int y) {
g.setPaint(Color.BLUE);
sY1 = Double.toString((yAxisStart-y)/SCALEFACTOR_Y);
g.drawString(sY1, xAxisEnd-10, y-3); // rita en label med aktuellt Y1-värde
g.drawLine(HALF_AXIS_MARGIN, y, xAxisEnd, y);
}
/*
* Ritar en vågrät markeringslinje i grafen på angiven Y2-koordinat.
*/
private void drawMarkerLineY2(int y) {
g.setPaint(Color.ORANGE);
sY2 = Double.toString((yAxisStart-y)/SCALEFACTOR_Y);
g.drawString(sY2, xAxisEnd-35, y-3); // rita en label med aktuellt Y2-värde
g.drawLine(HALF_AXIS_MARGIN, y, jComponentWidth - HALF_AXIS_MARGIN, y);
}
/*
* Flyttar/uppdaterar y-koordinaten för den vågräta markeringslinjen Y1
* Händelsehanterare i GUI aktiverar denna metod
*/
public void setMarkerLineY1pos(int y) {
markerLineY1pos= yAxisStart - y;
repaint();
}
/*
* Flyttar/uppdaterar y-koordinaten för den vågräta markeringslinjen Y2
* Händelsehanterare i GUI aktiverar denna metod
*/
public void setMarkerLineY2pos(int y) {
markerLineY2pos= yAxisStart - y;
repaint();
}
/*
* Flyttar/uppdaterar x-koordinaten för den lodräta markeringslinjen X1
* Händelsehanterare i GUI aktiverar denna metod
*/
public void setMarkerLineX1pos(int x) {
markerLineX1pos= x + xAxisStart;
repaint();
}
/*
* Flyttar/uppdaterar x-koordinaten för den lodräta markeringslinjen X2
* Händelsehanterare i GUI aktiverar denna metod
*/
public void setMarkerLineX2pos(int x) {
markerLineX2pos= x + xAxisStart;
repaint();
}
public static void setOrigo(Point2D origo) {
Graph.origo = origo;
}
public static Point2D getOrigo() {
return origo;
}
}
Kod: Markera allt
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.geom.AffineTransform;
import java.awt.geom.Line2D;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
/*
* Skapar en buffrad bild som ligger i botten av ett lager med flera bilder.
* Bilden består av en färgad rektangel som det går att rita i.
* Denna basbild innehåller en skalad x- och y-axel.
*/
public class ImageA extends BufferedImage {
private Graphics2D g;
private Rectangle2D rek;
private int jComponentWidth;
private int jComponentHeight;
private int xAxisLength;
private int yAxisLength;
private int xAxisStart;
private int xAxisEnd;
private int yAxisStart;
private int yAxisEnd;
private Point2D xEnd;
private Point2D yEnd;
private Point2D origo;
private int numberOfxMarkers;
private int numberOfyMarkers;
public ImageA(int width, int height, Color color) {
super(width, height, BufferedImage.TYPE_INT_ARGB);
jComponentWidth = width;
jComponentHeight = height;
g = this.createGraphics();
g.setStroke(new BasicStroke(1.0f));
rek = new Rectangle2D.Double(0,0,width,height);
g.setPaint(color);
g.fill(rek);
g.draw(rek);
g.setPaint(Color.BLACK);
drawAxis();
drawMarkers();
g.dispose();
}
/*
* Ritar markeringar med jämna mellanrum på de båda axlarna.
*
*/
private void drawMarkers() {
numberOfxMarkers = xAxisLength/Graph.X_MARKERS_SPACE;
numberOfyMarkers = yAxisLength/Graph.Y_MARKERS_SPACE;
int dx = xAxisLength/numberOfxMarkers;
int dy = yAxisLength/numberOfyMarkers;
int xs = xAxisStart;
int xe = xAxisEnd;
int ys = yAxisStart;
int ye = yAxisEnd;
Font font = new Font("SansSerif", Font.PLAIN, 14);
AffineTransform affineTransform = new AffineTransform();
affineTransform.rotate(Math.toRadians(90), 0, 0);
Font rotatedFont = font.deriveFont(affineTransform);
g.setFont(rotatedFont);
for(int i=xs;i<=xe;i+=dx) { // börja rita x-markörer från origo
drawXMarker(i,(i-xs));
}
font = new Font("SansSerif", Font.PLAIN, 11);
affineTransform = new AffineTransform();
affineTransform.rotate(Math.toRadians(0), 0, 0);
rotatedFont = font.deriveFont(affineTransform);
g.setFont(rotatedFont);
for(int i=ys;i>=ye;i-=dy) { // börja rita y-markörer från origo
drawYMarker(i,(ys-i)/Graph.SCALEFACTOR_Y);
}
}
/*
* Ritar markörer utmed x-axeln på de positioner som anges av
* parametern xpos.
*/
private void drawXMarker(int xpos,double scaleNumber) {
String s = String.valueOf((int)scaleNumber);
Point xm1 = new Point(xpos,(int)origo.getY()+Graph.MARKER_LENGTH);
Point xm2 = new Point(xpos,(int)origo.getY()-Graph.MARKER_LENGTH);
Line2D.Double marker = new Line2D.Double(xm1,xm2);
g.draw(marker);
drawXScale(s,xpos-3,(int)(origo.getY()+5));
}
/*
* Ritar markörer utmed y-axeln på de positioner som anges av
* parametern ypos.
*/
private void drawYMarker(int ypos, double scaleNumber) {
String s = String.valueOf(scaleNumber);
Point ym1 = new Point((int)origo.getX()-Graph.MARKER_LENGTH,ypos);
Point ym2 = new Point((int)origo.getX()+Graph.MARKER_LENGTH,ypos);
Line2D.Double marker = new Line2D.Double(ym1,ym2);
g.draw(marker);
drawYScale(s,(int)(origo.getX()),ypos);
}
/*
* Graderar x-axeln med tal
*/
private void drawXScale(String s, int xpos, int ypos) {
g.setPaint(Color.BLUE);
g.drawString(s, xpos-1, ypos+1);
}
/*
* Graderar y-axeln med tal
*/
private void drawYScale(String s, int xpos, int ypos) {
g.setPaint(Color.RED);
g.drawString(s, xpos-20, ypos+3);
}
/*
* Ritar de två axlarna med origo i sydväst.
* Axlarnas längd i pixlar begränsas av JComponent:ens höjd och bredd och
* den valda marginalen från dess ytterkanter till där axlarna ritas.
*/
private void drawAxis() {
xAxisLength = jComponentWidth - Graph.AXIS_MARGIN;
yAxisLength = jComponentHeight- Graph.AXIS_MARGIN;
xAxisStart = jComponentWidth - xAxisLength - Graph.HALF_AXIS_MARGIN;
yAxisEnd = jComponentHeight - yAxisLength - Graph.HALF_AXIS_MARGIN;
yAxisStart = jComponentHeight - Graph.HALF_AXIS_MARGIN;
xAxisEnd = xAxisLength + xAxisStart;
Graph.setOrigo(new Point(xAxisStart,yAxisStart));
origo = Graph.getOrigo();
xEnd = new Point(xAxisEnd,yAxisStart);
yEnd = new Point(xAxisStart,yAxisEnd);
Line2D.Double xAxel = new Line2D.Double(origo,xEnd);
Line2D.Double yAxel = new Line2D.Double(origo, yEnd);
g.draw(xAxel);
g.draw(yAxel);
}
}
Kod: Markera allt
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
/*
* Skapar en buffrad bild.
* Bilden består av en färgad rektangel som det går att rita i.
* Denna bild innehåller en plottad kurva.
*/
public class ImageB extends BufferedImage {
private Graphics2D g;
private Rectangle2D rek;
private Point2D origo;
public ImageB(int width, int height, Color color) {
super(width, height, BufferedImage.TYPE_INT_ARGB);
origo = Graph.getOrigo();
g = this.createGraphics();
g.setStroke(new BasicStroke(1.0f));
rek = new Rectangle2D.Double(0,0,width,height);
g.setPaint(color);
g.fill(rek);
g.draw(rek);
g.setPaint(Color.BLACK);
plotFunction(SwingWindow.A,SwingWindow.B,SwingWindow.C); // funktionskonstanter hämtas från main-klassen
g.dispose();
}
/*
* Ritar en funktion y(x) i x-y-grafen. y(x) = a + bx + cx^2
* y = 2.31 - 0.0047*R + 1.93*10^-6*R^2
*
*/
private void plotFunction(double a, double b, double c) {
double x1 = 0;
double y1 = 0;
double x2 = 0;
double y2 = 0;
while(y2>=0) {
y2 = (a + b*x2 + c*Math.pow(x2, 2))*100;
g.drawLine(x(x1), y(y1), x(x2), y(y2));
x1 = x2;
y1 = y2;
x2 = x2+1;
}
}
/*
* Parametern x refererar till en x-koordinat med ett origo som har x=0 och y=0
* Returnerar den absoluta x-koordinaten i förhållande till det origo
* som ritats i canvas med de faktiska x- och y-koordinaterna.
*/
private int x(double x) {
return (int)(origo.getX()+x-Graph.AXIS_MARGIN/2);
}
/*
* Parametern y refererar till en y-koordinat med ett origo som har x=0 och y=0
* Returnerar den absoluta y-koordinaten i förhållande till det origo
* som ritats i canvas med de faktiska x- och y-koordinaterna.
*/
private int y(double y) {
return (int)(origo.getY()-y-Graph.AXIS_MARGIN/2);
}
}
Kod: Markera allt
import javax.swing.JFrame;
import java.awt.SystemColor;
import javax.swing.JButton;
import javax.swing.Box;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.EventQueue;
import javax.swing.JSpinner;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.event.ChangeListener;
import javax.swing.event.ChangeEvent;
import java.awt.Color;
import javax.swing.SpringLayout;
import javax.swing.SpinnerNumberModel;
import javax.swing.JSlider;
public class SwingWindow extends JFrame {
private static final long serialVersionUID = 1L;
public final int WINDOW_WIDTH = 800;
public final int WINDOW_HEIGHT = 520;
public static final int JC_WIDTH = 772;
public static final int JC_HEIGHT = 365;
public final int SPINNER_X_STARTVALUE = 0;
public final int SPINNER_Y_STARTVALUE = 0;
// y = 2.31 - 0.0047*x + 1.93*10^-6*x^2
public static final double A = 2.31;
public static final double B = -0.0047;
public static final double C = 0.00000193;
private static JButton b0;
private static JButton b1;
private static JButton b2;
private static JSpinner spinner_X1;
private static JSpinner spinner_Y1;
private static JSpinner spinner_X2;
private static JSpinner spinner_Y2;
private static int spinner_X1_value;
private static int spinner_Y1_value;
private static int spinner_X2_value;
private static int spinner_Y2_value;
private JSlider sliderX1;
private JSlider sliderY1;
private JSlider sliderX2;
private JSlider sliderY2;
private Graph graph;
public static SwingWindow swingwindow;
private Box horizontalBox;
/**
* Launch the application.
*/
public static void main(String[] args) {
//swingwindow = new SwingWindow();
//swingwindow.setVisible(true);
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
swingwindow = new SwingWindow();
swingwindow.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}
/**
* Create the application.
*/
public SwingWindow() {
super("Swing");
setMaximumSize(new Dimension(1000, 800));
getContentPane().setBackground(new Color(240, 230, 140));
getContentPane().setLayout(null);
setBounds(400, 100, WINDOW_WIDTH, WINDOW_HEIGHT);
setDefaultCloseOperation(DO_NOTHING_ON_CLOSE);
setUpGUI();
}
/**
* Initialize the contents of the frame.
*/
private void setUpGUI() {
JPanel panel = new JPanel();
panel.setBackground(SystemColor.menu);
panel.setBounds(5, 376, 772, 100);
getContentPane().add(panel);
SpringLayout sl_panel = new SpringLayout();
panel.setLayout(sl_panel);
Box horizontalBox_1 = Box.createHorizontalBox();
sl_panel.putConstraint(SpringLayout.WEST, horizontalBox_1, 10, SpringLayout.WEST, panel);
sl_panel.putConstraint(SpringLayout.EAST, horizontalBox_1, -10, SpringLayout.EAST, panel);
horizontalBox_1.setOpaque(true);
sl_panel.putConstraint(SpringLayout.NORTH, horizontalBox_1, 11, SpringLayout.NORTH, panel);
panel.add(horizontalBox_1);
JLabel lblYMarker = new JLabel("Y1 marker");
horizontalBox_1.add(lblYMarker);
Component rigidArea = Box.createRigidArea(new Dimension(20, 20));
rigidArea.setMinimumSize(new Dimension(15, 20));
rigidArea.setPreferredSize(new Dimension(15, 20));
rigidArea.setMaximumSize(new Dimension(15, 20));
horizontalBox_1.add(rigidArea);
spinner_Y1 = new JSpinner();
spinner_Y1.setValue(0);
spinner_Y1.setDoubleBuffered(true);
spinner_Y1.setMinimumSize(new Dimension(15, 20));
spinner_Y1.setPreferredSize(new Dimension(15, 20));
spinner_Y1.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent e) {
spinner_Y1_value = (int) spinner_Y1.getValue();
sliderY1.setValue(spinner_Y1_value);
graph.setMarkerLineY1pos(spinner_Y1_value);
}
});
horizontalBox_1.add(spinner_Y1);
Component rigidArea_5 = Box.createRigidArea(new Dimension(20, 20));
rigidArea_5.setMinimumSize(new Dimension(15, 20));
rigidArea_5.setPreferredSize(new Dimension(15, 20));
rigidArea_5.setMaximumSize(new Dimension(15, 20));
horizontalBox_1.add(rigidArea_5);
JLabel lblXMarker = new JLabel("X1 marker");
horizontalBox_1.add(lblXMarker);
Component rigidArea_1 = Box.createRigidArea(new Dimension(20, 20));
rigidArea_1.setMinimumSize(new Dimension(15, 20));
rigidArea_1.setPreferredSize(new Dimension(15, 20));
rigidArea_1.setMaximumSize(new Dimension(15, 20));
horizontalBox_1.add(rigidArea_1);
spinner_X1 = new JSpinner();
spinner_X1.setModel(new SpinnerNumberModel(0, 0, 700, 1));
spinner_X1.setValue(0);
spinner_X1.setDoubleBuffered(true);
spinner_X1.setMinimumSize(new Dimension(15, 20));
spinner_X1.setPreferredSize(new Dimension(15, 20));
spinner_X1.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent e) {
spinner_X1_value = (int) spinner_X1.getValue();
sliderX1.setValue(spinner_X1_value);
graph.setMarkerLineX1pos(spinner_X1_value);
}
});
horizontalBox_1.add(spinner_X1);
Component rigidArea_8 = Box.createRigidArea(new Dimension(20, 20));
rigidArea_8.setMinimumSize(new Dimension(15, 20));
rigidArea_8.setPreferredSize(new Dimension(15, 20));
rigidArea_8.setMaximumSize(new Dimension(15, 20));
horizontalBox_1.add(rigidArea_8);
JLabel lblXMarker_1 = new JLabel("Y2 marker");
horizontalBox_1.add(lblXMarker_1);
Component rigidArea_6 = Box.createRigidArea(new Dimension(20, 20));
rigidArea_6.setMinimumSize(new Dimension(15, 20));
rigidArea_6.setPreferredSize(new Dimension(15, 20));
rigidArea_6.setMaximumSize(new Dimension(15, 20));
horizontalBox_1.add(rigidArea_6);
spinner_Y2 = new JSpinner();
spinner_Y2.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent e) {
spinner_Y2_value = (int) spinner_Y2.getValue();
sliderY2.setValue(spinner_Y2_value);
graph.setMarkerLineY2pos(spinner_Y2_value);
}
});
spinner_Y2.setDoubleBuffered(true);
spinner_Y2.setMinimumSize(new Dimension(15, 20));
spinner_Y2.setPreferredSize(new Dimension(15, 20));
horizontalBox_1.add(spinner_Y2);
Component rigidArea_7 = Box.createRigidArea(new Dimension(20, 20));
rigidArea_7.setMinimumSize(new Dimension(15, 20));
rigidArea_7.setPreferredSize(new Dimension(15, 20));
rigidArea_7.setMaximumSize(new Dimension(15, 20));
horizontalBox_1.add(rigidArea_7);
JLabel lblXMarker_2 = new JLabel("X2 marker");
horizontalBox_1.add(lblXMarker_2);
Component rigidArea_9 = Box.createRigidArea(new Dimension(20, 20));
rigidArea_9.setMinimumSize(new Dimension(15, 20));
rigidArea_9.setPreferredSize(new Dimension(15, 20));
rigidArea_9.setMaximumSize(new Dimension(15, 20));
horizontalBox_1.add(rigidArea_9);
spinner_X2 = new JSpinner();
spinner_X2.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent e) {
spinner_X2_value = (int) spinner_X2.getValue();
sliderX2.setValue(spinner_X2_value);
graph.setMarkerLineX2pos(spinner_X2_value);
}
});
spinner_X2.setDoubleBuffered(true);
spinner_X2.setPreferredSize(new Dimension(15, 20));
spinner_X2.setMinimumSize(new Dimension(15, 20));
horizontalBox_1.add(spinner_X2);
horizontalBox = Box.createHorizontalBox();
sl_panel.putConstraint(SpringLayout.WEST, horizontalBox, 0, SpringLayout.WEST, horizontalBox_1);
sl_panel.putConstraint(SpringLayout.EAST, horizontalBox, -10, SpringLayout.EAST, panel);
panel.add(horizontalBox);
b0 = new JButton("Plotta Kurva");
b0.setDoubleBuffered(true);
b0.setPreferredSize(new Dimension(130, 23));
b0.setMaximumSize(new Dimension(130, 23));
b0.addActionListener(new Listener().new PlotFunction());
Component horizontalGlue = Box.createHorizontalGlue();
horizontalBox.add(horizontalGlue);
horizontalBox.add(b0);
Component rigidArea_2 = Box.createRigidArea(new Dimension(20, 20));
rigidArea_2.setMaximumSize(new Dimension(22, 20));
rigidArea_2.setMinimumSize(new Dimension(22, 20));
rigidArea_2.setPreferredSize(new Dimension(30, 20));
horizontalBox.add(rigidArea_2);
b1 = new JButton("Radera Kurva");
b1.setDoubleBuffered(true);
b1.setPreferredSize(new Dimension(130, 23));
b1.setMaximumSize(new Dimension(130, 23));
b1.addActionListener(new Listener().new Repaint());
horizontalBox.add(b1);
Component rigidArea_3 = Box.createRigidArea(new Dimension(20, 20));
rigidArea_3.setMaximumSize(new Dimension(22, 20));
rigidArea_3.setMinimumSize(new Dimension(22, 20));
rigidArea_3.setPreferredSize(new Dimension(30, 20));
horizontalBox.add(rigidArea_3);
b2 = new JButton("------------");
b2.setDoubleBuffered(true);
b2.setPreferredSize(new Dimension(130, 23));
b2.setMaximumSize(new Dimension(130, 23));
// b2.addActionListener(new Listener().new Render());
horizontalBox.add(b2);
JButton b3 = new JButton("Avsluta");
b3.setDoubleBuffered(true);
b3.setMinimumSize(new Dimension(72, 23));
b3.setPreferredSize(new Dimension(130, 23));
b3.setMaximumSize(new Dimension(130, 23));
b3.addActionListener(new Listener().new Avbryt());
Component rigidArea_4 = Box.createRigidArea(new Dimension(20, 20));
rigidArea_4.setMaximumSize(new Dimension(22, 20));
rigidArea_4.setMinimumSize(new Dimension(22, 20));
rigidArea_4.setPreferredSize(new Dimension(30, 20));
horizontalBox.add(rigidArea_4);
horizontalBox.add(b3);
Component horizontalGlue_1 = Box.createHorizontalGlue();
horizontalBox.add(horizontalGlue_1);
Box horizontalBox_2 = Box.createHorizontalBox();
sl_panel.putConstraint(SpringLayout.NORTH, horizontalBox, 6, SpringLayout.SOUTH, horizontalBox_2);
sl_panel.putConstraint(SpringLayout.NORTH, horizontalBox_2, 6, SpringLayout.SOUTH, horizontalBox_1);
sl_panel.putConstraint(SpringLayout.WEST, horizontalBox_2, 0, SpringLayout.WEST, horizontalBox_1);
sl_panel.putConstraint(SpringLayout.EAST, horizontalBox_2, 0, SpringLayout.EAST, horizontalBox_1);
panel.add(horizontalBox_2);
sliderY1 = new JSlider();
sliderY1.setPreferredSize(new Dimension(220, 26));
sliderY1.setMajorTickSpacing(1);
sliderY1.setMaximum(298);
sliderY1.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent e) {
int value = sliderY1.getValue();
spinner_Y1.setValue(value);
}
});
sliderY1.setBackground(SystemColor.menu);
sliderY1.setValue(0);
sliderY1.setForeground(Color.WHITE);
horizontalBox_2.add(sliderY1);
sliderX1 = new JSlider();
sliderX1.setPreferredSize(new Dimension(220, 26));
sliderX1.setMajorTickSpacing(1);
sliderX1.setMaximum(700);
sliderX1.setValue(0);
sliderX1.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent e) {
int value = sliderX1.getValue();
spinner_X1.setValue(value);
}
});
Component rigidArea_10 = Box.createRigidArea(new Dimension(20, 20));
rigidArea_10.setPreferredSize(new Dimension(15, 20));
rigidArea_10.setMinimumSize(new Dimension(15, 20));
rigidArea_10.setMaximumSize(new Dimension(15, 20));
horizontalBox_2.add(rigidArea_10);
sliderX1.setForeground(Color.WHITE);
horizontalBox_2.add(sliderX1);
Component rigidArea_11 = Box.createRigidArea(new Dimension(20, 20));
rigidArea_11.setPreferredSize(new Dimension(15, 20));
rigidArea_11.setMinimumSize(new Dimension(15, 20));
rigidArea_11.setMaximumSize(new Dimension(15, 20));
horizontalBox_2.add(rigidArea_11);
sliderY2 = new JSlider();
sliderY2.setMinorTickSpacing(1);
sliderY2.setMajorTickSpacing(1);
sliderY2.setMaximum(298);
sliderY2.setValue(0);
sliderY2.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent e) {
int value = sliderY2.getValue();
spinner_Y2.setValue(value);
}
});
sliderY2.setPreferredSize(new Dimension(220, 26));
sliderY2.setForeground(Color.WHITE);
horizontalBox_2.add(sliderY2);
Component rigidArea_12 = Box.createRigidArea(new Dimension(20, 20));
rigidArea_12.setPreferredSize(new Dimension(15, 20));
rigidArea_12.setMinimumSize(new Dimension(15, 20));
rigidArea_12.setMaximumSize(new Dimension(15, 20));
horizontalBox_2.add(rigidArea_12);
sliderX2 = new JSlider();
sliderX2.setMinorTickSpacing(1);
sliderX2.setMajorTickSpacing(1);
sliderX2.setMaximum(700);
sliderX2.setValue(0);
sliderX2.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent e) {
int value = sliderX2.getValue();
spinner_X2.setValue(value);
}
});
sliderX2.setPreferredSize(new Dimension(220, 26));
sliderX2.setSnapToTicks(true);
sliderX2.setForeground(Color.WHITE);
horizontalBox_2.add(sliderX2);
graph = new Graph(5,5,JC_WIDTH,JC_HEIGHT);
getContentPane().add(graph);
}
}