| public Restore ( GraphicsState state ) : void | ||
| state | GraphicsState | |
| return | void | |
public override void Apply(Graphics graphics, Bitmap applyBitmap, Rectangle rect, RenderMode renderMode)
{
Rectangle applyRect = ImageHelper.CreateIntersectRectangle(applyBitmap.Size, rect, Invert);
if (applyRect.Width == 0 || applyRect.Height == 0)
{
// nothing to do
return;
}
GraphicsState state = graphics.Save();
if (Invert)
{
graphics.SetClip(applyRect);
graphics.ExcludeClip(rect);
}
ColorMatrix grayscaleMatrix = new ColorMatrix(new[] {
new[] {.3f, .3f, .3f, 0, 0},
new[] {.59f, .59f, .59f, 0, 0},
new[] {.11f, .11f, .11f, 0, 0},
new float[] {0, 0, 0, 1, 0},
new float[] {0, 0, 0, 0, 1}
});
using (ImageAttributes ia = new ImageAttributes())
{
ia.SetColorMatrix(grayscaleMatrix);
graphics.DrawImage(applyBitmap, applyRect, applyRect.X, applyRect.Y, applyRect.Width, applyRect.Height, GraphicsUnit.Pixel, ia);
}
graphics.Restore(state);
}
public void RedrawDeck()
{
if (m_ShowDeck != null)
{
System.Drawing.Graphics pGraphics = this.CreateGraphics();
m_ShowDeck.DrawToGraphics(pGraphics);
}
else if (m_DeckList != null)
{
System.Drawing.Graphics pGraphics = this.CreateGraphics();
pGraphics.Clear(Color.Honeydew);
int count = m_DeckList.Count;
int CurrentX = 0;
for (int i = 0; i < count; i++)
{
kernal.PlayedDeck deck = m_DeckList[i];
Size deckSize = deck.GetSize();
var saveState = pGraphics.Save();
pGraphics.TranslateTransform(CurrentX, 0);
deck.DrawToGraphics(pGraphics);
pGraphics.Restore(saveState);
CurrentX += deckSize.Width;
}
}
}
public override void Apply(Graphics graphics, Bitmap applyBitmap, Rectangle rect, RenderMode renderMode)
{
Rectangle applyRect = ImageHelper.CreateIntersectRectangle(applyBitmap.Size, rect, Invert);
if (applyRect.Width == 0 || applyRect.Height == 0)
{
// nothing to do
return;
}
int magnificationFactor = GetFieldValueAsInt(FieldType.MAGNIFICATION_FACTOR);
GraphicsState state = graphics.Save();
if (Invert)
{
graphics.SetClip(applyRect);
graphics.ExcludeClip(rect);
}
graphics.SmoothingMode = SmoothingMode.None;
graphics.InterpolationMode = InterpolationMode.NearestNeighbor;
graphics.CompositingQuality = CompositingQuality.HighQuality;
graphics.PixelOffsetMode = PixelOffsetMode.None;
int halfWidth = rect.Width / 2;
int halfHeight = rect.Height / 2;
int newWidth = rect.Width / magnificationFactor;
int newHeight = rect.Height / magnificationFactor;
Rectangle source = new Rectangle(rect.X + halfWidth - (newWidth / 2), rect.Y + halfHeight - (newHeight / 2), newWidth, newHeight);
graphics.DrawImage(applyBitmap, rect, source, GraphicsUnit.Pixel);
graphics.Restore(state);
}
protected void PaintTransparentBackground(Graphics g, Rectangle clipRect) {
// check if we have a parent
if (this.Parent != null) {
// convert the clipRects coordinates from ours to our parents
clipRect.Offset(this.Location);
PaintEventArgs e = new PaintEventArgs(g, clipRect);
GraphicsState state = g.Save();
try {
// move the graphics object so that we are drawing in
// the correct place
g.TranslateTransform((float)-this.Location.X, (float)-this.Location.Y);
// draw the parents background and foreground
this.InvokePaintBackground(this.Parent, e);
this.InvokePaint(this.Parent, e);
return;
} finally {
// reset everything back to where they were before
g.Restore(state);
clipRect.Offset(-this.Location.X, -this.Location.Y);
}
}
// we don't have a parent, so fill the rect with
// the default control color
g.FillRectangle(SystemBrushes.Control, clipRect);
}
public unsafe override void Apply(Graphics graphics, Bitmap applyBitmap, Rectangle rect, RenderMode renderMode)
{
int blurRadius = GetFieldValueAsInt(FieldType.BLUR_RADIUS);
double previewQuality = GetFieldValueAsDouble(FieldType.PREVIEW_QUALITY);
Rectangle applyRect = ImageHelper.CreateIntersectRectangle(applyBitmap.Size, rect, Invert);
if (applyRect.Width == 0 || applyRect.Height == 0)
{
return;
}
GraphicsState state = graphics.Save();
if (Invert)
{
graphics.SetClip(applyRect);
graphics.ExcludeClip(rect);
}
if (GDIplus.IsBlurPossible(blurRadius))
{
GDIplus.DrawWithBlur(graphics, applyBitmap, applyRect, null, null, blurRadius, false);
}
else
{
using (IFastBitmap fastBitmap = FastBitmap.CreateCloneOf(applyBitmap, applyRect))
{
ImageHelper.ApplyBoxBlur(fastBitmap, blurRadius);
fastBitmap.DrawTo(graphics, applyRect);
}
}
graphics.Restore(state);
return;
}
public static void DrawFocusedItemMark(System.Drawing.Graphics g, float x, float y, bool drawWhiteBounds = false)
{
if (focusedItemMark == null)
{
var b = FocusedItemMarkBounds;
focusedItemMark = new GraphicsPath();
focusedItemMark.AddPolygon(new []
{
new PointF(0, b.Top),
new PointF(b.Width - 1, 0),
new PointF(0, b.Bottom),
});
focusedItemMarkBorder = new GraphicsPath();
focusedItemMarkBorder.AddPolygon(new[]
{
new PointF(0, b.Top - 1.5f),
new PointF(b.Width, 0),
new PointF(0, b.Bottom + 1.5f),
});
}
GraphicsState state = g.Save();
g.TranslateTransform(x, y);
g.SmoothingMode = SmoothingMode.AntiAlias;
g.FillPath(System.Drawing.Brushes.Blue, focusedItemMark);
if (drawWhiteBounds)
{
g.DrawPath(System.Drawing.Pens.White, focusedItemMarkBorder);
}
g.Restore(state);
}
/// <summary>
/// Prints an image box onto the specified graphics.
/// </summary>
/// <param name="imageBox">Image box to print.</param>
/// <param name="graphics">Graphics in which image box should be contained.</param>
/// <param name="box">Rectangle within which the image box should be contained.</param>
/// <param name="imageResolution">Image resolution.</param>
public static void Print(this ImageBox imageBox, Graphics graphics, RectF box, int imageResolution)
{
var state = graphics.Save();
FillBox(imageBox.FilmBox, box, graphics);
var boxCopy = box;
if (imageBox.FilmBox.Trim == "YES")
{
boxCopy.Inflate(-BORDER, -BORDER);
}
if (imageBox.ImageSequence != null && imageBox.ImageSequence.Contains(DicomTag.PixelData))
{
Image bitmap = null;
try
{
var image = new DicomImage(imageBox.ImageSequence);
var frame = image.RenderImage().As<Image>();
bitmap = frame;
DrawBitmap(graphics, boxCopy, bitmap, imageResolution, imageBox.FilmBox.EmptyImageDensity);
}
finally
{
if (bitmap != null)
{
bitmap.Dispose();
}
}
}
graphics.Restore(state);
}
/// <summary>
/// Implements the Apply code for the Brightness Filet
/// </summary>
/// <param name="graphics"></param>
/// <param name="applyBitmap"></param>
/// <param name="rect"></param>
/// <param name="renderMode"></param>
public override void Apply(Graphics graphics, Bitmap applyBitmap, Rectangle rect, RenderMode renderMode) {
Rectangle applyRect = ImageHelper.CreateIntersectRectangle(applyBitmap.Size, rect, Invert);
if (applyRect.Width == 0 || applyRect.Height == 0) {
// nothing to do
return;
}
GraphicsState state = graphics.Save();
if (Invert) {
graphics.SetClip(applyRect);
graphics.ExcludeClip(rect);
}
using (IFastBitmap fastBitmap = FastBitmap.CreateCloneOf(applyBitmap, applyRect)) {
Color highlightColor = GetFieldValueAsColor(FieldType.FILL_COLOR);
for (int y = fastBitmap.Top; y < fastBitmap.Bottom; y++) {
for (int x = fastBitmap.Left; x < fastBitmap.Right; x++) {
Color color = fastBitmap.GetColorAt(x, y);
color = Color.FromArgb(color.A, Math.Min(highlightColor.R, color.R), Math.Min(highlightColor.G, color.G), Math.Min(highlightColor.B, color.B));
fastBitmap.SetColorAt(x, y, color);
}
}
fastBitmap.DrawTo(graphics, applyRect.Location);
}
graphics.Restore(state);
}
private void DrawGrid(System.Drawing.Graphics gfx)
{
GraphicsState gstate = gfx.Save();
Pen pen = new Pen(Color.Red);
Rectangle destRect = new Rectangle(0, 0, this.BackBuffer.Width, this.BackBuffer.Height);
GraphicsPath path = new GraphicsPath(FillMode.Alternate);
for (int index1 = 0; index1 < this._rows; ++index1)
{
for (int index2 = 0; index2 < this._cols; ++index2)
{
int x = index2 * this.SnapSize.Width;
int y = index1 * this.SnapSize.Height;
path.AddRectangle(new Rectangle(x, y, this.SnapSize.Width, this.SnapSize.Height));
}
}
path.Widen(pen);
Region region = new Region(path);
gfx.Clip = region;
gfx.DrawImage((Image)this.BackBuffer, destRect, 0, 0, destRect.Width, destRect.Height, GraphicsUnit.Pixel, this._atts);
gfx.Restore(gstate);
region.Dispose();
pen.Dispose();
}
public void Draw (Graphics graphics, Route route, bool atEnd)
{
if (graphics == null) return;
if (route == null) return;
GraphicsState state = graphics.Save();
float direction = 0;
PointF pos = default(PointF);
if (atEnd)
{
pos = route.GetEndPoint();
direction = ConvertDirection(route.GetEndDirection());
}
else
{
pos = route.GetStartPoint();
direction = ConvertDirection(route.GetStartDirection());
}
// In matrix math, the correct way is to put rotation BEFORE
// translation. However, the simple transformation maethods of
// GDI+ works in "Prepend" mode, which reverses the order of
// operations.
graphics.TranslateTransform(pos.X, pos.Y);
graphics.RotateTransform(direction);
Paint(graphics);
graphics.Restore(state);
}
protected override void Paint(sd.Graphics graphics, sd.Rectangle clipBounds, sd.Rectangle cellBounds, int rowIndex, swf.DataGridViewElementStates cellState, object value, object formattedValue, string errorText, swf.DataGridViewCellStyle cellStyle, swf.DataGridViewAdvancedBorderStyle advancedBorderStyle, swf.DataGridViewPaintParts paintParts)
{
// save graphics state to prevent artifacts in other paint operations in the grid
var state = graphics.Save();
if (!ReferenceEquals(cachedGraphicsKey, graphics) || cachedGraphics == null)
{
cachedGraphicsKey = graphics;
cachedGraphics = new Graphics(new GraphicsHandler(graphics, dispose: false));
}
else
{
((GraphicsHandler)cachedGraphics.Handler).SetInitialState();
}
graphics.PixelOffsetMode = sd.Drawing2D.PixelOffsetMode.Half;
graphics.SetClip(cellBounds);
var color = new sd.SolidBrush(cellState.HasFlag(swf.DataGridViewElementStates.Selected) ? cellStyle.SelectionBackColor : cellStyle.BackColor);
graphics.FillRectangle(color, cellBounds);
var args = new CellPaintEventArgs(cachedGraphics, cellBounds.ToEto(), cellState.ToEto(), value);
Handler.Callback.OnPaint(Handler.Widget, args);
graphics.ResetClip();
graphics.Restore(state);
}
protected override void Render(System.Drawing.Graphics gfx)
{
base.Render(gfx);
System.Drawing.Drawing2D.GraphicsState graph = gfx.Save();
if (TitleImage != null)
{
gfx.DrawImage(TitleImage, (this.PinPoint.X - 25) + (this.Size.Width - this.PinPoint.X), 5, 17.5f, 17.5f);
}
gfx.Restore(graph);
}
protected override void Render(System.Drawing.Graphics gfx)
{
base.Render(gfx);
System.Drawing.Drawing2D.GraphicsState graph = gfx.Save();
if (TextImage != null && DrawImage)
{
gfx.DrawImage(TextImage, ImageOffsetX, ImageOffsetY, 17.5f, 17.5f);
gfx.Restore(graph);
}
}
/// <summary>
/// 重新绘制本区域内的内容
/// </summary>
/// <param name="rect">相对当前屏幕的坐标矩形</param>
public void paintArea(GDI.Rectangle rect)
{
if (rect.Height == 0 || rect.Width == 0)
{
return;
}
GDI.Drawing2D.GraphicsState state = g.Save();
g.SetClip(rect);
// 开始画图吧
double iOffsetX = rect.X;
int iColumn = GetCellColumn(ref iOffsetX);
if (iColumn == -1)
{
g.Restore(state);
return;
}
GB_GridView.CellPaintEventArgs e = new GB_GridView.CellPaintEventArgs();
g.FillRectangle(m_background, rect);
double iColumnWidth = rect.X - iOffsetX;
for (int j = iColumn; j < Columns.Count; ++j)
{
if (iColumnWidth > ActualWidth)
{
break; // 说明这一行画完了，开始画下一行吧
}
e.Bounds = new GDI.Rectangle((int)iColumnWidth, 0, (int)Columns[j].Width, m_bufferedBmp.PixelHeight);
iColumnWidth += Columns[j].Width;
e.ColumnIndex = j;
e.RowIndex = -1;
e.States = GB_GridView.GridViewElementStates.Visible;
e.Graphics = g;
e.Value = Columns[j].Header.ToString();
DefaultPaintCell(e);
}
g.Restore(state);
}
protected override void Render(System.Drawing.Graphics gfx)
{
base.Render(gfx);
System.Drawing.Drawing2D.GraphicsState graph = gfx.Save();
if (RowImage != null)
{
gfx.DrawImage(RowImage, this.Labels[0].OffsetX - 20, 2, 17.5f, 17.5f);
gfx.Restore(graph);
}
}
public virtual void DrawToGraphics (Graphics graphics, float x, float y, float scaleX, float scaleY)
{
if (graphics == null) return;
GraphicsState state = graphics.Save();
graphics.TranslateTransform (x, y);
graphics.ScaleTransform(scaleX, scaleY);
Draw(graphics);
//graphics.DrawRectangle(Pens.Magenta, 0, 0, ShapeWidth, ShapeHeight);
graphics.Restore(state);
}
public override void Draw(Graphics graphics)
{
if (graphics == null) return;
GraphicsState state = graphics.Save();
graphics.TranslateTransform(17.0f, 0.0f);
graphics.ScaleTransform(-1.0f, 1.0f);
MethodShape.DrawBrick(graphics, brickBrush1, brickBrush2, brickBrush3);
graphics.Restore(state);
graphics.FillRectangle(Brushes.Gray, 1.0f, 4.5f, 3.5f, 0.5f);
graphics.FillRectangle(Brushes.Gray, 0.0f, 6.5f, 3.5f, 0.5f);
graphics.FillRectangle(Brushes.Gray, 2.0f, 8.5f, 3.5f, 0.5f);
}
protected override void PaintPanel(Graphics g)
{
if (g == null) throw new ArgumentNullException("g");
var scroll = Hexgrid.ScrollPosition;
if (DesignMode) { g.FillRectangle(Brushes.Gray, ClientRectangle); return; }
g.Clear(Color.Black);
if (IsTransposed) { g.Transform = TransposeMatrix; }
g.TranslateTransform(scroll.X, scroll.Y);
g.ScaleTransform(MapScale, MapScale);
var state = g.Save();
g.DrawImageUnscaled(MapBuffer, Point.Empty);
g.Restore(state); state = g.Save();
Host.PaintUnits(g);
g.Restore(state); state = g.Save();
Host.PaintHighlight(g);
}
public override void Render(System.Drawing.Rectangle rectangle, System.Drawing.Graphics graphics)
{
GraphicsState s = graphics.Save();
Rectangle rt = new System.Drawing.Rectangle(0, 0, 57, 88);
graphics.TranslateTransform(-rt.Width / 2, -rt.Height / 2, MatrixOrder.Append);
graphics.RotateTransform(20, MatrixOrder.Append);
graphics.TranslateTransform(((rectangle.X + rectangle.Width)) / 2, ((rectangle.Y + rectangle.Height)) / 2, MatrixOrder.Append);
graphics.FillRectangle(Brushes.White, rt);
graphics.Restore(s);
}
private void DrawElement(Graphics g, Act2DMapLayoutObject.Element e)
{
var bitmap = file.CreateBitmapForResource(e.resourceID);
if (bitmap == null) return;
var saved = g.Save();
g.TranslateTransform(e.x, e.y);
g.TranslateTransform(bitmap.Width * 0.5f, bitmap.Height * 0.5f);
g.RotateTransform(e.rotate);
g.ScaleTransform(e.scale_x, e.scale_y);
g.TranslateTransform(-bitmap.Width * 0.5f, -bitmap.Height * 0.5f);
g.DrawImage(bitmap, new PointF(0.0f, 0.0f));
g.Restore(saved);
}
internal override void draw(Graphics g)
{
RectangleF rcNode = item.getRotatedBounds();
Rectangle rcDev = Utilities.docToDevice(g, getIconRect(rcNode));
if (rcDev.Width < 6 || rcDev.Height < 6) return;
GraphicsState state = g.Save();
item.flowChart.unsetTransforms(g);
if ((item as Node).Expanded)
g.DrawIcon(imgExpanded, rcDev.X, rcDev.Y);
else
g.DrawIcon(imgCollapsed, rcDev.X, rcDev.Y);
g.Restore(state);
}
/// <summary>
/// Draw grid cells
/// </summary>
private void DrawGrid(System.Drawing.Graphics gfx)
{
// Save state
GraphicsState state = gfx.Save();
// Created invert pen
Pen pen = new Pen(Color.Red);
// Get rendering rectangle
Rectangle rect = new Rectangle(0, 0, BackBuffer.Width, BackBuffer.Height);
// Create a new graphics path for inverted lines
GraphicsPath path = new GraphicsPath(FillMode.Alternate);
// Iterate through vertical tiles
for (int row = 0; row < _rows; row++)
{
// Iterate through horizontal tiles
for (int col = 0; col < _cols; col++)
{
// Get position coordinates
int x = col * SnapSize.Width;
int y = row * SnapSize.Height;
// Add rectangle path
path.AddRectangle(new Rectangle(x, y, SnapSize.Width, SnapSize.Height));
}
}
// Widen the path with pen
path.Widen(pen);
// Create new region
Region region = new Region(path);
// Set the region
gfx.Clip = region;
// Draw the backbuffer image
gfx.DrawImage(BackBuffer, rect, 0, 0, rect.Width, rect.Height, GraphicsUnit.Pixel, _atts);
// Restore the graphics state to non-inverted
gfx.Restore(state);
// Dispose of all temp objects
region.Dispose();
pen.Dispose();
}
protected override void DrawToolTip(Graphics g, GMapMarker m, int x, int y)
{
GraphicsState s = g.Save();
g.SmoothingMode = SmoothingMode.AntiAlias;
System.Drawing.Size st = g.MeasureString(m.ToolTipText, TooltipFont).ToSize();
System.Drawing.Rectangle rect = new System.Drawing.Rectangle(x, y, st.Width + Control.TooltipTextPadding.Width, st.Height + Control.TooltipTextPadding.Height);
rect.Offset(m.ToolTipOffset.X, m.ToolTipOffset.Y);
g.DrawLine(TooltipPen, x, y, rect.X + rect.Width / 2, rect.Y + rect.Height / 2);
g.FillRectangle(TooltipBackground, rect);
g.DrawRectangle(TooltipPen, rect);
g.DrawString(m.ToolTipText, TooltipFont, Brushes.Navy, rect, TooltipFormat);
g.Restore(s);
}
public override void Draw(Graphics graphics)
{
if (graphics == null) return;
GraphicsState state = graphics.Save();
CollapseExpandShape.DrawButton(graphics);
if (collapsed)
{
graphics.TranslateTransform(0, 21);
graphics.ScaleTransform(1, -1);
}
CollapseExpandShape.DrawArrow(graphics);
graphics.TranslateTransform(0, 6);
CollapseExpandShape.DrawArrow(graphics);
graphics.Restore(state);
}
public override void Render(GDI.Graphics g, Map map)
{
if (map.Center == null)
{
throw (new ApplicationException("Cannot render map. View center not specified"));
}
g.SmoothingMode = SmoothingMode;
var envelope = ToSource(map.Envelope); //View to render
if (DataSource == null)
{
throw (new ApplicationException("DataSource property not set on layer '" + LayerName + "'"));
}
// Get the transform
var transform = new Matrix3x2(g.Transform.Elements);
// Save state of the graphics object
var gs = g.Save();
// Create and prepare the render target
var rt = RenderTargetFactory.Create(_d2d1Factory, g, map);
// Set anti-alias mode and transform
rt.AntialiasMode = AntialiasMode;
rt.Transform = transform;
if (Theme != null)
{
RenderInternal(_d2d1Factory, rt, map, envelope, Theme);
}
else
{
RenderInternal(_d2d1Factory, rt, map, envelope);
}
// Clean up the render target
RenderTargetFactory.CleanUp(rt, g, map);
// Restore the graphics object
g.Restore(gs);
// Invoke LayerRendered event
OnLayerRendered(g);
}
public RectangleF PaintSymbol(System.Drawing.Graphics g, System.Drawing.RectangleF bounds)
{
if (Shape != XYPlotScatterStyles.Shape.NoSymbol)
{
GraphicsState gs = g.Save();
g.TranslateTransform(bounds.X + 0.5f * bounds.Width, bounds.Y + 0.5f * bounds.Height);
Paint(g);
g.Restore(gs);
if (this.SymbolSize > bounds.Height)
{
bounds.Inflate(0, this.SymbolSize - bounds.Height);
}
}
return(bounds);
}
public RectangleF PaintSymbol(System.Drawing.Graphics g, System.Drawing.RectangleF bounds)
{
if (_scatterSymbol is NoSymbol)
{
return(bounds);
}
var cachedPathData = new CachedPathData();
var cachedBrushData = new CachedBrushData();
var scatterSymbol = CalculateOverriddenScatterSymbol();
CalculatePaths(scatterSymbol, _symbolSize, ref cachedPathData);
CalculateBrushes(scatterSymbol, _color, cachedPathData, ref cachedBrushData);
GraphicsState gs = g.Save();
g.TranslateTransform(bounds.X + 0.5f * bounds.Width, bounds.Y + 0.5f * bounds.Height);
if (null != cachedPathData.InsetPath)
{
g.FillPath(cachedBrushData.InsetBrush, cachedPathData.InsetPath);
}
if (null != cachedPathData.FillPath)
{
g.FillPath(cachedBrushData.FillBrush, cachedPathData.FillPath);
}
if (null != cachedPathData.FramePath)
{
g.FillPath(cachedBrushData.FrameBrush, cachedPathData.FramePath);
}
cachedBrushData.Clear();
cachedPathData.Clear();
g.Restore(gs);
if (SymbolSize > bounds.Height)
{
bounds.Inflate(0, (float)(SymbolSize - bounds.Height));
}
return(bounds);
}
/// <summary>
/// Draws a shadow around a defined path.
/// </summary>
/// <param name="g">The current Graphics handle.</param>
/// <param name="path">The path which should have a shadow.</param>
/// <param name="color">The color of the shadow.</param>
/// <param name="dx">The horizontal shift.</param>
/// <param name="dy">The vertical shift.</param>
/// <param name="blur">The blurness.</param>
public static void DrawShadow(this System.Drawing.Graphics g, GraphicsPath path, Color color, float dx, float dy, float blur)
{
var bounds = path.GetBounds();
var bpw = blur / (float)bounds.Width / 2f;
var bph = blur / (float)bounds.Height / 2f;
var tdx = -(float)bounds.Left - (float)bounds.Width / 2f;
var tdy = -(float)bounds.Top - (float)bounds.Height / 2f;
path.Transform(new Matrix(1f, 0f, 0f, 1f, tdx, tdy));
Region original = new Region(path);
path.Transform(new Matrix(1f + bpw, 0f, 0f, 1f + bph, dx, dy));
Region transform = new Region(path);
transform.Exclude(original);
var gs = g.Save();
g.TranslateTransform(-tdx, -tdy);
if (blur <= 0f)
{
g.FillRegion(new SolidBrush(color), transform);
}
else
{
var lgb = new PathGradientBrush(path);
lgb.CenterColor = color;
lgb.SurroundColors = new Color[] { Color.Transparent };
var colors = new Color[3];
var positions = new float[3];
for (var i = 0; i < 3; i++)
{
colors[i] = Color.FromArgb(255 * (2 - i) / 2, color);
positions[i] = (2f - i) / 2f;
}
lgb.InterpolationColors.Colors = colors;
lgb.InterpolationColors.Positions = positions;
g.FillRegion(lgb, transform);
}
g.Restore(gs);
}
public static void DoGrid(this WidgetMidiList widget, FloatRect grid, Graphics g)
{
var gs = g.Save();
using (g.Clip = new Region(grid))
{
using (var p0 = new Pen(Color.Black)) foreach (var i in widget.GetHLines(4))
g.DrawLines(p0, new Point[] { new FloatPoint(i.XO, grid.Top), new FloatPoint(i.XO, grid.Bottom) });
using (var p1 = new Pen(Gray130)) foreach (var i in widget.GetHLines(Convert.ToInt32(Math.Pow(4, 2))))
g.DrawLines(p1, new Point[] { new FloatPoint(i.XO, grid.Top), new FloatPoint(i.XO, grid.Bottom) });
using (var p2 = new Pen(White)) foreach (var i in widget.GetHLines(Convert.ToInt32(Math.Pow(4, 3))))
g.DrawLines(p2, new Point[] { new FloatPoint(i.XO, grid.Top), new FloatPoint(i.XO, grid.Bottom) });
g.ResetClip();
}
g.Restore(gs);
}
/// <summary>
/// Implements the Apply code for the Brightness Filet
/// </summary>
/// <param name="graphics"></param>
/// <param name="applyBitmap"></param>
/// <param name="rect"></param>
/// <param name="renderMode"></param>
public override void Apply(Graphics graphics, Bitmap applyBitmap, Rectangle rect, RenderMode renderMode) {
Rectangle applyRect = ImageHelper.CreateIntersectRectangle(applyBitmap.Size, rect, Invert);
if (applyRect.Width == 0 || applyRect.Height == 0) {
// nothing to do
return;
}
GraphicsState state = graphics.Save();
if (Invert) {
graphics.SetClip(applyRect);
graphics.ExcludeClip(rect);
}
float brightness = GetFieldValueAsFloat(FieldType.BRIGHTNESS);
using (ImageAttributes ia = ImageHelper.CreateAdjustAttributes(brightness, 1f, 1f)) {
graphics.DrawImage(applyBitmap, applyRect, applyRect.X, applyRect.Y, applyRect.Width, applyRect.Height, GraphicsUnit.Pixel, ia);
}
graphics.Restore(state);
}
public override void OnDraw(System.Drawing.Graphics g)
{
SizeF size1 = this[0].CalculateDrawSize(g);
string s = new string((char)0xD6, 1);
Font ft = new Font("Symbol", size1.Height, FontStyle.Regular, GraphicsUnit.Pixel);
SizeF size = g.MeasureString(s, ft);
//
float w = size1.Width + size.Width;
float h = size1.Height;
//
float a1 = (float)0.5177618;
float b1 = (float)0.1262125;
float a2 = (float)0.0719113648;
float b2 = (float)0.378640622;
int nLineTop = (int)(a2 * size.Height + b2);
int nLineLeft = (int)(a1 * size.Height + b1);
if (IsFocused)
{
g.FillRectangle(TextBrushBKFocus0, (float)0, (float)0, w, h);
g.FillRectangle(TextBrushBKFocus, (float)0, (float)0, w, h);
g.DrawString(s, ft, TextBrushFocus, 0, 0);
}
else
{
g.DrawString(s, ft, TextBrush, 0, 0);
}
if (IsFocused)
{
g.DrawLine(new Pen(TextBrushFocus), nLineLeft, nLineTop, nLineLeft + size1.Width, nLineTop);
}
else
{
g.DrawLine(new Pen(TextBrush), nLineLeft, nLineTop, nLineLeft + size1.Width, nLineTop);
}
//
System.Drawing.Drawing2D.GraphicsState gt = g.Save();
g.TranslateTransform(nLineLeft + 1, nLineTop + 1);
this[0].Position = new Point(this.Position.X + nLineLeft + 1, Position.Y + nLineTop + 1);
this[0].Draw(g);
g.Restore(gt);
}
protected override void Paint(Graphics graphics, Rectangle clipBounds, Rectangle cellBounds, int rowIndex, DataGridViewElementStates dataGridViewElementState, object value, object formattedValue, string errorText, DataGridViewCellStyle cellStyle, DataGridViewAdvancedBorderStyle advancedBorderStyle, DataGridViewPaintParts paintParts)
{
this.checkBox.Size = CheckBoxRenderer.GetGlyphSize(graphics, CheckBoxState.UncheckedNormal);
this.checkBox.Location = new Point(2, cellBounds.Height / 2 - this.checkBox.Height / 2);
this.checkRectangle.Size = new Size(this.checkBox.Right + 1, clipBounds.Height);
Point realLocation = this.checkBox.Location + (Size)cellBounds.Location;
ButtonState state = GetCheckBoxState();
Padding newPadding = cellStyle.Padding;
newPadding.Left = checkRectangle.Width;
cellStyle.Padding = newPadding;
GraphicsState gstate = graphics.Save();
graphics.ExcludeClip(new Rectangle(realLocation, this.checkBox.Size));
base.Paint(graphics, clipBounds, cellBounds, rowIndex, dataGridViewElementState, value, formattedValue, errorText, cellStyle, advancedBorderStyle, paintParts);
graphics.Restore(gstate);
CheckBoxRenderer.DrawCheckBox(graphics, realLocation, ConvertFromButtonState(state, false, this.mouseInCheckBox));
}
public static void DoNoteIds(this WidgetMidiList widget, FloatRect grid, Graphics g)
{
var gs = g.Save();
using (g.Clip = new Region(grid))
{
foreach (var i in widget.GetHLines(Convert.ToInt32(Math.Pow(4, 2))))
{
var r2=new FloatRect(i.XO-16,grid.Top,32,24);
g.FillEllipse(Brushes.Black,r2);
g.DrawText((i.Index / 4).ToString(),Color.White,widget.Font,r2);
}
foreach (var i in widget.GetHLines(Convert.ToInt32(Math.Pow(4, 3))))
{
var r2=new FloatRect(i.XO-16,grid.Top+32,32,24);
g.FillEllipse(Brushes.Black,r2);
g.DrawText((i.Index / 64).ToString(),Color.White,widget.Font,r2);
}
g.ResetClip();
}
g.Restore(gs);
}
protected override void Paint(sd.Graphics graphics, sd.Rectangle clipBounds, sd.Rectangle cellBounds, int rowIndex, swf.DataGridViewElementStates cellState, object value, object formattedValue, string errorText, swf.DataGridViewCellStyle cellStyle, swf.DataGridViewAdvancedBorderStyle advancedBorderStyle, swf.DataGridViewPaintParts paintParts)
{
// save graphics state to prevent artifacts in other paint operations in the grid
var state = graphics.Save();
if (!object.ReferenceEquals(cachedGraphicsKey, graphics) || cachedGraphics == null)
{
cachedGraphicsKey = graphics;
cachedGraphics = new Graphics(new GraphicsHandler(graphics, shouldDisposeGraphics: false));
}
else
{
((GraphicsHandler)cachedGraphics.Handler).SetInitialState();
}
graphics.SetClip(cellBounds);
var args = new DrawableCellPaintEventArgs(cachedGraphics, cellBounds.ToEto(), cellState.ToEto(), value);
Handler.Callback.OnPaint(Handler.Widget, args);
graphics.ResetClip();
graphics.Restore(state);
}
public static void DrawWatermarkText(Graphics graphics, string text, string fontName) {
int imageHeight = (int)graphics.VisibleClipBounds.Height;
int imageWidth = (int)graphics.VisibleClipBounds.Width;
int maxTextWidth = (int)(imageHeight * 0.4);
int[] fontSizes = new int[] { 72, 48, 36, 24, 18, 18, 14, 12, 10 };
Font font = null;
foreach(int fontSize in fontSizes) {
font = new Font(fontName, fontSize, GraphicsUnit.Pixel);
if(graphics.MeasureString(text, font).Width <= maxTextWidth)
break;
}
GraphicsState state = graphics.Save();
SmoothGraphics(graphics);
graphics.RotateTransform(-90);
float padding = font.Size / 2;
graphics.TranslateTransform(-imageHeight + padding, imageWidth - font.GetHeight() - padding);
graphics.TextContrast = 12;
graphics.PageUnit = font.Unit;
graphics.DrawString(text, font, new SolidBrush(Color.FromArgb(120, Color.Black)), 1, 1);
graphics.DrawString(text, font, new SolidBrush(Color.FromArgb(120, Color.White)), 0, 0);
graphics.Restore(state);
}
public RectangleF PaintSymbol(System.Drawing.Graphics g, System.Drawing.RectangleF bounds)
{
if (!LineConnectionStyles.NoConnection.Instance.Equals(_connectionStyle))
{
GraphicsState gs = g.Save();
g.TranslateTransform(bounds.X + 0.5f * bounds.Width, bounds.Y + 0.5f * bounds.Height);
float halfwidth = bounds.Width / 2;
if (UseSymbolGap == true)
{
// plot a line with the length of symbolsize from
var symGap = (float)(_symbolGapOffset + _symbolGapFactor * _symbolSize);
PaintLine(g, new PointF(-halfwidth, 0), new PointF(-symGap / 2, 0));
PaintLine(g, new PointF(symGap / 2, 0), new PointF(halfwidth, 0));
}
else // no gap
{
PaintLine(g, new PointF(-halfwidth, 0), new PointF(halfwidth, 0));
}
g.Restore(gs);
}
return(bounds);
}
private static void PaintText(Graphics graphics, Rectangle cellBounds, string valueString)
{
RectangleF drawArea = DrawAreaFromCellBounds(cellBounds);
RectangleF textRect = drawArea;
GraphicsPath pathText = new GraphicsPath();
pathText.AddString(valueString, ValueFont.FontFamily, (int)ValueFont.Style, ValueFont.Size, textRect, ValueStringFormat);
GraphicsState state = graphics.Save();
graphics.SmoothingMode = SmoothingMode.AntiAlias;
graphics.DrawPath(ValuePen, pathText);
graphics.FillPath(ValueFill, pathText);
graphics.Restore(state);
}
/// <summary>
/// 绘制透明背景
/// </summary>
/// <param name="graphics"></param>
/// <param name="clipRect"></param>
protected void PaintTransparentBackground(Graphics graphics, Rectangle clipRect)
{
if ((this.Parent != null)) {
//相对于父容器，设置cliprect
clipRect.Offset(this.Location);
//保存graphics当前的状态
GraphicsState state = graphics.Save();
//相对于父容器，设置graphicsobject
graphics.TranslateTransform((float)-this.Location.X, (float)-this.Location.Y);
graphics.SmoothingMode = SmoothingMode.HighSpeed;
//绘制父容器
PaintEventArgs e = new PaintEventArgs(graphics, clipRect);
try {
this.InvokePaintBackground(this.Parent, e);
this.InvokePaint(this.Parent, e);
} finally {
//还原graphics状态，还原clipRect先前的位置
graphics.Restore(state);
clipRect.Offset(-this.Location.X, -this.Location.Y);
}
}
}
public override void OnDraw(System.Drawing.Graphics g)
{
Type t = typeof(LogicValueEquality);
System.Drawing.ToolboxBitmapAttribute tba = TypeDescriptor.GetAttributes(t)[typeof(System.Drawing.ToolboxBitmapAttribute)] as System.Drawing.ToolboxBitmapAttribute;
Bitmap bmp = (System.Drawing.Bitmap)tba.GetImage(t);
float enclosureWidth = 0;
float enclosureHeight = 0;
float yParenthesis = 0;
SizeF size1 = this[0].CalculateDrawSize(g);
SizeF size2 = this[1].CalculateDrawSize(g);
float h = size1.Height;
if (h < size2.Height)
{
h = size2.Height;
}
SizeF size3 = new SizeF(h, h);
bool useParenthesis = (this.Rank() < this.Parent.Rank());
if (useParenthesis)
{
SizeF size4 = g.MeasureString("(", ftParenthesis);
enclosureWidth = size4.Width;
enclosureHeight = size4.Height;
}
float w = size1.Width + size2.Width + size3.Width + enclosureWidth + enclosureWidth;
if (IsFocused)
{
g.FillRectangle(this.TextBrushBKFocus0, new Rectangle(0, 0, (int)w, (int)h));
}
float y = 0;
if (size1.Height < h)
{
y = (h - size1.Height) / (float)2;
}
float x = size1.Width + size3.Width + enclosureWidth;
if (useParenthesis)
{
if (enclosureHeight < h)
{
yParenthesis = (h - enclosureHeight) / (float)2;
}
if (IsFocused)
{
g.DrawString("(", ftParenthesis, this.TextBrushFocus, new PointF(0, yParenthesis));
}
else
{
g.DrawString("(", ftParenthesis, this.TextBrush, new PointF(0, yParenthesis));
}
}
//
System.Drawing.Drawing2D.GraphicsState gt = g.Save();
g.TranslateTransform(enclosureWidth, y);
this[0].Position = new Point(this.Position.X + (int)enclosureWidth, Position.Y + (int)y);
this[0].Draw(g);
g.Restore(gt);
y = 0;
if (size3.Height < h)
{
y = (h - size3.Height) / (float)2;
}
//draw operator
gt = g.Save();
g.TranslateTransform(size1.Width + enclosureWidth, y);
g.DrawImage(bmp, new RectangleF(0, 0, size3.Width, size3.Height));
g.Restore(gt);
//
y = 0;
if (size2.Height < h)
{
y = (h - size2.Height) / (float)2;
}
gt = g.Save();
g.TranslateTransform(x, y);
this[1].Position = new Point(Position.X + (int)x, (int)y + Position.Y);
this[1].Draw(g);
g.Restore(gt);
//
if (useParenthesis)
{
if (IsFocused)
{
g.DrawString(")", ftParenthesis, this.TextBrushFocus, new PointF(x + size2.Width, yParenthesis));
}
else
{
g.DrawString(")", ftParenthesis, this.TextBrush, new PointF(x + size2.Width, yParenthesis));
}
}
}
public override void Paint(System.Drawing.Graphics g, IPaintContext paintContext)
{
if (null == _cachedArea)
{
return;
}
bool orientationIsVertical = IsOrientationVertical;
bool scaleIsReversed = IsScaleReversed;
int pixelH = orientationIsVertical ? _bitmapPixelsAcross : _bitmapPixelsAlong;
int pixelV = orientationIsVertical ? _bitmapPixelsAlong : _bitmapPixelsAcross;
if (null == _bitmap || _bitmap.Width != pixelH || _bitmap.Height != pixelV)
{
if (null != _bitmap)
{
_bitmap.Dispose();
}
_bitmap = new Bitmap(pixelH, pixelV, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
}
Data.AltaxoVariant porg;
Data.AltaxoVariant pend;
NumericalScale originalZScale;
Plot.IColorProvider colorProvider;
if (null != PlotItem)
{
porg = PlotItem.Style.Scale.OrgAsVariant;
pend = PlotItem.Style.Scale.EndAsVariant;
originalZScale = PlotItem.Style.Scale;
colorProvider = PlotItem.Style.ColorProvider;
}
else
{
porg = 0;
pend = 1;
originalZScale = new LinearScale();
colorProvider = new Plot.ColorProvider.ColorProviderBGRY();
}
var legendScale = (NumericalScale)ScaleWithTicks;
var legendTickSpacing = ScaleWithTicks.TickSpacing;
// Fill the bitmap
for (int i = 0; i < _bitmapPixelsAlong; i++)
{
double r = (scaleIsReversed ^ orientationIsVertical) ? 1 - i / (double)(_bitmapPixelsAlong - 1) : i / (double)(_bitmapPixelsAlong - 1);
double l = originalZScale.PhysicalToNormal(legendScale.NormalToPhysical(r));
var color = colorProvider.GetColor(l);
if (orientationIsVertical)
{
for (int j = 0; j < _bitmapPixelsAcross; j++)
{
_bitmap.SetPixel(j, i, color);
}
}
else
{
for (int j = 0; j < _bitmapPixelsAcross; j++)
{
_bitmap.SetPixel(i, j, color);
}
}
}
var graphicsState = g.Save();
TransformGraphics(g);
{
// Three tricks are neccessary to get the color legend (which is the bitmap) drawn smooth and uniformly:
// Everything other than this will result in distorted image, or soft (unsharp) edges
var graphicsState2 = g.Save(); // Of course, save the graphics state so we can make our tricks undone afterwards
g.InterpolationMode = InterpolationMode.Default; // Trick1: Set the interpolation mode, whatever it was before, back to default
g.PixelOffsetMode = PixelOffsetMode.Default; // Trick2: Set the PixelOffsetMode, whatever it was before, back to default
g.DrawImage(_bitmap,
new RectangleF(0, 0, (float)Size.X, (float)Size.Y),
new Rectangle(0, 0, pixelH - 1, pixelV - 1), GraphicsUnit.Pixel); // Trick3: Paint both in X and Y direction one pixel less than the source bitmap acually has, this prevents soft edges
g.Restore(graphicsState2); // make our tricks undone here
}
_axisStyles.Paint(g, paintContext, _cachedArea);
g.Restore(graphicsState);
}
public override void Paint(Graphics g, object obj)
{
System.Drawing.Drawing2D.GraphicsState gs = g.Save();
g.TranslateTransform(X,Y);
g.RotateTransform(-_rotation);
// Modification of StringFormat is necessary to avoid
// too big spaces between successive words
StringFormat strfmt = (StringFormat)StringFormat.GenericTypographic.Clone();
strfmt.FormatFlags |= StringFormatFlags.MeasureTrailingSpaces;
strfmt.LineAlignment = StringAlignment.Near;
strfmt.Alignment = StringAlignment.Near;
// next statement is necessary to have a consistent string length both
// on 0 degree rotated text and rotated text
// without this statement, the text is fitted to the pixel grid, which
// leads to "steps" during scaling
g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias;
if(this.AutoSize)
{
SizeF mySize = g.MeasureString(_text, _font);
this.Width = mySize.Width;
this.Height = mySize.Height;
g.DrawString(_text, _font, new SolidBrush(_color), 0, 0, strfmt);
}
else
{
System.Drawing.RectangleF rect = new RectangleF(0, 0, this.Width, this.Height);
g.DrawString(_text, _font, new SolidBrush(_color), rect, strfmt);
}
g.Restore(gs);
}
private void AddLabels(Graphics g, ChartStyle cs3d, ChartLabels cl, Axes ax)
{
float xOffset = ChartArea.Width / 30.0f;
float yOffset = ChartArea.Height / 30.0f;
SizeF labelFontSize = g.MeasureString("A", cl.LabelFont);
SizeF titleFontSize = g.MeasureString("A", cl.TitleFont);
SizeF tickFontSize = g.MeasureString("A", cl.TickFont);
SolidBrush aBrush = new SolidBrush(cl.TickFontColor);
StringFormat sFormat = new StringFormat();
// Create the x-axis tick marks:
aBrush = new SolidBrush(cl.TickFontColor);
for (float fX = ax.XMin; fX <= ax.XMax; fX += ax.XTick)
{
PointF yAxisPoint = Point2D(new PointF(fX, ax.YMin), ax);
sFormat.Alignment = StringAlignment.Far;
SizeF sizeXTick = g.MeasureString(fX.ToString(), cl.TickFont);
g.DrawString(fX.ToString(), cl.TickFont, aBrush,
new PointF(yAxisPoint.X + sizeXTick.Width / 2,
yAxisPoint.Y + 4f), sFormat);
}
// Create the y-axis tick marks:
for (float fY = ax.YMin; fY <= ax.YMax; fY += ax.YTick)
{
PointF xAxisPoint = Point2D(new PointF(ax.XMin, fY), ax);
sFormat.Alignment = StringAlignment.Far;
g.DrawString(fY.ToString(), cl.TickFont, aBrush,
new PointF(xAxisPoint.X - 3f,
xAxisPoint.Y - tickFontSize.Height / 2), sFormat);
}
// Add horizontal axis label:
aBrush = new SolidBrush(cl.LabelFontColor);
SizeF stringSize = g.MeasureString(cl.XLabel, cl.LabelFont);
g.DrawString(cl.XLabel, cl.LabelFont, aBrush,
new Point(PlotArea.X + PlotArea.Width / 2 -
(int)stringSize.Width / 2, ChartArea.Bottom -
(int)yOffset - (int)labelFontSize.Height));
// Add y-axis label:
sFormat.Alignment = StringAlignment.Center;
stringSize = g.MeasureString(cl.YLabel, cl.LabelFont);
// Save the state of the current Graphics object
GraphicsState gState = g.Save();
g.TranslateTransform(xOffset, yOffset + titleFontSize.Height
+ yOffset / 3 + PlotArea.Height / 2);
g.RotateTransform(-90);
g.DrawString(cl.YLabel, cl.LabelFont, aBrush, 0, 0, sFormat);
// Restore it:
g.Restore(gState);
// Add title:
aBrush = new SolidBrush(cl.TitleColor);
stringSize = g.MeasureString(cl.Title, cl.TitleFont);
if (cl.Title.ToUpper() != "NO TITLE")
{
g.DrawString(cl.Title, cl.TitleFont, aBrush,
new Point(PlotArea.X + PlotArea.Width / 2 -
(int)stringSize.Width / 2, ChartArea.Top + (int)yOffset));
}
aBrush.Dispose();
}
/// <summary>
/// Simply restores the original state of the Graphics object
/// </summary>
/// <param name="g">The Graphics object being drawn upon</param>
protected void RestoreTransform(Graphics g)
{
g.Restore(state);
}
partial void PopStateImp()
{
g.Restore(stateStack.Peek());
stateStack.Pop();
}
private void drawPlaybackIndicators(Graphics g)
{
// Playback start/end arrows
if (PlaybackStartTime.HasValue || PlaybackEndTime.HasValue) {
GraphicsState gstate = g.Save();
g.TranslateTransform(0, -_arrowBase/2);
if (PlaybackStartTime.HasValue) {
// start arrow (faces left) |<|
int x = (int) timeToPixels(PlaybackStartTime.Value);
g.FillPolygon(Brushes.DarkGray, new Point[]
{
new Point(x, Height - _arrowBase/2), // left mid point
new Point(x + _arrowLength, Height - _arrowBase), // right top point
new Point(x + _arrowLength, Height) // right bottom point
});
g.DrawLine(Pens.DarkGray, x, Height - _arrowBase, x, Height);
}
if (PlaybackEndTime.HasValue) {
// end arrow (faces right) |>|
int x = (int) timeToPixels(PlaybackEndTime.Value);
g.FillPolygon(Brushes.DarkGray, new Point[]
{
new Point(x, Height - _arrowBase/2), // right mid point
new Point(x - _arrowLength, Height - _arrowBase), // left top point
new Point(x - _arrowLength, Height) // left bottom point
});
g.DrawLine(Pens.DarkGray, x, Height - _arrowBase, x, Height);
}
if (PlaybackStartTime.HasValue && PlaybackEndTime.HasValue) {
// line between the two
using (Pen p = new Pen(Color.DarkGray)) {
p.Width = 4;
int x1 = (int) timeToPixels(PlaybackStartTime.Value) + _arrowLength;
int x2 = (int) timeToPixels(PlaybackEndTime.Value) - _arrowLength;
int y = Height - _arrowBase/2;
g.DrawLine(p, x1, y, x2, y);
}
}
g.Restore(gstate);
}
// Current position arrow
if (PlaybackCurrentTime.HasValue) {
int x = (int) timeToPixels(PlaybackCurrentTime.Value);
g.FillPolygon(Brushes.Green, new Point[]
{
new Point(x, _arrowLength), // bottom mid point
new Point(x - _arrowBase/2, 0), // top left point
new Point(x + _arrowBase/2, 0), // top right point
});
}
}
public override void OnDraw(System.Drawing.Graphics g)
{
SizeF sizeS = g.MeasureString(sybmol, ftSymbol);
SizeF sizeFunction = this[0].CalculateDrawSize(g);
this[1].IsSuperscript = true;
SizeF sizeIndex = this[1].CalculateDrawSize(g);
this[2].IsSuperscript = true;
SizeF sizeBegin = this[2].CalculateDrawSize(g);
this[3].IsSuperscript = true;
SizeF sizeEnd = this[3].CalculateDrawSize(g);
SizeF sizeEq = g.MeasureString("=", root.FontSuperscript);
//
float w0 = sizeIndex.Width + sizeEq.Width + sizeBegin.Width;
float w1 = w0;
if (w1 < sizeS.Width)
{
w1 = sizeS.Width;
}
if (w1 < sizeEnd.Width)
{
w1 = sizeEnd.Width;
}
float w = sizeFunction.Width + w1;
float h1 = sizeIndex.Height;
if (h1 < sizeEq.Height)
{
h1 = sizeEq.Height;
}
if (h1 < sizeBegin.Height)
{
h1 = sizeBegin.Height;
}
float h2 = h1 + sizeS.Height + sizeEnd.Height;
float h = sizeFunction.Height;
if (h < h2)
{
h = h2;
}
//
float x = 0;
if (sizeEnd.Width < w1)
{
x = (w1 - sizeEnd.Width) / (float)2;
}
if (IsFocused)
{
g.FillRectangle(this.TextBrushBKFocus0, new Rectangle(0, 0, (int)w, (int)h));
}
System.Drawing.Drawing2D.GraphicsState gt = g.Save();
g.TranslateTransform(x, 0);
this[3].Position = new Point(this.Position.X + (int)x, Position.Y);
this[3].Draw(g);
g.Restore(gt);
//
x = 0;
if (sizeS.Width < w1)
{
x = (w1 - sizeS.Width) / (float)2;
}
float y = sizeEnd.Height;
if (IsFocused)
{
g.FillRectangle(this.TextBrushBKFocus, new Rectangle((int)x, (int)y, (int)sizeS.Width, (int)sizeS.Height));
g.DrawString(sybmol, ftSymbol, TextBrushFocus, x, y);
}
else
{
g.DrawString(sybmol, ftSymbol, TextBrush, x, y);
}
//
x = 0;
if (w0 < w1)
{
x = (w1 - w0) / (float)2;
}
float y1 = y + sizeS.Height;
y = y1;
if (sizeIndex.Height < (h - y1))
{
y = y1 + ((h - y1) - sizeIndex.Height) / (float)2;
}
gt = g.Save();
g.TranslateTransform(x, y);
this[1].Position = new Point(this.Position.X + (int)x, Position.Y + (int)y);
this[1].Draw(g);
g.Restore(gt);
//
x = x + sizeIndex.Width;
y = y1;
if (sizeEq.Height < (h - y1))
{
y = y1 + ((h - y1) - sizeEq.Height) / (float)2;
}
g.DrawString("=", root.FontSuperscript, TextBrush, x, y);
//
x = x + sizeEq.Width;
y = y1;
if (sizeBegin.Height < (h - y1))
{
y = y1 + ((h - y1) - sizeBegin.Height) / (float)2;
}
gt = g.Save();
g.TranslateTransform(x, y);
this[2].Position = new Point(this.Position.X + (int)x, Position.Y + (int)y);
this[2].Draw(g);
g.Restore(gt);
//
x = w1;
y = 0;
if (sizeFunction.Height < h)
{
y = (h - sizeFunction.Height) / (float)2;
}
gt = g.Save();
g.TranslateTransform(x, y);
this[0].Position = new Point(this.Position.X + (int)x, Position.Y + (int)y);
this[0].Draw(g);
g.Restore(gt);
}
protected void PaintTransparentBackground(Graphics graphics, Rectangle clipRect)
{
graphics.Clear(Color.Transparent);
if ((Parent != null)) {
clipRect.Offset(Location);
PaintEventArgs e = new PaintEventArgs(graphics, clipRect);
GraphicsState state = graphics.Save();
graphics.SmoothingMode = SmoothingMode.HighSpeed;
try {
graphics.TranslateTransform(-Location.X, -Location.Y);
InvokePaintBackground(Parent, e);
InvokePaint(Parent, e);
} finally {
graphics.Restore(state);
clipRect.Offset(-Location.X, -Location.Y);
}
}
}
public void DrawTextField(Graphics g, Rectangle rect, string text, Font font, Color textColor, Color backColor, TextBoxState state, TextBoxStyle style, int scroll = 0, int cursorPos = -1, int selLength = 0)
{
if (rect.Width < 4 || rect.Height < 4) return;
GraphicsState oldState = g.Save();
// Draw Background
Rectangle textRect = DrawTextBoxBorder(g, rect, state, style, backColor);
Rectangle textRectScrolled = new Rectangle(
textRect.X - scroll,
textRect.Y,
textRect.Width + scroll,
textRect.Height);
if (text == null) return;
RectangleF clipRect = g.ClipBounds;
clipRect = textRect;
g.SetClip(clipRect);
// Draw Selection
if ((state & TextBoxState.Focus) == TextBoxState.Focus && cursorPos >= 0 && selLength != 0)
{
int selPos = Math.Min(cursorPos + selLength, cursorPos);
CharacterRange[] charRanges = new [] { new CharacterRange(selPos, Math.Abs(selLength)) };
Region[] charRegions = MeasureStringLine(g, text, charRanges, font, textRectScrolled);
RectangleF selectionRect = charRegions.Length > 0 ? charRegions[0].GetBounds(g) : RectangleF.Empty;
selectionRect.Inflate(0, 2);
selectionRect.Y += GetFontYOffset(font);
if (selPos == 0)
{
selectionRect.X -= 2;
selectionRect.Width += 2;
}
if (selPos + Math.Abs(selLength) == text.Length)
{
selectionRect.Width += 2;
}
if ((state & TextBoxState.ReadOnlyFlag) == TextBoxState.ReadOnlyFlag)
g.FillRectangle(new SolidBrush(Color.FromArgb(128, this.ColorGrayText)), selectionRect);
else
g.FillRectangle(new SolidBrush(Color.FromArgb(128, this.ColorHightlight)), selectionRect);
}
// Draw Text
if ((state & TextBoxState.Disabled) == TextBoxState.Disabled ||
(state & TextBoxState.ReadOnlyFlag) == TextBoxState.ReadOnlyFlag)
textColor = Color.FromArgb(128, textColor);
DrawStringLine(g, text, font, textRectScrolled, textColor);
// Draw Cursor
if ((state & TextBoxState.ReadOnlyFlag) != TextBoxState.ReadOnlyFlag && cursorPos >= 0 && selLength == 0)
{
CharacterRange[] charRanges = new [] { new CharacterRange(0, cursorPos) };
Region[] charRegions = MeasureStringLine(g, text, charRanges, font, textRectScrolled);
RectangleF textRectUntilCursor = charRegions.Length > 0 ? charRegions[0].GetBounds(g) : RectangleF.Empty;
int curPixelPos = textRectScrolled.X + (int)textRectUntilCursor.Width + 2;
DrawCursor(g, new Rectangle(curPixelPos, textRectScrolled.Top + 1, 1, textRectScrolled.Height - 2));
}
g.Restore(oldState);
}
/// <summary>
/// Paint the shape group in the graphic context.
/// </summary>
/// <param name="g">Graphic context.</param>
/// <param name="paintContext">The paint context.</param>
public override void Paint(Graphics g, IPaintContext paintContext)
{
GraphicsState gs = g.Save();
this.TransformGraphics(g);
foreach (GraphicBase graphics in _groupedObjects)
graphics.Paint(g, paintContext);
g.Restore(gs);
}
public void DrawComboButton(Graphics g, Rectangle rect, ButtonState state, string text, Image icon = null)
{
if (rect.Width < 8 + dropDownIcon.Width || rect.Height < 4) return;
GraphicsState graphicsState = g.Save();
DrawButtonBackground(g, rect, state);
Rectangle innerRect = new Rectangle(rect.X + 1, rect.Y + 1, rect.Width - 2, rect.Height - 2);
Color colorText;
if (state == ButtonState.Disabled)
colorText = this.ColorGrayText;
else
colorText = this.ColorText;
Rectangle dropDownIconRect = new Rectangle(
innerRect.Right - dropDownIcon.Width - 4,
innerRect.Y + innerRect.Height / 2 - dropDownIcon.Height / 2,
dropDownIcon.Width,
dropDownIcon.Height);
innerRect = new Rectangle(innerRect.X + 2, innerRect.Y, innerRect.Width - dropDownIconRect.Width - 6, innerRect.Height);
Image stateDropDownIcon = dropDownIcon.Normal;
if (state == ButtonState.Disabled) stateDropDownIcon = dropDownIcon.Disabled;
g.DrawImageUnscaled(stateDropDownIcon, dropDownIconRect.Location);
RectangleF clipRect = innerRect;
clipRect.Intersect(g.ClipBounds);
g.SetClip(clipRect);
if (icon == null && !string.IsNullOrEmpty(text))
{
DrawStringLine(g, text, this.DefaultFont, innerRect, colorText);
}
else if (string.IsNullOrEmpty(text))
{
Rectangle iconRect;
iconRect = new Rectangle(
innerRect.X + innerRect.Width / 2 - icon.Width / 2,
innerRect.Y + innerRect.Height / 2 - icon.Height / 2,
icon.Width,
icon.Height);
g.DrawImageUnscaled(icon, iconRect);
}
else
{
Region[] charRegions = MeasureStringLine(g, text, new [] { new CharacterRange(0, text.Length) }, this.DefaultFont, innerRect);
SizeF textSize = charRegions[0].GetBounds(g).Size;
Size iconTextSize;
Rectangle textRect;
Rectangle iconRect;
iconTextSize = new Size(icon.Width + (int)textSize.Width, innerRect.Height);
iconRect = new Rectangle(
innerRect.X,
innerRect.Y + innerRect.Height / 2 - icon.Height / 2,
icon.Width,
icon.Height);
textRect = new Rectangle(
iconRect.Right,
innerRect.Y,
innerRect.Width - iconRect.Width,
innerRect.Height);
g.DrawImageUnscaled(icon, iconRect);
DrawStringLine(g, text, this.DefaultFont, textRect, colorText);
}
g.Restore(graphicsState);
}
public void DrawEan13Barcode(System.Drawing.Graphics g, System.Drawing.Point pt)
{
float width = this.Width * this.Scale;
float height = this.Height * this.Scale;
// EAN13 Barcode should be a total of 113 modules wide.
float lineWidth = width / 113f;
// Save the GraphicsState.
System.Drawing.Drawing2D.GraphicsState gs = g.Save();
// Set the PageUnit to Inch because all of our measurements are in inches.
g.PageUnit = System.Drawing.GraphicsUnit.Millimeter;
// Set the PageScale to 1, so a millimeter will represent a true millimeter.
g.PageScale = 1;
System.Drawing.SolidBrush brush = new System.Drawing.SolidBrush(System.Drawing.Color.Black);
float xPosition = 0;
System.Text.StringBuilder strbEAN13 = new System.Text.StringBuilder();
System.Text.StringBuilder sbTemp = new System.Text.StringBuilder();
float xStart = pt.X;
float yStart = pt.Y;
float xEnd = 0;
System.Drawing.Font font = new System.Drawing.Font("Arial", this._fFontSize * this.Scale);
// Calculate the Check Digit.
this.CalculateChecksumDigit();
sbTemp.AppendFormat("{0}{1}{2}{3}",
this.CountryCode,
this.ManufacturerCode,
this.ProductCode,
this.ChecksumDigit);
string sTemp = sbTemp.ToString();
string sLeftPattern = "";
// Convert the left hand numbers.
sLeftPattern = ConvertLeftPattern(sTemp.Substring(0, 7));
// Build the UPC Code.
strbEAN13.AppendFormat("{0}{1}{2}{3}{4}{1}{0}",
this._sQuiteZone, this._sLeadTail,
sLeftPattern,
this._sSeparator,
ConvertToDigitPatterns(sTemp.Substring(7), this._aRight));
string sTempUPC = strbEAN13.ToString();
float fTextHeight = g.MeasureString(sTempUPC, font).Height;
// Draw the barcode lines.
for (int i = 0; i < strbEAN13.Length; i++)
{
if (sTempUPC.Substring(i, 1) == "1")
{
if (xStart == pt.X)
{
xStart = xPosition;
}
// Save room for the UPC number below the bar code.
if ((i > 12 && i < 55) || (i > 57 && i < 101))
{
// Draw space for the number
g.FillRectangle(brush, xPosition, yStart, lineWidth, height - fTextHeight);
}
else
{
// Draw a full line.
g.FillRectangle(brush, xPosition, yStart, lineWidth, height);
}
}
xPosition += lineWidth;
xEnd = xPosition;
}
// Draw the upc numbers below the line.
xPosition = xStart - g.MeasureString(this.CountryCode.Substring(0, 1), font).Width;
float yPosition = yStart + (height - fTextHeight);
// Draw 1st digit of the country code.
g.DrawString(sTemp.Substring(0, 1), font, brush, new System.Drawing.PointF(xPosition, yPosition));
xPosition += (g.MeasureString(sTemp.Substring(0, 1), font).Width + 43 * lineWidth) -
(g.MeasureString(sTemp.Substring(1, 6), font).Width);
// Draw MFG Number.
g.DrawString(sTemp.Substring(1, 6), font, brush, new System.Drawing.PointF(xPosition, yPosition));
xPosition += g.MeasureString(sTemp.Substring(1, 6), font).Width + (11 * lineWidth);
// Draw Product ID.
g.DrawString(sTemp.Substring(7), font, brush, new System.Drawing.PointF(xPosition, yPosition));
// Restore the GraphicsState.
g.Restore(gs);
}
// TODO: Correctly Draw the Slide Annotation
private void DrawSlide(DeckTraversalModel traversal, int index, System.Drawing.Rectangle rect, System.Drawing.Graphics buffer)
{
// Save the old state
System.Drawing.Drawing2D.GraphicsState oldState;
using (Synchronizer.Lock(traversal.SyncRoot)) {
using (Synchronizer.Lock(traversal.Deck.SyncRoot)) {
using (Synchronizer.Lock(traversal.Deck.TableOfContents.SyncRoot)) {
TableOfContentsModel.Entry entry = traversal.Deck.TableOfContents.Entries[index];
using (Synchronizer.Lock(entry.Slide.SyncRoot)) {
//Draw the background color
//First see if there is a Slide BG, if not, try the Deck. Otherwise, use transparent.
if (entry.Slide.BackgroundColor != Color.Empty)
{
buffer.FillRectangle(new System.Drawing.SolidBrush(entry.Slide.BackgroundColor), rect);
}
else if (traversal.Deck.DeckBackgroundColor != Color.Empty)
{
buffer.FillRectangle(new System.Drawing.SolidBrush(traversal.Deck.DeckBackgroundColor), rect);
}
else
{
buffer.FillRectangle(new System.Drawing.SolidBrush(Color.Transparent), rect);
}
//Draw the background Template
if (entry.Slide.BackgroundTemplate != null)
{
using (BackgroundTemplateRenderer render = new BackgroundTemplateRenderer(entry.Slide.BackgroundTemplate)) {
render.Zoom = entry.Slide.Zoom;
render.DrawAll(buffer, rect);
}
}
//Get the Slide content and draw it
oldState = buffer.Save();
Model.Presentation.SlideModel.SheetCollection sheets = entry.Slide.ContentSheets;
for (int i = 0; i < sheets.Count; i++)
{
SlideDisplayModel display = new SlideDisplayModel(buffer, null);
Rectangle slide = rect;
float zoom = 1f;
if (entry.Slide != null)
{
slide = entry.Slide.Bounds;
zoom = entry.Slide.Zoom;
}
System.Drawing.Drawing2D.Matrix pixel, ink;
display.FitSlideToBounds(System.Windows.Forms.DockStyle.Fill, rect, zoom, ref slide, out pixel, out ink);
using (Synchronizer.Lock(display.SyncRoot)) {
display.Bounds = slide;
display.PixelTransform = pixel;
display.InkTransform = ink;
}
Viewer.Slides.SheetRenderer r = Viewer.Slides.SheetRenderer.ForStaticSheet(display, sheets[i]);
r.Paint(new System.Windows.Forms.PaintEventArgs(buffer, rect));
r.Dispose();
}
//Restore the Old State
buffer.Restore(oldState);
oldState = buffer.Save();
//Get the Annotation content and draw it
sheets = entry.Slide.AnnotationSheets;
for (int i = 0; i < sheets.Count; i++)
{
SlideDisplayModel display = new SlideDisplayModel(buffer, null);
Rectangle slide = rect;
float zoom = 1f;
if (entry.Slide != null)
{
slide = entry.Slide.Bounds;
zoom = entry.Slide.Zoom;
}
System.Drawing.Drawing2D.Matrix pixel, ink;
display.FitSlideToBounds(System.Windows.Forms.DockStyle.Fill, rect, zoom, ref slide, out pixel, out ink);
using (Synchronizer.Lock(display.SyncRoot)) {
display.Bounds = slide;
display.PixelTransform = pixel;
display.InkTransform = ink;
}
Viewer.Slides.SheetRenderer r = Viewer.Slides.SheetRenderer.ForStaticSheet(display, sheets[i]);
if (r is Viewer.Slides.InkSheetRenderer)
{
((Viewer.Slides.InkSheetRenderer)r).Paint(buffer, rect);
}
else
{
r.Paint(new System.Windows.Forms.PaintEventArgs(buffer, rect));
}
r.Dispose();
}
//Restore the Old State
buffer.Restore(oldState);
/*
* Microsoft.Ink.Renderer renderer = new Microsoft.Ink.Renderer();
* for( int i = 0; i < sheets.Count; i++ ) {
* SheetModel sm = sheets[i];
* if( sm is InkSheetModel ) {
* InkSheetModel ism = sm as InkSheetModel;
* using( Synchronizer.Lock( ism.SyncRoot ) ) {
* foreach( Microsoft.Ink.Stroke stroke in ism.Ink.Strokes ) {
* renderer.Draw( buffer, stroke );
* }
* }
* } else if( sm is TextSheetModel ) {
* TextSheetModel tsm = sm as TextSheetModel;
* using( Synchronizer.Lock( tsm.SyncRoot ) ) {
* buffer.DrawString( tsm.Text, tsm.Font, new SolidBrush( tsm.Color ), tsm.Bounds );
* }
* } else if( sm is ImageSheetModel ) {
* //add any images in the AnnotationSheets
* ImageSheetModel image_sheet_model = (ImageSheetModel)sm;
* using( Synchronizer.Lock( image_sheet_model.SyncRoot ) ) {
* buffer.DrawImage( image_sheet_model.Image, image_sheet_model.Bounds );
* }
* } else {
* //Unknown, skip it
* continue;
* }
* }
*/
}
}
}
}
}
private void AddLabels(Graphics g)
{
float xOffset = ChartArea.Width / 30.0f;
float yOffset = ChartArea.Height / 30.0f;
SizeF labelFontSize = g.MeasureString("A", LabelFont);
SizeF titleFontSize = g.MeasureString("A", TitleFont);
// Add horizontal axis label:
SolidBrush aBrush = new SolidBrush(LabelFontColor);
SizeF stringSize = g.MeasureString(XLabel, LabelFont);
g.DrawString(XLabel, LabelFont, aBrush,
new Point(form1.PlotPanel.Left + form1.PlotPanel.Width / 2 -
(int)stringSize.Width / 2, ChartArea.Bottom -
(int)yOffset - (int)labelFontSize.Height));
// Add y-axis label:
StringFormat sFormat = new StringFormat();
sFormat.Alignment = StringAlignment.Center;
stringSize = g.MeasureString(YLabel, LabelFont);
// Save the state of the current Graphics object
GraphicsState gState = g.Save();
g.TranslateTransform(ChartArea.X + xOffset, ChartArea.Y
+ yOffset + titleFontSize.Height
+ yOffset / 3 + form1.PlotPanel.Height / 2);
g.RotateTransform(-90);
g.DrawString(YLabel, LabelFont, aBrush, 0, 0, sFormat);
// Restore it:
g.Restore(gState);
// Add title:
aBrush = new SolidBrush(TitleFontColor);
stringSize = g.MeasureString(Title, TitleFont);
if (Title.ToUpper() != "NO TITLE")
{
g.DrawString(Title, TitleFont, aBrush,
new Point(form1.PlotPanel.Left + form1.PlotPanel.Width / 2 -
(int)stringSize.Width / 2, ChartArea.Top + (int)yOffset));
}
aBrush.Dispose();
}
public override void OnDraw(System.Drawing.Graphics g)
{
string s = methodDisplayName;
string s1, s2;
if (isArrayMethod)
{
s1 = "[";
s2 = "]";
}
else
{
s1 = "(";
s2 = ")";
}
SizeF size0 = g.MeasureString(s, TextFont);
SizeF size1 = g.MeasureString(s1, TextFont);
SizeF size2 = g.MeasureString(",", TextFont);
float w = DrawSize.Width;
float h = DrawSize.Height;
float y, x = 0;
if (IsFocused)
{
g.FillRectangle(TextBrushBKFocus0, (float)0, (float)0, w, h);
g.FillRectangle(TextBrushBKFocus, (float)0, (float)0, size0.Width + size1.Width, h);
y = 0;
if (size0.Height < h)
{
y = (h - size0.Height) / (float)2;
}
g.DrawString(s, TextFont, TextBrushFocus, x, y);
x = size0.Width;
y = 0;
if (size1.Height < h)
{
y = (h - size1.Height) / (float)2;
}
g.DrawString(s1, TextFont, TextBrushFocus, x, y);
}
else
{
y = 0;
if (size0.Height < h)
{
y = (h - size0.Height) / (float)2;
}
g.DrawString(s, TextFont, TextBrush, x, y);
x = size0.Width;
y = 0;
if (size1.Height < h)
{
y = (h - size1.Height) / (float)2;
}
g.DrawString(s1, TextFont, TextBrush, x, y);
}
x = size0.Width + size1.Width;
int n = ChildNodeCount;
for (int i = 0; i < n; i++)
{
this[i].CalculateDrawSize(g);
if (i > 0)
{
if (IsFocused)
{
g.FillRectangle(TextBrushBKFocus, x, (float)0, size2.Width, h);
g.DrawString(",", TextFont, TextBrushFocus, x, h - size2.Height);
}
else
{
g.DrawString(",", TextFont, TextBrush, x, h - size2.Height);
}
x = x + size2.Width;
}
y = h - this[i].DrawSize.Height;
System.Drawing.Drawing2D.GraphicsState gt = g.Save();
g.TranslateTransform(x, y);
this[i].Position = new Point(this.Position.X + (int)x, Position.Y + (int)y);
this[i].Draw(g);
g.Restore(gt);
x = x + this[i].DrawSize.Width;
}
//
y = 0;
if (size1.Height < h)
{
y = (h - size1.Height) / (float)2;
}
if (IsFocused)
{
g.FillRectangle(TextBrushBKFocus, x, (float)0, size1.Width, h);
g.DrawString(s2, TextFont, TextBrushFocus, x, y);
}
else
{
g.DrawString(s2, TextFont, TextBrush, x, y);
}
}
public override void OnDraw(System.Drawing.Graphics g)
{
SizeF size0 = this[0].CalculateDrawSize(g);
SizeF sizeS = g.MeasureString(";", TextFont);
SizeF size1 = this[1].CalculateDrawSize(g);
float w = size0.Width + sizeS.Width + size1.Width;
float h = size0.Height;
if (h < sizeS.Height)
{
h = sizeS.Height;
}
if (h < size1.Height)
{
h = size1.Height;
}
if (IsFocused)
{
g.FillRectangle(TextBrushBKFocus0, (float)0, (float)0, w, h);
}
float x = 0;
float y = 0;
if (size0.Height < h)
{
y = (h - size0.Height) / (float)2;
}
System.Drawing.Drawing2D.GraphicsState gt = g.Save();
g.TranslateTransform(x, y);
this[0].Position = new Point(this.Position.X + (int)x, Position.Y + (int)y);
this[0].Draw(g);
g.Restore(gt);
x = size0.Width;
if (sizeS.Height < h)
{
y = (h - sizeS.Height) / (float)2;
}
else
{
y = 0;
}
if (IsFocused)
{
g.FillRectangle(TextBrushBKFocus, x, (float)0, sizeS.Width, h);
g.DrawString(";", TextFont, TextBrushFocus, x, y);
}
else
{
g.DrawString(";", TextFont, TextBrush, x, y);
}
x = x + sizeS.Width;
if (size1.Height < h)
{
y = (h - size1.Height) / (float)2;
}
else
{
y = 0;
}
gt = g.Save();
g.TranslateTransform(x, y);
this[1].Position = new Point(this.Position.X + (int)x, Position.Y + (int)y);
this[1].Draw(g);
g.Restore(gt);
}
public override void OnDraw(System.Drawing.Graphics g)
{
int n = Branches;
float w = DrawSize.Width;
float h = DrawSize.Height;
SizeF sizeB = g.MeasureString(symbol, ftBrace);
float x = 0;
float y;
if (sizeB.Height < h)
{
y = (h - sizeB.Height) / (float)2;
}
else
{
y = 0;
}
if (IsFocused)
{
g.FillRectangle(TextBrushBKFocus0, (float)0, (float)0, w, h);
g.FillRectangle(TextBrushBKFocus, (float)0, (float)0, sizeB.Width, h);
g.DrawString(symbol, ftBrace, TextBrushFocus, x, y);
}
else
{
g.DrawString(symbol, ftBrace, TextBrush, x, y);
}
x = sizeB.Width;
y = 0;
if (nContentHeight < h)
{
y = (h - nContentHeight) / (float)2;
}
System.Drawing.Drawing2D.GraphicsState gt;
for (int i = 0; i < n; i++)
{
SizeF size = this[i].CalculateDrawSize(g);
gt = g.Save();
g.TranslateTransform(x, y);
this[i].Position = new Point(this.Position.X + (int)x, Position.Y + (int)y);
this[i].Draw(g);
g.Restore(gt);
y = y + size.Height;
}
SizeF size01 = g.MeasureString("default; ", TextFont);
if (IsFocused)
{
g.FillRectangle(TextBrushBKFocus, x, y, size01.Width, size01.Height);
g.DrawString("default; ", TextFont, TextBrushFocus, x, y);
}
else
{
g.DrawString("default; ", TextFont, TextBrush, x, y);
}
x = x + size01.Width;
gt = g.Save();
g.TranslateTransform(x, y);
this[n].Position = new Point(this.Position.X + (int)x, Position.Y + (int)y);
this[n].Draw(g);
g.Restore(gt);
}