|
public Intersect ( |
||
| path | Path. | |
| return | void | |
public Region CombineAreas()
{
Region region = new Region();
region.MakeEmpty();
foreach (Area area in Areas)
{
region.Union(area.Region);
}
region.Intersect(new Region(Crop.Bounds));
return region;
}
//draw round rectangular button function
void DrawRoundRectangularButton(Graphics g)
{
Color c1 = Color.FromArgb(color1Transparent, color1);
Color c2 = Color.FromArgb(color2Transparent, color2);
Brush b = new System.Drawing.Drawing2D.LinearGradientBrush(ClientRectangle, c1, c2, angle);
Region region = new System.Drawing.Region(new Rectangle(5, 5, this.Width, this.Height));
GraphicsPath grp = new GraphicsPath();
grp.AddArc(5, 5, 40, 40, 180, 90);
grp.AddLine(25, 5, this.Width - 25, 5);
grp.AddArc(this.Width - 45, 5, 40, 40, 270, 90);
grp.AddLine(this.Width - 5, 25, this.Width - 5, this.Height - 25);
grp.AddArc(this.Width - 45, this.Height - 45, 40, 40, 0, 90);
grp.AddLine(25, this.Height - 5, this.Width - 25, this.Height - 5);
grp.AddArc(5, this.Height - 45, 40, 40, 90, 90);
grp.AddLine(5, 25, 5, this.Height - 25);
region.Intersect(grp);
g.FillRegion(b, region);
for (int i = 0; i < borderWidth; i++)
{
g.DrawArc(new Pen(buttonborder_1), 5 + i, 5 + i, 40, 40, 180, 90);
g.DrawLine(new Pen(buttonborder_1), 25, 5 + i, this.Width - 25, 5 + i);
g.DrawArc(new Pen(buttonborder_1), this.Width - 45 - i, 5 + i, 40, 40, 270, 90);
g.DrawLine(new Pen(buttonborder_1), 5 + i, 25, 5 + i, this.Height - 25);
g.DrawLine(new Pen(buttonborder_2), this.Width - 5 - i, 25, this.Width - 5 - i, this.Height - 25);
g.DrawArc(new Pen(buttonborder_2), this.Width - 45 - i, this.Height - 45 - i, 40, 40, 0, 90);
g.DrawLine(new Pen(buttonborder_2), 25, this.Height - 5 - i, this.Width - 25, this.Height - 5 - i);
g.DrawArc(new Pen(buttonborder_2), 5 + i, this.Height - 45 - i, 40, 40, 90, 90);
}
if (showButtonText)
{
Point p = new Point(textX, textY);
SolidBrush frcolor = new SolidBrush(this.ForeColor);
g.DrawString(text, this.Font, frcolor, p);
}
b.Dispose();
}
// Returns a percentage of the ErrorArea circle trespassing on the zone.
// If anyone knows calculus better than me I'd welcome you to clean up this function =)
public float TrespassArea(Point3D pntLocation, float flErrorRadius) {
float flReturnPercentage = 0.0F;
float flErrorArea = (float)(flErrorRadius * flErrorRadius * Math.PI);
GraphicsPath gpLocationError = new GraphicsPath();
gpLocationError.AddEllipse(new RectangleF(pntLocation.X - flErrorRadius, pntLocation.Y - flErrorRadius, flErrorRadius * 2, flErrorRadius * 2));
gpLocationError.CloseAllFigures();
Region regZone = new Region(this.ZoneGraphicsPath);
regZone.Intersect(gpLocationError);
RectangleF[] a_recScans = regZone.GetRegionScans(new Matrix());
Rectangle recIntersection = new Rectangle(int.MaxValue, int.MaxValue, 0, 0);
int iPixelCount = 0;
if (a_recScans.Length > 0) {
for (int i = 0; i < a_recScans.Length; i++) {
recIntersection.X = a_recScans[i].X < recIntersection.X ? (int)a_recScans[i].X : recIntersection.X;
recIntersection.Y = a_recScans[i].Y < recIntersection.Y ? (int)a_recScans[i].Y : recIntersection.Y;
recIntersection.Width = a_recScans[i].Right > recIntersection.Right ? (int)a_recScans[i].Right - recIntersection.X : recIntersection.Width;
recIntersection.Height = a_recScans[i].Bottom > recIntersection.Bottom ? (int)a_recScans[i].Bottom - recIntersection.Y : recIntersection.Height;
}
//recIntersection = this.RecFtoRec(regZone.GetBounds(this.CreateGraphics()));
Point pntVisible = new Point(recIntersection.X, recIntersection.Y);
for (pntVisible.X = recIntersection.X; pntVisible.X <= recIntersection.Right; pntVisible.X++) {
for (pntVisible.Y = recIntersection.Y; pntVisible.Y <= recIntersection.Bottom; pntVisible.Y++) {
if (regZone.IsVisible(pntVisible) == true) {
iPixelCount++;
}
}
}
}
flReturnPercentage = (float)iPixelCount / flErrorArea;
// Accounts for low error when using this method. (98.4% should be 100%)
// but using regZone.GetRegionScans is slightly lossy.
if (flReturnPercentage > 0.0F) {
flReturnPercentage = (float)Math.Min(1.0F, flReturnPercentage + 0.02);
}
return flReturnPercentage;
}
/// <summary>
/// Initialize a new instance of the Clipping class.
/// </summary>
/// <param name="graphics">Graphics context.</param>
/// <param name="path">Path to clip.</param>
/// <param name="exclude">Exclude path from clipping.</param>
public Clipping(Graphics graphics, GraphicsPath path, bool exclude)
{
// Cache graphics instance
_graphics = graphics;
// Save the existing clipping region
_previousRegion = _graphics.Clip;
// Add clipping of path to existing clipping region
_newRegion = _previousRegion.Clone();
if (exclude)
_newRegion.Exclude(path);
else
_newRegion.Intersect(path);
_graphics.Clip = _newRegion;
}
protected override void OnPaint(PaintEventArgs e)
{
base.OnPaint(e);
e.Graphics.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
Region regionRing = new Region(outCircle.Path);
//形成圆环
regionRing.Xor(innerCircle.Path);
//截取部分圆环
regionRing.Intersect(clipRectangle);
e.Graphics.FillRegion(Brushes.Red, regionRing);
//画处边框
using (Pen p = new Pen(Brushes.Black))
{
e.Graphics.DrawPath(p, outCircle.Path);
e.Graphics.DrawPath(p, innerCircle.Path);
}
}
private void Form1_Paint(object sender, PaintEventArgs e)
{
Graphics g = e.Graphics;
g.Clear(this.BackColor);
// Создаем два прямоугольника
Rectangle rect1 = new Rectangle(40, 40, 140, 140);
Rectangle rect2 = new Rectangle(100, 100, 140, 140);
// Создаем два региона
Region rgn1 = new Region(rect1);
Region rgn2 = new Region(rect2);
g.DrawRectangle(Pens.Blue, rect1);
g.DrawRectangle(Pens.Black, rect2);
// определяем область пересеченияния
rgn1.Intersect(rgn2);
// заливаем ее красным цветом
g.FillRegion(Brushes.Red, rgn1);
g.Dispose();
}
static BlockRegions()
{
int n = Constants.PROJ_WIDTH / 4;
WholeBlock = new Region();
WholeBlock.MakeEmpty();
for (int i = 0; i <= n; i++)
{
WholeBlock.Union(new Rectangle(n * 2 - 1 - 2 * i, i, i * 4 + 2, Constants.PROJ_HEIGHT - 2 * i));
}
WholeBlock.Intersect(new Rectangle(0, 0, Constants.PROJ_WIDTH, Constants.PROJ_HEIGHT));
InnerBlock = new Region();
InnerBlock.MakeEmpty();
for (int i = 0; i <= n; i++)
{
InnerBlock.Union(new Rectangle(n * 2 - 1 - 2 * i, i + 1, i * 4 + 2, Constants.PROJ_HEIGHT - 2 - 2 * i));
}
InnerBlock.Intersect(new Rectangle(1, 1, Constants.PROJ_WIDTH - 2, Constants.PROJ_HEIGHT - 2));
OuterBorder = WholeBlock.Clone();
OuterBorder.Exclude(InnerBlock);
Top = InnerBlock.Clone();
Top.Translate(0, -Constants.BLOCK_HEIGHT);
Top.Intersect(InnerBlock);
Left = InnerBlock.Clone();
Left.Exclude(Top);
Top.Translate(0, 1);
Left.Exclude(Top);
Top.Translate(0, -1);
Right = Left.Clone();
Left.Intersect(new Rectangle(0, 0, Constants.PROJ_WIDTH / 2, Constants.PROJ_HEIGHT));
Right.Intersect(new Rectangle(Constants.PROJ_WIDTH / 2 + 1, 0, Constants.PROJ_WIDTH / 2, Constants.PROJ_HEIGHT));
InnerBorder = InnerBlock.Clone();
InnerBorder.Exclude(Top);
InnerBorder.Exclude(Left);
InnerBorder.Exclude(Right);
}
public static Rectangle DrawIcons(Graphics gr, Rectangle aTextRect, CustomAppointment anAppointment, ImageList anAppIcons)
{
if ((anAppIcons != null) && (anAppointment.IconIndexes != null))
{
int length = anAppointment.IconIndexes.Length;
int width = anAppIcons.ImageSize.Width;
int num3 = aTextRect.Width / 3;
if ((aTextRect.Width / 2) > width)
{
int x = (aTextRect.Right - 1) - width;
int y = aTextRect.Y + 1;
Region clip = gr.Clip;
Region region2 = new Region(aTextRect);
region2.Intersect(clip);
gr.Clip = region2;
for (int i = length - 1; i >= 0; i--)
{
using (Image image = anAppIcons.Images[anAppointment.IconIndexes[i]])
{
Rectangle rect = new Rectangle(x, y, width, width);
DrawSingleIcon(gr, rect, image);
}
x -= width;
if (num3 >= (x - aTextRect.X))
{
aTextRect.Width -= width * (length - i);
return aTextRect;
}
}
gr.ResetClip();
region2.Dispose();
region2 = null;
if (clip != null)
{
gr.Clip = clip;
}
aTextRect.Width -= width * length;
}
}
return aTextRect;
}
private void DrawRegionOperations()
{
g = this.CreateGraphics();
// Создаем два прямоугольника
Rectangle rect1 = new Rectangle(100, 100, 120, 120);
Rectangle rect2 = new Rectangle(70, 70, 120, 120);
// Создаем два региона
Region rgn1 = new Region(rect1);
Region rgn2 = new Region(rect2);
// рисуем прямоугольники
g.DrawRectangle(Pens.Green, rect1);
g.DrawRectangle(Pens.Black, rect2);
// обработаем перечисление и вызовем соответствующий метод
switch (rgnOperation)
{
case RegionOperations.Union:
rgn1.Union(rgn2);
break;
case RegionOperations.Complement:
rgn1.Complement(rgn2);
break;
case RegionOperations.Intersect:
rgn1.Intersect(rgn2);
break;
case RegionOperations.Exclude:
rgn1.Exclude(rgn2);
break;
case RegionOperations.Xor:
rgn1.Xor(rgn2);
break;
default:
break;
}
// Рисуем регион
g.FillRegion(Brushes.Blue, rgn1);
g.Dispose();
}
void DrawRegionOperation()
{
g = this.CreateGraphics();
Rectangle rect1 = new Rectangle(100, 100, 120, 120);
Rectangle rect2 = new Rectangle(70, 70, 120, 120);
Region rgn1 = new Region(rect1);
Region rgn2 = new Region(rect2);
g.DrawRectangle(Pens.Blue, rect1);
g.DrawRectangle(Pens.Red, rect2);
switch(rgnOperation)
{
case RegionOperation.Union:
rgn1.Union(rgn2);
break;
case RegionOperation.Complement:
rgn1.Complement(rgn2);
break;
case RegionOperation.Intersect:
rgn1.Intersect(rgn2);
break;
case RegionOperation.Exclude:
rgn1.Exclude(rgn2);
break;
case RegionOperation.Xor:
rgn1.Xor(rgn2);
break;
default:
break;
}
g.FillRegion(Brushes.Tomato, rgn1);
g.Dispose();
}
//draw round rectangular button function
void DrawRoundRectangularButton(Graphics g)
{
Color c1 = Color.FromArgb(color1Transparent, color1);
Color c2 = Color.FromArgb(color2Transparent, color2);
int radius = 20;
Brush b = new System.Drawing.Drawing2D.LinearGradientBrush(ClientRectangle, c1, c2, angle);
Region region = new System.Drawing.Region(new Rectangle(5, 5, this.Width, this.Height));
GraphicsPath grp = new GraphicsPath();
grp.AddArc(5, 5, radius, radius, 180, 90);
grp.AddArc(this.Width - (radius + 5), 5, radius, radius, 270, 90);
grp.AddArc(this.Width - (radius + 5), this.Height - (radius + 5), radius, radius, 0, 90);
grp.AddArc(5, this.Height - (radius + 5), radius, radius, 90, 90);
region.Intersect(grp);
g.FillRegion(b, region);
if (showButtonText)
{
Point p = new Point(textX, textY);
SolidBrush frcolor = new SolidBrush(this.ForeColor);
g.DrawString(text, this.Font, frcolor, p);
}
b.Dispose();
}
public override void DataGridPaintParentRows (Graphics g, Rectangle clip, DataGrid grid)
{
Rectangle rect_row = new Rectangle ();
rect_row.X = grid.ParentRowsArea.X;
rect_row.Width = grid.ParentRowsArea.Width;
rect_row.Height = (grid.CaptionFont.Height + 3);
object[] parentRows = grid.data_source_stack.ToArray();
Region current_clip;
Region prev_clip = g.Clip;
for (int row = 0; row < parentRows.Length; row++) {
rect_row.Y = grid.ParentRowsArea.Y + row * rect_row.Height;
if (clip.IntersectsWith (rect_row) == false)
continue;
current_clip = new Region (rect_row);
current_clip.Intersect (prev_clip);
g.Clip = current_clip;
DataGridPaintParentRow (g, rect_row, (DataGridDataSource)parentRows[parentRows.Length - row - 1], grid);
current_clip.Dispose ();
}
g.Clip = prev_clip;
}
public override void DataGridPaintColumnHeaders (Graphics g, Rectangle clip, DataGrid grid)
{
if (!grid.CurrentTableStyle.ColumnHeadersVisible)
return;
Rectangle columns_area = grid.column_headers_area;
// Paint corner shared between row and column header
if (grid.CurrentTableStyle.CurrentRowHeadersVisible) {
Rectangle rect_bloc = grid.column_headers_area;
rect_bloc.Width = grid.RowHeaderWidth;
if (clip.IntersectsWith (rect_bloc)) {
if (grid.FlatMode)
g.FillRectangle (ResPool.GetSolidBrush (grid.CurrentTableStyle.CurrentHeaderBackColor), rect_bloc);
else
CPDrawBorder3D (g, rect_bloc, Border3DStyle.RaisedInner,
Border3DSide.Left | Border3DSide.Right |
Border3DSide.Top | Border3DSide.Bottom | Border3DSide.Middle,
grid.CurrentTableStyle.CurrentHeaderBackColor);
}
columns_area.X += grid.RowHeaderWidth;
columns_area.Width -= grid.RowHeaderWidth;
}
// Set column painting
Rectangle rect_columnhdr = new Rectangle ();
int col_pixel;
Region current_clip;
Region prev_clip = g.Clip;
rect_columnhdr.Y = columns_area.Y;
rect_columnhdr.Height = columns_area.Height;
int column_cnt = grid.FirstVisibleColumn + grid.VisibleColumnCount;
for (int column = grid.FirstVisibleColumn; column < column_cnt; column++) {
if (grid.CurrentTableStyle.GridColumnStyles[column].bound == false)
continue;
col_pixel = grid.GetColumnStartingPixel (column);
rect_columnhdr.X = columns_area.X + col_pixel - grid.HorizPixelOffset;
rect_columnhdr.Width = grid.CurrentTableStyle.GridColumnStyles[column].Width;
if (clip.IntersectsWith (rect_columnhdr) == false)
continue;
current_clip = new Region (rect_columnhdr);
current_clip.Intersect (columns_area);
current_clip.Intersect (prev_clip);
g.Clip = current_clip;
DataGridPaintColumnHeader (g, rect_columnhdr, grid, column);
current_clip.Dispose ();
}
g.Clip = prev_clip;
Rectangle not_usedarea = grid.column_headers_area;
not_usedarea.X = (column_cnt == 0) ? grid.RowHeaderWidth : rect_columnhdr.X + rect_columnhdr.Width;
not_usedarea.Width = grid.ClientRectangle.X + grid.ClientRectangle.Width - not_usedarea.X;
g.FillRectangle (ResPool.GetSolidBrush (grid.BackgroundColor), not_usedarea);
}
bool IWorkflowDesignerMessageSink.OnPaint(PaintEventArgs e, Rectangle viewPort)
{
try
{
Rectangle bounds = Bounds;
if (IsVisible && viewPort.IntersectsWith(bounds))
{
GlyphManager glyphManager = GetService(typeof(IDesignerGlyphProviderService)) as GlyphManager;
bounds.Width += 1; bounds.Height += 1;
using (GraphicsPath graphicsPath = ActivityDesignerPaint.GetDesignerPath(this, Point.Empty, new Size(DesignerTheme.BorderWidth, DesignerTheme.BorderWidth), DesignerEdges.All, false))
using (Region clipRegion = new Region(graphicsPath))
{
Region oldRegion = e.Graphics.Clip;
clipRegion.Intersect(oldRegion);
clipRegion.Intersect(viewPort);
bool restoredClipState = false;
try
{
ActivityDesignerPaintEventArgs eventArgs = new ActivityDesignerPaintEventArgs(e.Graphics, bounds, viewPort, DesignerTheme);
e.Graphics.Clip = clipRegion;
OnPaint(eventArgs);
e.Graphics.Clip = oldRegion;
restoredClipState = true;
if (glyphManager != null)
glyphManager.DrawDesignerGlyphs(eventArgs, this);
DrawingState &= (~DrawingStates.InvalidDraw);
}
catch
{
//Eat the exception thrown
DrawingState |= DrawingStates.InvalidDraw;
}
finally
{
if (!restoredClipState)
e.Graphics.Clip = oldRegion;
if (DrawingState != DrawingStates.Valid)
ActivityDesignerPaint.DrawInvalidDesignerIndicator(e.Graphics, this);
}
}
}
}
catch
{
}
return true;
}
protected override void OnPaint(PaintEventArgs e)
{
Region clippingRegion = e.Graphics.Clip;
TimeSpan time = TimeSpan.FromHours(EpgControl.EpgHoursOffset);
int left = 0;
const int step = 15;
for (int count = 0; count < (24 * 60) / step; count++)
{
TimeSpan nextTime = time.Add(TimeSpan.FromMinutes(step));
int nextLeft = EpgTimeControl.GetTimeCursorPosition(nextTime, 0);
Rectangle visibleRectangle = new Rectangle(left - 1, 0, nextLeft - left + 1, this.Height);
visibleRectangle.Intersect(e.ClipRectangle);
Region cellRegion = new Region(visibleRectangle);
cellRegion.Intersect(clippingRegion);
if (!cellRegion.IsEmpty(e.Graphics))
{
int lineLeft = Math.Max(0, left - 1);
e.Graphics.DrawLine(_epgBorderPen, lineLeft, 0, lineLeft, this.Height - 1);
string timeText = EpgTimeControl.GetTimeString(time);
e.Graphics.DrawString(timeText, _timeFont, _timeBrush, lineLeft + 1, 2);
}
left = nextLeft;
time = nextTime;
}
if (this.CursorAtTime.HasValue)
{
int position = EpgTimeControl.GetTimeCursorPosition(_cursorAtTime.Value, -1);
e.Graphics.DrawLine(_cursorPen, position, 0, position, this.Height - 1);
e.Graphics.DrawLine(_cursorShadowPen, position + 1, 0, position + 1, this.Height - 1);
string timeText = EpgTimeControl.GetTimeString(this.CursorAtTime.Value);
SizeF size = e.Graphics.MeasureString(timeText, _cursorFont);
e.Graphics.FillRectangle(_cursorBgBrush, position + 2, 1, size.Width, size.Height);
e.Graphics.DrawString(timeText, _cursorFont, _cursorBrush, position + 2, 0);
}
base.OnPaint(e);
}
// end DrawGraph
private bool DrawItem(Graphics wa, Graph.LaneRow row)
{
if (row == null || row.NodeLane == -1)
{
return false;
}
// Clip to the area we're drawing in, but draw 1 pixel past so
// that the top/bottom of the line segment's anti-aliasing isn't
// visible in the final rendering.
int top = wa.RenderingOrigin.Y + _rowHeight / 2;
var laneRect = new Rectangle(0, top, Width, _rowHeight);
Region oldClip = wa.Clip;
var newClip = new Region(laneRect);
newClip.Intersect(oldClip);
wa.Clip = newClip;
wa.Clear(Color.Transparent);
for (int r = 0; r < 2; r++)
for (int lane = 0; lane < row.Count; lane++)
{
int mid = wa.RenderingOrigin.X + (int)((lane + 0.5) * LaneWidth);
for (int item = 0; item < row.LaneInfoCount(lane); item++)
{
Graph.LaneInfo laneInfo = row[lane, item];
//Draw all non-relative items first, them draw
//all relative items on top
if (laneInfo.Junctions.FirstOrDefault() != null)
if (laneInfo.Junctions.First().IsRelative == (r == 0))
continue;
List<Color> curColors = GetJunctionColors(laneInfo.Junctions);
// Create the brush for drawing the line
Brush brushLineColor;
bool drawBorder = BranchBorders; //hide border for "non-relatives"
if (curColors.Count == 1 || !StripedBranchChange)
{
if (curColors[0] != _nonRelativeColor)
{
brushLineColor = new SolidBrush(curColors[0]);
}
else if (curColors.Count > 1 && curColors[1] != _nonRelativeColor)
{
brushLineColor = new SolidBrush(curColors[1]);
}
else
{
drawBorder = false;
brushLineColor = new SolidBrush(_nonRelativeColor);
}
}
else
{
brushLineColor = new HatchBrush(HatchStyle.DarkDownwardDiagonal, curColors[0], curColors[1]);
if (curColors[0] == _nonRelativeColor && curColors[1] == _nonRelativeColor) drawBorder = false;
}
for (int i = drawBorder ? 0 : 2; i < 3; i++)
{
Pen penLine;
if (i == 0)
{
penLine = new Pen(new SolidBrush(Color.White), LaneLineWidth + 2);
}
else if (i == 1)
{
penLine = new Pen(new SolidBrush(Color.Black), LaneLineWidth + 1);
}
else
{
penLine = new Pen(brushLineColor, LaneLineWidth);
}
if (laneInfo.ConnectLane == lane)
{
wa.DrawLine
(
penLine,
new Point(mid, top - 1),
new Point(mid, top + _rowHeight + 2)
);
}
else
{
wa.DrawBezier
(
penLine,
new Point(mid, top - 1),
new Point(mid, top + _rowHeight + 2),
new Point(mid + (laneInfo.ConnectLane - lane) * LaneWidth, top - 1),
new Point(mid + (laneInfo.ConnectLane - lane) * LaneWidth, top + _rowHeight + 2)
);
}
}
}
}
// Reset the clip region
wa.Clip = oldClip;
{
// Draw node
var nodeRect = new Rectangle
(
wa.RenderingOrigin.X + (LaneWidth - NodeDimensions) / 2 + row.NodeLane * LaneWidth,
wa.RenderingOrigin.Y + (_rowHeight - NodeDimensions) / 2,
NodeDimensions,
NodeDimensions
);
Brush nodeBrush;
bool drawBorder = BranchBorders;
List<Color> nodeColors = GetJunctionColors(row.Node.Ancestors);
if (nodeColors.Count == 1)
{
nodeBrush = new SolidBrush(nodeColors[0]);
if (nodeColors[0] == _nonRelativeColor) drawBorder = false;
}
else
{
nodeBrush = new LinearGradientBrush(nodeRect, nodeColors[0], nodeColors[1],
LinearGradientMode.Horizontal);
if (nodeColors[0] == _nonRelativeColor && nodeColors[1] == Color.LightGray) drawBorder = false;
}
if (_filterMode == FilterType.Highlight && row.Node.IsFiltered)
{
Rectangle highlightRect = nodeRect;
highlightRect.Inflate(2, 3);
wa.FillRectangle(Brushes.Yellow, highlightRect);
wa.DrawRectangle(new Pen(Brushes.Black), highlightRect);
}
if (row.Node.Data == null)
{
wa.FillEllipse(Brushes.White, nodeRect);
wa.DrawEllipse(new Pen(Color.Red, 2), nodeRect);
}
else if (row.Node.IsActive)
{
wa.FillRectangle(nodeBrush, nodeRect);
nodeRect.Inflate(1, 1);
wa.DrawRectangle(new Pen(Color.Black, 3), nodeRect);
}
else if (row.Node.IsSpecial)
{
wa.FillRectangle(nodeBrush, nodeRect);
if (drawBorder)
{
wa.DrawRectangle(new Pen(Color.Black, 1), nodeRect);
}
}
else
{
wa.FillEllipse(nodeBrush, nodeRect);
if (drawBorder)
{
wa.DrawEllipse(new Pen(Color.Black, 1), nodeRect);
}
}
}
return true;
}
private void drawCells(Graphics g, System.Drawing.Pen pen,
System.Drawing.Brush brText, RectangleF rc)
{
// DrawBorder3D does not honor clipping, so...
CellFrameStyle cb = cellBorders;
if (flowChart.NowPrinting && cb == CellFrameStyle.System3D)
cb = CellFrameStyle.Simple;
// draw the cells
if (cells != null)
{
bool[,] coveredCells =
hasSpanningCells ? getCoveredCells() : null;
RectangleF cellsRect = RectangleF.FromLTRB(rc.Left,
rc.Top + captionHeight, rc.Right, rc.Bottom);
int rowFrom = CurrentRow - maxRowSpan + 1;
if (rowFrom < 0)
rowFrom = 0;
float h = rc.Top + captionHeight;
for (int r = rowFrom; r < rowsCount; r++)
{
RectangleF cellRect = rc;
cellRect.Y = h;
if (cellRect.Top >= rc.Bottom) break;
cellRect.Height = ((Row)rowsList[r]).Height;
if (cellRect.Bottom >= rc.Bottom) break;
// If it is a hidden row below a collapsed header row, skip it
if (isRowCollapsed(r))
continue;
if (rowFrom >= currScrollRow)
h += ((Row)rowsList[r]).Height;
for (int c = 0; c < columnsCount; ++c)
{
RectangleF imgRect = RectangleF.Empty;
cellRect = getSpannedCellRect(r, c, true, ref imgRect);
if (cellRect.Height == 0 ||
cellRect.Width == 0 ||
cellRect.Bottom <= cellsRect.Top)
continue;
Cell cell = (Cell)cells[r * columnsCount + c];
if (!hasSpanningCells)
{
cell.draw(g, pen, brText, cellRect, Font, cb, r, c, imgRect);
}
else
{
// If the cell is covered by a spanned cell
// and is not a span cell itself, do not draw it
if (!coveredCells[c,r] ||
(cell.RowSpan != 1 || cell.ColumnSpan != 1))
{
if (cell.RowSpan != 1 || cell.ColumnSpan != 1)
{
RectangleF cellVisibleRect =
RectangleF.Intersect(cellRect, cellsRect);
// Clip with the visible rect, and draw in the
// absolute rect
Region oldClip = g.Clip;
Region newClip = new Region(cellVisibleRect);
newClip.Intersect(oldClip);
g.Clip = newClip;
cell.draw(g, pen, brText, cellRect, Font, cb, r, c, imgRect);
g.Clip = oldClip;
newClip.Dispose();
}
else
{
cell.draw(g, pen, brText, cellRect, Font, cb, r, c, imgRect);
}
}
}
cellRect.X = cellRect.Right;
if (cellRect.Left >= rc.Right) break;
}
}
}
}
public void EmptyRegionWithInfiniteRegion ()
{
Region empty = new Region ();
empty.MakeEmpty ();
Assert.IsTrue (empty.IsEmpty (graphic), "IsEmpty");
Region region = new Region ();
Assert.IsTrue (region.IsInfinite (graphic), "IsInfinite");
region.Union (empty);
Assert.IsTrue (region.IsInfinite (graphic), "Union-IsInfinite");
region.Xor (empty);
Assert.IsTrue (region.IsInfinite (graphic), "Xor-IsInfinite");
region.Exclude (empty);
Assert.IsTrue (region.IsInfinite (graphic), "Exclude-IsInfinite");
region.Intersect (empty);
Assert.IsTrue (region.IsEmpty (graphic), "Intersect-IsEmpty");
region.MakeInfinite ();
region.Complement (empty);
Assert.IsTrue (region.IsEmpty (graphic), "Complement-IsEmpty");
}
public void EmptyPathWithInfiniteRegion ()
{
GraphicsPath gp = new GraphicsPath ();
Region region = new Region ();
Assert.IsTrue (region.IsInfinite (graphic), "IsInfinite");
region.Union (gp);
Assert.IsTrue (region.IsInfinite (graphic), "Union-IsInfinite");
region.Xor (gp);
Assert.IsTrue (region.IsInfinite (graphic), "Xor-IsInfinite");
region.Exclude (gp);
Assert.IsTrue (region.IsInfinite (graphic), "Exclude-IsInfinite");
region.Intersect (gp);
Assert.IsTrue (region.IsEmpty (graphic), "Intersect-IsEmpty");
region.MakeInfinite ();
region.Complement (gp);
Assert.IsTrue (region.IsEmpty (graphic), "Complement-IsEmpty");
}
public void Translate_Float ()
{
Region r1 = new Region (sp1);
Region r2 = new Region (sp2);
r2.Translate (-2.0f, -2.0f);
r1.Intersect (r2);
CompareSmallRegion (r1, self1, 7, 7);
}
/// <summary>
/// Draws each element in group on graph object
/// </summary>
/// <param name="graphObj">Graph object to be drawn on</param>
/// <param name="dx">X region</param>
/// <param name="dy">Y region</param>
/// <param name="zoom">Zoom value</param>
public override void Draw(Graphics graphObj, int dx, int dy, float zoom)
{
GraphicsState oldGraphState = graphObj.Save(); //store previos trasformation
Matrix matrix = graphObj.Transform; // get previous trasformation
PointF point = new PointF(zoom * (region.X0 + dx + (region.X1 - region.X0) / 2),
zoom * (region.Y0 + dy + (region.Y1 - region.Y0) / 2));
if (this.Rotation > 0)
{
matrix.RotateAt(this.Rotation, point, MatrixOrder.Append); //add a trasformation
}
//X MIRROR //Y MIRROR
if (this.xMirror || this.yMirror)
{
matrix.Translate(-(region.X0 + region.Width / 2 + dx) * zoom,
-(region.Y0 + region.Height / 2 + dy) * zoom, MatrixOrder.Append);
if (this.xMirror)
{
matrix.Multiply(new Matrix(-1, 0, 0, 1, 0, 0), MatrixOrder.Append);
}
if (this.yMirror)
{
matrix.Multiply(new Matrix(1, 0, 0, -1, 0, 0), MatrixOrder.Append);
}
matrix.Translate((region.X0 + region.Width / 2 + dx) * zoom,
(region.Y0 + region.Height / 2 + dy) * zoom, MatrixOrder.Append);
}
if (this.groupZoomX > 0 && this.groupZoomY > 0)
{
matrix.Translate((-1) * zoom * (region.X0 + dx +
(region.X1 - region.X0) / 2), (-1) * zoom * (region.Y0 + dy +
(region.Y1 - region.Y0) / 2), MatrixOrder.Append);
matrix.Scale(this.groupZoomX, this.groupZoomY, MatrixOrder.Append);
matrix.Translate(zoom * (region.X0 + dx + (region.X1 - region.X0) / 2),
zoom * (region.Y0 + dy + (region.Y1 - region.Y0) / 2),
MatrixOrder.Append);
}
graphObj.Transform = matrix;
if (this.IsGraphPath)
{
Brush myBrush = GetBrush(dx, dy, zoom);
Pen myPen = this.CreatePen(zoom);
GraphicsPath graphPath = new GraphicsPath();
foreach (ShapeElement element in this.elementList)
{
element.AddToGraphPath(graphPath, dx, dy, zoom);
}
if (this.FillEnabled)
{
graphObj.FillPath(myBrush, graphPath);
if (this.ShowBorder)
{
graphObj.DrawPath(myPen, graphPath);
}
}
else
{
graphObj.DrawPath(myPen, graphPath);
}
if (myBrush != null)
{
myBrush.Dispose();
}
myPen.Dispose();
}
else
{
//MANAGE This.GroupDisplay
System.Drawing.Region gregion = new System.Drawing.Region();
if (GroupDisplay != GroupDisplay.Default)
{
bool first = true;
foreach (ShapeElement element in this.elementList)
{
GraphicsPath graphPath = new GraphicsPath(FillMode.Winding);
element.AddToGraphPath(graphPath, dx, dy, zoom);
if (first)
{
gregion.Intersect(graphPath);
}
else
{
switch (GroupDisplay)
{
case GroupDisplay.Intersect:
gregion.Intersect(graphPath);
break;
case GroupDisplay.Xor:
gregion.Xor(graphPath);
break;
case GroupDisplay.Exclude:
gregion.Exclude(graphPath);
break;
default:
break;
}
}
first = false;
}
graphObj.SetClip(gregion, CombineMode.Intersect);
}
foreach (ShapeElement element in this.elementList)
{
element.Draw(graphObj, dx, dy, zoom);
}
if (GroupDisplay != GroupDisplay.Default)
{
graphObj.ResetClip();
}
}
graphObj.Restore(oldGraphState);//restore previos trasformation
if (this.Selected)
{
Brush myBrush = GetBrush(dx, dy, zoom);
Pen myPen = this.CreatePen(zoom);
graphObj.DrawRectangle(myPen, Rectangle.Round(region.GetRectangleF(dx, dy, zoom)));
if (myBrush != null)
{
myBrush.Dispose();
}
myPen.Dispose();
}
matrix.Dispose();
}
public override void DataGridPaintRowContents (Graphics g, int row, Rectangle row_rect, bool is_newrow,
Rectangle clip, DataGrid grid)
{
Rectangle rect_cell = new Rectangle ();
int col_pixel;
Color backcolor, forecolor;
Brush backBrush, foreBrush;
Rectangle not_usedarea = Rectangle.Empty;
rect_cell.Y = row_rect.Y;
rect_cell.Height = row_rect.Height;
if (grid.IsSelected (row)) {
backcolor = grid.SelectionBackColor;
forecolor = grid.SelectionForeColor;
} else {
if (row % 2 == 0) {
backcolor = grid.BackColor;
} else {
backcolor = grid.AlternatingBackColor;
}
forecolor = grid.ForeColor;
}
backBrush = ResPool.GetSolidBrush (backcolor);
foreBrush = ResPool.GetSolidBrush (forecolor);
// PaintCells at row, column
int column_cnt = grid.FirstVisibleColumn + grid.VisibleColumnCount;
DataGridCell current_cell = grid.CurrentCell;
if (column_cnt > 0) {
Region prev_clip = g.Clip;
Region current_clip;
for (int column = grid.FirstVisibleColumn; column < column_cnt; column++) {
if (grid.CurrentTableStyle.GridColumnStyles[column].bound == false)
continue;
col_pixel = grid.GetColumnStartingPixel (column);
rect_cell.X = row_rect.X + col_pixel - grid.HorizPixelOffset;
rect_cell.Width = grid.CurrentTableStyle.GridColumnStyles[column].Width;
if (clip.IntersectsWith (rect_cell)) {
current_clip = new Region (rect_cell);
current_clip.Intersect (row_rect);
current_clip.Intersect (prev_clip);
g.Clip = current_clip;
Brush colBackBrush = backBrush;
Brush colForeBrush = foreBrush;
// If we are in the precise cell we are editing, then use the normal colors
// even if we are selected.
if (grid.is_editing && column == current_cell.ColumnNumber && row == current_cell.RowNumber) {
colBackBrush = ResPool.GetSolidBrush (grid.BackColor);
colForeBrush = ResPool.GetSolidBrush (grid.ForeColor);
}
if (is_newrow) {
grid.CurrentTableStyle.GridColumnStyles[column].PaintNewRow (g, rect_cell,
colBackBrush,
colForeBrush);
} else {
grid.CurrentTableStyle.GridColumnStyles[column].Paint (g, rect_cell, grid.ListManager, row,
colBackBrush,
colForeBrush,
grid.RightToLeft == RightToLeft.Yes);
}
current_clip.Dispose ();
}
}
g.Clip = prev_clip;
if (row_rect.X + row_rect.Width > rect_cell.X + rect_cell.Width) {
not_usedarea.X = rect_cell.X + rect_cell.Width;
not_usedarea.Width = row_rect.X + row_rect.Width - rect_cell.X - rect_cell.Width;
not_usedarea.Y = row_rect.Y;
not_usedarea.Height = row_rect.Height;
}
}
else {
not_usedarea = row_rect;
}
if (!not_usedarea.IsEmpty && clip.IntersectsWith (not_usedarea))
g.FillRectangle (ResPool.GetSolidBrush (grid.BackgroundColor),
not_usedarea);
}
// end drawGraph
private bool DrawItem(Graphics wa, Graph.ILaneRow row)
{
if (row == null || row.NodeLane == -1)
{
return false;
}
// Clip to the area we're drawing in, but draw 1 pixel past so
// that the top/bottom of the line segment's anti-aliasing isn't
// visible in the final rendering.
int top = wa.RenderingOrigin.Y + rowHeight / 2;
var laneRect = new Rectangle(0, top, Width, rowHeight);
Region oldClip = wa.Clip;
var newClip = new Region(laneRect);
newClip.Intersect(oldClip);
wa.Clip = newClip;
wa.Clear(Color.Transparent);
//for (int r = 0; r < 2; r++)
for (int lane = 0; lane < row.Count; lane++)
{
int mid = wa.RenderingOrigin.X + (int)((lane + 0.5) * LANE_WIDTH);
for (int item = 0; item < row.LaneInfoCount(lane); item++)
{
Graph.LaneInfo laneInfo = row[lane, item];
bool highLight = (RevisionGraphDrawStyle == RevisionGraphDrawStyleEnum.DrawNonRelativesGray && laneInfo.Junctions.Any(j => j.IsRelative)) ||
(RevisionGraphDrawStyle == RevisionGraphDrawStyleEnum.HighlightSelected && laneInfo.Junctions.Any(j => j.HighLight)) ||
(RevisionGraphDrawStyle == RevisionGraphDrawStyleEnum.Normal);
List<Color> curColors = GetJunctionColors(laneInfo.Junctions);
// Create the brush for drawing the line
Brush brushLineColor = null;
Pen brushLineColorPen = null;
try
{
bool drawBorder = Settings.BranchBorders && highLight; //hide border for "non-relatives"
if (curColors.Count == 1 || !Settings.StripedBranchChange)
{
if (curColors[0] != nonRelativeColor)
{
brushLineColor = new SolidBrush(curColors[0]);
}
else if (curColors.Count > 1 && curColors[1] != nonRelativeColor)
{
brushLineColor = new SolidBrush(curColors[1]);
}
else
{
drawBorder = false;
brushLineColor = new SolidBrush(nonRelativeColor);
}
}
else
{
Color lastRealColor = curColors.LastOrDefault(c => c != nonRelativeColor);
if (lastRealColor.IsEmpty)
{
brushLineColor = new SolidBrush(nonRelativeColor);
drawBorder = false;
}
else
{
brushLineColor = new HatchBrush(HatchStyle.DarkDownwardDiagonal, curColors[0], lastRealColor);
}
}
for (int i = drawBorder ? 0 : 2; i < 3; i++)
{
Pen penLine = null;
if (i == 0)
{
penLine = whiteBorderPen;
}
else if (i == 1)
{
penLine = blackBorderPen;
}
else
{
if (brushLineColorPen == null)
brushLineColorPen = new Pen(brushLineColor, LANE_LINE_WIDTH);
penLine = brushLineColorPen;
}
if (laneInfo.ConnectLane == lane)
{
wa.DrawLine
(
penLine,
new Point(mid, top - 1),
new Point(mid, top + rowHeight + 2)
);
}
else
{
wa.DrawBezier
(
penLine,
new Point(mid, top - 1),
new Point(mid, top + rowHeight + 2),
new Point(mid + (laneInfo.ConnectLane - lane) * LANE_WIDTH, top - 1),
new Point(mid + (laneInfo.ConnectLane - lane) * LANE_WIDTH, top + rowHeight + 2)
);
}
}
}
finally
{
if (brushLineColorPen != null)
((IDisposable)brushLineColorPen).Dispose();
if (brushLineColor != null)
((IDisposable)brushLineColor).Dispose();
}
}
}
// Reset the clip region
wa.Clip = oldClip;
{
// Draw node
var nodeRect = new Rectangle
(
wa.RenderingOrigin.X + (LANE_WIDTH - NODE_DIMENSION) / 2 + row.NodeLane * LANE_WIDTH,
wa.RenderingOrigin.Y + (rowHeight - NODE_DIMENSION) / 2,
NODE_DIMENSION,
NODE_DIMENSION
);
Brush nodeBrush;
List<Color> nodeColors = GetJunctionColors(row.Node.Ancestors);
bool highlight = (RevisionGraphDrawStyle == RevisionGraphDrawStyleEnum.DrawNonRelativesGray && row.Node.Ancestors.Any(j => j.IsRelative)) ||
(RevisionGraphDrawStyle == RevisionGraphDrawStyleEnum.HighlightSelected && row.Node.Ancestors.Any(j => j.HighLight)) ||
(RevisionGraphDrawStyle == RevisionGraphDrawStyleEnum.Normal);
bool drawBorder = Settings.BranchBorders && highlight;
if (nodeColors.Count == 1)
{
nodeBrush = new SolidBrush(highlight ? nodeColors[0] : nonRelativeColor);
if (nodeColors[0] == nonRelativeColor) drawBorder = false;
}
else
{
nodeBrush = new LinearGradientBrush(nodeRect, nodeColors[0], nodeColors[1],
LinearGradientMode.Horizontal);
if (nodeColors.All(c => c == nonRelativeColor))
drawBorder = false;
}
if (filterMode == FilterType.Highlight && row.Node.IsFiltered)
{
Rectangle highlightRect = nodeRect;
highlightRect.Inflate(2, 3);
wa.FillRectangle(Brushes.Yellow, highlightRect);
wa.DrawRectangle(Pens.Black, highlightRect);
}
if (row.Node.Data == null)
{
wa.FillEllipse(Brushes.White, nodeRect);
using (var pen = new Pen(Color.Red, 2))
{
wa.DrawEllipse(pen, nodeRect);
}
}
else if (row.Node.IsActive)
{
wa.FillRectangle(nodeBrush, nodeRect);
nodeRect.Inflate(1, 1);
using (var pen = new Pen(Color.Black, 3))
wa.DrawRectangle(pen, nodeRect);
}
else if (row.Node.IsSpecial)
{
wa.FillRectangle(nodeBrush, nodeRect);
if (drawBorder)
{
wa.DrawRectangle(Pens.Black, nodeRect);
}
}
else
{
wa.FillEllipse(nodeBrush, nodeRect);
if (drawBorder)
{
wa.DrawEllipse(Pens.Black, nodeRect);
}
}
}
return true;
}
private void SnippingTool_Paint(object sender, PaintEventArgs e)
{
using (Brush b = new SolidBrush(Color.FromArgb(120, Color.White)))
using (Pen pen = new Pen(Color.Red, 1))
using (Region region = new Region(new Rectangle(0, 0, Width, Height)))
{
// Create a region
// Negate it from the current sleection
region.Exclude(rcSelect);
region.Intersect(e.ClipRectangle);
// Draw overlay of non-selected portions
e.Graphics.FillRegion(b, region);
// Draw selection
e.Graphics.DrawRectangle(pen, rcSelect.X, rcSelect.Y, rcSelect.Width - 1, rcSelect.Height - 1);
}
}
public void SetClip(Region region, CombineMode combineMode)
{
// We need to reset the clip that is active now so that the graphic
// states are correct when we set them.
ResetClip ();
switch (combineMode)
{
case CombineMode.Replace:
// Set our clip region by cloning the region that is passed for now
clipRegion = region.Clone ();
break;
case CombineMode.Intersect:
clipRegion.Intersect (region);
break;
case CombineMode.Union:
clipRegion.Union (region);
break;
case CombineMode.Exclude:
clipRegion.Exclude (region);
break;
case CombineMode.Xor:
clipRegion.Xor (region);
break;
default:
throw new NotImplementedException ("SetClip for CombineMode " + combineMode + " not implemented");
}
//Unlike the current path, the current clipping path is part of the graphics state.
//Therefore, to re-enlarge the paintable area by restoring the clipping path to a
//prior state, you must save the graphics state before you clip and restore the graphics
//state after you’ve completed any clipped drawing.
context.SaveState ();
if (clipRegion.IsEmpty) {
context.ClipToRect (CGRect.Empty);
} else {
//context.ClipToRect ((RectangleF)clipRegion.regionObject);
context.AddPath (clipRegion.regionPath);
context.ClosePath ();
context.Clip ();
}
clipSet++;
}
private void DrawImageBackground(PageImage pi, StyleInfo si, Graphics g, RectangleF r)
{
Stream strm = null;
System.Drawing.Image im = null;
try
{
strm = new MemoryStream(pi.ImageData);
im = System.Drawing.Image.FromStream(strm);
// http://www.fyireporting.com/forum/viewtopic.php?t=892
//A.S.> convert pt to px if needed(when printing we need px, when draw preview - pt)
RectangleF r2;
if (g.PageUnit == GraphicsUnit.Pixel)
{
r2 = new RectangleF(r.Left + (si.PaddingLeft * g.DpiX) / 72,
r.Top + (si.PaddingTop * g.DpiX) / 72,
r.Width - ((si.PaddingLeft + si.PaddingRight) * g.DpiX) / 72,
r.Height - ((si.PaddingTop + si.PaddingBottom) * g.DpiX) / 72);
}
else
{
// adjust drawing rectangle based on padding
r2 = new RectangleF(r.Left + si.PaddingLeft,
r.Top + si.PaddingTop,
r.Width - si.PaddingLeft - si.PaddingRight,
r.Height - si.PaddingTop - si.PaddingBottom);
}
int repeatX = 0;
int repeatY = 0;
switch (pi.Repeat)
{
case ImageRepeat.Repeat:
repeatX = (int)Math.Floor(r2.Width / pi.SamplesW);
repeatY = (int)Math.Floor(r2.Height / pi.SamplesH);
break;
case ImageRepeat.RepeatX:
repeatX = (int)Math.Floor(r2.Width / pi.SamplesW);
repeatY = 1;
break;
case ImageRepeat.RepeatY:
repeatY = (int)Math.Floor(r2.Height / pi.SamplesH);
repeatX = 1;
break;
case ImageRepeat.NoRepeat:
default:
repeatX = repeatY = 1;
break;
}
//make sure the image is drawn at least 1 times
repeatX = Math.Max(repeatX, 1);
repeatY = Math.Max(repeatY, 1);
float startX = r2.Left;
float startY = r2.Top;
Region saveRegion = g.Clip;
Region clipRegion = new Region(g.Clip.GetRegionData());
clipRegion.Intersect(r2);
g.Clip = clipRegion;
for (int i = 0; i < repeatX; i++)
{
for (int j = 0; j < repeatY; j++)
{
float currX = startX + i * pi.SamplesW;
float currY = startY + j * pi.SamplesH;
g.DrawImage(im, new RectangleF(currX, currY, pi.SamplesW, pi.SamplesH));
}
}
g.Clip = saveRegion;
}
finally
{
if (strm != null)
strm.Close();
if (im != null)
im.Dispose();
}
}
protected override void OnPaint(PaintEventArgs e)
{
using (Region region = new Region(new Rectangle(0, 0, this.Width, this.Height)))
{
region.Exclude(select);
region.Intersect(e.ClipRectangle);
e.Graphics.FillRegion(brush, region);
e.Graphics.DrawRectangle(pen, select.X, select.Y, select.Width - 1, select.Height - 1);
}
}
private void CalcWalkableArea()
{
if (_battle == null)
{
return;
}
int width = _battle.Width / 8;
int height = _battle.Height / 8;
Image image = new Bitmap(width, height);
Graphics graphics = Graphics.FromImage(image);
graphics.FillRectangle(new SolidBrush(Color.Black), new Rectangle(0, 0, width, height));
BTBLib.Region battleBoundary = null;
List <BTBLib.Region> boundaries = new List <BTBLib.Region>();
List <BTBLib.Region> inverseBoundaries = new List <BTBLib.Region>();
foreach (BTBLib.Region region in _battle.Regions)
{
if (region.IsClosed)
{
if (region.IsBattleBoundary)
{
battleBoundary = region;
}
else if (region.IsBoundaryInversed)
{
inverseBoundaries.Add(region);
}
else if (region.IsBoundary)
{
boundaries.Add(region);
}
}
}
if (battleBoundary == null)
{
return;
}
boundaries.Insert(0, battleBoundary);
System.Drawing.Region graphicsRegion = new System.Drawing.Region(new Rectangle(0, 0, width, height));
foreach (BTBLib.Region region in boundaries)
{
Point[] points = new Point[region.Lines.Count];
for (int i = 0; i < points.Length; ++i)
{
var segment = region.Lines[i];
points[i] = new Point(segment.StartX / 8, height - segment.StartY / 8);
}
GraphicsPath graphicsPath = new GraphicsPath();
graphicsPath.AddPolygon(points);
graphicsRegion.Intersect(graphicsPath);
}
foreach (BTBLib.Region region in inverseBoundaries)
{
Point[] points = new Point[region.Lines.Count];
for (int i = 0; i < points.Length; ++i)
{
var segment = region.Lines[i];
points[i] = new Point(segment.StartX / 8, height - segment.StartY / 8);
}
GraphicsPath graphicsPath = new GraphicsPath();
graphicsPath.AddPolygon(points);
graphicsRegion.Exclude(graphicsPath);
}
graphics.FillRegion(new SolidBrush(Color.Red), graphicsRegion);
//Form form = new Form();
//form.ClientSize = new Size(width * 3, height * 3);
//PictureBox pictureBox = new PictureBox();
//pictureBox.Image = image;
//pictureBox.SizeMode = PictureBoxSizeMode.Zoom;
//form.Controls.Add(pictureBox);
//pictureBox.Dock = DockStyle.Fill;
//form.Show();
ImageForm form = new ImageForm();
form.SetImage(image);
form.ShowDialog();
}
private void DrawTabFocusIndicator(GraphicsPath tabpath, int index, Graphics graphics)
{
if (this._FocusTrack && this._TabControl.Focused && index == this._TabControl.SelectedIndex)
{
Brush focusBrush = null;
RectangleF pathRect = tabpath.GetBounds();
Rectangle focusRect = Rectangle.Empty;
switch (this._TabControl.Alignment)
{
case TabAlignment.Top:
focusRect = new Rectangle((int)pathRect.X, (int)pathRect.Y, (int)pathRect.Width, 4);
focusBrush = new LinearGradientBrush(focusRect, this._FocusColor, SystemColors.Window, LinearGradientMode.Vertical);
break;
case TabAlignment.Bottom:
focusRect = new Rectangle((int)pathRect.X, (int)pathRect.Bottom - 4, (int)pathRect.Width, 4);
focusBrush = new LinearGradientBrush(focusRect, SystemColors.ControlLight, this._FocusColor, LinearGradientMode.Vertical);
break;
case TabAlignment.Left:
focusRect = new Rectangle((int)pathRect.X, (int)pathRect.Y, 4, (int)pathRect.Height);
focusBrush = new LinearGradientBrush(focusRect, this._FocusColor, SystemColors.ControlLight, LinearGradientMode.Horizontal);
break;
case TabAlignment.Right:
focusRect = new Rectangle((int)pathRect.Right - 4, (int)pathRect.Y, 4, (int)pathRect.Height);
focusBrush = new LinearGradientBrush(focusRect, SystemColors.ControlLight, this._FocusColor, LinearGradientMode.Horizontal);
break;
}
// Ensure the focus stip does not go outside the tab
Region focusRegion = new Region(focusRect);
focusRegion.Intersect(tabpath);
graphics.FillRegion(focusBrush, focusRegion);
focusRegion.Dispose();
focusBrush.Dispose();
}
}
/// <summary>
/// The draw tab focus indicator.
/// </summary>
/// <param name="brush">
/// The brush.
/// </param>
/// <param name="tabpath">
/// The tabpath.
/// </param>
/// <param name="index">
/// The index.
/// </param>
/// <param name="graphics">
/// The graphics.
/// </param>
private void DrawTabFocusIndicator(Brush brush, GraphicsPath tabpath, int index, Graphics graphics)
{
if (this.Focused && index == this.SelectedIndex)
{
RectangleF pathRect = tabpath.GetBounds();
Rectangle focusRect = Rectangle.Empty;
switch (this.Alignment)
{
case TabAlignment.Top:
focusRect = new Rectangle((int)pathRect.X, (int)pathRect.Y, (int)pathRect.Width, this.IndicatorWidth);
break;
case TabAlignment.Bottom:
focusRect = new Rectangle(
(int)pathRect.X,
(int)pathRect.Bottom - this.IndicatorWidth,
(int)pathRect.Width,
this.IndicatorWidth);
break;
case TabAlignment.Left:
focusRect = new Rectangle((int)pathRect.X, (int)pathRect.Y, this.IndicatorWidth, (int)pathRect.Height);
break;
case TabAlignment.Right:
focusRect = new Rectangle(
(int)pathRect.Right - this.IndicatorWidth,
(int)pathRect.Y,
this.IndicatorWidth,
(int)pathRect.Height);
break;
}
// Ensure the focus stip does not go outside the tab
using (var focusRegion = new Region(focusRect))
{
focusRegion.Intersect(tabpath);
graphics.FillRegion(brush, focusRegion);
}
}
}
public override void OnPaint(object sender, RibbonElementPaintEventArgs e)
{
Owner.Renderer.OnRenderRibbonItem(new RibbonItemRenderEventArgs(Owner, e.Graphics, e.Clip, this));
if (e.Mode != RibbonElementSizeMode.Compact)
{
Region lastClip = e.Graphics.Clip;
Region newClip = new Region(lastClip.GetBounds(e.Graphics));
newClip.Intersect(ContentBounds);
e.Graphics.SetClip(newClip.GetBounds(e.Graphics));
foreach (RibbonButton button in Buttons)
{
if (!button.Bounds.IsEmpty)
button.OnPaint(this, new RibbonElementPaintEventArgs(button.Bounds, e.Graphics, ButtonsSizeMode));
}
e.Graphics.SetClip(lastClip.GetBounds(e.Graphics));
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Paints the current <see cref="T:System.Windows.Forms.DataGridViewCell"></see>.
/// </summary>
/// <param name="graphics">The <see cref="T:System.Drawing.Graphics"></see> used to
/// paint the <see cref="T:System.Windows.Forms.DataGridViewCell"></see>.</param>
/// <param name="clipBounds">A <see cref="T:System.Drawing.Rectangle"></see> that
/// represents the area of the <see cref="T:System.Windows.Forms.DataGridView"></see>
/// that needs to be repainted.</param>
/// <param name="cellBounds">A <see cref="T:System.Drawing.Rectangle"></see> that
/// contains the bounds of the <see cref="T:System.Windows.Forms.DataGridViewCell"></see>
/// that is being painted.</param>
/// <param name="rowIndex">The row index of the cell that is being painted.</param>
/// <param name="cellState">A bitwise combination of
/// <see cref="T:System.Windows.Forms.DataGridViewElementStates"></see> values that
/// specifies the state of the cell.</param>
/// <param name="value">The data of the <see cref="T:System.Windows.Forms.DataGridViewCell">
/// </see> that is being painted.</param>
/// <param name="formattedValue">The formatted data of the
/// <see cref="T:System.Windows.Forms.DataGridViewCell"></see> that is being painted.
/// </param>
/// <param name="errorText">An error message that is associated with the cell.</param>
/// <param name="cellStyle">A <see cref="T:System.Windows.Forms.DataGridViewCellStyle">
/// </see> that contains formatting and style information about the cell.</param>
/// <param name="advancedBorderStyle">A
/// <see cref="T:System.Windows.Forms.DataGridViewAdvancedBorderStyle"></see> that
/// contains border styles for the cell that is being painted.</param>
/// <param name="paintParts">A bitwise combination of the
/// <see cref="T:System.Windows.Forms.DataGridViewPaintParts"></see> values that
/// specifies which parts of the cell need to be painted.</param>
/// ------------------------------------------------------------------------------------
protected override void Paint(Graphics graphics, Rectangle clipBounds,
Rectangle cellBounds, int rowIndex, DataGridViewElementStates cellState,
object value, object formattedValue, string errorText, DataGridViewCellStyle cellStyle,
DataGridViewAdvancedBorderStyle advancedBorderStyle, DataGridViewPaintParts paintParts)
{
if (!m_fAllowPaint)
return;
// Clear the background
Region background = new Region(cellBounds);
background.Xor(GetCellContentDisplayRectangle(advancedBorderStyle));
background.Intersect(clipBounds);
graphics.FillRegion(SystemBrushes.Window, background);
// Invalidate the view so that it redraws
if (m_Control != null)
{
Point pt = m_Control.PointToClient(DataGridView.PointToScreen(new Point(clipBounds.X, clipBounds.Y)));
Rectangle borderRect = BorderWidths(advancedBorderStyle);
Rectangle toDraw = new Rectangle(0, 0,
cellBounds.Width, cellBounds.Height);
Rectangle clientClip = new Rectangle(pt.X, pt.Y, clipBounds.Width, clipBounds.Height);
toDraw.Intersect(clientClip);
m_Control.Invalidate(toDraw, true);
m_Control.Update();
}
// Finally draw the borders
if ((paintParts & DataGridViewPaintParts.Border) == DataGridViewPaintParts.Border)
PaintBorder(graphics, clipBounds, cellBounds, cellStyle, advancedBorderStyle);
}
private void DrawImageSized(PageImage pi, Image im, Graphics g, RectangleF r)
{
float height, width; // some work variables
StyleInfo si = pi.SI;
// adjust drawing rectangle based on padding
// http://www.fyireporting.com/forum/viewtopic.php?t=892
//A.S.> convert pt to px if needed(when printing we need px, when draw preview - pt)
RectangleF r2;
if (g.PageUnit == GraphicsUnit.Pixel)
{
r2 = new RectangleF(r.Left + (si.PaddingLeft * g.DpiX) / 72,
r.Top + (si.PaddingTop * g.DpiX) / 72,
r.Width - ((si.PaddingLeft + si.PaddingRight) * g.DpiX) / 72,
r.Height - ((si.PaddingTop + si.PaddingBottom) * g.DpiX) / 72);
}
else
{
// adjust drawing rectangle based on padding
r2 = new RectangleF(r.Left + si.PaddingLeft,
r.Top + si.PaddingTop,
r.Width - si.PaddingLeft - si.PaddingRight,
r.Height - si.PaddingTop - si.PaddingBottom);
}
Rectangle ir; // int work rectangle
ir = new Rectangle(Convert.ToInt32(r2.Left), Convert.ToInt32(r2.Top),
Convert.ToInt32(r2.Width), Convert.ToInt32(r2.Height));
switch (pi.Sizing)
{
case ImageSizingEnum.AutoSize:
// Note: GDI+ will stretch an image when you only provide
// the left/top coordinates. This seems pretty stupid since
// it results in the image being out of focus even though
// you don't want the image resized.
if (g.DpiX == im.HorizontalResolution &&
g.DpiY == im.VerticalResolution)
{
ir = new Rectangle(Convert.ToInt32(r2.Left), Convert.ToInt32(r2.Top),
im.Width, im.Height);
}
g.DrawImage(im, ir);
break;
case ImageSizingEnum.Clip:
Region saveRegion = g.Clip;
Region clipRegion = new Region(g.Clip.GetRegionData());
clipRegion.Intersect(r2);
g.Clip = clipRegion;
if (g.DpiX == im.HorizontalResolution &&
g.DpiY == im.VerticalResolution)
{
ir = new Rectangle(Convert.ToInt32(r2.Left), Convert.ToInt32(r2.Top),
im.Width, im.Height);
}
g.DrawImage(im, ir);
g.Clip = saveRegion;
break;
case ImageSizingEnum.FitProportional:
float ratioIm = (float)im.Height / (float)im.Width;
float ratioR = r2.Height / r2.Width;
height = r2.Height;
width = r2.Width;
if (ratioIm > ratioR)
{ // this means the rectangle width must be corrected
width = height * (1 / ratioIm);
}
else if (ratioIm < ratioR)
{ // this means the ractangle height must be corrected
height = width * ratioIm;
}
r2 = new RectangleF(r2.X, r2.Y, width, height);
g.DrawImage(im, r2);
break;
case ImageSizingEnum.Fit:
default:
g.DrawImage(im, r2);
break;
}
if (SelectTool && pi.AllowSelect && _SelectList.Contains(pi))
{
g.FillRectangle(new SolidBrush(Color.FromArgb(50, _SelectItemColor)), ir);
}
return;
}
internal override PaintEventArgs PaintEventStart(ref Message msg, IntPtr handle, bool client)
{
PaintEventArgs paint_event;
Hwnd hwnd;
Hwnd paint_hwnd;
//
// handle (and paint_hwnd) refers to the window that is should be painted.
// msg.HWnd (and hwnd) refers to the window that got the paint message.
//
hwnd = Hwnd.ObjectFromHandle(msg.HWnd);
if (msg.HWnd == handle) {
paint_hwnd = hwnd;
} else {
paint_hwnd = Hwnd.ObjectFromHandle (handle);
}
if (Caret.Visible == true) {
Caret.Paused = true;
HideCaret();
}
Graphics dc;
if (client) {
dc = Graphics.FromHwnd (paint_hwnd.client_window);
Region clip_region = new Region ();
clip_region.MakeEmpty();
foreach (Rectangle r in hwnd.ClipRectangles) {
/* Expand the region slightly.
* See bug 464464.
*/
Rectangle r2 = Rectangle.FromLTRB (r.Left, r.Top, r.Right, r.Bottom + 1);
clip_region.Union (r2);
}
if (hwnd.UserClip != null) {
clip_region.Intersect(hwnd.UserClip);
}
dc.Clip = clip_region;
paint_event = new PaintEventArgs(dc, hwnd.Invalid);
hwnd.expose_pending = false;
hwnd.ClearInvalidArea();
hwnd.drawing_stack.Push (paint_event);
hwnd.drawing_stack.Push (dc);
return paint_event;
} else {
dc = Graphics.FromHwnd (paint_hwnd.whole_window);
if (!hwnd.nc_invalid.IsEmpty) {
dc.SetClip (hwnd.nc_invalid);
paint_event = new PaintEventArgs(dc, hwnd.nc_invalid);
} else {
paint_event = new PaintEventArgs(dc, new Rectangle(0, 0, hwnd.width, hwnd.height));
}
hwnd.nc_expose_pending = false;
hwnd.ClearNcInvalidArea ();
hwnd.drawing_stack.Push (paint_event);
hwnd.drawing_stack.Push (dc);
return paint_event;
}
}
