////////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS ------------------------------
// Date Name Tracking # Description
// --------- ------------------- ------------- ----------------------
// 13JUN2009 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////////
/**
* Constructor
* @param r
* @param at
*/
internal RectIterator(Rectangle r, AffineTransform at)
{
_x = r.GetX();
_y = r.GetY();
_w = r.GetWidth();
_h = r.GetHeight();
_affine = at;
if (_w < 0 || _h < 0)
{
_index = 6;
}
}
////////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS ------------------------------
// Date Name Tracking # Description
// --------- ------------------- ------------- ----------------------
// 13JUN2009 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////////
/**
* Adds a <code>Rectangle</code> object to this
* <code>Rectangle</code>. The resulting <code>Rectangle</code>
* is the union of the two <code>Rectangle</code> objects.
* @param r the <code>Rectangle</code> to add to this
* <code>Rectangle</code>.
*/
public void Add(Rectangle r)
{
int x1 = Math.Min(GetMinX(), r.GetMinX());
int x2 = Math.Max(GetMaxX(), r.GetMaxX());
int y1 = Math.Min(GetMinY(), r.GetMinY());
int y2 = Math.Max(GetMaxY(), r.GetMaxY());
SetRect(x1, y1, x2 - x1, y2 - y1);
}
public abstract void Enlarge(Rectangle r);
////////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS ------------------------------
// Date Name Tracking # Description
// --------- ------------------- ------------- ----------------------
// 13JUN2009 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////////
/**
* Determines whether or not the interior of the arc intersects
* the interior of the specified rectangle.
*
* @param x The X coordinate of the rectangle's upper-left corner.
* @param y The Y coordinate of the rectangle's upper-left corner.
* @param w The width of the rectangle.
* @param h The height of the rectangle.
*
* @return <CODE>true</CODE> if the arc intersects the rectangle,
* <CODE>false</CODE> if the arc doesn't intersect the rectangle.
*/
public override bool Intersects(int x, int y, int w, int h)
{
double aw = GetWidth();
double ah = GetHeight();
if (w <= 0 || h <= 0 || aw <= 0 || ah <= 0)
{
return false;
}
double ext = GetAngleExtent();
if (ext == 0)
{
return false;
}
double ax = GetX();
double ay = GetY();
double axw = ax + aw;
double ayh = ay + ah;
double xw = x + w;
double yh = y + h;
// check bbox
if (x >= axw || y >= ayh || xw <= ax || yh <= ay)
{
return false;
}
// extract necessary data
double axc = GetCenterX();
double ayc = GetCenterY();
Point sp = GetStartPoint();
Point ep = GetEndPoint();
double sx = sp.GetX();
double sy = sp.GetY();
double ex = ep.GetX();
double ey = ep.GetY();
/*
* Try to catch rectangles that intersect arc in areas
* outside of rectagle with left top corner coordinates
* (Min(center x, start point x, end point x),
* Min(center y, start point y, end point y))
* and rigth bottom corner coordinates
* (Max(center x, start point x, end point x),
* Max(center y, start point y, end point y)).
* So we'll check axis segments outside of rectangle above.
*/
if (ayc >= y && ayc <= yh)
{ // 0 and 180
if ((sx < xw && ex < xw && axc < xw &&
axw > x && ContainsAngle(0)) ||
(sx > x && ex > x && axc > x &&
ax < xw && ContainsAngle(180)))
{
return true;
}
}
if (axc >= x && axc <= xw)
{ // 90 and 270
if ((sy > y && ey > y && ayc > y &&
ay < yh && ContainsAngle(90)) ||
(sy < yh && ey < yh && ayc < yh &&
ayh > y && ContainsAngle(270)))
{
return true;
}
}
/*
* For PIE we should check intersection with pie slices;
* also we should do the same for arcs with extent is greater
* than 180, because we should cover case of rectangle, which
* situated between center of arc and chord, but does not
* intersect the chord.
*/
Rectangle rect = new Rectangle((int)(x + .5),
(int)(y + .5),
(int)(w + .5),
(int)(h + .5));
if (_type == PIE || MathEx.Abs(ext) > 180)
{
// for PIE: try to find intersections with pie slices
if (rect.IntersectsLine((int)(axc + .5),
(int)(ayc + .5),
(int)(sx + .5),
(int)(sy + .5)) ||
rect.IntersectsLine((int)(axc + .5),
(int)(ayc + .5),
(int)(ex + .5),
(int)(ey + .5)))
{
return true;
}
}
else
{
// for CHORD and OPEN: try to find intersections with chord
if (rect.IntersectsLine((int)(sx + .5),
(int)(sy + .5), (int)(ex + .5),
(int)(ey + .5)))
{
return true;
}
}
// finally check the rectangle corners inside the arc
if (Contains(x, y) || Contains(x + w, y) ||
Contains(x, y + h) || Contains(x + w, y + h))
{
return true;
}
return false;
}
///////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS ------------------------------
// Date Name Tracking # Description
// --------- ------------------- ------------- ----------------------
// 13JUN2009 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////////
/**
* Constructs a new arc, initialized to the specified location,
* size, angular extents, and closure type.
*
* @param ellipseBounds The framing rectangle that defines the
* outer boundary of the full ellipse of which this arc is a
* partial section.
* @param start The starting angle of the arc in degrees.
* @param extent The angular extent of the arc in degrees.
* @param type The closure type for the arc:
* {@link #OPEN}, {@link #CHORD}, or {@link #PIE}.
*/
public Arc(Rectangle ellipseBounds,
double start, double extent, int type)
: this(type)
{
X = ellipseBounds.GetX();
Y = ellipseBounds.GetY();
Width = ellipseBounds.GetWidth();
Height = ellipseBounds.GetHeight();
Start = start;
Extent = extent;
}
////////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS ------------------------------
// Date Name Tracking # Description
// 13JUN2009 ------------------- ------------- ----------------------
// 08NOV2008 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////////
/**
* Sets the location, size, angular extents, and closure type of
* this arc to the specified values.
*
* @param rect The framing rectangle that defines the
* outer boundary of the full ellipse of which this arc is a
* partial section.
* @param angSt The starting angle of the arc in degrees.
* @param angExt The angular extent of the arc in degrees.
* @param closure The closure type for the arc:
* {@link #OPEN}, {@link #CHORD}, or {@link #PIE}.
*/
public void SetArc(Rectangle rect, double angSt, double angExt,
int closure)
{
SetArc(rect.GetX(), rect.GetY(), rect.GetWidth(), rect.GetHeight(),
angSt, angExt, closure);
}
////////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS ------------------------------
// Date Name Tracking # Description
// --------- ------------------- ------------- ----------------------
// 13JUN2009 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////////
/**
* Resets this <code>Polygon</code> object to an empty polygon.
* The coordinate arrays and the data in them are left untouched
* but the number of points is reset to zero to mark the old
* vertex data as invalid and to start accumulating new vertex
* data at the beginning.
* All internally-cached data relating to the old vertices
* are discarded.
* that since the coordinate arrays from before the reset
* are reused, creating a new empty <code>Polygon</code> might
* be more memory efficient than resetting the current one if
* the number of vertices in the new polygon data is significantly
* smaller than the number of vertices in the data from before the
* reset.
*/
public void Reset()
{
NumOfNpoints = 0;
_bounds = null;
}
////////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS ------------------------------
// Date Name Tracking # Description
// --------- ------------------- ------------- ----------------------
// 13JUN2009 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////////
/**
* {@inheritDoc}
*/
public bool Intersects(Rectangle r)
{
return Intersects(r.X, r.Y, r.Width, r.Height);
}
////////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS ------------------------------
// Date Name Tracking # Description
// --------- ------------------- ------------- ----------------------
// 13JUN2009 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////////
/**
* Tests if the interior of the specified {@link PathIterator}
* intersects the interior of a specified {@link Rectangle}.
* <p>
* This method provides a basic facility for implementors of
* the {@link IShape} interface to implement support for the
* {@link IShape#intersects(Rectangle)} method.
* <p>
* This method object may conservatively return true in
* cases where the specified rectangular area intersects a
* segment of the path, but that segment does not represent a
* boundary between the interior and exterior of the path.
* Such a case may occur if some set of segments of the
* path are retraced in the reverse direction such that the
* two sets of segments cancel each other out without any
* interior area between them.
* To determine whether segments represent true boundaries of
* the interior of the path would require extensive calculations
* involving all of the segments of the path and the winding
* rule and are thus beyond the scope of this implementation.
*
* @param pi the specified {@code PathIterator}
* @param r the specified {@code Rectangle}
* @return {@code true} if the specified {@code PathIterator} and
* the interior of the specified {@code Rectangle}
* intersect each other; {@code false} otherwise.
*/
public static bool Intersects(PathIterator pi, Rectangle r)
{
return Intersects(pi, r.X, r.Y, r.Width, r.Height);
}
////////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS ------------------------------
// Date Name Tracking # Description
// --------- ------------------- ------------- ----------------------
// 13JUN2009 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////////
/**
* Tests if the specified {@link Rectangle} is entirely inside the
* closed boundary of the specified {@link PathIterator}.
* <p>
* This method provides a basic facility for implementors of
* the {@link IShape} interface to implement support for the
* {@link IShape#contains(Rectangle)} method.
* <p>
* This method object may conservatively return false in
* cases where the specified rectangular area intersects a
* segment of the path, but that segment does not represent a
* boundary between the interior and exterior of the path.
* Such segments could lie entirely within the interior of the
* path if they are part of a path with a {@link #WIND_NON_ZERO}
* winding rule or if the segments are retraced in the reverse
* direction such that the two sets of segments cancel each
* other out without any exterior area falling between them.
* To determine whether segments represent true boundaries of
* the interior of the path would require extensive calculations
* involving all of the segments of the path and the winding
* rule and are thus beyond the scope of this implementation.
*
* @param pi the specified {@code PathIterator}
* @param r a specified {@code Rectangle}
* @return {@code true} if the specified {@code PathIterator} contains
* the specified {@code Rectangle}; {@code false} otherwise.
*/
public static bool Contains(PathIterator pi, Rectangle r)
{
return Contains(pi, r.X, r.Y, r.Width, r.Height);
}
////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS --------------------------
// Date Name Tracking # Description
// --------- ------------------- ------------- ------------------
// 18JUN2009 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////
/**
*
* @param mapDirection
* @param X
* @param Y
* @param Width
* @param Height
*/
private void DrawRouteImage(MapDirection mapDirection, int x, int y,
int width, int height)
{
if (!_routeDrawWaypointOnly)
{
_sutherlandHodgman = new SutherlandHodgman(_screenBounds);
ArrayList polyline = new ArrayList();
int minLevel = NeedShowLevel(mapDirection.Polyline.NumLevels, GetZoom());
for (int i = 0; i < mapDirection.Polyline.GetVertexCount(); i++)
{
int level = mapDirection.Polyline.GetLevel(i);
if (level >= minLevel)
{
polyline.Add(mapDirection.Polyline.GetVertex(i));
}
}
ArrayList clippedPts = _sutherlandHodgman.ClipPline(polyline);
GeoPoint newPt1;
GeoPoint newPt2;
GeoPoint drawPt1 = new GeoPoint(0, 0), drawPt2 = new GeoPoint(0, 0);
const int steps = 1;
int numOfTiles = MAP_TILE_WIDTH / _mapDrawingTileWidth;
Rectangle drawArea = new Rectangle();
Rectangle intersectRect = new Rectangle(0, 0, width, height);
int xIndex;
for (xIndex = 0; xIndex < numOfTiles; xIndex++)
{
int yIndex;
for (yIndex = 0; yIndex < numOfTiles; yIndex++)
{
bool hasPt1 = false;
GeoLatLng pt1 = null;
_routeGraphics2D.Clear(Color.White);
drawArea.X = xIndex * _mapDrawingTileWidth;
drawArea.Y = yIndex * _mapDrawingTileWidth;
drawArea.Width = drawArea.Height = _mapDrawingTileWidth;
drawArea = intersectRect.Intersection(drawArea);
int totalPointSize = clippedPts.Count;
if (!drawArea.IsEmpty())
{
_routeGraphics2D.SetClip(0, 0,
drawArea.Width, drawArea.Height);
try
{
for (int j = 0; j < totalPointSize; j += steps)
{
GeoLatLng pt = (GeoLatLng)clippedPts[j];
int level = minLevel;
if (hasPt1 == false)
{
if (level >= minLevel)
{
{
{
hasPt1 = true;
pt1 = pt;
continue;
}
}
}
}
if (hasPt1)
{
if (level >= minLevel)
{
GeoLatLng pt2 = pt;
newPt1 = FromLatLngToMapPixel(pt1);
newPt2 = FromLatLngToMapPixel(pt2);
newPt1.X -= x + xIndex * _mapDrawingTileWidth;
newPt1.Y -= y + yIndex * _mapDrawingTileWidth;
newPt2.X -= x + xIndex * _mapDrawingTileWidth;
newPt2.Y -= y + yIndex * _mapDrawingTileWidth;
drawPt1.X = (int)newPt1.X;
drawPt1.Y = (int)newPt1.Y;
drawPt2.X = (int)newPt2.X;
drawPt2.Y = (int)newPt2.Y;
if ((drawPt1.Distance(drawPt2) > 0))
{
_routeGraphics2D.DrawLine(RoutePen, (int)drawPt1.X,
(int)drawPt1.Y,
(int)drawPt2.X, (int)drawPt2.Y);
pt1 = pt2;
if (_readListener != null)
{
_readListener.readProgress(j,
totalPointSize);
}
}
}
}
}
}
catch (Exception)
{
}
}
_routeGraphics.DrawRGB(_routeGraphics2D.GetRGB(), 0,
_mapDrawingTileWidth,
xIndex * _mapDrawingTileWidth,
yIndex * _mapDrawingTileWidth,
_mapDrawingTileWidth,
_mapDrawingTileWidth, true);
}
}
}
else
{
_routeGraphics.SetColor(TRANSPARENCY);
_routeGraphics.FillRect(0, 0, MAP_TILE_WIDTH, MAP_TILE_WIDTH);
}
}
public override void Enlarge(Rectangle r)
{
r.Add((int)(_x0 + 0.5), (int)(_y0 + 0.5));
double t = -_xcoeff1 / (2 * _xcoeff2);
if (t > 0 && t < 1)
{
r.Add((int)(XforT(t) + .5), (int)(YforT(t) + .5));
}
r.Add((int)(_x1 + 0.5), (int)(_y1 + 0.5));
}
////////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS ------------------------------
// Date Name Tracking # Description
// --------- ------------------- ------------- ----------------------
// 13JUN2009 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////////
/**
* Returns a new <code>Rectangle</code> object representing the
* union of this <code>Rectangle</code> with the specified
* <code>Rectangle</code>.
* @param r the <code>Rectangle</code> to be combined with
* this <code>Rectangle</code>
* @return the smallest <code>Rectangle</code> containing both
* the specified <code>Rectangle</code> and this
* <code>Rectangle</code>.
*/
public Rectangle CreateUnion(Rectangle r)
{
return Union(r);
}
////////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS ------------------------------
// Date Name Tracking # Description
// --------- ------------------- ------------- ----------------------
// 13JUN2009 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////////
/**
* Returns a new <code>Rectangle</code> object representing the
* intersection of this <code>Rectangle2D</code> with the specified
* <code>Rectangle</code>.
* @param r the <code>Rectangle</code> to be intersected with
* this <code>Rectangle</code>
* @return the largest <code>Rectangle</code> contained in both
* the specified <code>Rectangle</code> and in this
* <code>Rectangle</code>.
*/
public Rectangle CreateIntersection(Rectangle r)
{
return Intersection(r);
}
////////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS ------------------------------
// Date Name Tracking # Description
// --------- ------------------- ------------- ----------------------
// 13JUN2009 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////////
/**
* Checks whether or not this <code>Rectangle</code> entirely contains
* the specified <code>Rectangle</code>.
*
* @param rect the specified <code>Rectangle</code>
* @return <code>true</code> if the <code>Rectangle</code>
* is contained entirely inside this <code>Rectangle</code>;
* <code>false</code> otherwise
*/
public override bool Contains(Rectangle rect)
{
return Contains(rect.X, rect.Y, rect._size.GetWidth(), rect._size.GetHeight());
}
////////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS ------------------------------
// Date Name Tracking # Description
// --------- ------------------- ------------- ----------------------
// 13JUN2009 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////////
/**
* {@inheritDoc}
*/
public bool Intersects(Rectangle r)
{
return Intersects(r.GetX(), r.GetY(), r.GetWidth(), r.GetHeight());
}
////////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS ------------------------------
// Date Name Tracking # Description
// --------- ------------------- ------------- ----------------------
// 13JUN2009 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////////
/**
* {@inheritDoc}
*/
public bool Contains(Rectangle r)
{
return Contains(r.X, r.Y, r.Width, r.Height);
}
////////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS ------------------------------
// Date Name Tracking # Description
// --------- ------------------- ------------- ----------------------
// 13JUN2009 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////////
private Rectangle GetCachedBounds()
{
if (_cachedBounds != null)
{
return _cachedBounds;
}
Rectangle r = new Rectangle();
if (_curves.Count > 0)
{
Curve c = (Curve)_curves[0];
// First point is always an order 0 curve (moveto)
r.SetRect((int)(c.GetX0() + .5),
(int)(c.GetY0() + .5), 0, 0);
for (int i = 1; i < _curves.Count; i++)
{
((Curve)_curves[i]).Enlarge(r);
}
}
return (_cachedBounds = r);
}
////////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS ------------------------------
// Date Name Tracking # Description
// --------- ------------------- ------------- ----------------------
// 13JUN2009 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////////
/**
* Invalidates or flushes any internally-cached data that depends
* on the vertex coordinates of this <code>Polygon</code>.
* This method should be called after any direct manipulation
* of the coordinates in the <code>xpoints</code> or
* <code>ypoints</code> arrays to avoid inconsistent results
* from methods such as <code>getBounds</code> or <code>contains</code>
* that might cache data from earlier computations relating to
* the vertex coordinates.
*/
public void Invalidate()
{
_bounds = null;
}
////////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS ------------------------------
// Date Name Tracking # Description
// --------- ------------------- ------------- ----------------------
// 13JUN2009 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////////
private void InvalidateBounds()
{
_cachedBounds = null;
}
////////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS ------------------------------
// Date Name Tracking # Description
// --------- ------------------- ------------- ----------------------
// 13JUN2009 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////////
/*
* Calculates the bounding box of the points passed to the constructor.
* Sets <code>bounds</code> to the result.
* @param xpoints[] array of <i>x</i> coordinates
* @param ypoints[] array of <i>y</i> coordinates
* @param npoints the total number of points
*/
private void CalculateBounds(int[] xpoints, int[] ypoints, int npoints)
{
int boundsMinX = int.MaxValue;
int boundsMinY = int.MaxValue;
int boundsMaxX = int.MinValue;
int boundsMaxY = int.MinValue;
for (int i = 0; i < npoints; i++)
{
int x = xpoints[i];
boundsMinX = Math.Min(boundsMinX, x);
boundsMaxX = Math.Max(boundsMaxX, x);
int y = ypoints[i];
boundsMinY = Math.Min(boundsMinY, y);
boundsMaxY = Math.Max(boundsMaxY, y);
}
_bounds = new Rectangle(boundsMinX, boundsMinY,
boundsMaxX - boundsMinX,
boundsMaxY - boundsMinY);
}
public LinearGradientBrush(Rectangle rect, Color color1, Color color2,
float angle)
: this(rect, color1, color2, angle, NO_CYCLE)
{
}
////////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS ------------------------------
// Date Name Tracking # Description
// --------- ------------------- ------------- ----------------------
// 13JUN2009 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////////
private bool Contains(int x, int y, int w, int h,
Rectangle origrect)
{
if (!(Contains(x, y) &&
Contains(x + w, y) &&
Contains(x, y + h) &&
Contains(x + w, y + h)))
{
return false;
}
// If the shape is convex then we have done all the testing
// we need. Only PIE arcs can be concave and then only if
// the angular extents are greater than 180 degrees.
if (_type != PIE || MathEx.Abs(GetAngleExtent()) <= 180.0)
{
return true;
}
// For a PIE shape we have an additional test for the case where
// the angular extents are greater than 180 degrees and all four
// rectangular corners are inside the shape but one of the
// rectangle edges spans across the "missing wedge" of the arc.
// We can test for this case by checking if the rectangle intersects
// either of the pie angle segments.
if (origrect == null)
{
origrect = new Rectangle((int)(x + .5),
(int)(y + .5),
(int)(w + .5),
(int)(h + .5));
}
double halfW = GetWidth() / 2.0;
double halfH = GetHeight() / 2.0;
double xc = GetX() + halfW;
double yc = GetY() + halfH;
double angle = MathEx.ToRadians(-GetAngleStart());
double xe = xc + halfW * MathEx.Cos(angle);
double ye = yc + halfH * MathEx.Sin(angle);
if (origrect.IntersectsLine((int)(xc + .5),
(int)(yc + .5),
(int)(xe + .5),
(int)(ye + .5)))
{
return false;
}
angle += MathEx.ToRadians(-GetAngleExtent());
xe = xc + halfW * MathEx.Cos(angle);
ye = yc + halfH * MathEx.Sin(angle);
return !origrect.IntersectsLine((int)(xc + .5),
(int)(yc + .5),
(int)(xe + .5),
(int)(ye + .5));
}
public LinearGradientBrush(Rectangle rect, Color color1, Color color2,
float angle, int fillType)
{
_start = new Point(rect.X, rect.Y);
_end = new Point(rect.X + rect.Width, rect.Y + rect.Height);
_gradientTransform = new AffineTransform();
_fractions = new[] { 0, 100 };
_colors = new[] { color1, color2 };
bool opaque = true;
for (int i = 0; i < _colors.Length; i++)
{
opaque = opaque && (_colors[i].GetAlpha() == 0xff);
}
_transparency = opaque ? Color.OPAQUE : Color.TRANSLUCENT;
RectangleFP r = Utils.ToRectangleFP(rect);
_wrappedBrushFP = new LinearGradientBrushFP(r.GetLeft(), r.GetTop(),
r.GetRight(), r.GetBottom(),
MathFP.ToRadians(SingleFP.FromFloat(angle)));
for (int i = 0; i < _colors.Length; i++)
{
((LinearGradientBrushFP)_wrappedBrushFP)
.SetGradientColor(SingleFP.FromFloat(_fractions[i]
/ 255.0f),
_colors[i]._value);
}
((LinearGradientBrushFP)_wrappedBrushFP).UpdateGradientTable();
_wrappedBrushFP.SetMatrix(Utils.ToMatrixFP(_gradientTransform));
_wrappedBrushFP.FillMode = fillType;
}
////////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS ------------------------------
// Date Name Tracking # Description
// --------- ------------------- ------------- ----------------------
// 13JUN2009 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////////
/**
* Determines whether or not the interior of the arc entirely contains
* the specified rectangle.
*
* @param r The <CODE>Rectangle</CODE> to test.
*
* @return <CODE>true</CODE> if the arc contains the rectangle,
* <CODE>false</CODE> if the arc doesn't contain the rectangle.
*/
public override bool Contains(Rectangle r)
{
return Contains(r.GetX(), r.GetY(), r.GetWidth(), r.GetHeight(), r);
}
////////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS ------------------------------
// Date Name Tracking # Description
// --------- ------------------- ------------- ----------------------
// 15JUN2009 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////////
/**
* Constructs a {@code LinearGradientBrush}.
*
* @param start the gradient axis start {@code Point} in user space
* @param end the gradient axis end {@code Point} in user space
* @param fractions numbers ranging from 0 to 255 specifying the
* distribution of colors along the gradient
* @param colors array of colors corresponding to each fractional Value
* @param fillType either {@code NO_CYCLE}, {@code REFLECT},
* or {@code REPEAT}
* @param gradientTransform transform to apply to the gradient
*
* @throws NullPointerException
* if one of the points is null,
* or {@code fractions} array is null,
* or {@code colors} array is null,
* or {@code cycleMethod} is null,
* or {@code colorSpace} is null,
* or {@code gradientTransform} is null
* @throws IllegalArgumentException
* if start and end points are the same points,
* or {@code fractions.length != colors.length},
* or {@code colors} is less than 2 in size,
* or a {@code fractions} Value is less than 0.0 or greater than 1.0,
* or the {@code fractions} are not provided in strictly increasing order
*/
public LinearGradientBrush(Point start, Point end,
int[] fractions, Color[] colors,
AffineTransform gradientTransform, int fillType)
{
if (fractions == null)
{
throw new NullReferenceException("Fractions array cannot be null");
}
if (colors == null)
{
throw new NullReferenceException("Colors array cannot be null");
}
if (gradientTransform == null)
{
throw new NullReferenceException("Gradient transform cannot be " +
"null");
}
if (fractions.Length != colors.Length)
{
throw new ArgumentException("Colors and fractions must " +
"have equal size");
}
if (colors.Length < 2)
{
throw new ArgumentException("User must specify at least " +
"2 colors");
}
// check that values are in the proper range and progress
// in increasing order from 0 to 1
int previousFraction = -255;
for (int i = 0; i < fractions.Length; i++)
{
int currentFraction = fractions[i];
if (currentFraction < 0 || currentFraction > 255)
{
throw new ArgumentException("Fraction values must " +
"be in the range 0 to 255: " +
currentFraction);
}
if (currentFraction <= previousFraction)
{
throw new ArgumentException("Keyframe fractions " +
"must be increasing: " +
currentFraction);
}
previousFraction = currentFraction;
}
// We have to deal with the cases where the first gradient stop is not
// equal to 0 and/or the last gradient stop is not equal to 1.
// In both cases, create a new point and replicate the previous
// extreme point's color.
bool fixFirst = false;
bool fixLast = false;
int len = fractions.Length;
int off = 0;
if (fractions[0] != 0)
{
// first stop is not equal to zero, fix this condition
fixFirst = true;
len++;
off++;
}
if (fractions[fractions.Length - 1] != 255)
{
// last stop is not equal to one, fix this condition
fixLast = true;
len++;
}
this._fractions = new int[len];
Array.Copy(fractions, 0, this._fractions, off, fractions.Length);
this._colors = new Color[len];
Array.Copy(colors, 0, this._colors, off, colors.Length);
if (fixFirst)
{
this._fractions[0] = 0;
this._colors[0] = colors[0];
}
if (fixLast)
{
this._fractions[len - 1] = 255;
this._colors[len - 1] = colors[colors.Length - 1];
}
// copy the gradient transform
this._gradientTransform = new AffineTransform(gradientTransform);
// determine transparency
bool opaque = true;
for (int i = 0; i < colors.Length; i++)
{
opaque = opaque && (colors[i].GetAlpha() == 0xff);
}
_transparency = opaque ? Color.OPAQUE : Color.TRANSLUCENT;
// check input parameters
if (start == null || end == null)
{
throw new NullReferenceException("Start and end points must be" +
"non-null");
}
if (start.Equals(end))
{
throw new ArgumentException("Start point cannot equal" +
"endpoint");
}
// copy the points...
this._start = new Point(start.GetX(), start.GetY());
this._end = new Point(end.GetX(), end.GetY());
Rectangle rectangle = new Rectangle(start, end);
float dx = start.X - end.X;
float dy = start.Y - end.Y;
double angle = MathEx.Atan2(dy, dx);
int intAngle = SingleFP.FromDouble(angle);
RectangleFP r = Utils.ToRectangleFP(rectangle);
_wrappedBrushFP = new LinearGradientBrushFP(r.GetLeft(), r.GetTop(),
r.GetRight(), r.GetBottom(),
intAngle);
for (int i = 0; i < colors.Length; i++)
{
((LinearGradientBrushFP)_wrappedBrushFP).SetGradientColor
(SingleFP.FromFloat(fractions[i] / 100.0f),
colors[i]._value);
}
((LinearGradientBrushFP)_wrappedBrushFP).UpdateGradientTable();
_wrappedBrushFP.SetMatrix(Utils.ToMatrixFP(gradientTransform));
_wrappedBrushFP.FillMode = fillType;
}
public override void Enlarge(Rectangle r)
{
r.Add((int)(_x0 + .5),
(int)(_y0 + .5));
double[] eqn = { _xcoeff1, 2 * _xcoeff2, 3 * _xcoeff3 };
int numroots = QuadCurve.SolveQuadratic(eqn, eqn);
for (int i = 0; i < numroots; i++)
{
double t = eqn[i];
if (t > 0 && t < 1)
{
r.Add((int)(XforT(t) + .5), (int)(YforT(t) + .5));
}
}
r.Add((int)(_x1 + .5), (int)(_y1 + .5));
}
////////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS ------------------------------
// Date Name Tracking # Description
// --------- ------------------- ------------- ----------------------
// 02NOV2008 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////////
/**
* Sets the framing rectangle of this <code>IShape</code> to
* be the specified <code>Rectangle</code>. The framing rectangle is
* used by the subclasses of <code>RectangularShape</code> to define
* their geometry.
* @param r the specified <code>Rectangle</code>
*/
public void SetFrame(Rectangle r)
{
SetFrame(r.GetX(), r.GetY(), r.GetWidth(), r.GetHeight());
}
internal static RectangleFP ToRectangleFP(Rectangle rect)
{
return new RectangleFP(
SingleFP.FromInt(rect.GetMinX()),
SingleFP.FromInt(rect.GetMinY()),
SingleFP.FromInt(rect.GetMaxX()),
SingleFP.FromInt(rect.GetMaxY()));
}
public override void Enlarge(Rectangle r)
{
r.Add((int)(_x0 + 0.5), (int)(_y0 + 0.5));
r.Add((int)(_x1 + 0.5), (int)(_y1 + 0.5));
}
