public void DrawBackground(IUserInterfaceRenderContext renderContext, RenderElementDisplay display, Rectangle clientDest) { if (display.Style.Background == null) { return; } // This draws the background behind the border - a problem for borders which have transparency on their outer edges // but important for borders which have transparency on their inner edges. Oh what to do... //Rectangle backgroundRect = new Rectangle( // new Point(dest.X - display.Region.BorderToContentOffset.Left, // dest.Y - display.Region.BorderToContentOffset.Top), // display.Region.BorderRect.Size); // Here we make a compromise and set the background rectangle to be slightly smaller than // the border rectangle var borderLayout = display.Style.Border.ToLayoutBox(); Rectangle backgroundRect = new Rectangle( clientDest.X - display.Region.BorderToContentOffset.Left + borderLayout.Left / 2, clientDest.Y - display.Region.BorderToContentOffset.Top + borderLayout.Top / 2, display.BorderRect.Width - borderLayout.Width / 2, display.BorderRect.Height - borderLayout.Height / 2); styleRenderer.DrawBackground( renderContext.SpriteBatch, display.Style.Background, backgroundRect); }
public void CompleteRendering(Rectangle parentContentDest, IUserInterfaceRenderContext renderContext, IRenderElement widget) { var animation = widget.Display.Animation; var display = widget.Display; display.Animation.Buffer.RenderContext.SpriteBatch.End(); // Now use the parent render target. renderContext.GraphicsDevice.SetRenderTarget(renderContext.RenderTarget); var screenRect = animation.AnimatedBorderRect; screenRect.X += parentContentDest.X; screenRect.Y += parentContentDest.Y; renderContext.SpriteBatch.Draw( animation.RenderTarget, screenRect, null, animation.Color, 0, Vector2.Zero, SpriteEffects.None, animation.LayerDepth); }
public override void DoLayout(IUserInterfaceRenderContext renderContext, Size size) { int desty = 0; for (int y = 0; y < Rows; y++) { int destx = 0; for (int x = 0; x < Columns; x++) { var item = ChildAt(x, y); if (item == null) { destx += columnWidths[x]; continue; } item.Display.ContentRect = new Rectangle( destx + item.Display.Region.MarginToContentOffset.Left, desty + item.Display.Region.MarginToContentOffset.Top, SizeAt(x, y).Width, SizeAt(x, y).Height); destx += columnWidths[x]; } desty += rowHeights[y]; } Width = columnWidths.Sum(); Height = rowHeights.Sum(); }
private bool AnimateExit(RenderElementDisplay display, IUserInterfaceRenderContext renderContext, RenderElementAnimator animation) { animation.Alpha -= (float)renderContext.GameTime.ElapsedGameTime.TotalSeconds / transitionTime; if (animation.Alpha <= 0) { animation.Alpha = 0; animation.IsVisible = false; return(true); } const float shrinkMax = 0.1f; float shrink = shrinkMax * MathF.Pow(1 - animation.Alpha, 0.8f); float leftRightMargin = shrink * display.BorderRect.Width; float topBottomMargin = shrink * display.BorderRect.Height; animation.AnimatedBorderRect = new Rectangle( display.BorderRect.X + (int)leftRightMargin, display.BorderRect.Y + (int)leftRightMargin, display.BorderRect.Width - (int)(2 * leftRightMargin), display.BorderRect.Height - (int)(2 * leftRightMargin)); return(false); }
private void RefreshContent(IUserInterfaceRenderContext renderContext, int maxWidth) { if (!dirty && content != null) { if (maxWidth > content.Size.Width) { return; } dirty = true; } if (dirty || lastContentMaxWidth != maxWidth) { if (Props.Text == null) { content = null; } else { layoutOptions.Font = Style.Font; layoutOptions.MaxWidth = maxWidth; content = renderContext.CreateContentLayout(Props.Text, layoutOptions, Props.PerformLocalization); content.Options.ReadSlowly = Props.ReadSlowly; content.AnimationComplete += () => Props.AnimationComplete?.Invoke(evt.Reset(this)); } lastContentMaxWidth = maxWidth; dirty = false; } }
private bool AnimateEntry(RenderElementDisplay display, IUserInterfaceRenderContext renderContext, RenderElementAnimator animation) { animation.Alpha += (float)renderContext.GameTime.ElapsedGameTime.TotalSeconds / transitionTime; if (animation.Alpha >= 1) { animation.Alpha = 1; animation.AnimatedBorderRect = display.BorderRect; return(true); } const float shrinkMax = 0.1f; float shrink = shrinkMax * MathF.Pow(1 - animation.Alpha, 3); float leftRightMargin = shrink * display.BorderRect.Width; float topBottomMargin = shrink * display.BorderRect.Height; animation.AnimatedBorderRect = new Rectangle( display.BorderRect.X + (int)leftRightMargin, display.BorderRect.Y + (int)leftRightMargin, display.BorderRect.Width - (int)(2 * leftRightMargin), display.BorderRect.Height - (int)(2 * leftRightMargin)); Log.Debug($"Alpha: {animation.Alpha} BorderRect: {display.BorderRect} AnimatedBorderRect: {animation.AnimatedBorderRect}"); return(false); }
public Size CalcIdealSize(IUserInterfaceRenderContext renderContext, Size maxSize, IList <IRenderElement> children) { int idealCrossSize = 0; int idealAxisSize = 0; foreach (var item in children) { if (!item.Display.IsVisible) { continue; } var itemBox = item.Display.Region.MarginToContentOffset; var itemMaxSize = LayoutMath.ItemContentMaxSize(itemBox, maxSize); item.Display.Region.IdealContentSize = item.CalcIdealContentSize(renderContext, maxSize); var itemIdealContentSize = item.Display.Region.CalcConstrainedContentSize(maxSize); var itemIdealMarginSize = itemBox.Expand(itemIdealContentSize); idealCrossSize = Math.Max(idealCrossSize, CrossAxis(itemIdealMarginSize)); idealAxisSize += MainAxis(itemIdealMarginSize); } return(SetSize(idealAxisSize, idealCrossSize)); }
public void Draw(IUserInterfaceRenderContext renderContext) { contentLayoutOptions.Font = Font; contentLayoutOptions.MaxWidth = renderContext.Area.Width; var validItems = items.Where(kvp => kvp.Value.Visible && !string.IsNullOrWhiteSpace(kvp.Value.Text)); int totalWidth = 0; int count = 0; foreach (var itemKvp in validItems) { var item = itemKvp.Value; InitializeContent(renderContext, itemKvp.Key, item); totalWidth += item.Content.Size.Width + item.ButtonContent.Size.Width; count++; } totalWidth += (count - 1) * Margin; int x = (renderContext.Area.Width - totalWidth) / 2; foreach (var itemKvp in validItems) { DrawContent(renderContext, itemKvp.Value.ButtonContent, ref x); DrawContent(renderContext, itemKvp.Value.Content, ref x); x += Margin; } }
private static void DrawContent(IUserInterfaceRenderContext renderContext, IContentLayout content, ref int x) { content.Draw( new Vector2(x, renderContext.Area.Height - content.Size.Height), renderContext.SpriteBatch); x += content.Size.Width; }
public UIContext() { renderContext = CommonMocks.RenderContext().Object; scene = new UserInterfaceSceneDriver( renderContext, CommonMocks.StyleConfigurator().Object, CommonMocks.FontProvider().Object); }
public override void DoLayout(IUserInterfaceRenderContext renderContext, Size size) { PerformLayout(renderContext, size); foreach (var item in Children.Where(x => x.Display.IsVisible)) { item.DoLayout(renderContext, item.Display.ContentRect.Size); } }
public void DrawFrame(IUserInterfaceRenderContext renderContext, RenderElementDisplay display, Rectangle clientDest) { styleRenderer.DrawFrame( renderContext.SpriteBatch, display.Style.Border, new Rectangle( new Point(clientDest.X - display.Region.BorderToContentOffset.Left, clientDest.Y - display.Region.BorderToContentOffset.Top), display.BorderRect.Size)); }
public static void CalcIdealSize(IRenderElement item, IUserInterfaceRenderContext renderContext, Size parentMaxSize) { Size maxSize = ConstrainMaxSize(parentMaxSize, item.Style.Size); Size idealSize = item.CalcIdealContentSize(renderContext, maxSize); idealSize = ConstrainSize(idealSize, item.Style.Size); item.Display.Region.IdealContentSize = idealSize; }
public void UpdateAnimation(IUserInterfaceRenderContext renderContext, IRenderElement element) { var animator = element.Display.Animation; bool finished = animator.Transition?.Update(element.Display, renderContext) ?? false; if (finished) { AdvanceTransitionState(element); } }
public bool Update(RenderElementDisplay display, IUserInterfaceRenderContext renderContext) { var animator = display.Animation; animator.IsVisible = display.IsVisible; animator.AnimatedContentRect = display.ContentRect; animator.AnimatedBorderRect = display.BorderRect; animator.Alpha = 1; return(true); }
/// <summary> /// Updates the ideal size property for each child. /// Returns the total ideal margin size along the main axis. /// </summary> /// <param name="renderContext"></param> /// <param name="mySize"></param> /// <param name="children"></param> /// <returns></returns> private int CalcChildrenIdealSizes(IUserInterfaceRenderContext renderContext, Size mySize, IList <IRenderElement> children) { foreach (var item in children) { LayoutMath.CalcIdealSize(item, renderContext, mySize); item.Display.Region.SetContentSize(item.Display.Region.IdealContentSize); } return(children.Sum(x => MainAxis(x.Display.Region.IdealMarginSize))); }
private void InitializeContent(IUserInterfaceRenderContext renderContext, Buttons key, InstructionItem item) { if (item.ButtonContent == null) { item.ButtonContent = renderContext.CreateContentLayout( "{Button " + key + "} ", contentLayoutOptions, performLocalization: false); } if (item.Content == null) { item.Content = renderContext.CreateContentLayout(item.Text, contentLayoutOptions); } }
public override Size CalcIdealContentSize(IUserInterfaceRenderContext renderContext, Size maxSize) { Array.Clear(columnWidths, 0, columnWidths.Length); Array.Clear(rowHeights, 0, rowHeights.Length); for (int y = 0; y < Rows; y++) { for (int x = 0; x < Columns; x++) { var item = ChildAt(x, y); SetSizeAt(x, y, Size.Empty); if (item == null) { continue; } var itemBox = item.Display.Region.MarginToContentOffset; var itemMaxSize = LayoutMath.ItemContentMaxSize(itemBox, maxSize); item.Display.Region.IdealContentSize = item.CalcIdealContentSize(renderContext, maxSize); var itemIdealSize = item.Display.Region.CalcConstrainedContentSize(maxSize); SetSizeAt(x, y, itemIdealSize); columnWidths[x] = Math.Max(columnWidths[x], itemIdealSize.Width + itemBox.Width); rowHeights[y] = Math.Max(rowHeights[y], itemIdealSize.Height + itemBox.Height); } } for (int i = 0; i < Columns; i++) { columnWidths[i] = Math.Min(maxSize.Width, columnWidths[i]); } for (int i = 0; i < Rows; i++) { rowHeights[i] = Math.Min(maxSize.Height, rowHeights[i]); } var idealWidth = columnWidths.Sum(); var idealHeight = rowHeights.Sum(); return(new Size(idealWidth, idealHeight)); }
public UserInterfaceSceneDriver( IUserInterfaceRenderContext renderContext, IStyleConfigurator styles, IFontProvider fonts, IUserInterfaceAudio audio = null) { this.renderContext = renderContext; desktop = new Desktop(fonts, styles); desktop.Audio = audio; Desktop.UnhandledEvent += Desktop_UnhandledEvent; uiInput.UIAction += desktop.OnUserInterfaceAction; }
public bool Update(RenderElementDisplay display, IUserInterfaceRenderContext renderContext) { var animation = display.Animation; animation.IsVisible = true; if (animation.State == AnimationState.TransitionIn) { return(AnimateEntry(display, renderContext, animation)); } else if (animation.State == AnimationState.TransitionOut) { return(AnimateExit(display, renderContext, animation)); } return(true); }
public void PerformLayout( IUserInterfaceRenderContext renderContext, Size mySize, IRenderElementStyle myStyle, IList <IRenderElement> children) { int idealSizeOfAllChildren = CalcChildrenIdealSizes(renderContext, mySize, children); int extraSpace = MainAxis(mySize) - idealSizeOfAllChildren; GrowFlexItems(children, ref extraSpace); ContractItems(children, mySize, ref extraSpace); PositionChildren(mySize, myStyle, children); ApplyAlignment(mySize, myStyle, children); DistributeExtraSpace(myStyle, children, ref extraSpace); }
public override Size CalcIdealContentSize(IUserInterfaceRenderContext renderContext, Size maxSize) { UpdateChildLists(); maxSize = LayoutMath.ConstrainMaxSize(maxSize, Style.Size); switch (Direction) { case FlexDirection.Column: case FlexDirection.ColumnReverse: return(vertical.CalcIdealSize(renderContext, maxSize, layoutChildren)); case FlexDirection.Row: case FlexDirection.RowReverse: return(horizontal.CalcIdealSize(renderContext, maxSize, layoutChildren)); default: throw new InvalidOperationException(); } }
private void PerformLayout(IUserInterfaceRenderContext renderContext, Size size) { UpdateChildLists(); switch (Direction) { case FlexDirection.Column: case FlexDirection.ColumnReverse: vertical.PerformLayout(renderContext, size, Style, layoutChildren); break; case FlexDirection.Row: case FlexDirection.RowReverse: horizontal.PerformLayout(renderContext, size, Style, layoutChildren); break; default: throw new InvalidOperationException(); } }
public IUserInterfaceRenderContext PrepRenderState(IRenderElement widget, IUserInterfaceRenderContext renderContext) { var animation = widget.Display.Animation; var display = widget.Display; if (InitializeRenderTarget(display, renderContext.GraphicsDevice)) { if (display.Animation.Buffer.RenderContext == null) { display.Animation.Buffer.RenderContext = new UserInterfaceRenderContext( (UserInterfaceRenderContext)renderContext, new SpriteBatch(renderContext.GraphicsDevice), animation.RenderTarget); } display.Animation.Buffer.RenderContext.RenderTarget = animation.RenderTarget; } var newRenderContext = display.Animation.Buffer.RenderContext; newRenderContext.GameTime = renderContext.GameTime; newRenderContext.GraphicsDevice.SetRenderTarget(animation.RenderTarget); newRenderContext.GraphicsDevice.Clear(new Color(0, 0, 0, 0)); newRenderContext.GraphicsDevice.BlendState = blendState; newRenderContext.SpriteBatch.Begin(); widget.Display.Animation.Buffer.ContentDestination = new Rectangle( display.Region.MarginToContentOffset.Left, display.Region.MarginToContentOffset.Top, widget.Display.Animation.RenderTarget.Width - display.Region.MarginToContentOffset.Right, widget.Display.Animation.RenderTarget.Height - display.Region.MarginToContentOffset.Bottom); return(newRenderContext); }
public override void Update(IUserInterfaceRenderContext renderContext) { content?.Update(renderContext.GameTime); }
public override void Draw(IUserInterfaceRenderContext renderContext, Rectangle clientArea) { content?.Draw(clientArea.Location.ToVector2(), renderContext.SpriteBatch); }
public override Size CalcIdealContentSize(IUserInterfaceRenderContext renderContext, Size maxSize) { RefreshContent(renderContext, maxSize.Width); return(content?.Size ?? Size.Empty); }
public override void DoLayout(IUserInterfaceRenderContext renderContext, Size size) { }
public override void Draw(IUserInterfaceRenderContext renderContext, Rectangle clientArea) => renderContext.DrawChild(clientArea, child);
public override Size CalcIdealContentSize(IUserInterfaceRenderContext renderContext, Size maxSize) => child.CalcIdealMarginSize(renderContext, maxSize);