public override void MeasureString(string str, RFont font, double maxWidth, out int charFit, out double charFitWidth)
{
charFit = 0;
charFitWidth = 0;
var size = MeasureString(str, font);
for (int i = 1; i <= str.Length; i++)
{
charFit = i - 1;
RSize pSize = MeasureString(str.Substring(0, i), font);
if (pSize.Height <= size.Height && pSize.Width < maxWidth)
{
charFitWidth = pSize.Width;
}
else
{
break;
}
}
}
/// <summary>
/// Measures the bounds of box and children, recursively.
/// </summary>
/// <param name="g">Device context to draw</param>
public void PerformLayout(RGraphics g)
{
ArgChecker.AssertArgNotNull(g, "g");
_actualSize = RSize.Empty;
if (_root != null)
{
// if width is not restricted we set it to large value to get the actual later
_root.Size = new RSize(_maxSize.Width > 0 ? _maxSize.Width : 99999, 0);
_root.Location = _location;
_root.PerformLayout(g);
if (_maxSize.Width <= 0.1)
{
// in case the width is not restricted we need to double layout, first will find the width so second can layout by it (center alignment)
_root.Size = new RSize((int)Math.Ceiling(_actualSize.Width), 0);
_actualSize = RSize.Empty;
_root.PerformLayout(g);
}
}
}
/// <summary>
/// Perform the layout of the html in the control.
/// </summary>
protected override Size MeasureOverride(Size constraint)
{
if (_htmlContainer != null)
{
using (var ig = new GraphicsAdapter())
{
var horizontal = Padding.Left + Padding.Right + BorderThickness.Left + BorderThickness.Right;
var vertical = Padding.Top + Padding.Bottom + BorderThickness.Top + BorderThickness.Bottom;
var size = new RSize(constraint.Width < Double.PositiveInfinity ? constraint.Width - horizontal : 0, constraint.Height < Double.PositiveInfinity ? constraint.Height - vertical : 0);
var minSize = new RSize(MinWidth < Double.PositiveInfinity ? MinWidth - horizontal : 0, MinHeight < Double.PositiveInfinity ? MinHeight - vertical : 0);
var maxSize = new RSize(MaxWidth < Double.PositiveInfinity ? MaxWidth - horizontal : 0, MaxHeight < Double.PositiveInfinity ? MaxHeight - vertical : 0);
var newSize = HtmlRendererUtils.Layout(ig, _htmlContainer.HtmlContainerInt, size, minSize, maxSize, AutoSize, AutoSizeHeightOnly);
constraint = new Size(newSize.Width + horizontal, newSize.Height + vertical);
}
}
return(constraint);
}
/// <summary>
/// Draw play over the iframe if we found link url.
/// </summary>
private void DrawPlay(RGraphics g, RRect rect)
{
if (_isVideo && _imageWord.Width > 70 && _imageWord.Height > 50)
{
var prevMode = g.SetAntiAliasSmoothingMode();
var size = new RSize(60, 40);
var left = rect.Left + (rect.Width - size.Width) / 2;
var top = rect.Top + (rect.Height - size.Height) / 2;
g.DrawRectangle(g.GetSolidBrush(RColor.FromArgb(160, 0, 0, 0)), left, top, size.Width, size.Height);
RPoint[] points =
{
new RPoint(left + size.Width / 3f + 1, top + 3 * size.Height / 4f),
new RPoint(left + size.Width / 3f + 1, top + size.Height / 4f),
new RPoint(left + 2 * size.Width / 3f + 1, top + size.Height / 2f)
};
g.DrawPolygon(g.GetSolidBrush(RColor.White), points);
g.ReturnPreviousSmoothingMode(prevMode);
}
}
public override void MeasureString(string str, RFont font, double maxWidth, out int charFit, out double charFitWidth)
{
charFit = 0;
charFitWidth = 0;
if (_useGdiPlusTextRendering)
{
ReleaseHdc();
var size = MeasureString(str, font);
for (int i = 1; i <= str.Length; i++)
{
charFit = i - 1;
RSize pSize = MeasureString(str.Substring(0, i), font);
if (pSize.Height <= size.Height && pSize.Width < maxWidth)
{
charFitWidth = pSize.Width;
}
else
{
break;
}
}
}
else
{
#if !MONO
SetFont(font);
var size = new Size();
Win32Utils.GetTextExtentExPoint(_hdc, str, str.Length, (int)Math.Round(maxWidth), _charFit, _charFitWidth, ref size);
charFit = _charFit[0];
charFitWidth = charFit > 0 ? _charFitWidth[charFit - 1] : 0;
#endif
}
}
/// <summary>
/// Convert from core point to WPF point.
/// </summary>
public static Size ConvertRound(RSize s)
{
return(new Size((int)s.Width, (int)s.Height));
}
/// <summary>
/// Get top-left location to start drawing the image at depending on background-position value.
/// </summary>
/// <param name="backgroundPosition">the background-position value</param>
/// <param name="rectangle">the rectangle to position image in</param>
/// <param name="imgSize">the size of the image</param>
/// <returns>the top-left location</returns>
private static RPoint GetLocation(string backgroundPosition, RRect rectangle, RSize imgSize)
{
double left = rectangle.Left;
if (backgroundPosition.IndexOf("left", StringComparison.OrdinalIgnoreCase) > -1)
{
left = (rectangle.Left + .5f);
}
else if (backgroundPosition.IndexOf("right", StringComparison.OrdinalIgnoreCase) > -1)
{
left = rectangle.Right - imgSize.Width;
}
else if (backgroundPosition.IndexOf("0", StringComparison.OrdinalIgnoreCase) < 0)
{
left = (rectangle.Left + (rectangle.Width - imgSize.Width) / 2 + .5f);
}
double top = rectangle.Top;
if (backgroundPosition.IndexOf("top", StringComparison.OrdinalIgnoreCase) > -1)
{
top = rectangle.Top;
}
else if (backgroundPosition.IndexOf("bottom", StringComparison.OrdinalIgnoreCase) > -1)
{
top = rectangle.Bottom - imgSize.Height;
}
else if (backgroundPosition.IndexOf("0", StringComparison.OrdinalIgnoreCase) < 0)
{
top = (rectangle.Top + (rectangle.Height - imgSize.Height) / 2 + .5f);
}
return(new RPoint(left, top));
}
/// <summary>
/// Convert from core size to WPF size.
/// </summary>
public static Size Convert(RSize s)
{
return(new Size(s.Width, s.Height));
}
/// <summary>
/// Convert from core size to WinForms size.
/// </summary>
public static Size ConvertRound(RSize s)
{
return(new Size((int)Math.Round(s.Width), (int)Math.Round(s.Height)));
}
/// <summary>
/// Draw the background image at the required location repeating it over the X and Y axis.<br/>
/// Adjust location to left-top if starting location doesn't include all the range (adjusted to center or bottom/right).
/// </summary>
private static void DrawRepeat(RGraphics g, ImageLoadHandler imageLoadHandler, RRect rectangle, RRect srcRect, RRect destRect, RSize imgSize)
{
while (destRect.X > rectangle.X)
{
destRect.X -= imgSize.Width;
}
while (destRect.Y > rectangle.Y)
{
destRect.Y -= imgSize.Height;
}
using (var brush = g.GetTextureBrush(imageLoadHandler.Image, srcRect, destRect.Location))
{
g.DrawRectangle(brush, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height);
}
}
/// <summary>
/// Draw the given string using the given font and foreground color at given location.
/// </summary>
/// <param name="str">the string to draw</param>
/// <param name="font">the font to use to draw the string</param>
/// <param name="color">the text color to set</param>
/// <param name="point">the location to start string draw (top-left)</param>
/// <param name="size">used to know the size of the rendered text for transparent text support</param>
/// <param name="rtl">is to render the string right-to-left (true - RTL, false - LTR)</param>
public override void DrawString(string str, RFont font, RColor color, RPoint point, RSize size, bool rtl)
{
var textSurface = SDL_ttf.TTF_RenderUTF8_Blended(font.ToTTF_Font(), str, color.ToSDL());
if (textSurface.ShowSDLError("Graphics.DrawString: Unable to TTF_RenderUTF8_Blended!"))
{
return;
}
var texture_text = SDL.SDL_CreateTextureFromSurface(_renderer, textSurface);
if (texture_text.ShowSDLError("Graphics.DrawString: Unable to CreateTextureFromSurface!"))
{
SDL.SDL_FreeSurface(textSurface);
return;
}
var dst_rect = textSurface.As <SDL.SDL_Surface>().ToSDL_Rect().UpdatedByRPoint(point);
if (SDL.SDL_RenderCopy(_renderer, texture_text, IntPtr.Zero, ref dst_rect) < 0)
{
Helpers.ShowSDLError("Graphics.DrawString:Unable to SDL_RenderCopy!");
}
SDL.SDL_DestroyTexture(texture_text);
SDL.SDL_FreeSurface(textSurface);
}
public override void DrawString(string str, RFont font, RColor color, RPoint point, RSize size, bool rtl)
{
var xBrush = ((BrushAdapter)this._adapter.GetSolidBrush(color)).Brush;
this._g.DrawString(str, ((FontAdapter)font).Font, (XBrush)xBrush, point.X, point.Y, _stringFormat);
}
/// <summary>
/// Measure the size of the html by performing layout under the given restrictions.
/// </summary>
/// <param name="g">the graphics to use</param>
/// <param name="htmlContainer">the html to calculate the layout for</param>
/// <param name="minSize">the minimal size of the rendered html (zero - not limit the width/height)</param>
/// <param name="maxSize">the maximum size of the rendered html, if not zero and html cannot be layout within the limit it will be clipped (zero - not limit the width/height)</param>
/// <returns>return: the size of the html to be rendered within the min/max limits</returns>
public static RSize MeasureHtmlByRestrictions(RGraphics g, HtmlContainerInt htmlContainer, RSize minSize, RSize maxSize)
{
// first layout without size restriction to know html actual size
htmlContainer.PerformLayout(g);
if (maxSize.Width > 0 && maxSize.Width < htmlContainer.ActualSize.Width)
{
// to allow the actual size be smaller than max we need to set max size only if it is really larger
htmlContainer.MaxSize = new RSize(maxSize.Width, 0);
htmlContainer.PerformLayout(g);
}
// restrict the final size by min/max
var finalWidth = Math.Max(maxSize.Width > 0 ? Math.Min(maxSize.Width, (int)htmlContainer.ActualSize.Width) : (int)htmlContainer.ActualSize.Width, minSize.Width);
// if the final width is larger than the actual we need to re-layout so the html can take the full given width.
if (finalWidth > htmlContainer.ActualSize.Width)
{
htmlContainer.MaxSize = new RSize(finalWidth, 0);
htmlContainer.PerformLayout(g);
}
var finalHeight = Math.Max(maxSize.Height > 0 ? Math.Min(maxSize.Height, (int)htmlContainer.ActualSize.Height) : (int)htmlContainer.ActualSize.Height, minSize.Height);
return(new RSize(finalWidth, finalHeight));
}
/// <summary>
/// Get top-left location to start drawing the image at depending on background-position value.
/// </summary>
/// <param name="backgroundPosition">the background-position value</param>
/// <param name="rectangle">the rectangle to position image in</param>
/// <param name="imgSize">the size of the image</param>
/// <returns>the top-left location</returns>
private static RPoint GetLocation(string backgroundPosition, RRect rectangle, RSize imgSize, CssBox box)
{
double left = rectangle.Left;
double top = rectangle.Top;
if (backgroundPosition.Trim().ToLower() == "inherit")
{
return(new RPoint(left, top));
}
string[] bp = backgroundPosition.Trim().Split(' ');
string lr_str = "";
string tb_str = "";
foreach (var value in bp)
{
var val = value.Trim();
if (val == "")
{
continue;
}
if (lr_str == "")
{
lr_str = val.ToLower();
continue;
}
if (tb_str == "")
{
tb_str = val.ToLower();
continue;
}
//3d word found fallback to (0,0)
return(new RPoint(left, top));
}
if (tb_str == "")
{
tb_str = lr_str;
}
switch (lr_str)
{
case "left": break;
case "right": left = rectangle.Right - imgSize.Width; break;
case "center": left += (rectangle.Width - imgSize.Width) / 2; break;
default: left += CssValueParser.ParseLength(lr_str, rectangle.Width, box); break;
}
switch (tb_str)
{
case "top": break;
case "bottom": top = rectangle.Bottom - imgSize.Height; break;
case "center": top += (rectangle.Height - imgSize.Height) / 2; break;
default: top += CssValueParser.ParseLength(tb_str, rectangle.Height, box); break;
}
return(new RPoint(left, top));
}
/// <summary>
/// Draw the background image of the given box in the given rectangle.<br/>
/// Handle background-repeat and background-position values.
/// </summary>
/// <param name="g">the device to draw into</param>
/// <param name="box">the box to draw its background image</param>
/// <param name="imageLoadHandler">the handler that loads image to draw</param>
/// <param name="rectangle">the rectangle to draw image in</param>
public static void DrawBackgroundImage(RGraphics g, CssBox box, ImageLoadHandler imageLoadHandler, RRect rectangle, RGraphicsPath roundrect = null)
{
// image size depends if specific rectangle given in image loader
var imgSize = new RSize(imageLoadHandler.Rectangle == RRect.Empty ? imageLoadHandler.Image.Width : imageLoadHandler.Rectangle.Width,
imageLoadHandler.Rectangle == RRect.Empty ? imageLoadHandler.Image.Height : imageLoadHandler.Rectangle.Height);
// get the location by BackgroundPosition value
var location = GetLocation(box.BackgroundPosition, rectangle, imgSize, box);
var srcRect = imageLoadHandler.Rectangle == RRect.Empty
? new RRect(0, 0, imgSize.Width, imgSize.Height)
: new RRect(imageLoadHandler.Rectangle.Left, imageLoadHandler.Rectangle.Top, imgSize.Width, imgSize.Height);
// initial image destination rectangle
var destRect = new RRect(location, imgSize);
// need to clip so repeated image will be cut on rectangle
var lRectangle = rectangle;
lRectangle.Intersect(g.GetClip());
g.PushClip(lRectangle);
//rectangle - box to draw in
//imgSize - image size
//localion - inital location of image wo repeat
//destRect - RRect(location, imgSize)
//srcRect (0,0,imgSize)
//brushRect - This is rectangle which needs to be filled with Image from brushRect.Location with brushRect.Size multiple to Image size.
RRect brushRect = new RRect(location, imgSize);
switch (box.BackgroundRepeat)
{
case "no-repeat":
//brushRect = destRect;
break;
case "repeat-x":
if (brushRect.X > rectangle.X)
{
brushRect.X -= imgSize.Width * ((int)((brushRect.X - rectangle.X) / imgSize.Width) + 1);
}
if (brushRect.X + brushRect.Width < rectangle.X + rectangle.Width)
{
brushRect.Width = imgSize.Width * ((int)((rectangle.X + rectangle.Width - brushRect.X) / imgSize.Width) + 1);
}
break;
case "repeat-y":
if (brushRect.Y > rectangle.Y)
{
brushRect.Y -= imgSize.Height * ((int)((brushRect.Y - rectangle.Y) / imgSize.Height) + 1);
}
if (brushRect.Y + brushRect.Height < rectangle.Y + rectangle.Height)
{
brushRect.Height = imgSize.Height * ((int)((rectangle.Y + rectangle.Height - brushRect.Y) / imgSize.Height) + 1);
}
break;
default:
if (brushRect.X > rectangle.X)
{
brushRect.X -= imgSize.Width * ((int)((brushRect.X - rectangle.X) / imgSize.Width) + 1);
}
if (brushRect.X + brushRect.Width < rectangle.X + rectangle.Width)
{
brushRect.Width = imgSize.Width * ((int)((rectangle.X + rectangle.Width - brushRect.X) / imgSize.Width) + 1);
}
if (brushRect.Y > rectangle.Y)
{
brushRect.Y -= imgSize.Height * ((int)((brushRect.Y - rectangle.Y) / imgSize.Height) + 1);
}
if (brushRect.Y + brushRect.Height < rectangle.Y + rectangle.Height)
{
brushRect.Height = imgSize.Height * ((int)((rectangle.Y + rectangle.Height - brushRect.Y) / imgSize.Height) + 1);
}
break;
}
using (var brush = g.GetTextureBrush(imageLoadHandler.Image, brushRect, brushRect.Location))
{
if (roundrect == null)
{
g.DrawRectangle(brush, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height);
}
else
{
g.DrawPath(brush, roundrect);
}
}
g.PopClip();
}
public override void DrawString(string str, RFont font, RColor color, RPoint point, RSize size, bool rtl)
{
if (_useGdiPlusTextRendering)
{
ReleaseHdc();
SetRtlAlignGdiPlus(rtl);
var brush = ((BrushAdapter)_adapter.GetSolidBrush(color)).Brush;
_g.DrawString(str, ((FontAdapter)font).Font, brush, (int)(Math.Round(point.X) + (rtl ? size.Width : 0)), (int)Math.Round(point.Y), _stringFormat2);
}
else
{
#if !MONO
var pointConv = Utils.ConvertRound(point);
var colorConv = Utils.Convert(color);
if (color.A == 255)
{
SetFont(font);
SetTextColor(colorConv);
SetRtlAlignGdi(rtl);
Win32Utils.TextOut(_hdc, pointConv.X, pointConv.Y, str, str.Length);
}
else
{
InitHdc();
SetRtlAlignGdi(rtl);
DrawTransparentText(_hdc, str, font, pointConv, Utils.ConvertRound(size), colorConv);
}
#endif
}
}
public override void DrawString(string str, RFont font, RColor color, RPoint point, RSize size, bool rtl)
{
var pointConv = Utils.ConvertRound(point);
var colorConv = Utils.Convert(color);
if (color.A == 255)
{
// if (GloablRenderSettings.UseBus)
// {
_g.DrawString(str, font,
new BrushAdapter(new SKPaint
{
Style = SKPaintStyle.Fill,
Color = colorConv
}, false),
pointConv.X,
pointConv.Y, StringFormat.GenericTypographic);
// }
// else
// {
// SetFont(font);
// SetTextColor(colorConv);
// SkRendererAdapter.TextOut(_hdc, pointConv.X, pointConv.Y, str, str.Length);
// }
}
}
/// <summary>
/// Draw the background image at the required location repeating it over the Y axis.<br/>
/// Adjust location to top if starting location doesn't include all the range (adjusted to center or bottom).
/// </summary>
private static void DrawRepeatY(RGraphics g, RImage image, RRect rectangle, RRect srcRect, RRect destRect, RSize imgSize)
{
while (destRect.Y > rectangle.Y)
{
destRect.Y -= imgSize.Height;
}
using (var brush = g.GetTextureBrush(image, srcRect, destRect.Location))
{
g.DrawRectangle(brush, destRect.X, rectangle.Y, srcRect.Width, rectangle.Height);
}
}
public override void DrawString(string str, RFont font, RColor color, RPoint point, RSize size, bool rtl)
{
var colorConv = ((BrushAdapter)_adapter.GetSolidBrush(color)).Brush;
bool glyphRendered = false;
GlyphTypeface glyphTypeface = ((FontAdapter)font).GlyphTypeface;
if (glyphTypeface != null)
{
double width = 0;
ushort[] glyphs = new ushort[str.Length];
double[] widths = new double[str.Length];
int i = 0;
for (; i < str.Length; i++)
{
ushort glyph;
if (!glyphTypeface.CharacterToGlyphMap.TryGetValue(str[i], out glyph))
{
break;
}
glyphs[i] = glyph;
width += glyphTypeface.AdvanceWidths[glyph];
widths[i] = 96d / 72d * font.Size * glyphTypeface.AdvanceWidths[glyph];
}
if (i >= str.Length)
{
point.Y += glyphTypeface.Baseline * font.Size * 96d / 72d;
point.X += rtl ? 96d / 72d * font.Size * width : 0;
glyphRendered = true;
var glyphRun = new GlyphRun(glyphTypeface, rtl ? 1 : 0, false, 96d / 72d * font.Size, (float)GetDPI().PixelsPerDip, glyphs, Utils.ConvertRound(point), widths, null, null, null, null, null, null);
_g.DrawGlyphRun(colorConv, glyphRun);
}
}
if (!glyphRendered)
{
var formattedText = new FormattedText(str, CultureInfo.CurrentCulture, rtl ? FlowDirection.RightToLeft : FlowDirection.LeftToRight, ((FontAdapter)font).Font, 96d / 72d * font.Size, colorConv, GetDPI().PixelsPerDip);
point.X += rtl ? formattedText.Width : 0;
_g.DrawText(formattedText, Utils.ConvertRound(point));
}
}
/// <summary>
/// Get size that is max of <paramref name="size"/> and <paramref name="other"/> for width and height separately.
/// </summary>
public static RSize Max(RSize size, RSize other)
{
return(new RSize(Math.Max(size.Width, other.Width), Math.Max(size.Height, other.Height)));
}
public override void DrawString(string str, RFont font, RColor color, RPoint point, RSize size, bool rtl)
{
var text = GetText(str, font);
text.Constraint = Util.Convert(size);
_g.DrawText(new SolidColorBrush(Util.Convert(color)), Util.Convert(point), text);
}
public override void DrawString(string str, RFont font, RColor color, RPoint point, RSize size, bool rtl)
{
var brush = ((BrushAdapter)_adapter.GetSolidBrush(color)).Brush as SolidBrush ?? Brushes.Black;
_g.DrawText(((FontAdapter)font).Font, brush, (int)(Math.Round(point.X) + (rtl ? size.Width : 0)), (int)Math.Round(point.Y), str);
}
/// <summary>
/// Measures the bounds of box and children, recursively.<br/>
/// Performs layout of the DOM structure creating lines by set bounds restrictions.
/// </summary>
/// <param name="g">Device context to use</param>
protected override void PerformLayoutImp(RGraphics g)
{
if (Display == CssConstants.None)
{
return;
}
RectanglesReset();
var prevSibling = DomUtils.GetPreviousSibling(this);
double left = ContainingBlock.Location.X + ContainingBlock.ActualPaddingLeft + ActualMarginLeft +
ContainingBlock.ActualBorderLeftWidth;
double top =
(prevSibling == null && ParentBox != null ? ParentBox.ClientTop : ParentBox == null ? Location.Y : 0) +
MarginTopCollapse(prevSibling) + (prevSibling != null
? prevSibling.ActualBottom + prevSibling.ActualBorderBottomWidth
: 0);
Location = new RPoint(left, top);
ActualBottom = top;
//width at 100% (or auto)
double minwidth = GetMinimumWidth();
double width = ContainingBlock.Size.Width
- ContainingBlock.ActualPaddingLeft - ContainingBlock.ActualPaddingRight
- ContainingBlock.ActualBorderLeftWidth - ContainingBlock.ActualBorderRightWidth
- ActualMarginLeft - ActualMarginRight - ActualBorderLeftWidth - ActualBorderRightWidth;
//Check width if not auto
if (Width != CssConstants.Auto && !string.IsNullOrEmpty(Width))
{
width = CssValueParser.ParseLength(Width, width, this);
}
if (width < minwidth || width >= 9999)
{
width = minwidth;
}
double height = ActualHeight;
if (height < 1)
{
height = Size.Height + ActualBorderTopWidth + ActualBorderBottomWidth;
}
if (height < 1)
{
height = 2;
}
if (height <= 2 && ActualBorderTopWidth < 1 && ActualBorderBottomWidth < 1)
{
BorderTopStyle = BorderBottomStyle = CssConstants.Solid;
BorderTopWidth = "1px";
BorderBottomWidth = "1px";
}
Size = new RSize(width, height);
ActualBottom = Location.Y + ActualPaddingTop + ActualPaddingBottom + height;
}
/// <summary>
/// Convert from core size to WinForms size.
/// </summary>
public static SizeF Convert(RSize s)
{
return(new SizeF((float)s.Width, (float)s.Height));
}
/// <summary> /// Draw the given string using the given font and foreground color at given location. /// </summary> /// <param name="str">the string to draw</param> /// <param name="font">the font to use to draw the string</param> /// <param name="color">the text color to set</param> /// <param name="point">the location to start string draw (top-left)</param> /// <param name="size">used to know the size of the rendered text for transparent text support</param> /// <param name="rtl">is to render the string right-to-left (true - RTL, false - LTR)</param> public abstract void DrawString(String str, RFont font, RColor color, RPoint point, RSize size, bool rtl);
/// <summary>
/// Perform the layout of the html container by given size restrictions returning the final size.<br/>
/// The layout can be effected by the HTML content in the <paramref name="htmlContainer"/> if <paramref name="autoSize"/> or
/// <paramref name="autoSizeHeightOnly"/> is set to true.<br/>
/// Handle minimum and maximum size restrictions.<br/>
/// Handle auto size and auto size for height only. if <paramref name="autoSize"/> is true <paramref name="autoSizeHeightOnly"/>
/// is ignored.<br/>
/// </summary>
/// <param name="g">the graphics used for layout</param>
/// <param name="htmlContainer">the html container to layout</param>
/// <param name="size">the current size</param>
/// <param name="minSize">the min size restriction - can be empty for no restriction</param>
/// <param name="maxSize">the max size restriction - can be empty for no restriction</param>
/// <param name="autoSize">if to modify the size (width and height) by html content layout</param>
/// <param name="autoSizeHeightOnly">if to modify the height by html content layout</param>
public static RSize Layout(RGraphics g, HtmlContainerInt htmlContainer, RSize size, RSize minSize, RSize maxSize, bool autoSize, bool autoSizeHeightOnly)
{
if (autoSize)
{
htmlContainer.MaxSize = new RSize(0, 0);
}
else if (autoSizeHeightOnly)
{
htmlContainer.MaxSize = new RSize(size.Width, 0);
}
else
{
htmlContainer.MaxSize = size;
}
htmlContainer.PerformLayout(g);
RSize newSize = size;
if (autoSize || autoSizeHeightOnly)
{
if (autoSize)
{
if (maxSize.Width > 0 && maxSize.Width < htmlContainer.ActualSize.Width)
{
// to allow the actual size be smaller than max we need to set max size only if it is really larger
htmlContainer.MaxSize = maxSize;
htmlContainer.PerformLayout(g);
}
else if (minSize.Width > 0 && minSize.Width > htmlContainer.ActualSize.Width)
{
// if min size is larger than the actual we need to re-layout so all 100% layouts will be correct
htmlContainer.MaxSize = new RSize(minSize.Width, 0);
htmlContainer.PerformLayout(g);
}
newSize = htmlContainer.ActualSize;
}
else if (Math.Abs(size.Height - htmlContainer.ActualSize.Height) > 0.01)
{
var prevWidth = size.Width;
// make sure the height is not lower than min if given
newSize.Height = minSize.Height > 0 && minSize.Height > htmlContainer.ActualSize.Height
? minSize.Height
: htmlContainer.ActualSize.Height;
// handle if changing the height of the label affects the desired width and those require re-layout
if (Math.Abs(prevWidth - size.Width) > 0.01)
{
return(Layout(g, htmlContainer, size, minSize, maxSize, false, true));
}
}
}
return(newSize);
}
public static SDL.SDL_Rect UpdatedByRSize(this SDL.SDL_Rect rect, RSize size)
{
rect.w = (int)size.Width;
rect.h = (int)size.Height;
return(rect);
}
