protected override Size MeasureContents(ElementRenderData renderData)
{
if (this._image != null)
{
return this._image.Size;
}
return Size.Empty;
}
protected override Size Measure(ElementRenderData renderData)
{
Size size = base.Measure(renderData);
if ((this._width != 0) && (this._width > size.Width))
{
size = new Size(this._width, size.Height);
}
return size;
}
protected override void RenderForeground(ElementRenderData renderData)
{
if (this._thickness > 0)
{
Point location = this.ContentBounds.Location;
int dy = ((this.ContentBounds.Height - this._thickness) / 2) + 1;
location.Offset(0, dy);
Pen pen = new Pen(renderData.ForeColor, (float) this._thickness);
renderData.Graphics.DrawLine(pen, location.X, location.Y, location.X + this.ContentBounds.Width, location.Y);
pen.Dispose();
}
}
protected override Size Measure(ElementRenderData renderData)
{
int num = (int) (1.5 * renderData.FontSize);
return new Size(1, num + this._thickness);
}
protected override Size Measure(ElementRenderData renderData)
{
return new Size(0, 1);
}
public virtual Size CreateLayout(ElementRenderData renderData, Point offset, Size initialMaxSize)
{
int num = this._padding.Top + offset.Y;
int num2 = this._padding.Left + offset.X;
int width = initialMaxSize.Width;
int y = num;
int count = this.Elements.Count;
int num6 = 0;
for (int i = 0; i < count; i++)
{
SectionElement element = this.Elements[i];
if (element.Visible)
{
bool flag = false;
int height = 0;
int indentation = element.Indentation;
int x = num2 + indentation;
RenderedElements renderedElements = element.RenderedElements;
int num11 = renderedElements.Count;
if (num11 != 0)
{
ArrayList list = new ArrayList();
int num12 = -1;
bool flag2 = true;
for (int j = 0; j < num11; j++)
{
VisualElement element2 = renderedElements[j];
element2.SetBounds(Rectangle.Empty);
if (element2.Visible)
{
renderData.SetFontFamily(element2.GetFontFamily());
renderData.SetFontSize(element2.GetFontSize());
renderData.SetFontStyle(element2.GetFontStyle());
Size size = element2.GetSize(renderData);
if (!flag2 && ((element2.LayoutMode & LayoutMode.LineBreakBefore) != LayoutMode.Flow))
{
x = num2 + indentation;
y += height;
height = 0;
flag2 = true;
}
if (flag2)
{
if (num12 != -1)
{
list.Add(num12);
}
num12 = j;
}
if (element2.SizeMode == SizeMode.StretchHorizontal)
{
if (!flag2 && (size.Height != height))
{
flag = true;
}
if (size.Height > height)
{
height = size.Height;
}
Point location = new Point(x, y);
Size size2 = new Size((width - x) - this._padding.Right, height);
element2.SetBounds(new Rectangle(location, size2));
}
else
{
if ((x + size.Width) > (width - this._padding.Right))
{
if (element.AllowWrap && !flag2)
{
x = num2 + indentation;
y += height;
height = 0;
list.Add(num12);
flag2 = true;
}
else
{
y = num;
width = (x + size.Width) + this._padding.Right;
height = 0;
if (this._host != null)
{
this._host.ClearTrackedElements();
}
i = -1;
break;
}
}
if (flag2 && element2.IsEmpty)
{
goto Label_02BD;
}
element2.SetBounds(new Rectangle(new Point(x, y), size));
if (!flag2 && (size.Height != height))
{
flag = true;
}
x += size.Width;
if (size.Height > height)
{
height = size.Height;
}
flag2 = false;
}
if ((this._host != null) && (element2.RequiresTracking || element2.Clickable))
{
this._host.AddTrackedElement(element2);
}
if ((element2.LayoutMode & LayoutMode.LineBreakAfter) != LayoutMode.Flow)
{
x = num2 + indentation;
y += height;
height = 0;
flag2 = true;
}
Label_02BD:;
}
}
list.Add(num11);
if (flag)
{
int num14 = -1;
for (int k = 0; k < list.Count; k++)
{
int num16 = num14 + 1;
num14 = (int) list[k];
bool flag3 = false;
int num17 = 0;
bool flag4 = true;
for (int m = num16; m < num14; m++)
{
Rectangle bounds = renderedElements[m].Bounds;
if (!bounds.IsEmpty)
{
int num19 = bounds.Height;
if (!flag4 && (num19 != num17))
{
flag3 = true;
}
if (num19 > num17)
{
num17 = num19;
}
flag4 = false;
}
}
if (flag3)
{
for (int n = num16; n < num14; n++)
{
VisualElement element3 = renderedElements[n];
Rectangle rectangle2 = element3.Bounds;
if (!rectangle2.IsEmpty)
{
int num21 = ((num17 - rectangle2.Height) + 1) / 2;
if (num21 != 0)
{
element3.SetBounds(new Rectangle(rectangle2.Left, rectangle2.Top + num21, rectangle2.Width, rectangle2.Height));
element3.SetOuterBounds(new Rectangle(rectangle2.Left, rectangle2.Top, rectangle2.Width, num17));
}
}
}
}
}
}
}
else
{
if (num6 == 0)
{
Font font = null;
if (this._host != null)
{
font = this._host.Font;
}
if (font != null)
{
num6 = renderData.Graphics.MeasureString(" ", font).ToSize().Height;
}
else
{
num6 = 10;
}
}
height = num6;
}
y += height;
}
}
return new Size(width, y + this._padding.Bottom);
}
public virtual void CreateRendering(ElementRenderData renderData, Point offset, Point canvasExtent)
{
foreach (SectionElement element in this.Elements)
{
if (element.Visible)
{
RenderedElements renderedElements = element.RenderedElements;
int count = renderedElements.Count;
if (renderedElements.Count != 0)
{
for (int i = 0; i < count; i++)
{
VisualElement element2 = renderedElements[i];
Rectangle bounds = element2.Bounds;
if (!bounds.IsEmpty)
{
bounds.Offset(offset);
if ((bounds.Bottom >= 0) || (bounds.Top <= canvasExtent.Y))
{
renderData.SetFontFamily(element2.GetFontFamily());
renderData.SetFontSize(element2.GetFontSize());
renderData.SetFontStyle(element2.GetFontStyle());
renderData.SetBackColor(element2.GetBackColor());
renderData.SetForeColor(element2.GetForeColor());
element2.Render(renderData);
}
}
}
}
}
}
}
protected virtual void RenderBackground(ElementRenderData renderData)
{
Brush backColorBrush = renderData.BackColorBrush;
if (backColorBrush != null)
{
renderData.Graphics.FillRectangle(backColorBrush, this.Bounds);
}
}
private Size CalculateRendering(Graphics g)
{
if ((this._page == null) || (this._page.Elements.Count == 0))
{
return Size.Empty;
}
if (this._page.AntiAliasedText)
{
g.TextRenderingHint = TextRenderingHint.SingleBitPerPixel;
g.SmoothingMode = SmoothingMode.AntiAlias;
}
ElementRenderData renderData = new ElementRenderData(g, Point.Empty, false, this._page.AntiAliasedText);
Size empty = Size.Empty;
try
{
empty = this._page.CreateLayout(renderData, Point.Empty, new Size(base.ClientSize.Width, 0));
}
finally
{
if (renderData != null)
{
renderData.Dispose();
renderData = null;
}
}
return empty;
}
public void Render(ElementRenderData renderData)
{
this.RenderBackground(renderData);
this.RenderForeground(renderData);
}
internal void RenderFocusCues(ElementRenderData renderData)
{
Rectangle focusBounds = this.FocusBounds;
if (!focusBounds.IsEmpty)
{
focusBounds.Offset(renderData.ScrollPosition.X, renderData.ScrollPosition.Y);
Interop.RECT r = new Interop.RECT(focusBounds.Left, focusBounds.Top, focusBounds.Right, focusBounds.Bottom);
Interop.DrawFocusRect(renderData.GraphicsHandle, ref r);
}
}
protected override void RenderForeground(ElementRenderData renderData)
{
}
private void GenerateRendering(Graphics g)
{
Rectangle clientRectangle = base.ClientRectangle;
Brush brush = new SolidBrush(this._page.BackColor);
g.FillRectangle(brush, clientRectangle);
brush.Dispose();
Watermark watermark = this._page.Watermark;
if (watermark.Image != null)
{
Image image = watermark.Image;
Size size = image.Size;
Point empty = Point.Empty;
switch (watermark.Placement)
{
case WatermarkPlacement.TopRight:
empty = new Point(clientRectangle.Width - size.Width, 0);
break;
case WatermarkPlacement.BottomLeft:
empty = new Point(0, clientRectangle.Height - size.Height);
break;
case WatermarkPlacement.BottomRight:
empty = new Point(clientRectangle.Width - size.Width, clientRectangle.Height - size.Height);
break;
case WatermarkPlacement.Center:
empty = new Point((clientRectangle.Width - size.Width) / 2, (clientRectangle.Height - size.Height) / 2);
break;
}
g.DrawImageUnscaled(image, empty);
}
Point autoScrollPosition = base.AutoScrollPosition;
ElementRenderData renderData = null;
g.TranslateTransform((float) autoScrollPosition.X, (float) autoScrollPosition.Y);
try
{
if (this._page.AntiAliasedText)
{
g.TextRenderingHint = TextRenderingHint.AntiAlias;
g.SmoothingMode = SmoothingMode.AntiAlias;
}
renderData = new ElementRenderData(g, autoScrollPosition, base.ContainsFocus, this._page.AntiAliasedText);
renderData.SetLinkColor(this._page.LinkColor);
if (renderData.LinkColor.IsEmpty)
{
renderData.SetLinkColor(this.ForeColor);
}
renderData.SetHoverColor(this._page.HoverColor);
if (renderData.HoverColor.IsEmpty)
{
renderData.SetHoverColor(this._page.LinkColor);
}
if (renderData.HoverColor.IsEmpty)
{
renderData.SetHoverColor(this.ForeColor);
}
this._page.CreateRendering(renderData, autoScrollPosition, new Point(0, base.ClientSize.Height));
if (renderData.ShowFocus && (this._focusIndex != -1))
{
VisualElement element = (VisualElement) this._focusableElements[this._focusIndex];
Rectangle bounds = element.Bounds;
if (!bounds.IsEmpty)
{
bounds.Offset(autoScrollPosition);
if ((bounds.Bottom >= 0) && (bounds.Top <= base.ClientSize.Height))
{
element.RenderFocusCues(renderData);
}
}
}
}
finally
{
if (renderData != null)
{
renderData.Dispose();
renderData = null;
}
g.TranslateTransform((float) -autoScrollPosition.X, (float) -autoScrollPosition.Y);
}
}
protected override Size Measure(ElementRenderData renderData)
{
return Size.Empty;
}
protected override Size Measure(ElementRenderData renderData)
{
string text = this.Text;
Size empty = Size.Empty;
if (text.Length != 0)
{
if (renderData.AntiAliasedText)
{
return renderData.Graphics.MeasureString(this.Text, renderData.Font, new PointF(0f, 0f), renderData.TextFormat).ToSize();
}
IntPtr graphicsHandle = renderData.GraphicsHandle;
IntPtr hObject = Interop.SelectObject(graphicsHandle, renderData.FontHandle);
try
{
Interop.SIZE size = new Interop.SIZE();
Interop.GetTextExtentPoint32W(graphicsHandle, text, text.Length, ref size);
empty = new Size(size.x, size.y);
}
finally
{
Interop.SelectObject(graphicsHandle, hObject);
}
}
return empty;
}
protected void RenderText(ElementRenderData renderData, Color textColor)
{
IntPtr graphicsHandle = renderData.GraphicsHandle;
IntPtr hObject = Interop.SelectObject(graphicsHandle, renderData.FontHandle);
int nBkMode = Interop.SetBkMode(graphicsHandle, 1);
int color = Interop.SetTextColor(graphicsHandle, ColorTranslator.ToWin32(textColor));
try
{
Point location = this.ContentBounds.Location;
location.Offset(renderData.ScrollPosition.X, renderData.ScrollPosition.Y);
Interop.RECT lpRect = new Interop.RECT(0, 0, 0, 0);
Interop.ExtTextOut(graphicsHandle, location.X, location.Y, 0, ref lpRect, this.Text, this.Text.Length, null);
}
finally
{
Interop.SelectObject(graphicsHandle, hObject);
Interop.SetBkMode(graphicsHandle, nBkMode);
Interop.SetTextColor(graphicsHandle, color);
}
}
protected void RenderText(ElementRenderData renderData, Brush textBrush)
{
renderData.Graphics.DrawString(this.Text, renderData.Font, textBrush, (PointF) this.ContentBounds.Location, renderData.TextFormat);
}
protected override void RenderForeground(ElementRenderData renderData)
{
if (this.Text.Length != 0)
{
if (renderData.AntiAliasedText)
{
this.RenderText(renderData, renderData.ForeColorBrush);
}
else
{
this.RenderText(renderData, renderData.ForeColor);
}
}
}
protected override void RenderContents(ElementRenderData renderData)
{
if (this._image != null)
{
renderData.Graphics.DrawImageUnscaled(this._image, this.ContentBounds.Location);
}
}
protected override Size Measure(ElementRenderData renderData)
{
Size size = this.MeasureContents(renderData);
return new Size(((size.Width + this.Padding.Left) + this.Padding.Right) + (2 * this.BorderWidth), ((size.Height + this.Padding.Top) + this.Padding.Bottom) + (2 * this.BorderWidth));
}
internal Size GetSize(ElementRenderData renderData)
{
if (!this._sizeCalculated)
{
this._size = this.Measure(renderData);
this._sizeCalculated = true;
}
return this._size;
}
protected abstract void RenderContents(ElementRenderData renderData);
protected abstract Size Measure(ElementRenderData renderData);
protected override void RenderForeground(ElementRenderData renderData)
{
if (this.BorderWidth != 0)
{
Pen pen = new Pen(this.BorderColor, (float) this.BorderWidth);
renderData.Graphics.DrawRectangle(pen, base.ContentBounds);
pen.Dispose();
}
this.RenderContents(renderData);
}
protected virtual void RenderForeground(ElementRenderData renderData)
{
}
protected override void RenderForeground(ElementRenderData renderData)
{
if (base.Text.Length != 0)
{
bool flag = this._active && !this._hoverColor.IsEmpty;
bool flag2 = !this._active && !this._linkColor.IsEmpty;
Color empty = Color.Empty;
if (flag)
{
empty = renderData.HoverColor;
renderData.SetHoverColor(this._hoverColor);
}
else if (flag2)
{
empty = renderData.LinkColor;
renderData.SetLinkColor(this._linkColor);
}
try
{
if (renderData.AntiAliasedText)
{
Brush textBrush = null;
if (this._active)
{
textBrush = renderData.HoverColorBrush;
}
else if (this.ForeColor.IsEmpty)
{
textBrush = renderData.LinkColorBrush;
}
else
{
textBrush = renderData.ForeColorBrush;
}
base.RenderText(renderData, textBrush);
}
else
{
Color linkColor = renderData.LinkColor;
if (this._active)
{
linkColor = renderData.HoverColor;
}
else if (!this.ForeColor.IsEmpty)
{
linkColor = this.ForeColor;
}
base.RenderText(renderData, linkColor);
}
}
finally
{
if (flag)
{
renderData.SetHoverColor(empty);
}
else if (flag2)
{
renderData.SetLinkColor(empty);
}
}
}
}
