protected override void DoPerformLayout(RenderContext context)
{
base.DoPerformLayout(context);
// Setup brushes
if (Fill != null || (Stroke != null && StrokeThickness > 0))
{
using (GraphicsPath path = CalculateTransformedPath(GetPolygon(), _innerRect))
{
float centerX;
float centerY;
PointF[] pathPoints = path.PathPoints;
TriangulateHelper.CalcCentroid(pathPoints, out centerX, out centerY);
PositionColoredTextured[] verts;
if (Fill != null)
{
TriangulateHelper.FillPolygon_TriangleList(pathPoints, centerX, centerY, 1, out verts);
Fill.SetupBrush(this, ref verts, context.ZOrder, true);
PrimitiveBuffer.SetPrimitiveBuffer(ref _fillContext, ref verts, PrimitiveType.TriangleList);
}
else
PrimitiveBuffer.DisposePrimitiveBuffer(ref _fillContext);
if (Stroke != null && StrokeThickness > 0)
{
TriangulateHelper.TriangulateStroke_TriangleList(pathPoints, (float) StrokeThickness, true, 1, StrokeLineJoin, out verts);
Stroke.SetupBrush(this, ref verts, context.ZOrder, true);
PrimitiveBuffer.SetPrimitiveBuffer(ref _strokeContext, ref verts, PrimitiveType.TriangleList);
}
else
PrimitiveBuffer.DisposePrimitiveBuffer(ref _strokeContext);
}
}
}
public override void Render(RenderContext parentRenderContext)
{
Effect effect = Effect;
if (!IsVisible || effect == null)
return;
RectangleF bounds = ActualBounds;
if (bounds.Width <= 0 || bounds.Height <= 0)
return;
Matrix? layoutTransformMatrix = LayoutTransform == null ? new Matrix?() : LayoutTransform.GetTransform();
Matrix? renderTransformMatrix = RenderTransform == null ? new Matrix?() : RenderTransform.GetTransform();
RenderContext localRenderContext = parentRenderContext.Derive(bounds, layoutTransformMatrix, renderTransformMatrix, RenderTransformOrigin, Opacity);
_inverseFinalTransform = Matrix.Invert(localRenderContext.Transform);
DeviceEx device = SkinContext.Device;
Surface backBuffer = device.GetRenderTarget(0);
SurfaceDescription desc = backBuffer.Description;
SurfaceDescription? textureDesc = _texture == null ? new SurfaceDescription?() : _texture.GetLevelDescription(0);
if (!textureDesc.HasValue || textureDesc.Value.Width != desc.Width || textureDesc.Value.Height != desc.Height)
{
TryDispose(ref _texture);
_texture = new Texture(device, desc.Width, desc.Height, 1, Usage.RenderTarget, Format.A8R8G8B8, Pool.Default);
}
using (Surface destSurfaceRef = _texture.GetSurfaceLevel(0))
device.StretchRectangle(backBuffer, destSurfaceRef, TextureFilter.None);
UpdateEffectMask(effect, localRenderContext.OccupiedTransformedBounds, desc.Width, desc.Height, localRenderContext.ZOrder);
if (effect.BeginRender(_texture, new RenderContext(Matrix.Identity, 1.0d, bounds, localRenderContext.ZOrder)))
{
_effectContext.Render(0);
effect.EndRender();
}
}
public override void RenderOverride(RenderContext localRenderContext)
{
base.RenderOverride(localRenderContext);
FrameworkElement keyboardControl = _keyboardLayoutControl;
if (keyboardControl == null)
return;
keyboardControl.Render(localRenderContext);
}
protected override bool BeginRenderEffectOverride(Texture texture, RenderContext renderContext)
{
if (_refresh)
{
_effectContext = new EffectContext();
_refresh = false;
}
RectangleF rect = renderContext.OccupiedTransformedBounds;
SizeF frameSize = new SizeF(rect.Width, rect.Height);
_effectContext.ExtraParameters = GetShaderParameters();
_effectContext.ShaderEffect = _shaderEffectName;
Vector4 lastFrameData = new Vector4(rect.Width, rect.Height, 0.0f, 0.0f);
_effectContext.StartRender(renderContext, frameSize, texture, CROP_FULLSIZE, 0, lastFrameData);
return true;
}
protected override bool BeginRenderEffectOverride(Texture texture, RenderContext renderContext)
{
if (_refresh)
{
_imageContext = new ImageContext();
_refresh = false;
}
RectangleF rect = renderContext.OccupiedTransformedBounds;
SizeF frameSize = new SizeF(rect.Width, rect.Height);
_imageContext.FrameSize = frameSize;
_imageContext.ExtraParameters = GetShaderParameters();
_imageContext.ShaderEffect = SkinResources.EFFECTS_SUB_DIRECTORY + '\\' + _partialShaderEffect;
Vector4 lastFrameData = new Vector4(rect.Width, rect.Height, 0.0f, 0.0f);
_imageContext.StartRender(renderContext, frameSize, texture, CROP_FULLSIZE, Color.Transparent, lastFrameData);
return true;
}
protected override void RenderChildren(RenderContext localRenderContext)
{
// Lock access to Children during render pass to avoid controls to be disposed during rendering.
lock (Children.SyncRoot)
base.RenderChildren(localRenderContext);
}
protected override bool BeginRenderBrushOverride(PrimitiveBuffer primitiveContext, RenderContext renderContext)
{
Allocate();
if (_tex != null)
_tex.Bind(0);
return base.BeginRenderBrushOverride(primitiveContext, renderContext);
}
protected void SetEffectParameters(RenderContext renderContext)
{
Vector2 uvoffset = new Vector2(0.0f, 0.0f);
switch (Tile)
{
case TileMode.Tile:
// Tile both directions
_effect.Parameters[PARAM_TILE_U] = 1; // D3DTADDRESS_WRAP
_effect.Parameters[PARAM_TILE_V] = 1; // D3DTADDRESS_WRAP
break;
case TileMode.FlipX:
// Tile both directions but mirror texture on alterate repeats in u/x direction
_effect.Parameters[PARAM_TILE_U] = 2; // D3DTADDRESS_MIRROR
_effect.Parameters[PARAM_TILE_V] = 1; // D3DTADDRESS_WRAP
uvoffset.X = 1.0f - TextureMaxUV.X;
break;
case TileMode.FlipY:
// Tile both directions but mirror texture on alterate repeats in v/y direction
_effect.Parameters[PARAM_TILE_U] = 1; // D3DTADDRESS_WRAP
_effect.Parameters[PARAM_TILE_V] = 2; // D3DTADDRESS_MIRROR
uvoffset.Y = 1.0f - TextureMaxUV.Y;
break;
case TileMode.FlipXY:
// Tile and mirror texture in both directions
_effect.Parameters[PARAM_TILE_U] = 2; // D3DTADDRESS_MIRROR
_effect.Parameters[PARAM_TILE_V] = 2; // D3DTADDRESS_MIRROR
uvoffset = TextureMaxUV;
uvoffset.X = 1.0f - uvoffset.X;
uvoffset.Y = 1.0f - uvoffset.Y;
break;
case TileMode.None:
default:
// No tiling
_effect.Parameters[PARAM_TILE_U] = 4; // D3DTADDRESS_BORDER
_effect.Parameters[PARAM_TILE_V] = 4; // D3DTADDRESS_BORDER
break;
}
_effect.Parameters[PARAM_RELATIVE_TRANSFORM] = _relativeTransformCache;
_effect.Parameters[PARAM_TRANSFORM] = GetCachedFinalBrushTransform();
_effect.Parameters[PARAM_OPACITY] = (float) (Opacity * renderContext.Opacity);
_effect.Parameters[PARAM_TEXTURE_VIEWPORT] = _textureViewport;
_effect.Parameters[PARAM_BRUSH_TRANSFORM] = _brushTransform;
_effect.Parameters[PARAM_U_OFFSET] = uvoffset.X;
_effect.Parameters[PARAM_V_OFFSET] = uvoffset.Y;
}
protected override bool BeginRenderBrushOverride(PrimitiveBuffer primitiveContext, RenderContext renderContext)
{
if (Texture == null)
return false;
Matrix finalTransform = renderContext.Transform.Clone();
if (_refresh)
{
RefreshEffectParameters();
_effect = ContentManager.Instance.GetEffect(_simplemode ? EFFECT_TILE_SIMPLE : EFFECT_TILE);
_refresh = false;
}
if (_simplemode)
SetSimpleEffectParameters(renderContext);
else
SetEffectParameters(renderContext);
_effect.StartRender(Texture, finalTransform);
return true;
}
protected override bool BeginRenderOpacityBrushOverride(Texture tex, RenderContext renderContext)
{
if (_gradientBrushTexture == null || _refresh)
{
_gradientBrushTexture = BrushCache.Instance.GetGradientBrush(GradientStops);
if (_gradientBrushTexture == null)
return false;
}
Matrix finalTransform = renderContext.Transform.Clone();
if (_refresh)
{
_refresh = false;
_effect = ContentManager.Instance.GetEffect(EFFECT_LINEAROPACITYGRADIENT);
g_startpoint = new float[] {StartPoint.X, StartPoint.Y};
g_endpoint = new float[] {EndPoint.X, EndPoint.Y};
if (MappingMode == BrushMappingMode.Absolute)
{
g_startpoint[0] /= _vertsBounds.Width;
g_startpoint[1] /= _vertsBounds.Height;
g_endpoint[0] /= _vertsBounds.Width;
g_endpoint[1] /= _vertsBounds.Height;
}
g_framesize = new float[] {_vertsBounds.Width, _vertsBounds.Height};
if (RelativeTransform != null)
{
Matrix m = RelativeTransform.GetTransform();
m.Transform(ref g_startpoint[0], ref g_startpoint[1]);
m.Transform(ref g_endpoint[0], ref g_endpoint[1]);
}
}
SurfaceDescription desc = tex.GetLevelDescription(0);
float[] g_LowerVertsBounds = new float[] {_vertsBounds.Left / desc.Width, _vertsBounds.Top / desc.Height};
float[] g_UpperVertsBounds = new float[] {_vertsBounds.Right / desc.Width, _vertsBounds.Bottom / desc.Height};
_effect.Parameters[PARAM_TRANSFORM] = GetCachedFinalBrushTransform();
_effect.Parameters[PARAM_OPACITY] = (float) (Opacity * renderContext.Opacity);
_effect.Parameters[PARAM_STARTPOINT] = g_startpoint;
_effect.Parameters[PARAM_ENDPOINT] = g_endpoint;
_effect.Parameters[PARAM_FRAMESIZE] = g_framesize;
_effect.Parameters[PARAM_ALPHATEX] = _gradientBrushTexture.Texture;
_effect.Parameters[PARAM_UPPERVERTSBOUNDS] = g_UpperVertsBounds;
_effect.Parameters[PARAM_LOWERVERTSBOUNDS] = g_LowerVertsBounds;
GraphicsDevice.Device.SetSamplerState(0, SamplerState.AddressU, SpreadAddressMode);
_effect.StartRender(tex, finalTransform);
return true;
}
public override void RenderOverride(RenderContext localRenderContext)
{
ImageSourceState allocatedSource = GetLoadedSource(true);
if (allocatedSource == null)
base.RenderOverride(localRenderContext);
else
{
// Update source geometry if necessary (source has changed, layout has changed).
if (!allocatedSource.Setup)
{
allocatedSource.ImageSource.Setup(_innerRect, localRenderContext.ZOrder, SkinNeutralAR);
allocatedSource.Setup = true;
}
base.RenderOverride(localRenderContext);
allocatedSource.ImageSource.Render(localRenderContext, Stretch, StretchDirection);
}
}
protected abstract bool BeginRenderBrushOverride(PrimitiveBuffer primitiveContext, RenderContext renderContext);
public override void Render(RenderContext renderContext, Stretch stretchMode, StretchDirection stretchDirection)
{
if (!IsAllocated)
return;
SizeF rawSourceSize = RawSourceSize;
SizeF modifiedSourceSize = StretchSource(_imageContext.RotatedFrameSize, rawSourceSize, stretchMode, stretchDirection);
Vector4 frameData = new Vector4(rawSourceSize.Width, rawSourceSize.Height, (float) EffectTimer, 0);
if (_primitiveBuffer != null && _imageContext.StartRender(renderContext, modifiedSourceSize, Texture, TextureClip, BorderColor, frameData))
{
_primitiveBuffer.Render(0);
_imageContext.EndRender();
}
}
public override void DoRender(RenderContext localRenderContext)
{
base.DoRender(localRenderContext); // Do the actual rendering
// After rendering our children (in DoRender) the following line resets the RenderContext's bounds so
// that rendering with an OpacityMask will clip the final output correctly to our scrolled viewport.
localRenderContext.SetUntransformedBounds(ActualBounds);
}
public override void Render(RenderContext parentRenderContext)
{
if (OpacityMask == null && (TotalHeight > ActualHeight || TotalWidth > ActualWidth))
{
SolidColorBrush brush = new SolidColorBrush {Color = Color.Black};
OpacityMask = brush;
_forcedOpacityMask = true;
}
else if (_forcedOpacityMask && TotalHeight <= ActualHeight && TotalWidth <= ActualWidth && OpacityMask != null)
{
OpacityMask.Dispose();
OpacityMask = null;
_opacityMaskContext.Dispose();
_opacityMaskContext = null;
_forcedOpacityMask = false;
}
base.Render(parentRenderContext);
}
public bool BeginRenderBrush(PrimitiveBuffer primitiveContext, RenderContext renderContext)
{
if (_vertsBounds.IsEmpty)
return false;
return BeginRenderBrushOverride(primitiveContext, renderContext);
}
public override void RenderOverride(RenderContext localRenderContext)
{
base.RenderOverride(localRenderContext);
FrameworkElement content = Content;
if (content != null)
content.Render(localRenderContext);
}
protected override bool BeginRenderBrushOverride(PrimitiveBuffer primitiveBuffer, RenderContext renderContext)
{
Matrix finalTransform = renderContext.Transform.Clone();
Color4 v = ColorConverter.FromColor(Color);
v.Alpha *= (float) (Opacity * renderContext.Opacity);
_effect = ContentManager.Instance.GetEffect(EFFECT_SOLID);
_effect.Parameters[PARAM_SOLIDCOLOR] = v;
_effect.StartRender(finalTransform);
return true;
}
public override void Render(RenderContext renderContext, Stretch stretchMode, StretchDirection stretchDirection)
{
Allocate();
Texture currentTexture = CurrentTexture;
SizeF currentRawSourceSize = CurrentRawSourceSize;
RectangleF currentTextureClip = CurrentTextureClip;
Vector4 frameData = new Vector4(currentRawSourceSize.Width, currentRawSourceSize.Height, (float) EffectTimer, 0);
if (_transitionActive)
{
double elapsed = (SkinContext.FrameRenderingStartTime - _transitionStart).TotalSeconds / Math.Max(TransitionDuration, 0.01);
if (elapsed > 1.0)
_transitionActive = false;
else
{
Texture lastTexture = LastTexture;
SizeF lastRawSourceSize = LastRawSourceSize;
RectangleF lastTextureClip = LastTextureClip;
Vector4 lastFrameData = new Vector4(lastRawSourceSize.Width, lastRawSourceSize.Height, (float) EffectTimer, 0);
Texture start = lastTexture ?? NullTexture.Texture;
Texture end = currentTexture ?? NullTexture.Texture;
if (start != end)
{
SizeF startSize = StretchSource(_lastImageContext.RotatedFrameSize, lastRawSourceSize, stretchMode, stretchDirection);
SizeF endSize = StretchSource(_imageContext.RotatedFrameSize, currentRawSourceSize, stretchMode, stretchDirection);
// Render transition from last texture to current texture
_lastImageContext.Update(startSize, start, lastTextureClip);
if (_imageContext.StartRenderTransition(renderContext, (float) elapsed, _lastImageContext,
endSize, end, currentTextureClip, BorderColor, lastFrameData, frameData))
{
_primitiveBuffer.Render(0);
_imageContext.EndRenderTransition();
}
}
return;
}
}
if (IsAllocated)
{
SizeF sourceSize = StretchSource(_imageContext.RotatedFrameSize, currentRawSourceSize, stretchMode, stretchDirection);
if (_imageContext.StartRender(renderContext, sourceSize, currentTexture, currentTextureClip, BorderColor, frameData))
{
_primitiveBuffer.Render(0);
_imageContext.EndRender();
}
}
}
protected override bool BeginRenderBrushOverride(PrimitiveBuffer primitiveContext, RenderContext renderContext)
{
if (_gradientBrushTexture == null || _refresh)
{
_gradientBrushTexture = BrushCache.Instance.GetGradientBrush(GradientStops);
if (_gradientBrushTexture == null)
return false;
}
Matrix finalTransform = renderContext.Transform.Clone();
if (_refresh)
{
_refresh = false;
_effect = ContentManager.Instance.GetEffect(EFFECT_LINEARGRADIENT);
g_startpoint = new float[] {StartPoint.X, StartPoint.Y};
g_endpoint = new float[] {EndPoint.X, EndPoint.Y};
if (MappingMode == BrushMappingMode.Absolute)
{
g_startpoint[0] /= _vertsBounds.Width;
g_startpoint[1] /= _vertsBounds.Height;
g_endpoint[0] /= _vertsBounds.Width;
g_endpoint[1] /= _vertsBounds.Height;
}
g_framesize = new float[] {_vertsBounds.Width, _vertsBounds.Height};
if (RelativeTransform != null)
{
Matrix m = RelativeTransform.GetTransform();
m.Transform(ref g_startpoint[0], ref g_startpoint[1]);
m.Transform(ref g_endpoint[0], ref g_endpoint[1]);
}
}
_effect.Parameters[PARAM_FRAMESIZE] = g_framesize;
_effect.Parameters[PARAM_TRANSFORM] = GetCachedFinalBrushTransform();
_effect.Parameters[PARAM_OPACITY] = (float) (Opacity * renderContext.Opacity);
_effect.Parameters[PARAM_STARTPOINT] = g_startpoint;
_effect.Parameters[PARAM_ENDPOINT] = g_endpoint;
GraphicsDevice.Device.SetSamplerState(0, SamplerState.AddressU, SpreadAddressMode);
_effect.StartRender(_gradientBrushTexture.Texture, finalTransform);
return true;
}
protected override bool BeginRenderBrushOverride(PrimitiveBuffer primitiveContext, RenderContext renderContext)
{
IPlayerManager playerManager = ServiceRegistration.Get<IPlayerManager>(false);
if (playerManager == null)
return false;
ISlimDXVideoPlayer player = playerManager[Stream] as ISlimDXVideoPlayer;
if (player == null)
return false;
if (!RefreshEffectParameters(player))
return false;
lock (player.SurfaceLock)
{
Surface playerSurface = player.Surface;
if (playerSurface == null)
return false;
DeviceEx device = SkinContext.Device;
SurfaceDescription desc = playerSurface.Description;
SurfaceDescription? textureDesc = _texture == null ? new SurfaceDescription?() : _texture.GetLevelDescription(0);
if (!textureDesc.HasValue || textureDesc.Value.Width != desc.Width || textureDesc.Value.Height != desc.Height)
{
TryDispose(ref _texture);
_texture = new Texture(device, desc.Width, desc.Height, 1, Usage.RenderTarget, Format.A8R8G8B8, Pool.Default);
}
using (Surface target = _texture.GetSurfaceLevel(0))
device.StretchRectangle(playerSurface, target, TextureFilter.None);
}
return _imageContext.StartRender(renderContext, _scaledVideoSize, _texture, _videoTextureClip, BorderColor.ToArgb(), _lastFrameData);
}
protected override bool BeginRenderOpacityBrushOverride(Texture tex, RenderContext renderContext)
{
throw new NotImplementedException("VideoBrush doesn't support being rendered as an opacity brush");
}
public override void RenderOverride(RenderContext localRenderContext)
{
PerformLayout(localRenderContext);
base.RenderOverride(localRenderContext);
if (_backgroundContext != null)
{
if (Background.BeginRenderBrush(_backgroundContext, localRenderContext))
{
_backgroundContext.Render(0);
Background.EndRender();
}
}
FrameworkElement templateControl = _initializedTemplateControl;
if (templateControl == null)
return;
templateControl.Render(localRenderContext);
}
protected override bool BeginRenderOpacityBrushOverride(Texture tex, RenderContext renderContext)
{
if (Texture == null)
return false;
Matrix finalTransform = renderContext.Transform.Clone();
if (_refresh)
{
RefreshEffectParameters();
_effect = ContentManager.Instance.GetEffect(_simplemode ? EFFECT_TILE_OPACITY_SIMPLE : EFFECT_TILE_OPACITY);
_refresh = false;
}
if (_simplemode)
SetSimpleEffectParameters(renderContext);
else
SetEffectParameters(renderContext);
_effect.Parameters[PARAM_ALPHATEX] = Texture;
_effect.StartRender(tex, finalTransform);
return true;
}
public void PerformLayout(RenderContext localRenderContext)
{
if (!_performLayout)
return;
_performLayout = false;
// Setup background brush
if (Background != null)
{
SizeF actualSize = new SizeF((float) ActualWidth, (float) ActualHeight);
RectangleF rect = new RectangleF(ActualPosition.X - 0.5f, ActualPosition.Y - 0.5f,
actualSize.Width + 0.5f, actualSize.Height + 0.5f);
PositionColoredTextured[] verts = new PositionColoredTextured[6];
verts[0].Position = new Vector3(rect.Left, rect.Top, 1.0f);
verts[1].Position = new Vector3(rect.Left, rect.Bottom, 1.0f);
verts[2].Position = new Vector3(rect.Right, rect.Bottom, 1.0f);
verts[3].Position = new Vector3(rect.Left, rect.Top, 1.0f);
verts[4].Position = new Vector3(rect.Right, rect.Top, 1.0f);
verts[5].Position = new Vector3(rect.Right, rect.Bottom, 1.0f);
Background.SetupBrush(this, ref verts, localRenderContext.ZOrder, true);
PrimitiveBuffer.SetPrimitiveBuffer(ref _backgroundContext, ref verts, PrimitiveType.TriangleList);
}
else
PrimitiveBuffer.DisposePrimitiveBuffer(ref _backgroundContext);
}
protected void SetSimpleEffectParameters(RenderContext renderContext)
{
_effect.Parameters[PARAM_RELATIVE_TRANSFORM] = _relativeTransformCache;
_effect.Parameters[PARAM_TRANSFORM] = GetCachedFinalBrushTransform();
_effect.Parameters[PARAM_OPACITY] = (float) (Opacity * renderContext.Opacity);
_effect.Parameters[PARAM_TEXTURE_VIEWPORT] = _textureViewport;
_effect.Parameters[PARAM_BRUSH_TRANSFORM] = _brushTransform;
}
public override void RenderOverride(RenderContext localRenderContext)
{
base.RenderOverride(localRenderContext);
AllocFont();
HorizontalTextAlignEnum horzAlign = HorizontalTextAlignEnum.Left;
if (HorizontalContentAlignment == HorizontalAlignmentEnum.Right)
horzAlign = HorizontalTextAlignEnum.Right;
else if (HorizontalContentAlignment == HorizontalAlignmentEnum.Center)
horzAlign = HorizontalTextAlignEnum.Center;
VerticalTextAlignEnum vertAlign = VerticalTextAlignEnum.Top;
if (VerticalContentAlignment == VerticalAlignmentEnum.Bottom)
vertAlign = VerticalTextAlignEnum.Bottom;
else if (VerticalContentAlignment == VerticalAlignmentEnum.Center)
vertAlign = VerticalTextAlignEnum.Center;
Color4 color = ColorConverter.FromColor(Color);
color.Alpha *= (float) localRenderContext.Opacity;
// Update text cursor
if ((_cursorShapeInvalid || _cursorBrushInvalid) && CursorState == TextCursorState.Visible)
{
string textBeforeCaret = VisibleText;
textBeforeCaret = string.IsNullOrEmpty(textBeforeCaret) ? string.Empty : textBeforeCaret.Substring(0, CaretIndex);
float caretX = _asset.TextWidth(textBeforeCaret);
float textHeight = _asset.TextHeight(1);
float textInsetY;
switch (vertAlign)
{
case VerticalTextAlignEnum.Bottom:
textInsetY = _innerRect.Height - textHeight;
break;
case VerticalTextAlignEnum.Center:
textInsetY = (_innerRect.Height - textHeight) / 2;
break;
default: // VerticalTextAlignEnum.Top
textInsetY = 0;
break;
}
if (_virtualPosition + caretX < 10)
_virtualPosition = _innerRect.Width / 3 - caretX;
if (_virtualPosition + caretX > _innerRect.Width - 10)
_virtualPosition = _innerRect.Width * 2 / 3 - caretX;
Bound(ref _virtualPosition, -caretX, 0);
RectangleF cursorBounds = new RectangleF(_innerRect.X + _virtualPosition + caretX, _innerRect.Y + textInsetY, CURSOR_THICKNESS, textHeight);
UpdateCursorShape(cursorBounds, localRenderContext.ZOrder);
}
// Render text
_asset.Render(_innerRect, horzAlign, vertAlign, _virtualPosition, color, localRenderContext.ZOrder, localRenderContext.Transform);
// Render text cursor
if (_cursorBrush != null && CursorState == TextCursorState.Visible)
{
_cursorBrush.BeginRenderBrush(_cursorContext, localRenderContext);
_cursorContext.Render(0);
_cursorBrush.EndRender();
}
}
protected override bool BeginRenderOpacityBrushOverride(Texture tex, RenderContext renderContext)
{
Allocate();
if (_tex != null)
_tex.Bind(0);
return base.BeginRenderOpacityBrushOverride(tex, renderContext);
}
public override void RenderOverride(RenderContext localRenderContext)
{
base.RenderOverride(localRenderContext);
AllocFont();
HorizontalTextAlignEnum horzAlign = HorizontalTextAlignEnum.Left;
if (HorizontalContentAlignment == HorizontalAlignmentEnum.Right)
horzAlign = HorizontalTextAlignEnum.Right;
else if (HorizontalContentAlignment == HorizontalAlignmentEnum.Center)
horzAlign = HorizontalTextAlignEnum.Center;
VerticalTextAlignEnum vertAlign = VerticalTextAlignEnum.Top;
if (VerticalContentAlignment == VerticalAlignmentEnum.Bottom)
vertAlign = VerticalTextAlignEnum.Bottom;
else if (VerticalContentAlignment == VerticalAlignmentEnum.Center)
vertAlign = VerticalTextAlignEnum.Center;
Color4 color = ColorConverter.FromColor(Color);
color.Alpha *= (float) localRenderContext.Opacity;
_asset.Render(_innerRect, horzAlign, vertAlign, color, Wrap, true, localRenderContext.ZOrder,
Scroll, (float) ScrollSpeed, (float) ScrollDelay, localRenderContext.Transform);
}
protected override void RenderChildren(RenderContext localRenderContext)
{
base.RenderChildren(localRenderContext);
if (_ellipsisControl != null)
_ellipsisControl.Render(localRenderContext);
}
/// <summary>
/// Renders the <see cref="ImageContext"/>.
/// </summary>
/// <param name="renderContext">The current rendering context.</param>
/// <param name="targetImageSize">The size, the final image should take within the frame. This size is given in the same
/// orientation as the <paramref name="texture"/>, i.e. it is not rotated.</param>
/// <param name="texture">A texture object containing the image.</param>
/// <param name="textureClip">The section of the texture that should be rendered. Values are between 0 and 1.</param>
/// <param name="borderColor">The color to use outside the image's boundaries.</param>
/// <param name="frameData">Additional data to be used by the shaders.</param>
/// <returns><c>true</c> if the rendering operation was started.</returns>
public bool StartRender(RenderContext renderContext, SizeF targetImageSize, Texture texture, RectangleF textureClip,
Color borderColor, Vector4 frameData)
{
RefreshParameters(targetImageSize, texture, textureClip);
return(StartRender(renderContext, borderColor, frameData));
}
