//! Constructor
public SvgImageRenderSettings(ImageRenderSettings imgRenderSettings,
Vector2 scaleFactor,
bool antiAliasing)
: base(imgRenderSettings)
{
d_scaleFactor = scaleFactor;
d_antiAliasing = antiAliasing;
}
/// <summary>
/// Draw the tree item in its current state
/// </summary>
/// <param name="geometryBuffers"></param>
/// <param name="targetRect"></param>
/// <param name="alpha">
/// Alpha value to be used when rendering the item (between 0.0f and 1.0f).
/// </param>
/// <param name="clipper">
/// Rect object describing the clipping rectangle for the draw operation.
/// </param>
public virtual IEnumerable <GeometryBuffer> Draw(Rectf targetRect, float alpha, Rectf?clipper)
{
var geometryBuffers = new List <GeometryBuffer>();
var finalRect = targetRect;
var imgRenderSettings = new ImageRenderSettings(finalRect, clipper, true, new ColourRect(0xffffffff), alpha);
if (d_iconImage != null)
{
var finalPos = finalRect;
finalPos.Width = targetRect.Height; // xdinos ???
finalPos.Height = targetRect.Height;
imgRenderSettings.DestArea = finalPos;
geometryBuffers.AddRange(d_iconImage.CreateRenderGeometry(imgRenderSettings));
finalRect.d_min.X += targetRect.Height;
}
imgRenderSettings.DestArea = finalRect;
if (d_selected && d_selectBrush != null)
{
imgRenderSettings.MultiplyColours = d_selectCols;
geometryBuffers.AddRange(d_selectBrush.CreateRenderGeometry(imgRenderSettings));
}
var font = GetFont();
if (font == null)
{
return(geometryBuffers);
}
var draw_pos = finalRect.Position;
draw_pos.Y -= (font.GetLineSpacing() - font.GetBaseline()) * 0.5f;
if (!d_renderedStringValid)
{
ParseTextString();
}
var final_colours = new ColourRect(0xFFFFFFFF);
for (var i = 0; i < d_renderedString.GetLineCount(); ++i)
{
//d_renderedString.Draw(d_owner, i, geometryBuffers, draw_pos, final_colours, clipper, 0.0f);
geometryBuffers.AddRange(d_renderedString.CreateRenderGeometry(d_owner, i, draw_pos, final_colours, clipper, 0.0f));
draw_pos.Y += d_renderedString.GetPixelSize(d_owner, i).Height;
}
return(geometryBuffers);
}
private void CreateRenderGeometry(ListView listView)
{
var itemsArea = GetViewRenderArea();
var itemPos = _itemViewRenderer.GetItemRenderStartPosition(listView, itemsArea);
for (var i = 0; i < listView.GetItems().Count; ++i)
{
var item = listView.GetItems()[i];
var renderedString = item.d_string;
var size = item.d_size;
size.Width = Math.Max(itemsArea.Width, size.Width);
var itemRect = new Rectf(itemPos, size);
if (!string.IsNullOrEmpty(item.d_icon))
{
var img = ImageManager.GetSingleton().Get(item.d_icon);
var iconRect = itemRect;
iconRect.Width = size.Height;
iconRect.Height = size.Height;
var iconClipper = iconRect.GetIntersection(itemsArea);
var renderSettings = new ImageRenderSettings(iconRect, iconClipper, true, ICON_COLOUR_RECT, 1.0f);
var imgGeomBuffers = img.CreateRenderGeometry(renderSettings);
if (item.d_isSelected)
{
renderSettings = new ImageRenderSettings(iconRect, iconClipper, true, listView.GetSelectionColourRect());
var brushGeomBuffers = listView.GetSelectionBrushImage().CreateRenderGeometry(renderSettings);
listView.AppendGeometryBuffers(brushGeomBuffers);
}
listView.AppendGeometryBuffers(imgGeomBuffers);
itemRect.Left = itemRect.Left + iconRect.Width;
}
var itemClipper = itemRect.GetIntersection(itemsArea);
_itemViewRenderer.CreateRenderGeometryAndAddToItemView(listView, renderedString, itemRect,
listView.GetFont(), itemClipper,
item.d_isSelected);
itemPos.Y += size.Height;
}
}
public void CreateRenderGeometryAndAddToItemView(ItemView view, RenderedString renderedString, Rectf drawRect, Font font, Rectf?itemClipper, bool isSelected)
{
if (view.GetSelectionBrushImage() != null && isSelected)
{
var renderSettings = new ImageRenderSettings(drawRect, itemClipper, true, view.GetSelectionColourRect());
var brushGeomBuffers = view.GetSelectionBrushImage().CreateRenderGeometry(renderSettings);
view.AppendGeometryBuffers(brushGeomBuffers);
}
var drawPos = drawRect.Position;
for (var i = 0; i < renderedString.GetLineCount(); ++i)
{
drawPos.Y += CoordConverter.AlignToPixels((font.GetLineSpacing() - font.GetFontHeight()) * 0.5f);
var stringGeomBuffers = renderedString.CreateRenderGeometry(view, i, drawPos, null, itemClipper, 0.0f);
view.AppendGeometryBuffers(stringGeomBuffers);
drawPos.Y += renderedString.GetPixelSize(view, i).Height;
}
}
// Implement CEGUI::Image interface
public override List <GeometryBuffer> CreateRenderGeometry(ImageRenderSettings renderSettings)
{
var dest = renderSettings.DestArea;
// apply rendering offset to the destination Rect
dest.Offset(d_scaledOffset);
var clipArea = renderSettings.ClipArea;
// Calculate the actual (clipped) area to which we want to render to
var finalRect = clipArea.HasValue ? dest.GetIntersection(clipArea.Value) : dest;
// check if our Image is totally clipped and return if it is
if ((Math.Abs(finalRect.Width) < float.Epsilon) || (Math.Abs(finalRect.Height) < float.Epsilon))
{
return(new List <GeometryBuffer>());
}
// Calculate the scale factor for our Image which is the scaling of the Image
// area to the destination area of our render call
var scaleFactor = new Vector2(dest.Width / d_imageArea.Width, dest.Height / d_imageArea.Height);
// URGENT FIXME: Shouldn't this be in the hands of the user?
finalRect.d_min.X = CoordConverter.AlignToPixels(finalRect.d_min.X);
finalRect.d_min.Y = CoordConverter.AlignToPixels(finalRect.d_min.Y);
finalRect.d_max.X = CoordConverter.AlignToPixels(finalRect.d_max.X);
finalRect.d_max.Y = CoordConverter.AlignToPixels(finalRect.d_max.Y);
var svgRenderSettings = new SvgImageRenderSettings(renderSettings, scaleFactor, d_useGeometryAntialiasing);
var geometryBuffers = new List <GeometryBuffer>();
foreach (var shape in d_svgData.getShapes())
{
geometryBuffers.AddRange(shape.CreateRenderGeometry(svgRenderSettings));
}
return(geometryBuffers);
}
public override List <GeometryBuffer> CreateRenderGeometry(Rectf targetRect, float alpha, Rectf?clipper)
{
var geomBuffers = new List <GeometryBuffer>();
if (Selected && SelectBrush != null)
{
var imgRenderSettings = new ImageRenderSettings(targetRect, clipper, true, SelectCols, alpha);
geomBuffers.AddRange(SelectBrush.CreateRenderGeometry(imgRenderSettings));
}
var font = GetFont();
if (font == null)
{
return(geomBuffers);
}
var drawPos = targetRect.Position;
drawPos.Y += CoordConverter.AlignToPixels((font.GetLineSpacing() - font.GetFontHeight()) * 0.5f);
if (!_renderedStringValid)
{
ParseTextString();
}
var finalColours = new ColourRect(0xFFFFFFFF);
for (var i = 0; i < _renderedString.GetLineCount(); ++i)
{
geomBuffers.AddRange(_renderedString.CreateRenderGeometry(Owner, i, drawPos, finalColours, clipper, 0.0f));
drawPos.Y += _renderedString.GetPixelSize(Owner, i).Height;
}
return(geomBuffers);
}
/// <summary>
/// Render text lines.
/// </summary>
/// <param name="destArea"></param>
protected void CacheTextLines(Rectf destArea)
{
var w = (MultiLineEditbox)Window;
// text is already formatted, we just grab the lines and
// create the render geometry for them with the required alignment.
var drawArea = destArea;
var vertScrollPos = w.GetVertScrollbar().GetScrollPosition();
drawArea.Offset(new Lunatics.Mathematics.Vector2(-w.GetHorzScrollbar().GetScrollPosition(), -vertScrollPos));
var fnt = w.GetFont();
if (fnt != null)
{
// calculate final colours to use.
var alpha = w.GetEffectiveAlpha();
var normalTextCol = new ColourRect();
SetColourRectToUnselectedTextColour(ref normalTextCol);
normalTextCol.ModulateAlpha(alpha);
var selectTextCol = new ColourRect();
SetColourRectToSelectedTextColour(ref selectTextCol);
selectTextCol.ModulateAlpha(alpha);
var selectBrushCol = new ColourRect();
if (w.HasInputFocus())
{
SetColourRectToActiveSelectionColour(ref selectBrushCol);
}
else
{
SetColourRectToInactiveSelectionColour(ref selectBrushCol);
}
selectBrushCol.ModulateAlpha(alpha);
var lines = w.GetFormattedLines();
var numLines = lines.Count;
// calculate the range of visible lines
var sidx = (int)(vertScrollPos / fnt.GetLineSpacing());
var eidx = 1 + sidx + (int)(destArea.Height / fnt.GetLineSpacing());
eidx = Math.Min(eidx, numLines);
drawArea.d_min.Y += fnt.GetLineSpacing() * sidx;
// for each formatted line.
for (var i = sidx; i < eidx; ++i)
{
var lineRect = drawArea;
var currLine = lines[i];
var lineText = w.GetTextVisual().CEGuiSubstring(currLine.d_startIdx, currLine.d_length);
// offset the font little down so that it's centered within its own spacing
var oldTop = lineRect.Top;
lineRect.d_min.Y += (fnt.GetLineSpacing() - fnt.GetFontHeight()) * 0.5f;
// if it is a simple 'no selection area' case
ColourRect colours;
if ((currLine.d_startIdx >= w.GetSelectionEndIndex()) ||
((currLine.d_startIdx + currLine.d_length) <= w.GetSelectionStartIndex()) ||
(w.GetSelectionBrushImage() == null))
{
colours = normalTextCol;
// Create Geometry buffers for the text and add to the Window
var nextGlyphPos = 0.0f;
var textGeomBuffers = fnt.CreateRenderGeometryForText(lineText, out nextGlyphPos, lineRect.Position, destArea, true, colours);
w.AppendGeometryBuffers(textGeomBuffers);
}
else // we have at least some selection highlighting to do
{
// Start of actual rendering section.
String sect;
int sectIdx = 0, sectLen;
float selStartOffset = 0.0f;
// Create the render geometry for any text prior to selected region of line.
if (currLine.d_startIdx < w.GetSelectionStartIndex())
{
// calculate length of text section
sectLen = w.GetSelectionStartIndex() - currLine.d_startIdx;
// get text for this section
sect = lineText.CEGuiSubstring(sectIdx, sectLen);
sectIdx += sectLen;
// get the pixel offset to the beginning of the selection area highlight.
selStartOffset = fnt.GetTextAdvance(sect);
// Create the render geometry for this portion of the text
colours = normalTextCol;
var geomBuffers = fnt.CreateRenderGeometryForText(sect, lineRect.Position, destArea, true, colours);
// set position ready for next portion of text
lineRect.d_min.X += selStartOffset;
}
// calculate the length of the selected section
sectLen = Math.Min(w.GetSelectionEndIndex() - currLine.d_startIdx, currLine.d_length) - sectIdx;
// get the text for this section
sect = lineText.CEGuiSubstring(sectIdx, sectLen);
sectIdx += sectLen;
// get the extent to use as the width of the selection area highlight
var selAreaWidth = fnt.GetTextAdvance(sect);
var textTop = lineRect.Top;
lineRect.Top = oldTop;
// calculate area for the selection brush on this line
lineRect.Left = drawArea.Left + selStartOffset;
lineRect.Right = lineRect.Left + selAreaWidth;
lineRect.Bottom = lineRect.Top + fnt.GetLineSpacing();
// Create the render geometry for the selection area brush for this line
colours = selectBrushCol;
var renderSettings = new ImageRenderSettings(lineRect, destArea, true, colours);
var selectionGeomBuffers = w.GetSelectionBrushImage().CreateRenderGeometry(renderSettings);
w.AppendGeometryBuffers(selectionGeomBuffers);
// Create the render geometry for the text for this section
colours = selectTextCol;
var textGeomBuffers = fnt.CreateRenderGeometryForText(sect, lineRect.Position, destArea, true, colours);
w.AppendGeometryBuffers(textGeomBuffers);
lineRect.Top = textTop;
// Create the render geometry for any text beyond selected region of line
if (sectIdx < currLine.d_length)
{
// update render position to the end of the selected area.
lineRect.d_min.X += selAreaWidth;
// calculate length of this section
sectLen = currLine.d_length - sectIdx;
// get the text for this section
sect = lineText.CEGuiSubstring(sectIdx, sectLen);
// render the text for this section.
colours = normalTextCol;
var textAfterSelectionGeomBuffers = fnt.CreateRenderGeometryForText(sect, lineRect.Position, destArea, true, colours);
w.AppendGeometryBuffers(textAfterSelectionGeomBuffers);
}
}
// update master position for next line in paragraph.
drawArea.d_min.Y += fnt.GetLineSpacing();
}
}
}
