/* Copyright or (C) or Copr. GET / ENST, Telecom-Paris, Ludovic Apvrille
*
* ludovic.apvrille AT enst.fr
*
* This software is a computer program whose purpose is to allow the
* edition of TURTLE analysis, design and deployment diagrams, to
* allow the generation of RT-LOTOS or Java code from this diagram,
* and at last to allow the analysis of formal validation traces
* obtained from external tools, e.g. RTL from LAAS-CNRS and CADP
* from INRIA Rhone-Alpes.
*
* This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use,
* modify and/ or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info".
*
* As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited
* liability.
*
* In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security.
*
* The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms.
*/
package myutil;
import javax.swing.*;
import java.awt.*;
import java.awt.geom.Line2D;
import java.util.Vector;
/**
* Class GraphLib
* Creation: 01/12/2003
* @version 1.1 01/12/2003
* @author Ludovic APVRILLE
*/
public final class GraphicLib {
// EPSILON
private static double EPSILON = 0.00001;
public static final int NORTH = 0;
public static final int WEST = 1;
public static final int SOUTH = 2;
public static final int EAST = 3;
// Arrow
// Arrow type
// 0 : <-->
// 1 : -->
// 2 : <--
// 3 : ---
// Arrow Head
// 0 : |>
// 1 : >
private static int xPoints[] = new int[3];
private static int yPoints[] = new int[3];
public static int longueur = 10;
private static double angle = 0.523598775598;
public final static BasicStroke normalStroke = new BasicStroke(1.0f);
public final static BasicStroke stroke = new BasicStroke(2.0f);
public final static BasicStroke doubleStroke = new BasicStroke(4.0f);
public final static BasicStroke wideStroke = new BasicStroke(8.0f);
public static float dash1[] = {5.0f};
public static BasicStroke dashed = new BasicStroke(1.0f,
BasicStroke.CAP_BUTT,
BasicStroke.JOIN_MITER,
10.0f, dash1, 0.0f);
public static void setNormalStroke(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
g2.setStroke(GraphicLib.normalStroke);
}
public static void setMediumStroke(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
g2.setStroke(GraphicLib.stroke);
}
public static void setHighStroke(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
g2.setStroke(GraphicLib.doubleStroke);
}
public static void centerString(Graphics g, String s, int x, int y, int width) {
int w = g.getFontMetrics().stringWidth(s);
int posX = x + (width-w)/2;
g.drawString(s, posX, y);
}
public static void setDashed() {
}
public static void doubleColorRect(Graphics g, int x, int y, int width, int height, Color color1, Color color2) {
g.setColor(color1);
g.drawLine(x, y, x +width, y);
g.drawLine(x, y, x, y+height);
g.setColor(color2);
g.drawLine(x, y+height, x+width, y+height);
g.drawLine(x+width, y, x+width, y+height);
}
public static void dashedLine(Graphics g, int x1, int y1, int x2, int y2) {
Graphics2D g2 = (Graphics2D) g;
g2.setStroke(GraphicLib.dashed);
g2.draw(new Line2D.Float(x1, y1, x2, y2));
g2.setStroke(normalStroke);
}
public static void dashedRect(Graphics g, int x1, int y1, int width, int height) {
Graphics2D g2 = (Graphics2D) g;
g2.setStroke(GraphicLib.dashed);
g2.drawRect(x1, y1, width, height);
g2.setStroke(normalStroke);
}
public static void dashedArrowWithLine(Graphics g, int type, int head, int length, int x1, int y1, int x2, int y2, boolean full) {
Graphics2D g2 = (Graphics2D) g;
g2.setStroke(GraphicLib.dashed);
g2.drawLine(x1, y1, x2, y2);
g2.setStroke(normalStroke);
// extremite 1
if ((type == 0) || (type == 2)) {
drawArrow(g, x1, y1, x2, y2, head, length, full);
}
// extremite 2
if ((type == 0) || (type == 1)) {
drawArrow(g, x2, y2, x1, y1, head, length, full);
}
}
public static void arrowWithLine(Graphics g, int type, int head, int length, int x1, int y1, int x2, int y2, boolean full) {
g.drawLine(x1, y1, x2, y2);
// extremite 1
if ((type == 0) || (type == 2)) {
drawArrow(g, x1, y1, x2, y2, head, length, full);
}
// extremite 2
if ((type == 0) || (type == 1)) {
drawArrow(g, x2, y2, x1, y1, head, length, full);
}
}
private static void drawArrow(Graphics g, int x1, int y1, int x2, int y2, int head, int length, boolean full) {
// changement de repere
int x = x2 - x1;
int y = y2 - y1;
if (length == 0) {
length = longueur;
}
// passage en cds polaires
// double ro = Conversion.ro(x, y);
double alpha = Conversion.theta(x, y);
// tete de la fleche
xPoints[0] = x1;
yPoints[0] = y1;
xPoints[1] = (int)(length*Math.cos(alpha-angle) + x1);
yPoints[1] = (int)(length*Math.sin(alpha-angle) + y1);
xPoints[2] = (int)(length*Math.cos(alpha+angle) + x1);
yPoints[2] = (int)(length*Math.sin(alpha+angle) + y1);
if (full) {
g.fillPolygon(xPoints, yPoints, 3);
} else if (head == 0) {
// head must be filled in white
Color c = g.getColor();
g.setColor(Color.WHITE);
g.fillPolygon(xPoints, yPoints, 3);
g.setColor(c);
}
if (head == 0) {
g.drawPolygon(xPoints, yPoints, 3);
} else {
g.drawLine(x1, y1, xPoints[1], yPoints[1]);
g.drawLine(x1, y1, xPoints[2], yPoints[2]);
}
}
public static boolean isSegmentInRectangle(int x1, int y1, int x2, int y2, int x, int y, int width, int height) {
int x11 = Math.min(x1, x2);
int y11 = Math.min(y1, y2);
int x22 = Math.max(x1, x2);
int y22 = Math.max(y1, y2);
if ((x11 < x) || (x22 > x+width)) {
return false;
}
return !((y11 < y) || (y22 > y + height));
}
// Says whether the point belongs to the segment
// If no point can be found, return null
// If lines are parallel, returns one of the point
public static boolean pointBelongsToSegment(double x1, double y1, double x3, double y3, double x4, double y4) {
//System.out.println("Point on segment : x1=" + x1 + " y1=" + y1);
//System.out.println("x3=" + x3 + " y3=" + y3 +" x4=" + x4 + " y4=" + y4);
double y33 = Math.min(y3, y4);
double y44 = Math.max(y3, y4);
if (x3 == x4) {
// vertical line
if (Math.abs(x1 - x3) < EPSILON) {
if (((y1 >= y33) && (y44 >= y1)) || (Math.abs(y1-y44)<EPSILON) || (Math.abs(y1-y33)<EPSILON)) {
return true;
}
}
return false;
}
//System.out.println("Toto121");
double x33 = Math.min(x3, x4);
double x44 = Math.max(x3, x4);
if (((x1 >= x33) && (x44 >= x1)) || (Math.abs(x1-x44)<EPSILON) || (Math.abs(x1-y33)<EPSILON)) {
double y11 = y3 + (y3-y4)*(x1-x3)/(x3-x4);
//System.out.println("y1=" + y1 + " y11=" + y11);
if (Math.abs(y1-y11)<EPSILON){
//System.out.println("EPSILON");
if (((y1 >= y33) && (y44 >= y1)) || (Math.abs(y1-y44)<EPSILON) || (Math.abs(y1-y33)<EPSILON)) {
//System.out.println("OK");
return true;
}
}
}
return false;
}
// returns the Point intersection between two segments
// If no point can be found, return null
// If segments are parallel, returns one of the point
public static Point intersectionTwoSegments(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4) {
int type1 = 0, type2 = 0;
double x, y;
//System.out.println("x1=" + x1 + " y1=" + y1 +" x2=" + x2 + " y2=" + y2);
//System.out.println("x3=" + x3 + " y3=" + y3 +" x4=" + x4 + " y4=" + y4);
if (x1 == x2) {
if (y1 == y2) {
// only one point is provided
if (pointBelongsToSegment(x1, y1, x3, y3, x4, y4)) {
return new Point((int)x1, (int)y1);
} else {
return null;
}
}
// first line is vertical
type1 = 1;
}
if (x3 == x4) {
if (y3 == y4) {
// only one point is provided
if (pointBelongsToSegment(x3, y3, x1, y1, x2, y2)) {
return new Point((int)x3, (int)y3);
} else {
return null;
}
}
// line is vertical
type2 = 1;
}
double y11 = Math.min(y1, y2);
double y22 = Math.max(y1, y2);
double y33 = Math.min(y3, y4);
double y44 = Math.max(y3, y4);
if ((type1 == 1) && (type2 == 1)) {
// Both are vertical
//System.out.println("Toto11");
if (x1 != x3) {
//System.out.println("Toto12");
return null;
} else {
//System.out.println("Toto13");
if (((y11 >= y33) && (y44 >= y11)) || (Math.abs(y11-y44)<EPSILON) || (Math.abs(y11-y33)<EPSILON)){
return new Point((int)x1, (int)y1);
}
if (((y22 >= y33) && (y44 >= y22)) || (Math.abs(y22-y44)<EPSILON) || (Math.abs(y22-y33)<EPSILON)){
return new Point((int)x2, (int)y2);
}
if (((y33 >= y11) && (y22 >= y33)) || (Math.abs(y33-y11)<EPSILON) || (Math.abs(y22-y33)<EPSILON)){
return new Point((int)x3, (int)y3);
}
if (((y44 >= y11) && (y22 >= y44))|| (Math.abs(y44-y11)<EPSILON) || (Math.abs(y22-y44)<EPSILON)) {
return new Point((int)x4, (int)y4);
}
return null;
}
}
// at least one of them is not vertical
if ((type1 == 1) || (type2 == 1)){
//System.out.println("Toto21");
if (type1 == 1) {
// we switch segments so that the second is vertical
x = x1; y = y1;
x1 = x3; y1 = y3; x3 = x; y3 = y;
x= x2; y = y2;
x2 = x4; y2 = y4; x4 = x; y4 = y;
}
// we are now sure the second one is vertical and not the first one
y33 = Math.min(y3, y4);
y44 = Math.max(y3, y4);
// we calculate the point (x3, y) on the first segment
y = (((y1-y2)*(x3-x1))/(x1 - x2))+y1;
if ((y >= y33) && (y44 >= y)) {
// the point belongs to the vertical segment
// Does it also belongs to its original segment ?
if (pointBelongsToSegment(x3, y, x1, y1, x2, y2)) {
return new Point((int)x3, (int)y);
} else {
return null;
}
} else {
return null;
}
}
//System.out.println("Toto31");
double den = ((y1-y2)/(x1-x2)) - ((y3-y4)/(x3-x4));
if (Math.abs(den) < EPSILON) {
//System.out.println("Toto32");
// segments are parallel
// common point ?
if (pointBelongsToSegment(x1, y1, x3, y3, x4, y4)) {
return new Point((int)x1, (int)y1);
}
if (pointBelongsToSegment(x2, y2, x3, y3, x4, y4)) {
return new Point((int)x2, (int)y2);
}
if (pointBelongsToSegment(x3, y3, x1, y1, x2, y2)) {
return new Point((int)x3, (int)y3);
}
if (pointBelongsToSegment(x4, y4, x1, y1, x2, y2)) {
return new Point((int)x4, (int)y4);
}
} else {
//System.out.println("Toto34");
double num = y3 - y1 + (x1*(y1-y2)/(x1-x2)) - (x3*(y3-y4)/(x3-x4));
x = num / den;
double ya = ((y3-y4)*(x-x3))/(x3-x4) + y3;
//double yb = ((y1-y2)*(x-x1))/(x1-x2) + y1;
//System.out.println("Toto35 x=" + x + " ya=" + ya + " yb=" + yb);
if ((pointBelongsToSegment(x, ya, x1, y1, x2, y2)) && (pointBelongsToSegment(x, ya, x3, y3, x4, y4))) {
return new Point((int)x, (int)ya);
} else {
return null;
}
}
return null;
}
public static Point intersectionRectangleSegment(int x1, int y1, int width, int height, int x3, int y3, int x4, int y4) {
Point p;
// lelft
//System.out.println("Left");
p = intersectionTwoSegments(x1, y1, x1, y1 + height, x3, y3, x4, y4);
if (p != null)
return p;
// upper
//System.out.println("Upper");
p = intersectionTwoSegments(x1, y1, x1+width, y1, x3, y3, x4, y4);
if (p != null)
return p;
// right
//System.out.println("Right");
p = intersectionTwoSegments(x1+width, y1, x1+width, y1+height, x3, y3, x4, y4);
if (p != null)
return p;
// lower
//System.out.println("Lower");
p = intersectionTwoSegments(x1, y1+height, x1+width, y1+height, x3, y3, x4, y4);
if (p != null)
return p;
return null;
}
public static boolean isInRectangle(int x1, int y1, int x, int y, int width, int height) {
return x1 >= x &&
x + width >= x1 &&
y1 >= y &&
y + height >= y1;
}
public static Point putPointOnRectangle(int x1, int y1, int x, int y, int width, int height) {
// Compute the four distances between the point and the four segments
// Find the closer segment
// Project the point on it
// First done on x, then on y
int d1, d2, d3, d4; // distance, nonclockwise, starting on the top
int d; // minimal distance
Point p = new Point(); // returned point
d1 = Math.abs(y-y1);
d2 = Math.abs(x-x1);
d3 = Math.abs(y+height-y1);
d4 = Math.abs(x+width-x1);
d = Math.min(Math.min(Math.min(d1, d2), d3), d4);
if (d == d1) {
p.x = x1;
p.y = y;
} else if (d == d2) {
p.x = x;
p.y = y1;
} else if (d == d3) {
p.x = x1;
p.y = y + height;
} else {
p.x = x + width;
p.y = y1;
}
return p;
}
// Returns the closer segment of the rectangle, from a given point (x1, y1)
public static int getCloserOrientation (int x1, int y1, int x, int y, int width, int height) {
// Compute the four distances between the point and the four segments
// Find the closer segment
// Project the point on it
// First done on x, then on y
int d1, d2, d3, d4; // distance, nonclockwise, starting on the top
int d; // minimal distance
int ret; // returned orientation
d1 = Math.abs(y-y1);
d2 = Math.abs(x-x1);
d3 = Math.abs(y+height-y1);
d4 = Math.abs(x+width-x1);
d = Math.min(Math.min(Math.min(d1, d2), d3), d4);
if (d == d1) {
ret = NORTH;
} else if (d == d2) {
ret = WEST;
} else if (d == d3) {
ret = SOUTH;
} else {
ret = EAST;
}
return ret;
}
public static void centerOnScreen(Window w) {
Dimension screen = Toolkit.getDefaultToolkit().getScreenSize();
w.setLocation((screen.width - w.getSize().width)/2,(screen.height - w.getSize().height)/2);
}
public static void centerOnParent( final Window window ) {
centerOnParent( window, -1, -1 );
}
public static void centerOnParent( final Window w,
final int width,
final int heigth ) {
if ( width > 0 && heigth > 0 ) {
Dimension screenSize = GraphicsEnvironment.getLocalGraphicsEnvironment().getMaximumWindowBounds().getSize();
w.setSize( Math.min( width, screenSize.width ), Math.min( heigth, screenSize.height ) );
}
Window parent = w.getOwner();
if (parent == null) {
//TraceManager.addDev("Centering on screen");
centerOnScreen(w);
return;
}
Point p = parent.getLocation();
w.setLocation(((parent.getSize().width - w.getSize().width)/2) + p.x, ((parent.getSize().height - w.getSize().height)/2) + p.y);
}
// Trivial sorting algorithm as there are only a few tabs
// maxIndex is a non valid index
// Vector v contains elements that should be sorted the same way
public static void sortJTabbedPane(JTabbedPane jtp, Vector<?> v, int beginIndex, int maxIndex) {
//System.out.println("Sorting from " + beginIndex + " to " + maxIndex);
if (beginIndex >= maxIndex) {
return;
}
String s = jtp.getTitleAt(beginIndex);
int index = beginIndex;
// Search for the one to move
for(int i=beginIndex+1; i<maxIndex; i++) {
if (s.compareTo(jtp.getTitleAt(i)) > 0) {
index = i;
s = jtp.getTitleAt(i);
}
}
if (index != beginIndex) {
moveTabFromTo(jtp, v, index, beginIndex);
}
beginIndex ++;
sortJTabbedPane(jtp, v, beginIndex, maxIndex);
}
public static <E> void moveTabFromTo(JTabbedPane jtp, Vector<E> v, int src, int dst) {
// Get all the properties
Component comp = jtp.getComponentAt(src);
String label = jtp.getTitleAt(src);
Icon icon = jtp.getIconAt(src);
Icon iconDis = jtp.getDisabledIconAt(src);
String tooltip = jtp.getToolTipTextAt(src);
boolean enabled = jtp.isEnabledAt(src);
int keycode = jtp.getMnemonicAt(src);
int mnemonicLoc = jtp.getDisplayedMnemonicIndexAt(src);
Color fg = jtp.getForegroundAt(src);
Color bg = jtp.getBackgroundAt(src);
// Remove the tab
jtp.remove(src);
// Add a new tab
jtp.insertTab(label, icon, comp, tooltip, dst);
// Restore all properties
jtp.setDisabledIconAt(dst, iconDis);
jtp.setEnabledAt(dst, enabled);
jtp.setMnemonicAt(dst, keycode);
jtp.setDisplayedMnemonicIndexAt(dst, mnemonicLoc);
jtp.setForegroundAt(dst, fg);
jtp.setBackgroundAt(dst, bg);
E o = v.elementAt(src);
v.removeElementAt(src);
v.insertElementAt(o, dst);
}
public static void draw3DRoundRectangle(Graphics g, int x, int y, int width, int height, int arc, Color fillColor, Color borderColor) {
Color c = g.getColor();
g.setColor(fillColor);
g.fillRoundRect(x, y, width, height, arc, arc);
g.setColor(fillColor.brighter());
g.drawLine(x+1, y+(arc/2), x+1, y+height-(arc/2));
g.drawLine(x+(arc/2), y+1, x+width-(arc/2), y+1);
g.drawArc(x+1, y+1, arc, arc, -180, -90);
g.drawArc(x+1, y+height-arc-1, arc, arc, 180, 45);
g.drawArc(x+width-1-arc, y+1, arc, arc, 90, -45);
g.setColor(fillColor.darker());
g.drawLine(x+width-1, y+(arc/2), x+width-1, y+height-(arc/2));
g.drawLine(x+(arc/2), y+height-1, x+width-(arc/2), y+height-1);
g.drawArc(x+width-1-arc, y+height-1-arc, arc, arc, -90, 90);
g.drawArc(x+1, y+height-arc-1, arc, arc, -135, 45);
g.drawArc(x+width-1-arc, y+1, arc, arc, 45, -45);
g.setColor(borderColor);
g.drawRoundRect(x, y, width, height, arc, arc);
g.setColor(c);
}
public static void enableComponents(Container container, boolean enable) {
Component[] components = container.getComponents();
for (Component component : components) {
component.setEnabled(enable);
if (component instanceof Container) {
enableComponents((Container)component, enable);
}
}
}
public static JTabbedPane createTabbedPane() {
final JTabbedPane pane = new JTabbedPane( JTabbedPane.TOP, JTabbedPane.SCROLL_TAB_LAYOUT );
return pane;
}
public static JTabbedPane createTabbedPaneRegular() {
final JTabbedPane pane = new JTabbedPane( JTabbedPane.TOP);
return pane;
}
}