public override java.awt.Paint getPaint()
{
if (javaPaint == null)
{
javaPaint = new java.awt.Color(color.ToArgb());
}
return(javaPaint);
}
public override void setColor(java.awt.Color color)
{
if (color == null || color == this.javaPaint)
{
// Does not change the color, if it is null like in SunGraphics2D
return;
}
this.javaPaint = this.javaColor = color;
this.color = Color.FromArgb(color.getRGB());
if (brush is SolidBrush)
{
((SolidBrush)brush).Color = this.color;
}
else
{
brush.Dispose();
brush = new SolidBrush(this.color);
}
pen.Color = this.color;
pen.Brush = brush;
}
public override void fill3DRect(int x, int y, int width, int height, bool raised)
{
java.awt.Paint p = getPaint();
java.awt.Color c = getColor();
java.awt.Color brighter = c.brighter();
java.awt.Color darker = c.darker();
if (!raised)
{
setColor(darker);
}
else if (p != c)
{
setColor(c);
}
fillRect(x + 1, y + 1, width - 2, height - 2);
setColor(raised ? brighter : darker);
fillRect(x, y, 1, height);
fillRect(x + 1, y, width - 2, 1);
setColor(raised ? darker : brighter);
fillRect(x + 1, y + height - 1, width - 1, 1);
fillRect(x + width - 1, y, 1, height - 1);
setPaint(p);
}
public override java.awt.Paint getPaint()
{
if( javaPaint == null ) {
javaPaint = composite.GetColor(color);
}
return javaPaint;
}
public override void setPaint(java.awt.Paint paint)
{
if (paint is java.awt.Color)
{
setColor((java.awt.Color)paint);
return;
}
if (paint == null || this.javaPaint == paint)
{
return;
}
this.javaPaint = paint;
if (paint is java.awt.GradientPaint)
{
java.awt.GradientPaint gradient = (java.awt.GradientPaint)paint;
LinearGradientBrush linear;
if (gradient.isCyclic())
{
linear = new LinearGradientBrush(
J2C.ConvertPoint(gradient.getPoint1()),
J2C.ConvertPoint(gradient.getPoint2()),
composite.GetColor(gradient.getColor1()),
composite.GetColor(gradient.getColor2()));
}
else
{
//HACK because .NET does not support continue gradient like Java else Tile Gradient
//that we receize the rectangle very large (factor z) and set 4 color values
// a exact solution will calculate the size of the Graphics with the current transform
Color color1 = composite.GetColor(gradient.getColor1());
Color color2 = composite.GetColor(gradient.getColor2());
float x1 = (float)gradient.getPoint1().getX();
float x2 = (float)gradient.getPoint2().getX();
float y1 = (float)gradient.getPoint1().getY();
float y2 = (float)gradient.getPoint2().getY();
float diffX = x2 - x1;
float diffY = y2 - y1;
const float z = 60; //HACK zoom factor, with a larger factor .NET will make the gradient wider.
linear = new LinearGradientBrush(
new PointF(x1 - z * diffX, y1 - z * diffY),
new PointF(x2 + z * diffX, y2 + z * diffY),
color1,
color1);
ColorBlend colorBlend = new ColorBlend(4);
Color[] colors = colorBlend.Colors;
colors[0] = colors[1] = color1;
colors[2] = colors[3] = color2;
float[] positions = colorBlend.Positions;
positions[1] = z / (2 * z + 1);
positions[2] = (z + 1) / (2 * z + 1);
positions[3] = 1.0f;
linear.InterpolationColors = colorBlend;
}
linear.WrapMode = WrapMode.TileFlipXY;
brush = linear;
pen.Brush = brush;
return;
}
if (paint is java.awt.TexturePaint)
{
java.awt.TexturePaint texture = (java.awt.TexturePaint)paint;
brush = new TextureBrush(
J2C.ConvertImage(texture.getImage()),
J2C.ConvertRect(texture.getAnchorRect()),
composite.GetImageAttributes());
pen.Brush = brush;
return;
}
if (paint is java.awt.LinearGradientPaint) {
java.awt.LinearGradientPaint gradient = (java.awt.LinearGradientPaint)paint;
PointF start = J2C.ConvertPoint(gradient.getStartPoint());
PointF end = J2C.ConvertPoint(gradient.getEndPoint());
java.awt.Color[] javaColors = gradient.getColors();
ColorBlend colorBlend;
Color[] colors;
bool noCycle = gradient.getCycleMethod() == java.awt.MultipleGradientPaint.CycleMethod.NO_CYCLE;
if (noCycle) {
//HACK because .NET does not support continue gradient like Java else Tile Gradient
//that we receize the rectangle very large (factor z) and set 2 additional color values
//an exact solution will calculate the size of the Graphics with the current transform
float diffX = end.X - start.X;
float diffY = end.Y - start.Y;
SizeF size = GetSize();
//HACK zoom factor, with a larger factor .NET will make the gradient wider.
float z = Math.Min(10, Math.Max(size.Width / diffX, size.Height / diffY));
start.X -= z * diffX;
start.Y -= z * diffY;
end.X += z * diffX;
end.Y += z * diffY;
colorBlend = new ColorBlend(javaColors.Length + 2);
colors = colorBlend.Colors;
float[] fractions = gradient.getFractions();
float[] positions = colorBlend.Positions;
for (int i = 0; i < javaColors.Length; i++) {
colors[i + 1] = composite.GetColor(javaColors[i]);
positions[i + 1] = (z + fractions[i]) / (2 * z + 1);
}
colors[0] = colors[1];
colors[colors.Length - 1] = colors[colors.Length - 2];
positions[positions.Length - 1] = 1.0f;
} else {
colorBlend = new ColorBlend(javaColors.Length);
colors = colorBlend.Colors;
colorBlend.Positions = gradient.getFractions();
for (int i = 0; i < javaColors.Length; i++) {
colors[i] = composite.GetColor(javaColors[i]);
}
}
LinearGradientBrush linear = new LinearGradientBrush(start, end, colors[0], colors[colors.Length - 1]);
linear.InterpolationColors = colorBlend;
switch (gradient.getCycleMethod().ordinal()) {
case (int)java.awt.MultipleGradientPaint.CycleMethod.__Enum.NO_CYCLE:
case (int)java.awt.MultipleGradientPaint.CycleMethod.__Enum.REFLECT:
linear.WrapMode = WrapMode.TileFlipXY;
break;
case (int)java.awt.MultipleGradientPaint.CycleMethod.__Enum.REPEAT:
linear.WrapMode = WrapMode.Tile;
break;
}
brush = linear;
pen.Brush = brush;
return;
}
throw new NotImplementedException("setPaint("+paint.GetType().FullName+")");
}
public override void setComposite(java.awt.Composite comp)
{
if (comp == null)
{
throw new java.lang.IllegalArgumentException("null Composite");
}
this.javaComposite = comp;
composite = CompositeHelper.Create(comp,g);
java.awt.Paint oldPaint = javaPaint;
javaPaint = null;
setPaint(oldPaint);
}
public override void setColor(java.awt.Color color)
{
if (color == null || color == this.javaPaint)
{
// Does not change the color, if it is null like in SunGraphics2D
return;
}
this.javaPaint = this.javaColor = color;
this.color = composite.GetColor(color);
if (brush is SolidBrush)
{
((SolidBrush)brush).Color = this.color;
}
else
{
brush.Dispose();
brush = new SolidBrush(this.color);
}
pen.Color = this.color;
pen.Brush = brush;
}
public override void setPaint(java.awt.Paint paint)
{
if (paint is java.awt.Color)
{
setColor((java.awt.Color)paint);
return;
}
if (paint == null || this.javaPaint == paint)
{
return;
}
this.javaPaint = paint;
if (paint is java.awt.GradientPaint)
{
java.awt.GradientPaint gradient = (java.awt.GradientPaint)paint;
LinearGradientBrush linear;
if (gradient.isCyclic())
{
linear = new LinearGradientBrush(
J2C.ConvertPoint(gradient.getPoint1()),
J2C.ConvertPoint(gradient.getPoint2()),
composite.GetColor(gradient.getColor1()),
composite.GetColor(gradient.getColor2()));
}
else
{
//HACK because .NET does not support continue gradient like Java else Tile Gradient
//that we receize the rectangle very large (factor z) and set 4 color values
// a exact solution will calculate the size of the Graphics with the current transform
Color color1 = composite.GetColor(gradient.getColor1());
Color color2 = composite.GetColor(gradient.getColor2());
float x1 = (float)gradient.getPoint1().getX();
float x2 = (float)gradient.getPoint2().getX();
float y1 = (float)gradient.getPoint1().getY();
float y2 = (float)gradient.getPoint2().getY();
float diffX = x2 - x1;
float diffY = y2 - y1;
const float z = 60; //HACK zoom factor, with a larger factor .NET will make the gradient wider.
linear = new LinearGradientBrush(
new PointF(x1 - z * diffX, y1 - z * diffY),
new PointF(x2 + z * diffX, y2 + z * diffY),
color1,
color1);
ColorBlend colorBlend = new ColorBlend(4);
Color[] colors = colorBlend.Colors;
colors[0] = colors[1] = color1;
colors[2] = colors[3] = color2;
float[] positions = colorBlend.Positions;
positions[1] = z / (2 * z + 1);
positions[2] = (z + 1) / (2 * z + 1);
positions[3] = 1.0f;
linear.InterpolationColors = colorBlend;
}
linear.WrapMode = WrapMode.TileFlipXY;
brush = linear;
pen.Brush = brush;
return;
}
if (paint is java.awt.TexturePaint)
{
java.awt.TexturePaint texture = (java.awt.TexturePaint)paint;
Bitmap txtr = J2C.ConvertImage(texture.getImage());
java.awt.geom.Rectangle2D anchor = texture.getAnchorRect();
TextureBrush txtBrush;
brush = txtBrush = new TextureBrush(txtr, new Rectangle(0, 0, txtr.Width, txtr.Height), composite.GetImageAttributes());
txtBrush.TranslateTransform((float)anchor.getX(), (float)anchor.getY());
txtBrush.ScaleTransform((float)anchor.getWidth() / txtr.Width, (float)anchor.getHeight() / txtr.Height);
txtBrush.WrapMode = WrapMode.Tile;
pen.Brush = brush;
return;
}
if (paint is java.awt.LinearGradientPaint) {
java.awt.LinearGradientPaint gradient = (java.awt.LinearGradientPaint)paint;
PointF start = J2C.ConvertPoint(gradient.getStartPoint());
PointF end = J2C.ConvertPoint(gradient.getEndPoint());
java.awt.Color[] javaColors = gradient.getColors();
ColorBlend colorBlend;
Color[] colors;
bool noCycle = gradient.getCycleMethod() == java.awt.MultipleGradientPaint.CycleMethod.NO_CYCLE;
if (noCycle) {
//HACK because .NET does not support continue gradient like Java else Tile Gradient
//that we receize the rectangle very large (factor z) and set 2 additional color values
//an exact solution will calculate the size of the Graphics with the current transform
float diffX = end.X - start.X;
float diffY = end.Y - start.Y;
SizeF size = GetSize();
//HACK zoom factor, with a larger factor .NET will make the gradient wider.
float z = Math.Min(10, Math.Max(size.Width / diffX, size.Height / diffY));
start.X -= z * diffX;
start.Y -= z * diffY;
end.X += z * diffX;
end.Y += z * diffY;
colorBlend = new ColorBlend(javaColors.Length + 2);
colors = colorBlend.Colors;
float[] fractions = gradient.getFractions();
float[] positions = colorBlend.Positions;
for (int i = 0; i < javaColors.Length; i++) {
colors[i + 1] = composite.GetColor(javaColors[i]);
positions[i + 1] = (z + fractions[i]) / (2 * z + 1);
}
colors[0] = colors[1];
colors[colors.Length - 1] = colors[colors.Length - 2];
positions[positions.Length - 1] = 1.0f;
} else {
colorBlend = new ColorBlend(javaColors.Length);
colors = colorBlend.Colors;
colorBlend.Positions = gradient.getFractions();
for (int i = 0; i < javaColors.Length; i++) {
colors[i] = composite.GetColor(javaColors[i]);
}
}
LinearGradientBrush linear = new LinearGradientBrush(start, end, colors[0], colors[colors.Length - 1]);
linear.InterpolationColors = colorBlend;
switch (gradient.getCycleMethod().ordinal()) {
case (int)java.awt.MultipleGradientPaint.CycleMethod.__Enum.NO_CYCLE:
case (int)java.awt.MultipleGradientPaint.CycleMethod.__Enum.REFLECT:
linear.WrapMode = WrapMode.TileFlipXY;
break;
case (int)java.awt.MultipleGradientPaint.CycleMethod.__Enum.REPEAT:
linear.WrapMode = WrapMode.Tile;
break;
}
brush = linear;
pen.Brush = brush;
return;
}
if (paint is java.awt.RadialGradientPaint )
{
java.awt.RadialGradientPaint gradient = (java.awt.RadialGradientPaint)paint;
GraphicsPath path = new GraphicsPath();
SizeF size = GetSize();
PointF center = J2C.ConvertPoint(gradient.getCenterPoint());
float radius = gradient.getRadius();
int factor = (int)Math.Ceiling(Math.Max(size.Width, size.Height) / radius);
float diameter = radius * factor;
path.AddEllipse(center.X - diameter, center.Y - diameter, diameter * 2, diameter * 2);
java.awt.Color[] javaColors = gradient.getColors();
float[] fractions = gradient.getFractions();
int length = javaColors.Length;
ColorBlend colorBlend = new ColorBlend(length * factor);
Color[] colors = colorBlend.Colors;
float[] positions = colorBlend.Positions;
for (int c = 0, j = length - 1; j >= 0; )
{
positions[c] = (1 - fractions[j]) / factor;
colors[c++] = composite.GetColor(javaColors[j--]);
}
java.awt.MultipleGradientPaint.CycleMethod.__Enum cycle = (java.awt.MultipleGradientPaint.CycleMethod.__Enum)gradient.getCycleMethod().ordinal();
for (int f = 1; f < factor; f++)
{
int off = f * length;
for (int c = 0, j = length - 1; j >= 0; j--, c++)
{
switch (cycle)
{
case java.awt.MultipleGradientPaint.CycleMethod.__Enum.REFLECT:
if (f % 2 == 0)
{
positions[off + c] = (f + 1 - fractions[j]) / factor;
colors[off + c] = colors[c];
}
else
{
positions[off + c] = (f + fractions[c]) / factor;
colors[off + c] = colors[j];
}
break;
case java.awt.MultipleGradientPaint.CycleMethod.__Enum.NO_CYCLE:
positions[off + c] = (f + 1 - fractions[j]) / factor;
break;
default: //CycleMethod.REPEAT
positions[off + c] = (f + 1 - fractions[j]) / factor;
colors[off + c] = colors[c];
break;
}
}
}
if (cycle == java.awt.MultipleGradientPaint.CycleMethod.__Enum.NO_CYCLE && factor > 1)
{
Array.Copy(colors, 0, colors, colors.Length - length, length);
Color color = colors[length - 1];
for (int i = colors.Length - length - 1; i >= 0; i--)
{
colors[i] = color;
}
}
PathGradientBrush pathBrush = new PathGradientBrush(path);
pathBrush.CenterPoint = center;
pathBrush.InterpolationColors = colorBlend;
brush = pathBrush;
pen.Brush = brush;
return;
}
//generic paint to brush conversion for custom paints
//the tranform of the graphics should not change between the creation and it usage
using (Matrix transform = g.Transform)
{
SizeF size = GetSize();
int width = (int)size.Width;
int height = (int)size.Height;
java.awt.Rectangle bounds = new java.awt.Rectangle(0, 0, width, height);
java.awt.PaintContext context = paint.createContext(ColorModel.getRGBdefault(), bounds, bounds, C2J.ConvertMatrix(transform), getRenderingHints());
WritableRaster raster = (WritableRaster)context.getRaster(0, 0, width, height);
BufferedImage txtrImage = new BufferedImage(context.getColorModel(), raster, true, null);
Bitmap txtr = J2C.ConvertImage(txtrImage);
TextureBrush txtBrush;
brush = txtBrush = new TextureBrush(txtr, new Rectangle(0, 0, width, height), composite.GetImageAttributes());
transform.Invert();
txtBrush.Transform = transform;
txtBrush.WrapMode = WrapMode.Tile;
pen.Brush = brush;
return;
}
}
public override void setPaint(java.awt.Paint paint)
{
if (paint is java.awt.Color)
{
setColor((java.awt.Color)paint);
return;
}
if (paint == null || this.javaPaint == paint)
{
return;
}
this.javaPaint = paint;
if (paint is java.awt.GradientPaint)
{
java.awt.GradientPaint gradient = (java.awt.GradientPaint)paint;
LinearGradientBrush linear;
if (gradient.isCyclic())
{
linear = new LinearGradientBrush(
J2C.ConvertPoint(gradient.getPoint1()),
J2C.ConvertPoint(gradient.getPoint2()),
J2C.ConvertColor(gradient.getColor1()),
J2C.ConvertColor(gradient.getColor2()));
}
else
{
//HACK because .NET does not support continue gradient like Java else Tile Gradient
//that we receize the rectangle very large (factor z) and set 4 color values
// a exact solution will calculate the size of the Graphics with the current transform
Color color1 = J2C.ConvertColor(gradient.getColor1());
Color color2 = J2C.ConvertColor(gradient.getColor2());
float x1 = (float)gradient.getPoint1().getX();
float x2 = (float)gradient.getPoint2().getX();
float y1 = (float)gradient.getPoint1().getY();
float y2 = (float)gradient.getPoint2().getY();
float diffX = x2 - x1;
float diffY = y2 - y1;
const float z = 60; //HACK zoom factor, with a larger factor .NET will make the gradient wider.
linear = new LinearGradientBrush(
new PointF(x1 - z * diffX, y1 - z * diffY),
new PointF(x2 + z * diffX, y2 + z * diffY),
color1,
color1);
ColorBlend colorBlend = new ColorBlend(4);
Color[] colors = colorBlend.Colors;
colors[0] = colors[1] = color1;
colors[2] = colors[3] = color2;
float[] positions = colorBlend.Positions;
positions[1] = z / (2 * z + 1);
positions[2] = (z + 1) / (2 * z + 1);
positions[3] = 1.0f;
linear.InterpolationColors = colorBlend;
}
linear.WrapMode = WrapMode.TileFlipXY;
brush = linear;
pen.Brush = brush;
return;
}
if (paint is java.awt.TexturePaint)
{
java.awt.TexturePaint texture = (java.awt.TexturePaint)paint;
brush = new TextureBrush(
J2C.ConvertImage(texture.getImage()),
J2C.ConvertRect(texture.getAnchorRect()));
pen.Brush = brush;
return;
}
throw new NotImplementedException("setPaint("+paint.GetType().FullName+")");
}
public override java.awt.Paint getPaint()
{
if( javaPaint == null ) {
javaPaint = new java.awt.Color(color.ToArgb());
}
return javaPaint;
}
public override void setPaint(java.awt.Paint paint)
{
if (paint is java.awt.Color)
{
setColor((java.awt.Color)paint);
return;
}
if (paint == null || this.javaPaint == paint)
{
return;
}
this.javaPaint = paint;
if (paint is java.awt.GradientPaint)
{
java.awt.GradientPaint gradient = (java.awt.GradientPaint)paint;
LinearGradientBrush linear;
if (gradient.isCyclic())
{
linear = new LinearGradientBrush(
J2C.ConvertPoint(gradient.getPoint1()),
J2C.ConvertPoint(gradient.getPoint2()),
J2C.ConvertColor(gradient.getColor1()),
J2C.ConvertColor(gradient.getColor2()));
}
else
{
//HACK because .NET does not support continue gradient like Java else Tile Gradient
//that we receize the rectangle very large (factor z) and set 4 color values
// a exact solution will calculate the size of the Graphics with the current transform
Color color1 = J2C.ConvertColor(gradient.getColor1());
Color color2 = J2C.ConvertColor(gradient.getColor2());
float x1 = (float)gradient.getPoint1().getX();
float x2 = (float)gradient.getPoint2().getX();
float y1 = (float)gradient.getPoint1().getY();
float y2 = (float)gradient.getPoint2().getY();
float diffX = x2 - x1;
float diffY = y2 - y1;
const float z = 60; //HACK zoom factor, with a larger factor .NET will make the gradient wider.
linear = new LinearGradientBrush(
new PointF(x1 - z * diffX, y1 - z * diffY),
new PointF(x2 + z * diffX, y2 + z * diffY),
color1,
color1);
ColorBlend colorBlend = new ColorBlend(4);
Color[] colors = colorBlend.Colors;
colors[0] = colors[1] = color1;
colors[2] = colors[3] = color2;
float[] positions = colorBlend.Positions;
positions[1] = z / (2 * z + 1);
positions[2] = (z + 1) / (2 * z + 1);
positions[3] = 1.0f;
linear.InterpolationColors = colorBlend;
}
linear.WrapMode = WrapMode.TileFlipXY;
brush = linear;
pen.Brush = brush;
return;
}
if (paint is java.awt.TexturePaint)
{
java.awt.TexturePaint texture = (java.awt.TexturePaint)paint;
brush = new TextureBrush(
J2C.ConvertImage(texture.getImage()),
J2C.ConvertRect(texture.getAnchorRect()));
pen.Brush = brush;
return;
}
throw new NotImplementedException("setPaint(" + paint.GetType().FullName + ")");
}
