868 lines
28 KiB
Java
868 lines
28 KiB
Java
/*
|
|
|
|
Copyright 2006 Rene Grothmann, modified by Eric Hakenholz
|
|
|
|
This file is part of C.a.R. software.
|
|
|
|
C.a.R. is a free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, version 3 of the License.
|
|
|
|
C.a.R. is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
package rene.zirkel.graphics;
|
|
|
|
import java.awt.BasicStroke;
|
|
import java.awt.Color;
|
|
import java.awt.Font;
|
|
import java.awt.FontMetrics;
|
|
import java.awt.Graphics;
|
|
import java.awt.Graphics2D;
|
|
import java.awt.Image;
|
|
import java.awt.RenderingHints;
|
|
import java.awt.geom.AffineTransform;
|
|
import java.awt.geom.Arc2D;
|
|
import java.awt.geom.Ellipse2D;
|
|
import java.awt.geom.Line2D;
|
|
import java.awt.geom.Rectangle2D;
|
|
import java.awt.image.ImageObserver;
|
|
import rene.gui.Global;
|
|
import rene.zirkel.ZirkelFrame;
|
|
import rene.zirkel.objects.ConstructionObject;
|
|
import rene.zirkel.objects.PointObject;
|
|
import de.erichseifert.vectorgraphics2d.EPSGraphics2D;
|
|
import de.erichseifert.vectorgraphics2d.SVGGraphics2D;
|
|
import de.erichseifert.vectorgraphics2d.VectorGraphics2D;
|
|
import java.awt.geom.Path2D;
|
|
import rene.zirkel.ZirkelCanvas;
|
|
|
|
public class MainGraphics extends MyGraphics {
|
|
|
|
Graphics2D G=null;
|
|
BasicStroke Thin, Normal, Thick, SuperThick, DCross, DCrossNormal;
|
|
// AlphaComposite C, CO;
|
|
ZirkelCanvas ZC=null;
|
|
|
|
// Constructeur appelé par le paint de ZirkelCanvas ainsi que pour les exports :
|
|
public MainGraphics(final Graphics2D g, ZirkelCanvas zc) {
|
|
G=g;
|
|
ZC=zc;
|
|
G.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
|
|
RenderingHints.VALUE_ANTIALIAS_ON);
|
|
G.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
|
|
RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
|
|
G.setRenderingHint(RenderingHints.KEY_RENDERING,
|
|
RenderingHints.VALUE_RENDER_QUALITY);
|
|
G.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
|
|
RenderingHints.VALUE_INTERPOLATION_BICUBIC);
|
|
G.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,
|
|
RenderingHints.VALUE_STROKE_PURE);
|
|
|
|
if ((G instanceof EPSGraphics2D)||(G instanceof SVGGraphics2D)) {
|
|
VectorGraphics2D vg2D=(VectorGraphics2D) G;
|
|
vg2D.setFontRendering(VectorGraphics2D.FontRendering.VECTORS);
|
|
}
|
|
|
|
|
|
setDefaultLineSize(ZC.lineSize());
|
|
setDefaultFont(ZC.fontSize(), Global.getParameter("font.large", false), Global.getParameter("font.bold", false));
|
|
}
|
|
|
|
@Override
|
|
public void setColor(final Color c) {
|
|
G.setColor(c);
|
|
}
|
|
|
|
@Override
|
|
public void setColor(final ConstructionObject o) {
|
|
G.setStroke(Normal);
|
|
Color Col, LightCol, BrighterCol, BrighterLightCol;
|
|
// it's a personnal color :
|
|
if (o.getSpecialColor()!=null) {
|
|
final int i=o.getConditionalColor();
|
|
if (i!=-1) {
|
|
Col=ZirkelFrame.Colors[i];
|
|
LightCol=ZirkelFrame.LightColors[i];
|
|
BrighterCol=ZirkelFrame.BrighterColors[i];
|
|
BrighterLightCol=ZirkelFrame.BrighterLightColors[i];
|
|
} else {
|
|
final double lambda=0.4;
|
|
Col=o.getSpecialColor();
|
|
|
|
// System.out.println(o.getName()+" : "+Col);
|
|
|
|
final int r=(int) (255*(1-lambda)+Col.getRed()*lambda);
|
|
final int g=(int) (255*(1-lambda)+Col.getGreen()
|
|
*lambda);
|
|
final int b=(int) (255*(1-lambda)+Col.getBlue()
|
|
*lambda);
|
|
LightCol=new Color(r, g, b);
|
|
BrighterCol=Col.brighter();
|
|
BrighterLightCol=LightCol.brighter();
|
|
}
|
|
} else {
|
|
final int i=o.getColorIndex();
|
|
Col=ZirkelFrame.Colors[i];
|
|
LightCol=ZirkelFrame.LightColors[i];
|
|
BrighterCol=ZirkelFrame.BrighterColors[i];
|
|
BrighterLightCol=ZirkelFrame.BrighterLightColors[i];
|
|
}
|
|
if (o.isJobTarget()) {
|
|
setColor(ZirkelFrame.TargetColor);
|
|
} else if (o.indicated()) {
|
|
setColor(ZirkelFrame.IndicateColor);
|
|
} else if (o.selected()) {
|
|
setColor(ZirkelFrame.SelectColor);
|
|
} else {
|
|
if (o.getColorType()==ConstructionObject.THIN) {
|
|
if (o.isHidden()) {
|
|
setColor(BrighterLightCol);
|
|
} else {
|
|
setColor(LightCol);
|
|
}
|
|
} else {
|
|
if (o.isHidden()) {
|
|
setColor(BrighterCol);
|
|
} else {
|
|
setColor(Col);
|
|
}
|
|
}
|
|
}
|
|
if (o.getColorType()==ConstructionObject.THIN) {
|
|
G.setStroke(Thin);
|
|
} else if (o.getColorType()==ConstructionObject.THICK) {
|
|
G.setStroke(Thick);
|
|
} else {
|
|
G.setStroke(Normal);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void clearRect(final int x, final int y, final int w, final int h,
|
|
final Color c) {
|
|
G.setColor(c);
|
|
G.fillRect(x, y, w, h);
|
|
}
|
|
|
|
@Override
|
|
public void setFillColor(final ConstructionObject o) {
|
|
G.setStroke(Normal);
|
|
if (o.isJobTarget()) {
|
|
setColor(ZirkelFrame.TargetColor);
|
|
} else if ((o instanceof PointObject)&&o.indicated()) {
|
|
setColor(ZirkelFrame.IndicateColor);
|
|
} else {
|
|
Color Col, LightCol, BrighterCol, BrighterLightCol;
|
|
// it's a personnal color :
|
|
if (o.getSpecialColor()!=null) {
|
|
final int i=o.getConditionalColor();
|
|
if (i!=-1) {
|
|
Col=ZirkelFrame.Colors[i];
|
|
LightCol=ZirkelFrame.LightColors[i];
|
|
BrighterCol=ZirkelFrame.BrighterColors[i];
|
|
BrighterLightCol=ZirkelFrame.BrighterLightColors[i];
|
|
} else {
|
|
final double lambda=0.4;
|
|
Col=o.getSpecialColor();
|
|
final int r=(int) (255*(1-lambda)+Col.getRed()
|
|
*lambda);
|
|
final int g=(int) (255*(1-lambda)+Col.getGreen()
|
|
*lambda);
|
|
final int b=(int) (255*(1-lambda)+Col.getBlue()
|
|
*lambda);
|
|
LightCol=new Color(r, g, b);
|
|
BrighterCol=Col.brighter();
|
|
BrighterLightCol=LightCol.brighter();
|
|
}
|
|
} else {
|
|
final int i=o.getColorIndex();
|
|
Col=ZirkelFrame.Colors[i];
|
|
LightCol=ZirkelFrame.LightColors[i];
|
|
BrighterCol=ZirkelFrame.BrighterColors[i];
|
|
BrighterLightCol=ZirkelFrame.BrighterLightColors[i];
|
|
}
|
|
if (o.getColorType()!=ConstructionObject.THICK) {
|
|
if (o.isHidden()) {
|
|
setColor(BrighterLightCol);
|
|
} else {
|
|
setColor(LightCol);
|
|
}
|
|
} else {
|
|
if (o.isHidden()) {
|
|
setColor(BrighterCol);
|
|
} else {
|
|
setColor(Col);
|
|
}
|
|
}
|
|
if (o.getColorType()==ConstructionObject.THIN) {
|
|
G.setStroke(Thin);
|
|
} else if (o.getColorType()==ConstructionObject.THICK) {
|
|
G.setStroke(Thick);
|
|
} else {
|
|
G.setStroke(Normal);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void setLabelColor(final ConstructionObject o) {
|
|
if (o.labelSelected()) {
|
|
setColor(ZirkelFrame.SelectColor);
|
|
} else if (o.isFilled()) {
|
|
final int type=o.getColorType();
|
|
o.setColorType(ConstructionObject.NORMAL);
|
|
setColor(o);
|
|
o.setColorType(type);
|
|
} else {
|
|
setColor(o);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void drawRect(final double x, final double y, final double w,
|
|
final double h) {
|
|
if (test(x)||test(y)||test(x+w)||test(y+h)) {
|
|
return;
|
|
}
|
|
G.setStroke(Normal);
|
|
G.draw(new Rectangle2D.Double(x, y, w, h));
|
|
}
|
|
|
|
public void drawMarkerRect(final double x, final double y, final double w,
|
|
final double h) {
|
|
if (test(x)||test(y)||test(x+w)||test(y+h)) {
|
|
return;
|
|
}
|
|
G.setColor(ZirkelFrame.IndicateColor);
|
|
G.setStroke(SuperThick);
|
|
G.draw(new Rectangle2D.Double(x, y, w, h));
|
|
G.setStroke(Normal);
|
|
}
|
|
|
|
@Override
|
|
public void drawLine(final double x, final double y, final double x1,
|
|
final double y1) {
|
|
if (test(x)||test(y)||test(x1)||test(y1)) {
|
|
return;
|
|
}
|
|
G.setStroke(Normal);
|
|
G.draw(new Line2D.Double(x, y, x1, y1));
|
|
}
|
|
|
|
@Override
|
|
public void drawThickLine(final double x, final double y, final double x1,
|
|
final double y1) {
|
|
if (test(x)||test(y)||test(x1)||test(y1)) {
|
|
return;
|
|
}
|
|
G.setStroke(Thick);
|
|
G.draw(new Line2D.Double(x, y, x1, y1));
|
|
G.setStroke(Normal);
|
|
}
|
|
|
|
public void drawMarkerLine(final double x, final double y, final double x1,
|
|
final double y1) {
|
|
if (test(x)||test(y)||test(x1)||test(y1)) {
|
|
return;
|
|
}
|
|
G.setColor(ZirkelFrame.IndicateColor);
|
|
G.setStroke(SuperThick);
|
|
G.draw(new Line2D.Double(x, y, x1, y1));
|
|
G.setStroke(Normal);
|
|
}
|
|
|
|
@Override
|
|
public void drawLine(final double x, final double y, final double x1,
|
|
final double y1, final ConstructionObject o) {
|
|
if (test(x)||test(y)||test(x1)||test(y1)) {
|
|
return;
|
|
}
|
|
G.draw(new Line2D.Double(x, y, x1, y1));
|
|
}
|
|
|
|
public boolean test(final double x) {
|
|
return Math.abs(x)>1e5;
|
|
}
|
|
|
|
@Override
|
|
public void drawArc(final double x, final double y, final double w,
|
|
final double h, final double a, final double b) {
|
|
if (test(x)||test(y)||test(w)||test(h)) {
|
|
return;
|
|
}
|
|
G.setStroke(Normal);
|
|
G.draw(new Arc2D.Double(x, y, w, h, a, b, Arc2D.OPEN));
|
|
}
|
|
|
|
@Override
|
|
public void drawArc(final double x, final double y, final double w,
|
|
final double h, final double a, final double b,
|
|
final ConstructionObject o) {
|
|
if (test(x)||test(y)||test(w)||test(h)) {
|
|
return;
|
|
} else {
|
|
G.draw(new Arc2D.Double(x, y, w, h, a, b, Arc2D.OPEN));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public FontMetrics getFontMetrics() {
|
|
return G.getFontMetrics();
|
|
}
|
|
private MyFormula TXF=null;
|
|
|
|
public void setTeXEqn(final String s) {
|
|
if (ZC==null) {
|
|
return;
|
|
}
|
|
if (TXF==null) {
|
|
try {
|
|
// Si la librairie JLaTeXMath est présente :
|
|
TXF=new MyTeXFormula(ZC, G);
|
|
} catch (Error e) {
|
|
// Sinon on passe au bon vieux HotEqn :
|
|
TXF=new MyHotEqnFormula(ZC, G);
|
|
}
|
|
}
|
|
TXF.setEquation(s);
|
|
}
|
|
|
|
public double paintTeXEqn(double c, double r) {
|
|
if (TXF==null) {
|
|
return 0;
|
|
}
|
|
G.setStroke(Normal);
|
|
return TXF.paint(c, r, G);
|
|
}
|
|
|
|
public double drawStringExtended(String s, final double x, final double y) {
|
|
Font myFont=G.getFont();
|
|
double w=0;
|
|
boolean isTeX=false;
|
|
String[] strs=computeString(s);
|
|
// Alternance texte-formule. La première boucle correspond à du texte,
|
|
// la deuxième à une formule TeX, troisième à du texte, etc... :
|
|
for (String mystr:strs){
|
|
if (isTeX){
|
|
setTeXEqn(mystr);
|
|
paintTeXEqn(x+w, y-TXF.getEquationAscent()+StrAsc);
|
|
w+=TXF.getEquationWidth();
|
|
}else{
|
|
G.setFont(myFont);
|
|
drawString(mystr, x+w, y+StrAsc);
|
|
w+=getFontMetrics().getStringBounds(mystr, G).getWidth();
|
|
}
|
|
isTeX=!isTeX;
|
|
}
|
|
return StrH;
|
|
}
|
|
|
|
|
|
private double StrH=0, StrW=0, StrAsc=0;
|
|
private String Str="";
|
|
private String[] Strs;
|
|
|
|
public String[] computeString(String s){
|
|
if (s.equals(Str)) {
|
|
return Strs;
|
|
}
|
|
Str=s;
|
|
Strs=s.split("\\$");
|
|
Font myFont=G.getFont();
|
|
StrAsc=0;
|
|
StrH=0;
|
|
StrW=0;
|
|
boolean isTeX=false;
|
|
// Alternance texte-formule :
|
|
for (String mystr:Strs){
|
|
if (isTeX){
|
|
setTeXEqn(mystr);
|
|
StrH=Math.max(StrH, TXF.getEquationHeight());
|
|
StrW+=TXF.getEquationWidth();
|
|
StrAsc= Math.max(StrAsc, TXF.getEquationAscent());
|
|
}else{
|
|
G.setFont(myFont);
|
|
StrH=Math.max(StrH, getFontMetrics().getStringBounds(mystr, G).getHeight());
|
|
StrW+=getFontMetrics().getStringBounds(mystr, G).getWidth();
|
|
StrAsc=Math.max(StrAsc, getFontMetrics().getLineMetrics(mystr, G).getAscent());
|
|
}
|
|
isTeX=!isTeX;
|
|
}
|
|
return Strs;
|
|
}
|
|
|
|
public double getW() {
|
|
return StrW;
|
|
}
|
|
|
|
@Override
|
|
public double stringWidth(final String s) {
|
|
computeString(s);
|
|
return StrW;
|
|
}
|
|
|
|
@Override
|
|
public double stringHeight(final String s) {
|
|
computeString(s);
|
|
return StrH;
|
|
}
|
|
|
|
|
|
@Override
|
|
public double stringAscent(final String s) {
|
|
computeString(s);
|
|
return StrAsc;
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
public void drawString(final String s, final double x, final double y) {
|
|
if (test(x)||test(y)) {
|
|
return;
|
|
}
|
|
G.drawString(s, (float) x, (float) y);
|
|
// G.drawString(AngleObject.translateToUnicode("éèéééer"), (float) x, (float) y);
|
|
}
|
|
|
|
@Override
|
|
public void drawOval(final double x, final double y, final double w,
|
|
final double h) {
|
|
if (test(x)||test(y)||test(w)||test(h)) {
|
|
return;
|
|
}
|
|
G.setStroke(Normal);
|
|
G.draw(new Ellipse2D.Double(x, y, w, h));
|
|
}
|
|
|
|
@Override
|
|
public void drawOval(final double x, final double y, final double w,
|
|
final double h, final ConstructionObject o) {
|
|
if (test(x)||test(y)||test(w)||test(h)) {
|
|
return;
|
|
} else {
|
|
G.draw(new Ellipse2D.Double(x, y, w, h));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void drawCircle(final double x, final double y, final double r,
|
|
final ConstructionObject o) {
|
|
if (r>10*(W+H)) {
|
|
drawLargeCircleArc(x, y, r, 0, 360);
|
|
} else {
|
|
G.draw(new Ellipse2D.Double(x-r, y-r, 2*r, 2*r));
|
|
}
|
|
}
|
|
|
|
public void drawMarkerArc(final double x, final double y, final double r,
|
|
final double a, final double b) {
|
|
if (test(x)||test(y)||test(r)) {
|
|
return;
|
|
}
|
|
G.setColor(ZirkelFrame.IndicateColor);
|
|
G.setStroke(SuperThick);
|
|
G.draw(new Arc2D.Double(x-r, y-r, 2*r, 2*r, a, b, Arc2D.OPEN));
|
|
}
|
|
|
|
@Override
|
|
public void drawCircleArc(final double x, final double y, final double r,
|
|
final double a, final double b, final ConstructionObject o) {
|
|
if (r>10*(W+H)) {
|
|
drawLargeCircleArc(x, y, r, a, b);
|
|
} else {
|
|
G.draw(new Arc2D.Double(x-r, y-r, 2*r, 2*r, a, b,
|
|
Arc2D.OPEN));
|
|
}
|
|
}
|
|
|
|
void drawLargeCircleArc(final double x, final double y, final double r,
|
|
final double a, final double b) {
|
|
if (r>1E10) {
|
|
return;
|
|
}
|
|
final double dw=Math.sqrt((W+H)/r/10);
|
|
double w=a;
|
|
double x0=x+r*Math.cos(w/180*Math.PI);
|
|
double y0=y-r*Math.sin(w/180*Math.PI);
|
|
w=w+dw;
|
|
while (w<a+b+dw) {
|
|
if (w>a+b) {
|
|
w=a+b;
|
|
}
|
|
final double x1=x+r*Math.cos(w/180*Math.PI);
|
|
final double y1=y-r*Math.sin(w/180*Math.PI);
|
|
final double dx=(x0+x1)/2, dy=(y0+y1)/2;
|
|
if (Math.sqrt(dx*dx+dy*dy)<=10*(W+H)) {
|
|
G.draw(new Line2D.Double(x0, y0, x1, y1));
|
|
}
|
|
x0=x1;
|
|
y0=y1;
|
|
w+=dw;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void fillRect(final double x, final double y, final double w,
|
|
final double h, final boolean outline, final boolean transparent,
|
|
final ConstructionObject o) {
|
|
if (test(x)||test(y)||test(w)||test(h)) {
|
|
return;
|
|
}
|
|
setFillColor(o);
|
|
Color oldC=G.getColor();
|
|
int alpha=(transparent&&!o.isSolid())?128:255;
|
|
Color c=new Color(oldC.getRed(), oldC.getGreen(), oldC.getBlue(), alpha);
|
|
G.setColor(c);
|
|
G.fill(new Rectangle2D.Double(x, y, w, h));
|
|
G.setColor(oldC);
|
|
if (outline) {
|
|
setColor(o);
|
|
G.draw(new Rectangle2D.Double(x, y, w, h));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void fillOval(final double x, final double y, final double w,
|
|
final double h, final boolean outline, final boolean transparent,
|
|
final ConstructionObject o) {
|
|
if (test(x)||test(y)||test(w)||test(h)) {
|
|
return;
|
|
}
|
|
if (o.getColorType()!=ConstructionObject.INVISIBLE) {
|
|
setFillColor(o);
|
|
Color oldC=G.getColor();
|
|
int alpha=(transparent&&!o.isSolid())?128:255;
|
|
Color c=new Color(oldC.getRed(), oldC.getGreen(), oldC.getBlue(), alpha);
|
|
G.setColor(c);
|
|
try {
|
|
G.fill(new Ellipse2D.Double(x, y, w, h));
|
|
} catch (final Exception e) {
|
|
}
|
|
G.setColor(oldC);
|
|
}
|
|
if (outline) {
|
|
setColor(o);
|
|
drawOval(x, y, w, h);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void fillArc(final double x, final double y, final double w,
|
|
final double h, final double a, final double b,
|
|
final boolean outline, final boolean transparent,
|
|
final boolean arcb, final ConstructionObject o) {
|
|
if (test(x)||test(y)||test(w)||test(h)) {
|
|
return;
|
|
}
|
|
setFillColor(o);
|
|
Color oldC=G.getColor();
|
|
int alpha=(transparent&&!o.isSolid())?128:255;
|
|
Color c=new Color(oldC.getRed(), oldC.getGreen(), oldC.getBlue(), alpha);
|
|
G.setColor(c);
|
|
final Arc2D arc=new Arc2D.Double(x, y, w, h, a, b, arcb?Arc2D.PIE
|
|
:Arc2D.CHORD);
|
|
G.fill(arc);
|
|
G.setColor(oldC);
|
|
if (outline) {
|
|
setColor(o);
|
|
arc.setArcType(Arc2D.OPEN);
|
|
G.setStroke(Normal);
|
|
G.draw(arc);
|
|
}
|
|
}
|
|
int xx[]=new int[64], yy[]=new int[64];
|
|
|
|
@Override
|
|
public void fillPolygon(final double x[], final double y[], final int n,
|
|
final boolean outline, final boolean transparent,
|
|
final ConstructionObject o) {
|
|
if (n<1) return;
|
|
|
|
Path2D path=new Path2D.Double();
|
|
path.moveTo(x[0], y[0]);
|
|
for (int i=1;i<n;i++) {
|
|
path.lineTo(x[i], y[i]);
|
|
}
|
|
path.lineTo(x[0], y[0]);
|
|
|
|
if (o.getColorType()!=ConstructionObject.INVISIBLE) {
|
|
setFillColor(o);
|
|
Color oldC=G.getColor();
|
|
int alpha=(transparent&&!o.isSolid())?128:255;
|
|
Color c=new Color(oldC.getRed(), oldC.getGreen(), oldC.getBlue(), alpha);
|
|
G.setColor(c);
|
|
G.fill(path);
|
|
G.setColor(oldC);
|
|
}
|
|
if (outline) {
|
|
setColor(o);
|
|
G.setStroke(Normal);
|
|
G.draw(path);
|
|
}
|
|
}
|
|
|
|
// Uniquement appelée par AreaObject :
|
|
@Override
|
|
public void fillPolygon(final double x[], final double y[], final int n,
|
|
final ConstructionObject o) {
|
|
if (n<1) return;
|
|
|
|
Path2D path=new Path2D.Double();
|
|
path.moveTo(x[0], y[0]);
|
|
for (int i=1;i<n;i++) {
|
|
path.lineTo(x[i], y[i]);
|
|
}
|
|
path.lineTo(x[0], y[0]);
|
|
|
|
if (o.isFilled()) {
|
|
// Petite modif de code. On passe aux couleurs avec transparence plutôt qu'utiliser
|
|
// le setComposite :
|
|
setFillColor(o);
|
|
Color oldC=G.getColor();
|
|
int alpha=((o.getColorType()!=ConstructionObject.THICK)&&(!o.isSolid()))?128:255;
|
|
Color c=new Color(oldC.getRed(), oldC.getGreen(), oldC.getBlue(), alpha);
|
|
G.setColor(c);
|
|
G.fill(path);
|
|
G.setColor(oldC);
|
|
}
|
|
if (!o.isFilled()||o.indicated()||o.selected()
|
|
||o.getColorType()==ConstructionObject.NORMAL) {
|
|
setColor(o);
|
|
if (o.indicated()||o.selected()) {
|
|
G.setStroke(Normal);
|
|
} else {
|
|
if (o.getColorType()==ConstructionObject.THIN) {
|
|
G.setStroke(Thin);
|
|
} else if (o.getColorType()==ConstructionObject.THICK) {
|
|
G.setStroke(Thick);
|
|
} else {
|
|
G.setStroke(Normal);
|
|
}
|
|
}
|
|
G.draw(path);
|
|
}
|
|
|
|
}
|
|
|
|
@Override
|
|
public void drawImage(final Image i, final int x, final int y,
|
|
final ImageObserver o) {
|
|
G.drawImage(i, x, y, o);
|
|
}
|
|
|
|
@Override
|
|
public void drawImage(final Image i, final int x, final int y, final int w,
|
|
final int h, final ImageObserver o) {
|
|
G.drawImage(i, x, y, w, h, o);
|
|
}
|
|
|
|
|
|
FontStruct FS=new FontStruct();
|
|
|
|
@Override
|
|
public void setDefaultLineSize(double graphicsLineSize) {
|
|
final float dash[]={(float) (graphicsLineSize*5.0), (float) (graphicsLineSize*5.0)};
|
|
Thin=new BasicStroke((float) (graphicsLineSize), BasicStroke.CAP_BUTT,
|
|
BasicStroke.JOIN_MITER, 10.0f, dash, 0.0f);
|
|
Normal=new BasicStroke((float) (graphicsLineSize), BasicStroke.CAP_ROUND,
|
|
BasicStroke.JOIN_MITER);
|
|
Thick=new BasicStroke((float) (graphicsLineSize*2.0), BasicStroke.CAP_ROUND,
|
|
BasicStroke.JOIN_MITER);
|
|
DCross=new BasicStroke((float) (graphicsLineSize*3.0),
|
|
BasicStroke.CAP_SQUARE, BasicStroke.JOIN_MITER);
|
|
DCrossNormal=new BasicStroke((float) (graphicsLineSize*1.5),
|
|
BasicStroke.CAP_SQUARE, BasicStroke.JOIN_MITER);
|
|
SuperThick=new BasicStroke((float) (20), BasicStroke.CAP_ROUND,
|
|
BasicStroke.JOIN_ROUND);
|
|
}
|
|
|
|
@Override
|
|
public void setFont(double h, final boolean bold) {
|
|
Font f=FS.getFont(h, bold);
|
|
if (f!=null) {
|
|
G.setFont(f);
|
|
} else {
|
|
if (G instanceof VectorGraphics2D) {
|
|
f=new Font("Arial",
|
|
bold?Font.BOLD:Font.PLAIN, (int)h);
|
|
f=f.deriveFont((float)h);
|
|
} else {
|
|
f=new Font(Global.getParameter("font.name", "dialog"),
|
|
bold?Font.BOLD:Font.PLAIN, (int)h);
|
|
f=f.deriveFont((float)h);
|
|
}
|
|
|
|
// f=new Font(Global.getParameter("font.name", "dialog"),
|
|
// bold?Font.BOLD:Font.PLAIN, h);
|
|
FS.storeFont(h, bold, f);
|
|
G.setFont(f);
|
|
}
|
|
}
|
|
double fsize;
|
|
boolean flarge, fbold;
|
|
int ffactor=Global.getParameter("ffactor", 130);
|
|
|
|
@Override
|
|
public void setDefaultFont(double h, final boolean large,
|
|
final boolean bold) {
|
|
ffactor=Global.getParameter("ffactor", 130);
|
|
fsize=h;
|
|
flarge=large;
|
|
fbold=bold;
|
|
setFont(large, bold);
|
|
}
|
|
|
|
@Override
|
|
public void setFont(final boolean large, final boolean bold) {
|
|
|
|
double size=fsize;
|
|
// int size=eric.JGlobals.FixFontSize(fsize);
|
|
|
|
if (large) {
|
|
size=size*ffactor/100;
|
|
}
|
|
if (flarge) {
|
|
size=size*ffactor/100;
|
|
}
|
|
setFont(size, bold||fbold);
|
|
}
|
|
|
|
@Override
|
|
public void drawImage(final Image i, final double x, final double y,
|
|
final double x1, final double y1, final double x2, final double y2,
|
|
final ImageObserver o) {
|
|
try {
|
|
final int w=i.getWidth(o), h=i.getHeight(o);
|
|
final AffineTransform AT=new AffineTransform((x1-x)/w,
|
|
(y1-y)/w, (x2-x)/h, (y2-y)/h, x, y);
|
|
G.drawImage(i, AT, o);
|
|
} catch (final Exception e) {
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public Graphics getGraphics() {
|
|
return G;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
@Override
|
|
public void fillOval(final double x, final double y, final double w,
|
|
final double h, final Color WithColor) {
|
|
try {
|
|
G.setColor(WithColor);
|
|
G.fill(new Ellipse2D.Double(x, y, w, h));
|
|
} catch (final Exception e) {
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void fillRect(final double x, final double y, final double w,
|
|
final double h, final Color WithColor) {
|
|
try {
|
|
G.setColor(WithColor);
|
|
G.fill(new Rectangle2D.Double(x, y, w, h));
|
|
} catch (final Exception e) {
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void drawDiamond(final double x, final double y, final double w,
|
|
final boolean isThick, final ConstructionObject o) {
|
|
AffineTransform aT=G.getTransform();
|
|
Rectangle2D r=new Rectangle2D.Double(x, y, w, w);
|
|
AffineTransform rotate45=AffineTransform.getRotateInstance(Math.PI/4, x+w/2, y+w/2);
|
|
G.transform(rotate45);
|
|
if (isThick) {
|
|
setColor(o);
|
|
} else {
|
|
G.setColor(new Color(250, 250, 250));
|
|
}
|
|
G.fill(r);
|
|
if (!isThick) {
|
|
setColor(o);
|
|
G.draw(r);
|
|
}
|
|
G.setTransform(aT);
|
|
|
|
// final double dw=w/2;
|
|
// final int dx[]=new int[4], dy[]=new int[4];
|
|
// dx[0]=(int) (x+dw);
|
|
// dy[0]=(int) (y);
|
|
// dx[1]=(int) (x+w);
|
|
// dy[1]=(int) (y+dw);
|
|
// dx[2]=(int) (x+dw);
|
|
// dy[2]=(int) (y+w);
|
|
// dx[3]=(int) (x);
|
|
// dy[3]=(int) (y+dw);
|
|
// if (isThick) {
|
|
// setColor(o);
|
|
// } else {
|
|
// G.setColor(new Color(250, 250, 250));
|
|
// }
|
|
// G.fillPolygon(dx, dy, 4);
|
|
// if (!isThick) {
|
|
// setColor(o);
|
|
// G.drawPolygon(dx, dy, 4);
|
|
// }
|
|
}
|
|
|
|
@Override
|
|
public void drawDcross(final double x, final double y, final double w,
|
|
final boolean isThick, final ConstructionObject o) {
|
|
final double x1=x+w, y1=y+w;
|
|
setColor(o);
|
|
if (isThick) {
|
|
G.setStroke(DCross);
|
|
} else {
|
|
G.setStroke(DCrossNormal);
|
|
}
|
|
G.draw(new Line2D.Double(x, y, x1, y1));
|
|
G.draw(new Line2D.Double(x, y1, x1, y));
|
|
G.setStroke(Normal);
|
|
}
|
|
|
|
@Override
|
|
public void setAntialiasing(final boolean bool) {
|
|
if (bool) {
|
|
G.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
|
|
RenderingHints.VALUE_ANTIALIAS_ON);
|
|
// G.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
|
|
// RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
|
|
} else {
|
|
G.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
|
|
RenderingHints.VALUE_ANTIALIAS_OFF);
|
|
// G.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
|
|
// RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void drawAxisLine(final double x, final double y, final double x1,
|
|
final double y1, float thickness) {
|
|
if (test(x)||test(y)||test(x1)||test(y1)) {
|
|
return;
|
|
}
|
|
|
|
// G.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,
|
|
// RenderingHints.VALUE_STROKE_NORMALIZE);
|
|
// G.setStroke(new BasicStroke(thickness));
|
|
G.setStroke(new BasicStroke(thickness, BasicStroke.CAP_ROUND, BasicStroke.JOIN_MITER));
|
|
G.draw(new Line2D.Double(x, y, x1, y1));
|
|
G.setStroke(Normal);
|
|
// G.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,
|
|
// RenderingHints.VALUE_STROKE_PURE);
|
|
}
|
|
}
|