public override void Start()
{
base.Start();
// create the light buttons
var buttonLightDirect0 = CreateLightButton(DirectionalLight1);
var buttonLightDirect1 = CreateLightButton(DirectionalLight2);
var buttonLightPoint = CreateLightButton(PointLight);
var buttonLightSpot = CreateLightButton(SpotLight);
// create the shadow buttons
var buttonShadowDirectional0 = CreateShadowButton(buttonLightDirect0, DirectionalLight1);
var buttonShadowDirectional1 = CreateShadowButton(buttonLightDirect1, DirectionalLight2);
var buttonShadowSpot = CreateShadowButton(buttonLightSpot, SpotLight);
// create the UI stack panel
var stackPanel = new StackPanel
{
Orientation = Orientation.Vertical,
HorizontalAlignment = HorizontalAlignment.Left,
MinimumWidth = 160,
Children =
{
buttonLightDirect0, buttonShadowDirectional0,
buttonLightDirect1, buttonShadowDirectional1,
buttonLightPoint,
buttonLightSpot, buttonShadowSpot
}
};
Entity.Get<UIComponent>().RootElement = stackPanel;
}
protected override async Task LoadContent()
{
await base.LoadContent();
var font = Content.Load<SpriteFont>("MicrosoftSansSerif15");
// root panel (any kind of panel could be used for this test)
canvas = new Canvas
{
BackgroundColor = Color.LightBlue,
};
// child panel with children to be rendered
stackPanel = new StackPanel
{
Children =
{
new TextBlock { Text = "Some text.", Font = font, TextColor = Color.Black },
new TextBlock { Text = "Some other text.", Font = font, TextColor = Color.Black }
},
Orientation = Orientation.Vertical
};
canvas.Children.Add(stackPanel);
UIComponent.Page = new Engine.UIPage { RootElement = canvas };
}
public void TestProperties()
{
var stackPanel = new StackPanel();
// test default values
Assert.AreEqual(Orientation.Vertical, stackPanel.Orientation);
}
protected override async Task LoadContent()
{
await base.LoadContent();
var background = new Entity { new BackgroundComponent { Texture = Content.Load<Texture>("XenkoBackground") } };
Scene.Entities.Add(background);
var text1 = new TextBlock { Text = "text block button 1", Font = Content.Load<SpriteFont>("CourierNew12"), SynchronousCharacterGeneration = true };
ApplyTextBlockDefaultStyle(text1);
button1 = new Button { Content = text1 };
ApplyButtonDefaultStyle(button1);
button1.SetCanvasRelativePosition(new Vector3(0.025f, 0.05f, 0f));
edit1 = new EditText() { Text = "Edit text 1", Font = Content.Load<SpriteFont>("CourierNew12"), SynchronousCharacterGeneration = true, };
ApplyEditTextDefaultStyle(edit1);
edit1.SetCanvasRelativePosition(new Vector3(0.025f, 0.15f, 0f));
var text2 = new TextBlock { Text = "text block button 2", Font = Content.Load<SpriteFont>("MicrosoftSansSerif15"), SynchronousCharacterGeneration = true };
ApplyTextBlockDefaultStyle(text2);
button2 = new Button { Content = text2 };
ApplyButtonDefaultStyle(button2);
edit2 = new EditText() { Text = "Edit text 2", Font = Content.Load<SpriteFont>("MicrosoftSansSerif15"), };
ApplyEditTextDefaultStyle(edit2);
stackPanel = new StackPanel
{
Children = { button2, edit2 },
HorizontalAlignment = HorizontalAlignment.Center,
VerticalAlignment = VerticalAlignment.Center,
Orientation = Orientation.Horizontal
};
stackPanel.SetCanvasRelativePosition(new Vector3(0.5f, 0.5f, 0f));
stackPanel.SetCanvasPinOrigin(new Vector3(.5f));
canvas = new Canvas { Children = {button1, edit1, stackPanel}, CanBeHitByUser = true };
button1.MouseOverStateChanged += (sender, args) => { triggeredButton1 = true; oldValueButton1 = args.OldValue; newValueButton1 = args.NewValue;};
button2.MouseOverStateChanged += (sender, args) => { triggeredButton2 = true;};
edit1.MouseOverStateChanged += (sender, args) => { triggeredEdit1 = true;};
edit2.MouseOverStateChanged += (sender, args) => { triggeredEdit2 = true;};
canvas.MouseOverStateChanged += (sender, args) => { triggeredCanvas = true;};
stackPanel.MouseOverStateChanged += (sender, args) => { triggeredStackPanel = true;};
canvas.UIElementServices = new UIElementServices { Services = this.Services };
UIComponent.Page = new Engine.UIPage { RootElement = canvas };
}
protected override async Task LoadContent()
{
await base.LoadContent();
var sprite = new Sprite(Asset.Load<Texture>("BorderButton")) { Borders = new Vector4(64, 64, 64, 64) };
var bi1 = new ImageElement { Source = sprite, Height = 150 };
var bi2 = new ImageElement { Source = sprite, Height = 300 };
var bi3 = new ImageElement { Source = sprite, Height = 500 };
stackPanel = new StackPanel { Orientation = Orientation.Vertical };
stackPanel.Children.Add(bi1);
stackPanel.Children.Add(bi2);
stackPanel.Children.Add(bi3);
UIComponent.RootElement = new ScrollViewer { Content = stackPanel, ScrollMode = ScrollingMode.HorizontalVertical };
}
protected override async Task LoadContent()
{
await base.LoadContent();
var image1 = new ImageElement
{
Source = new Sprite(Asset.Load<Texture>("BorderButtonCentered")) { Region = new Rectangle(256, 128, 512, 256), Borders = new Vector4(0.125f, 0.25f, 0.125f, 0.25f) },
VerticalAlignment = VerticalAlignment.Center,
HorizontalAlignment = HorizontalAlignment.Center
};
var image2 = new ImageElement
{
Source = new Sprite(Asset.Load<Texture>("uv")) { Region = new Rectangle(0, 0, 512, 512) },
VerticalAlignment = VerticalAlignment.Center,
HorizontalAlignment = HorizontalAlignment.Center
};
var image3 = new ImageElement
{
Source = new Sprite(Asset.Load<Texture>("uv")) { Region = new Rectangle(512, 0, 512, 512) },
VerticalAlignment = VerticalAlignment.Center,
HorizontalAlignment = HorizontalAlignment.Center
};
var image4 = new ImageElement
{
Source = new Sprite(Asset.Load<Texture>("uv")) { Region = new Rectangle(0, 512, 512, 512) },
VerticalAlignment = VerticalAlignment.Center,
HorizontalAlignment = HorizontalAlignment.Center
};
var image5 = new ImageElement
{
Source = new Sprite(Asset.Load<Texture>("uv")) { Region = new Rectangle(512, 512, 512, 512) },
VerticalAlignment = VerticalAlignment.Center,
HorizontalAlignment = HorizontalAlignment.Center
};
stackPanel = new StackPanel { Orientation = Orientation.Vertical };
stackPanel.Children.Add(image1);
stackPanel.Children.Add(image2);
stackPanel.Children.Add(image3);
stackPanel.Children.Add(image4);
stackPanel.Children.Add(image5);
UIComponent.RootElement = new ScrollViewer { Content = stackPanel };
}
protected override async Task LoadContent()
{
await base.LoadContent();
// build the randomStackPanel elements
randomStackPanel = new StackPanel { Orientation = Orientation.Vertical };
for (int i = 0; i < 30; i++)
randomStackPanel.Children.Add(CreateButton(0, i, 50, 1200, true));
// build the randomStackPanel elements
virtualizedStackPanel = new StackPanel { Orientation = Orientation.Vertical, ItemVirtualizationEnabled = true };
for (int i = 0; i < 30; i++)
virtualizedStackPanel.Children.Add(CreateButton(0, i, 75, 1200));
// build the uniform grid
uniformGrid = new UniformGrid { Columns = 15, Rows = 20 };
for (int c = 0; c < uniformGrid.Columns; ++c)
{
for (int r = 0; r < uniformGrid.Rows; ++r)
uniformGrid.Children.Add(CreateButton(c,r, 175, 300));
}
// build the grid
const int gridColumns = 10;
const int gridRows = 10;
grid = new Grid();
grid.LayerDefinitions.Add(new StripDefinition(StripType.Auto));
for (int i = 0; i < gridColumns; i++)
grid.ColumnDefinitions.Add(new StripDefinition(StripType.Auto));
for (int i = 0; i < gridRows; i++)
grid.RowDefinitions.Add(new StripDefinition(StripType.Auto));
for (int c = 0; c < gridColumns; ++c)
{
for (int r = 0; r < gridRows; ++r)
grid.Children.Add(CreateButton(c, r, 50 + r * 30, 100 + c * 40));
}
// build the scroll viewer
scrollViewer = new TestScrollViewer { Name = "sv", Content = randomStackPanel, ScrollMode = ScrollingMode.HorizontalVertical, SnapToAnchors = true };
// set the scroll viewer as the root
UIComponent.RootElement = scrollViewer;
}
protected override async Task LoadContent()
{
await base.LoadContent();
var sprites = Content.Load<SpriteSheet>("UIImages");
var img1 = new ImageElement { Name = "UV 1 stack panel", Source = (SpriteFromTexture)new Sprite(Content.Load<Texture>("uv")) };
var img2 = new ImageElement { Name = "UV 2 stack panel", Source = (SpriteFromTexture)new Sprite(Content.Load<Texture>("uv")) };
img3 = new ImageElement { Name = "UV 3 stack panel", Source = (SpriteFromTexture)new Sprite(Content.Load<Texture>("uv")) };
stackPanel = new StackPanel { Orientation = Orientation.Vertical };
stackPanel.Children.Add(img1);
stackPanel.Children.Add(img2);
stackPanel.Children.Add(img3);
var img4 = new ImageElement { Name = "UV grid", Source = (SpriteFromTexture)new Sprite(Content.Load<Texture>("uv")) };
var img5 = new ImageElement { Name = "UV grid 2", Source = (SpriteFromTexture)new Sprite(Content.Load<Texture>("uv")) };
var img6 = new ImageElement { Name = "Game screen grid", Source = SpriteFromSheet.Create(sprites, "GameScreen") };
img4.DependencyProperties.Set(GridBase.ColumnPropertyKey, 0);
img4.DependencyProperties.Set(GridBase.RowPropertyKey, 0);
img5.DependencyProperties.Set(GridBase.ColumnPropertyKey, 1);
img5.DependencyProperties.Set(GridBase.RowPropertyKey, 0);
img6.DependencyProperties.Set(GridBase.ColumnPropertyKey, 0);
img6.DependencyProperties.Set(GridBase.RowPropertyKey, 1);
img6.DependencyProperties.Set(GridBase.ColumnSpanPropertyKey, 2);
grid = new UniformGrid { Columns = 2, Rows = 2 };
grid.Children.Add(img4);
grid.Children.Add(img5);
grid.Children.Add(img6);
scrollViewer = new ScrollViewer { Content = grid, ScrollMode = ScrollingMode.HorizontalVertical};
contentDecorator = new ContentDecorator { Content = scrollViewer };
UIComponent.Page = new Engine.UIPage { RootElement = contentDecorator };
}
public void TestSurroudingAnchor(bool virtualizeItems)
{
var stackSize = new Vector3(100, 200, 300);
var childSize1 = new Vector3(50, 150, 250);
var childSize2 = new Vector3(150, 250, 350);
var childSize3 = new Vector3(250, 250, 350);
var stackPanel = new StackPanel { Size = stackSize, ItemVirtualizationEnabled = virtualizeItems, Orientation = Orientation.Horizontal };
var child1 = new StackPanel { Size = childSize1 };
var child2 = new StackPanel { Size = childSize2 };
var child3 = new StackPanel { Size = childSize3 };
stackPanel.Children.Add(child1);
stackPanel.Children.Add(child2);
stackPanel.Children.Add(child3);
stackPanel.Arrange(Vector3.Zero, false);
// checks in the scrolling direction
stackPanel.ScrollToBeginning(Orientation.Horizontal);
Utilities.AssertAreNearlyEqual(new Vector2(0, 50), stackPanel.GetSurroudingAnchorDistances(Orientation.Horizontal, 0));
stackPanel.ScrolllToElement(0.5f);
Utilities.AssertAreNearlyEqual(new Vector2(-25, 25), stackPanel.GetSurroudingAnchorDistances(Orientation.Horizontal, 0));
stackPanel.ScrolllToElement(1f);
Utilities.AssertAreNearlyEqual(new Vector2(0, 150), stackPanel.GetSurroudingAnchorDistances(Orientation.Horizontal, 0));
stackPanel.ScrolllToElement(2 + 3/5f);
Utilities.AssertAreNearlyEqual(new Vector2(-150, 100), stackPanel.GetSurroudingAnchorDistances(Orientation.Horizontal, 0));
stackPanel.ScrollToEnd(Orientation.Horizontal);
Utilities.AssertAreNearlyEqual(new Vector2(-150, 100), stackPanel.GetSurroudingAnchorDistances(Orientation.Horizontal, 0));
// checks in other directions
Assert.AreEqual(new Vector2(0, 200), stackPanel.GetSurroudingAnchorDistances(Orientation.Vertical, -1));
Assert.AreEqual(new Vector2(-100, 100), stackPanel.GetSurroudingAnchorDistances(Orientation.Vertical, 100));
Assert.AreEqual(new Vector2(-200, 0), stackPanel.GetSurroudingAnchorDistances(Orientation.Vertical, 500));
Assert.AreEqual(new Vector2(0, 300), stackPanel.GetSurroudingAnchorDistances(Orientation.InDepth, -1));
Assert.AreEqual(new Vector2(-150, 150), stackPanel.GetSurroudingAnchorDistances(Orientation.InDepth, 150));
Assert.AreEqual(new Vector2(-300, 0), stackPanel.GetSurroudingAnchorDistances(Orientation.InDepth, 500));
}
public void TestScrollToExtrema(bool virtualizeItems)
{
var stackSize = new Vector3(100, 200, 300);
var childSize1 = new Vector3(50, 150, 250);
var childSize2 = new Vector3(150, 250, 350);
var childSize3 = new Vector3(250, 250, 350);
var stackPanel = new StackPanel { Size = stackSize, ItemVirtualizationEnabled = virtualizeItems, Orientation = Orientation.Horizontal };
var child1 = new StackPanel { Size = childSize1 };
var child2 = new StackPanel { Size = childSize2 };
var child3 = new StackPanel { Size = childSize3 };
stackPanel.Children.Add(child1);
stackPanel.Children.Add(child2);
stackPanel.Children.Add(child3);
stackPanel.Arrange(Vector3.Zero, false);
// pre-arranged
stackPanel.ScrollToEnd(Orientation.Horizontal);
Utilities.AssertAreNearlyEqual(2 + 3 / 5f, stackPanel.ScrollPosition);
stackPanel.ScrollToBeginning(Orientation.Horizontal);
Utilities.AssertAreNearlyEqual(0, stackPanel.ScrollPosition);
// post arranged
stackPanel.InvalidateArrange();
stackPanel.ScrollToEnd(Orientation.Horizontal);
Utilities.AssertAreNearlyEqual(0, stackPanel.ScrollPosition);
stackPanel.Arrange(Vector3.Zero, false);
Utilities.AssertAreNearlyEqual(2 + 3 / 5f, stackPanel.ScrollPosition);
stackPanel.InvalidateArrange();
stackPanel.ScrollToBeginning(Orientation.Horizontal);
Utilities.AssertAreNearlyEqual(2 + 3 / 5f, stackPanel.ScrollPosition);
stackPanel.Arrange(Vector3.Zero, false);
Utilities.AssertAreNearlyEqual(0, stackPanel.ScrollPosition);
}
public void TestScrollOf(bool virtualizeItems)
{
var stackSize = new Vector3(100, 200, 300);
var childSize1 = new Vector3(50, 150, 250);
var childSize2 = new Vector3(150, 250, 350);
var childSize3 = new Vector3(250, 250, 350);
var stackPanel = new StackPanel
{
Size = stackSize,
ItemVirtualizationEnabled = virtualizeItems,
Orientation = Orientation.Horizontal,
LayoutingContext = new LayoutingContext()
};
var child1 = new StackPanel { Size = childSize1 };
var child2 = new StackPanel { Size = childSize2 };
var child3 = new StackPanel { Size = childSize3 };
stackPanel.Children.Add(child1);
stackPanel.Children.Add(child2);
stackPanel.Children.Add(child3);
stackPanel.Arrange(Vector3.Zero, false);
// pre-arranged
stackPanel.ScrollOf(childSize1);
Utilities.AssertAreNearlyEqual(1, stackPanel.ScrollPosition);
stackPanel.ScrollOf(childSize1);
Utilities.AssertAreNearlyEqual(1 + 1 / 3f, stackPanel.ScrollPosition);
// post arranged
stackPanel.InvalidateArrange();
stackPanel.ScrollOf(childSize1);
Utilities.AssertAreNearlyEqual(1 + 1 / 3f, stackPanel.ScrollPosition);
stackPanel.Arrange(Vector3.Zero, false);
Utilities.AssertAreNearlyEqual(1 + 2 / 3f, stackPanel.ScrollPosition);
stackPanel.InvalidateArrange();
stackPanel.ScrollOf(- 2 *childSize1);
Utilities.AssertAreNearlyEqual(1 + 2 / 3f, stackPanel.ScrollPosition);
stackPanel.Arrange(Vector3.Zero, false);
Utilities.AssertAreNearlyEqual(1, stackPanel.ScrollPosition);
}
private static void TestScrollBarPosition(bool virtualizeChildren)
{
var stackSize = new Vector3(100, 200, 300);
var childSize1 = new Vector3(50, 150, 250);
var childSize2 = new Vector3(150, 250, 350);
var childSize3 = new Vector3(250, 250, 350);
var stackPanel = new StackPanel { Size = stackSize, ItemVirtualizationEnabled = virtualizeChildren, Orientation = Orientation.Horizontal };
Assert.AreEqual(Vector3.Zero, stackPanel.ScrollBarPositions);
var child1 = new StackPanel { Size = childSize1 };
var child2 = new StackPanel { Size = childSize2 };
var child3 = new StackPanel { Size = childSize3 };
stackPanel.Children.Add(child1);
stackPanel.Children.Add(child2);
stackPanel.Children.Add(child3);
var reference = Vector3.Zero;
stackPanel.ScrollToBeginning(Orientation.Horizontal);
stackPanel.Arrange(Vector3.Zero, false);
Assert.AreEqual(reference, stackPanel.ScrollBarPositions);
reference[0] = 1;
stackPanel.ScrollToEnd(Orientation.Horizontal);
stackPanel.Arrange(Vector3.Zero, false);
Assert.AreEqual(reference, stackPanel.ScrollBarPositions);
stackPanel.ScrolllToElement(1);
stackPanel.Arrange(Vector3.Zero, false);
if (virtualizeChildren)
{
reference[0] = 1 / (2 + (childSize3.X - stackPanel.Size.X) / childSize3.X);
}
else
{
reference[0] = childSize1.X / (childSize1.X + childSize2.X + childSize3.X - stackPanel.Size.X);
}
Assert.AreEqual(reference, stackPanel.ScrollBarPositions);
}
public void TestScrollToNeighborScreen(bool virtualizeItems)
{
var stackSize = new Vector3(100, 200, 300);
var childSize1 = new Vector3(50, 150, 250);
var childSize2 = new Vector3(150, 250, 350);
var childSize3 = new Vector3(250, 250, 350);
var stackPanel = new StackPanel { Size = stackSize, ItemVirtualizationEnabled = virtualizeItems, Orientation = Orientation.Horizontal };
var child1 = new StackPanel { Size = childSize1 };
var child2 = new StackPanel { Size = childSize2 };
var child3 = new StackPanel { Size = childSize3 };
stackPanel.Children.Add(child1);
stackPanel.Children.Add(child2);
stackPanel.Children.Add(child3);
stackPanel.Arrange(Vector3.Zero, false);
// pre-arranged
stackPanel.ScrollToNextPage(Orientation.Horizontal);
Utilities.AssertAreNearlyEqual(1 + 1 / 3f, stackPanel.ScrollPosition);
stackPanel.ScrollToPreviousPage(Orientation.Horizontal);
Utilities.AssertAreNearlyEqual(0, stackPanel.ScrollPosition);
stackPanel.ScrolllToElement(1 + 2 / 3f);
stackPanel.ScrollToPreviousPage(Orientation.Horizontal);
Utilities.AssertAreNearlyEqual(1f, stackPanel.ScrollPosition);
stackPanel.ScrolllToElement(1 + 2 / 3f);
stackPanel.ScrollToNextPage(Orientation.Horizontal);
Utilities.AssertAreNearlyEqual(2.2f, stackPanel.ScrollPosition);
// reset scrolling
stackPanel.ScrollToBeginning(Orientation.Horizontal);
stackPanel.Arrange(Vector3.Zero, false);
// post arranged
stackPanel.InvalidateArrange();
stackPanel.ScrollToNextPage(Orientation.Horizontal);
Utilities.AssertAreNearlyEqual(0, stackPanel.ScrollPosition);
stackPanel.Arrange(Vector3.Zero, false);
Utilities.AssertAreNearlyEqual(1 + 1 / 3f, stackPanel.ScrollPosition);
stackPanel.InvalidateArrange();
stackPanel.ScrollToPreviousPage(Orientation.Horizontal);
Utilities.AssertAreNearlyEqual(1 + 1 / 3f, stackPanel.ScrollPosition);
stackPanel.Arrange(Vector3.Zero, false);
Utilities.AssertAreNearlyEqual(0, stackPanel.ScrollPosition);
stackPanel.ScrolllToElement(1 + 2 / 3f);
stackPanel.Arrange(Vector3.Zero, false);
stackPanel.InvalidateArrange();
stackPanel.ScrollToPreviousPage(Orientation.Horizontal);
Utilities.AssertAreNearlyEqual(1 + 2 / 3f, stackPanel.ScrollPosition);
stackPanel.Arrange(Vector3.Zero, false);
Utilities.AssertAreNearlyEqual(1, stackPanel.ScrollPosition);
stackPanel.ScrolllToElement(1 + 2 / 3f);
stackPanel.Arrange(Vector3.Zero, false);
stackPanel.InvalidateArrange();
stackPanel.ScrollToNextPage(Orientation.Horizontal);
Utilities.AssertAreNearlyEqual(1 + 2 / 3f, stackPanel.ScrollPosition);
stackPanel.Arrange(Vector3.Zero, false);
Utilities.AssertAreNearlyEqual(2.2f, stackPanel.ScrollPosition);
}
protected override async Task LoadContent()
{
await base.LoadContent();
var random = new Random(0);
var Sprites = Asset.Load<SpriteSheet>("UIImages");
var img1 = new ImageElement { Source = new Sprite(Asset.Load<Texture>("uv")) };
var img2 = new ImageElement { Source = Sprites["GameScreenLeft"] };
var img3 = new ImageElement { Source = Sprites["GameScreenRight"] };
stackPanel1 = new StackPanel { Orientation = Orientation.Vertical, ItemVirtualizationEnabled = true };
stackPanel1.Children.Add(img1);
stackPanel1.Children.Add(img2);
stackPanel1.Children.Add(img3);
stackPanel2 = new StackPanel { Orientation = Orientation.Vertical, ItemVirtualizationEnabled = true };
for (var i = 0; i < 1000; i++)
stackPanel2.Children.Add(new Button { Name = "" + i, Height = 75, Content = new TextBlock { Text = "button number " + i, Font = Asset.Load<SpriteFont>("MicrosoftSansSerif15") } });
stackPanel3 = new StackPanel { Orientation = Orientation.Vertical, ItemVirtualizationEnabled = true, VerticalAlignment = VerticalAlignment.Center };
for (var i = 0; i < 103; i++)
stackPanel3.Children.Add(new Button { Name = "" + i, Height = 50 + 500 * random.NextFloat(), Content = new TextBlock { Text = "random button number " + i, Font = Asset.Load<SpriteFont>("MicrosoftSansSerif15") } });
stackPanel4 = new StackPanel { Orientation = Orientation.Vertical, ItemVirtualizationEnabled = true };
for (var i = 0; i < 5; i++)
stackPanel4.Children.Add(new Button { Name = "" + i, Height = i * 30, Content = new TextBlock { Text = "random button number " + i, Font = Asset.Load<SpriteFont>("MicrosoftSansSerif15") } });
currentStackPanel = stackPanel1;
scrollViewer = new ScrollViewer { Name = "sv", Content = currentStackPanel, ScrollMode = ScrollingMode.Vertical };
UIComponent.RootElement = scrollViewer;
}
public void TestViewport(bool virtualizeChildren)
{
var random = new Random();
var childSize1 = new Vector3(50, 150, 250);
var childSize2 = new Vector3(150, 250, 350);
var childSize3 = new Vector3(250, 250, 350);
var childSize4 = new Vector3(350, 250, 350);
var stackPanel = new StackPanel { DepthAlignment = DepthAlignment.Stretch, ItemVirtualizationEnabled = virtualizeChildren };
Assert.AreEqual(Vector3.Zero, stackPanel.Viewport);
var child1 = new StackPanel { Size = childSize1 };
var child2 = new StackPanel { Size = childSize2 };
var child3 = new StackPanel { Size = childSize3 };
var child4 = new StackPanel { Size = childSize4 };
stackPanel.Children.Add(child1);
stackPanel.Children.Add(child2);
stackPanel.Children.Add(child3);
stackPanel.Children.Add(child4);
var referencePosition = Vector3.Zero;
stackPanel.Arrange(referencePosition, false);
Assert.AreEqual(referencePosition, stackPanel.Viewport);
referencePosition = random.NextVector3();
stackPanel.Arrange(referencePosition, false);
Assert.AreEqual(referencePosition, stackPanel.Viewport);
referencePosition = random.NextVector3();
stackPanel.ScrollToEnd(Orientation.Horizontal);
stackPanel.ScrollToEnd(Orientation.Vertical);
stackPanel.Children.Remove(child4);
stackPanel.Arrange(referencePosition, false);
Assert.AreEqual(referencePosition, stackPanel.Viewport);
var stackSize = new Vector3(100, 200, 300);
stackPanel.Size = stackSize;
stackPanel.Arrange(Vector3.Zero, false);
Assert.AreEqual(stackSize, stackPanel.Viewport);
}
private void TestExtent(Orientation direction)
{
var stackSize = new Vector3(100, 200, 300);
var childSize1 = new Vector3(50, 150, 250);
var childSize2 = new Vector3(150, 250, 350);
var stackPanel = new StackPanel { Size = stackSize, Orientation = direction };
Assert.AreEqual(Vector3.Zero, stackPanel.Extent);
var child1 = new StackPanel { Size = childSize1 };
var child2 = new StackPanel { Size = childSize2 };
var child3 = new StackPanel { Size = childSize1 };
stackPanel.Children.Add(child1);
stackPanel.Children.Add(child2);
stackPanel.Children.Add(child3);
stackPanel.Arrange(Vector3.Zero, false);
var exactReferenceExtent = stackSize;
exactReferenceExtent[(int)direction] = 0;
foreach (var child in stackPanel.Children)
exactReferenceExtent[(int)direction] += child.Size[(int)direction];
Assert.AreEqual(exactReferenceExtent, stackPanel.Extent);
// with virtualized items.
stackPanel.ItemVirtualizationEnabled = true;
stackPanel.Arrange(Vector3.Zero, false);
var childCount = 0;
var approximatedSize = 0f;
var approximatedReferenceExtent = stackSize;
while (childCount < stackPanel.Children.Count-1 && approximatedSize < stackPanel.Size[(int)direction])
{
++childCount;
approximatedSize += stackPanel.Children[stackPanel.Children.Count - childCount].Size[(int)direction];
}
approximatedReferenceExtent[(int)direction] = stackPanel.Children.Count / (float)childCount * approximatedSize;
Assert.AreEqual(approximatedReferenceExtent, stackPanel.Extent);
}
public void TestOffset()
{
var stackSize = new Vector3(100, 200, 300);
var childSize1 = new Vector3(50, 150, 250);
var childSize2 = new Vector3(150, 250, 350);
var childSize3 = new Vector3(250, 250, 350);
var childSize4 = new Vector3(350, 250, 350);
var stackPanel = new StackPanel { Size = stackSize, Orientation = Orientation.Horizontal };
Assert.AreEqual(Vector3.Zero, stackPanel.Offset);
var child1 = new StackPanel { Size = childSize1 };
var child2 = new StackPanel { Size = childSize2 };
var child3 = new StackPanel { Size = childSize3 };
var child4 = new StackPanel { Size = childSize4 };
stackPanel.Children.Add(child1);
stackPanel.Children.Add(child2);
stackPanel.Children.Add(child3);
stackPanel.Children.Add(child4);
var refenceOffset = Vector3.Zero;
// non virtualized children
stackPanel.ScrolllToElement(1);
stackPanel.Arrange(Vector3.Zero, false);
refenceOffset[0] -= childSize1.X;
Assert.AreEqual(refenceOffset, stackPanel.Offset);
stackPanel.ScrolllToElement(2.5f);
stackPanel.Arrange(Vector3.Zero, false);
refenceOffset[0] -= childSize2.X + childSize3.X / 2;
Assert.AreEqual(refenceOffset, stackPanel.Offset);
stackPanel.ScrollToEnd(Orientation.Horizontal);
stackPanel.Arrange(Vector3.Zero, false);
refenceOffset[0] = -childSize1.X - childSize2.X - childSize3.X - childSize4.X + stackPanel.Size.X;
Assert.IsTrue((refenceOffset-stackPanel.Offset).Length() < 0.001);
// virtualized children
refenceOffset[0] = 0;
stackPanel.ScrolllToElement(0);
stackPanel.ItemVirtualizationEnabled = true;
stackPanel.Arrange(Vector3.Zero, false);
Assert.AreEqual(refenceOffset, stackPanel.Offset);
refenceOffset[0] = 0;
stackPanel.ScrolllToElement(1);
stackPanel.Arrange(Vector3.Zero, false);
Assert.AreEqual(refenceOffset, stackPanel.Offset);
refenceOffset[0] = -childSize3.X / 2;
stackPanel.ScrolllToElement(2.5f);
stackPanel.Arrange(Vector3.Zero, false);
Assert.AreEqual(refenceOffset, stackPanel.Offset);
stackPanel.ScrollToEnd(Orientation.Horizontal);
stackPanel.Arrange(Vector3.Zero, false);
refenceOffset[0] = -childSize4.X + stackPanel.Size.X;
Assert.IsTrue((refenceOffset-stackPanel.Offset).Length() < 0.001);
}
public void TestBasicInvalidations()
{
var panel = new StackPanel();
var child = new StackPanel();
panel.Children.Add(child);
// - test the properties that are not supposed to invalidate the object layout state
UIElementLayeringTests.TestNoInvalidation(panel, () => child.DependencyProperties.Set(ZIndexPropertyKey, 37));
}
/// <summary>
/// Creates UI showing parameters of Fault formation algorithm
/// </summary>
private void CreateUI()
{
var virtualResolution = new Vector3(GraphicsDevice.Presenter.BackBuffer.Width, GraphicsDevice.Presenter.BackBuffer.Height, 1);
loadingModal = new ModalElement { Visibility = Visibility.Collapsed };
loadingTextBlock = new TextBlock { Font = Font, Text = "Loading a model...", Visibility = Visibility.Collapsed, TextColor = Color.White, TextSize = 22 };
loadingTextBlock.SetCanvasPinOrigin(new Vector3(0.5f, 0.5f, 1f));
loadingTextBlock.SetCanvasRelativePosition(new Vector3(0.5f, 0.5f, 0));
// Parameters Grid
var parametersGrid = new Grid();
parametersGrid.LayerDefinitions.Add(new StripDefinition(StripType.Auto));
parametersGrid.RowDefinitions.Add(new StripDefinition(StripType.Auto));
parametersGrid.RowDefinitions.Add(new StripDefinition(StripType.Auto));
parametersGrid.RowDefinitions.Add(new StripDefinition(StripType.Auto));
parametersGrid.RowDefinitions.Add(new StripDefinition(StripType.Auto));
parametersGrid.RowDefinitions.Add(new StripDefinition(StripType.Auto));
parametersGrid.ColumnDefinitions.Add(new StripDefinition(StripType.Auto));
parametersGrid.ColumnDefinitions.Add(new StripDefinition(StripType.Star));
parametersGrid.ColumnDefinitions.Add(new StripDefinition(StripType.Fixed, 30));
parametersGrid.ColumnDefinitions.Add(new StripDefinition(StripType.Fixed, 30));
// Terrain Size
var terrainSizeText = new TextBlock
{
Font = Font,
Text = "" + (int)Math.Pow(2, terrainSizePowerFactor),
TextAlignment = TextAlignment.Center,
VerticalAlignment = VerticalAlignment.Center,
HorizontalAlignment = HorizontalAlignment.Center,
MinimumWidth = 60
};
terrainSizeText.SetGridRow(0);
terrainSizeText.SetGridColumn(1);
var terrainSizeIncButton = new Button { Content = new TextBlock { Text = "+", Font = Font, TextAlignment = TextAlignment.Center } };
terrainSizeIncButton.SetGridRow(0);
terrainSizeIncButton.SetGridColumn(3);
var terrainSizeDecButton = new Button { Content = new TextBlock { Text = "-", Font = Font, TextAlignment = TextAlignment.Center } };
terrainSizeDecButton.SetGridRow(0);
terrainSizeDecButton.SetGridColumn(2);
terrainSizeIncButton.Click += (s, e) =>
{
TerrainSizePowerFactor++;
terrainSizeText.Text = "" + (int)Math.Pow(2, TerrainSizePowerFactor);
};
terrainSizeDecButton.Click += (s, e) =>
{
TerrainSizePowerFactor--;
terrainSizeText.Text = "" + (int)Math.Pow(2, TerrainSizePowerFactor);
};
var terrainSizeDescription = new TextBlock
{
Font = Font,
Text = "Terrain Size:",
TextAlignment = TextAlignment.Center,
VerticalAlignment = VerticalAlignment.Center,
HorizontalAlignment = HorizontalAlignment.Left
};
terrainSizeDescription.SetGridRow(0);
terrainSizeDescription.SetGridColumn(0);
parametersGrid.Children.Add(terrainSizeDescription);
parametersGrid.Children.Add(terrainSizeText);
parametersGrid.Children.Add(terrainSizeDecButton);
parametersGrid.Children.Add(terrainSizeIncButton);
// Iteration
var iterationText = new TextBlock
{
Font = Font,
Text = "" + (int)Math.Pow(2, IterationPowerFactor),
TextAlignment = TextAlignment.Center,
VerticalAlignment = VerticalAlignment.Center,
HorizontalAlignment = HorizontalAlignment.Center
};
iterationText.SetGridRow(1);
iterationText.SetGridColumn(1);
var iterationIncButton = new Button { Content = new TextBlock { Text = "+", Font = Font, TextAlignment = TextAlignment.Center } };
iterationIncButton.SetGridRow(1);
iterationIncButton.SetGridColumn(3);
var iterationDecButton = new Button { Content = new TextBlock { Text = "-", Font = Font, TextAlignment = TextAlignment.Center } };
iterationDecButton.SetGridRow(1);
iterationDecButton.SetGridColumn(2);
iterationIncButton.Click += (s, e) =>
{
IterationPowerFactor++;
iterationText.Text = "" + (int)Math.Pow(2, IterationPowerFactor);
};
iterationDecButton.Click += (s, e) =>
{
IterationPowerFactor--;
iterationText.Text = "" + (int)Math.Pow(2, IterationPowerFactor);
};
var iterationDescription = new TextBlock
{
Font = Font,
Text = "Iteration:",
TextAlignment = TextAlignment.Center,
VerticalAlignment = VerticalAlignment.Center,
HorizontalAlignment = HorizontalAlignment.Left
};
iterationDescription.SetGridRow(1);
iterationDescription.SetGridColumn(0);
parametersGrid.Children.Add(iterationDescription);
parametersGrid.Children.Add(iterationText);
parametersGrid.Children.Add(iterationDecButton);
parametersGrid.Children.Add(iterationIncButton);
// Filter Intensity
var filterIntensityText = new TextBlock
{
Font = Font,
Text = "" + FilterHeightBandStrength,
TextAlignment = TextAlignment.Center,
VerticalAlignment = VerticalAlignment.Center,
HorizontalAlignment = HorizontalAlignment.Center
};
filterIntensityText.SetGridRow(2);
filterIntensityText.SetGridColumn(1);
var filterIncButton = new Button { Content = new TextBlock { Text = "+", Font = Font, TextAlignment = TextAlignment.Center } };
filterIncButton.SetGridRow(2);
filterIncButton.SetGridColumn(3);
var filterDecButton = new Button { Content = new TextBlock { Text = "-", Font = Font, TextAlignment = TextAlignment.Center } };
filterDecButton.SetGridRow(2);
filterDecButton.SetGridColumn(2);
filterIncButton.Click += (s, e) =>
{
FilterHeightBandStrength += 0.1f;
filterIntensityText.Text = "" + FilterHeightBandStrength;
};
filterDecButton.Click += (s, e) =>
{
FilterHeightBandStrength -= 0.1f;
filterIntensityText.Text = "" + FilterHeightBandStrength;
};
var filterIntensityDescription = new TextBlock
{
Font = Font,
Text = "Filter Intensity:",
TextAlignment = TextAlignment.Center,
VerticalAlignment = VerticalAlignment.Center,
HorizontalAlignment = HorizontalAlignment.Left
};
filterIntensityDescription.SetGridRow(2);
filterIntensityDescription.SetGridColumn(0);
parametersGrid.Children.Add(filterIntensityDescription);
parametersGrid.Children.Add(filterIntensityText);
parametersGrid.Children.Add(filterDecButton);
parametersGrid.Children.Add(filterIncButton);
// Height Scale
var heightScaleText = new TextBlock
{
Font = Font,
Text = "" + TerrainHeightScale,
TextAlignment = TextAlignment.Center,
VerticalAlignment = VerticalAlignment.Center,
HorizontalAlignment = HorizontalAlignment.Center
};
heightScaleText.SetGridRow(3);
heightScaleText.SetGridColumn(1);
var heightScaleIncButton = new Button { Content = new TextBlock { Text = "+", Font = Font, TextAlignment = TextAlignment.Center } };
heightScaleIncButton.SetGridRow(3);
heightScaleIncButton.SetGridColumn(3);
var heightScaleDecButton = new Button { Content = new TextBlock { Text = "-", Font = Font, TextAlignment = TextAlignment.Center } };
heightScaleDecButton.SetGridRow(3);
heightScaleDecButton.SetGridColumn(2);
heightScaleIncButton.Click += (s, e) =>
{
TerrainHeightScale++;
heightScaleText.Text = "" + TerrainHeightScale;
};
heightScaleDecButton.Click += (s, e) =>
{
TerrainHeightScale--;
heightScaleText.Text = "" + TerrainHeightScale;
};
var heightScaleDescription = new TextBlock
{
Font = Font,
Text = "Height Scale:",
TextAlignment = TextAlignment.Center,
VerticalAlignment = VerticalAlignment.Center,
HorizontalAlignment = HorizontalAlignment.Left
};
heightScaleDescription.SetGridRow(3);
heightScaleDescription.SetGridColumn(0);
parametersGrid.Children.Add(heightScaleDescription);
parametersGrid.Children.Add(heightScaleText);
parametersGrid.Children.Add(heightScaleDecButton);
parametersGrid.Children.Add(heightScaleIncButton);
// Zoom
var zoomFactorIncButton = new Button { Content = new TextBlock { Text = "+", Font = Font, TextAlignment = TextAlignment.Center } };
zoomFactorIncButton.SetGridRow(4);
zoomFactorIncButton.SetGridColumn(3);
var zoomFactorDecButton = new Button { Content = new TextBlock { Text = "-", Font = Font, TextAlignment = TextAlignment.Center } };
zoomFactorDecButton.SetGridRow(4);
zoomFactorDecButton.SetGridColumn(2);
zoomFactorIncButton.Click += (s, e) =>
{
zoomFactor -= 0.1f;
UpdateCamera();
};
zoomFactorDecButton.Click += (s, e) =>
{
zoomFactor += 0.1f;
UpdateCamera();
};
var zoomDescription = new TextBlock
{
Font = Font,
Text = "Zoom",
TextAlignment = TextAlignment.Center,
VerticalAlignment = VerticalAlignment.Center,
HorizontalAlignment = HorizontalAlignment.Right
};
zoomDescription.SetGridRow(4);
zoomDescription.SetGridColumn(0);
parametersGrid.Children.Add(zoomDescription);
parametersGrid.Children.Add(zoomFactorDecButton);
parametersGrid.Children.Add(zoomFactorIncButton);
// Light toggle button
var lightToggleButton = new Button { Content = new TextBlock { Text = "Directional Light Off", Font = Font }, HorizontalAlignment = HorizontalAlignment.Left };
lightToggleButton.Click += (s, e) =>
{
var ligh0 = DirectionalLight0.Get<LightComponent>();
var ligh1 = DirectionalLight1.Get<LightComponent>();
ligh0.Enabled = !ligh0.Enabled;
ligh1.Enabled = !ligh1.Enabled;
((TextBlock)lightToggleButton.Content).Text = ligh0.Enabled ? "Directional Light Off" : "Directional Light On";
};
// Re-create terrain
var reCreateTerrainButton = new Button { Content = new TextBlock { Text = "Recreate terrain", Font = Font }, HorizontalAlignment = HorizontalAlignment.Left };
reCreateTerrainButton.Click += (s, e) => GenerateTerrain();
var descriptionCanvas = new StackPanel
{
Children =
{
new TextBlock { Font = Font, Text = "Fault formation parameters", TextSize = 19},
parametersGrid,
lightToggleButton,
reCreateTerrainButton
}
};
var activeButton = new Button
{
Content = new TextBlock { Text = "Description Off", Font = Font },
Padding = new Thickness(10, 10, 10, 10),
Margin = new Thickness(0, 0, 0, 20),
HorizontalAlignment = HorizontalAlignment.Left
};
var isDescriptionOn = true;
activeButton.Click += (s, e) =>
{
isDescriptionOn = !isDescriptionOn;
((TextBlock)activeButton.Content).Text = isDescriptionOn ? "Description Off" : "Description On";
descriptionCanvas.Visibility = isDescriptionOn ? Visibility.Visible : Visibility.Collapsed;
};
var buttonDescription = new StackPanel { Orientation = Orientation.Vertical, Children = { activeButton, descriptionCanvas } };
var uiComponent = UIEntity.Get<UIComponent>();
uiComponent.RootElement = new Canvas { Children = { buttonDescription, loadingModal, loadingTextBlock } };
uiComponent.Resolution = virtualResolution;
}
protected override async Task LoadContent()
{
await base.LoadContent();
var resolution = (Vector3)UIComponent.VirtualResolution;
var canvas = new Canvas();
var imgElt = new ImageElement { Name = "UV image", Source = new Sprite(Asset.Load<Texture>("uv")), Width = resolution.X / 5, Height = resolution.Y / 5, StretchType = StretchType.Fill };
imgElt.DependencyProperties.Set(Canvas.PinOriginPropertyKey, 0.5f * Vector3.One);
imgElt.DependencyProperties.Set(Canvas.AbsolutePositionPropertyKey, new Vector3(resolution.X / 10, resolution.Y / 10, 0));
imgElt.DependencyProperties.Set(Panel.ZIndexPropertyKey, -1);
stackPanel = new StackPanel { Orientation = Orientation.Vertical };
scrollViewer = new ScrollViewer { ScrollMode = ScrollingMode.Vertical };
scrollViewer.DependencyProperties.Set(Canvas.AbsolutePositionPropertyKey, new Vector3(resolution.X / 4, resolution.Y / 10, 0));
scrollViewer.Content = stackPanel;
var button1 = new Button { Margin = Thickness.UniformRectangle(5), Padding = Thickness.UniformRectangle(5), LocalMatrix = Matrix.Scaling(2, 2, 2) };
var textOnly = new TextBlock { Text = "Text only button", Font = Asset.Load<SpriteFont>("MicrosoftSansSerif15"), TextColor = new Color(1f, 0, 0, 0.5f) };
button1.Content = textOnly;
var button2 = new Button { Name = "Button2", Margin = Thickness.UniformRectangle(5), Padding = Thickness.UniformRectangle(5) };
var imageContent = new ImageElement { Name = "Image Button2", Source = new Sprite(Asset.Load<Texture>("uv")), StretchType = StretchType.FillOnStretch, MaximumHeight = 50 };
button2.Content = imageContent;
var button3 = new Button { Margin = Thickness.UniformRectangle(5), Padding = Thickness.UniformRectangle(5) };
var stackContent = new StackPanel { Orientation = Orientation.Horizontal };
var stackImage = new ImageElement { Name = "Image stack panel", Source = new Sprite(Asset.Load<Texture>("uv")), MaximumHeight = 50 };
var stackText = new TextBlock { Text = "button text", Font = Asset.Load<SpriteFont>("MicrosoftSansSerif15"), Margin = Thickness.UniformRectangle(5) };
stackContent.Children.Add(stackImage);
stackContent.Children.Add(stackText);
button3.Content = stackContent;
var button4 = new Button { Margin = Thickness.UniformRectangle(5), HorizontalAlignment = HorizontalAlignment.Right, Padding = Thickness.UniformRectangle(5) };
var imageContent2 = new ImageElement { Name = "button 4 uv image", Source = new Sprite(Asset.Load<Texture>("uv")), StretchType = StretchType.FillOnStretch, MaximumHeight = 40, Opacity = 0.5f };
button4.Content = imageContent2;
var button5 = new Button { Margin = Thickness.UniformRectangle(5), HorizontalAlignment = HorizontalAlignment.Left, Padding = Thickness.UniformRectangle(5) };
var textOnly2 = new TextBlock { Text = "Left aligned", Font = Asset.Load<SpriteFont>("MicrosoftSansSerif15") };
button5.Content = textOnly2;
var button6 = new ImageButton
{
Height = 50,
Margin = Thickness.UniformRectangle(5),
HorizontalAlignment = HorizontalAlignment.Center,
PressedImage = new Sprite(Asset.Load<Texture>("ImageButtonPressed")),
NotPressedImage = new Sprite(Asset.Load<Texture>("ImageButtonNotPressed")),
};
toggle = new ToggleButton
{
Content = new TextBlock { Text = "Toggle button test", Font = Asset.Load<SpriteFont>("MicrosoftSansSerif15") },
IsThreeState = true
};
scrollingText = new ScrollingText { Font = Asset.Load<SpriteFont>("MicrosoftSansSerif15"), Text = "<<<--- Scrolling text in a button ", IsEnabled = IsUpdateAutomatic };
var button7 = new Button { Margin = Thickness.UniformRectangle(5), Content = scrollingText };
var uniformGrid = new UniformGrid { Rows = 2, Columns = 2 };
var gridText = new TextBlock { Text = "Uniform grid", Font = Asset.Load<SpriteFont>("MicrosoftSansSerif15"), TextAlignment = TextAlignment.Center};
gridText.DependencyProperties.Set(GridBase.ColumnSpanPropertyKey, 2);
var buttonLeft = new Button { Content = new TextBlock { Text = "unif-grid left", Font = Asset.Load<SpriteFont>("MicrosoftSansSerif15"), TextAlignment = TextAlignment.Center } };
buttonLeft.DependencyProperties.Set(GridBase.RowPropertyKey, 1);
var buttonRight = new Button { Content = new TextBlock { Text = "unif-grid right", Font = Asset.Load<SpriteFont>("MicrosoftSansSerif15"), TextAlignment = TextAlignment.Center } };
buttonRight.DependencyProperties.Set(GridBase.RowPropertyKey, 1);
buttonRight.DependencyProperties.Set(GridBase.ColumnPropertyKey, 1);
uniformGrid.Children.Add(gridText);
uniformGrid.Children.Add(buttonLeft);
uniformGrid.Children.Add(buttonRight);
stackPanel.Children.Add(button1);
stackPanel.Children.Add(button2);
stackPanel.Children.Add(button3);
stackPanel.Children.Add(button4);
stackPanel.Children.Add(button5);
stackPanel.Children.Add(button6);
stackPanel.Children.Add(toggle);
stackPanel.Children.Add(button7);
stackPanel.Children.Add(uniformGrid);
canvas.Children.Add(imgElt);
canvas.Children.Add(scrollViewer);
UIComponent.RootElement = canvas;
}
protected override async Task LoadContent()
{
await base.LoadContent();
var random = new Random(0);
var sprites = Content.Load<SpriteSheet>("UIImages");
var img1 = new ImageElement { Source = (SpriteFromTexture)new Sprite(Content.Load<Texture>("uv")) };
var img2 = new ImageElement { Source = SpriteFromSheet.Create(sprites, "GameScreenLeft") };
var img3 = new ImageElement { Source = SpriteFromSheet.Create(sprites, "GameScreenRight") };
stackPanel1 = new StackPanel { Orientation = Orientation.Vertical, ItemVirtualizationEnabled = true };
stackPanel1.Children.Add(img1);
stackPanel1.Children.Add(img2);
stackPanel1.Children.Add(img3);
stackPanel2 = new StackPanel { Orientation = Orientation.Vertical, ItemVirtualizationEnabled = true };
for (var i = 0; i < 1000; i++)
stackPanel2.Children.Add(CreateButton("" + i, 75, "button number " + i));
stackPanel3 = new StackPanel { Orientation = Orientation.Vertical, ItemVirtualizationEnabled = true, VerticalAlignment = VerticalAlignment.Center };
for (var i = 0; i < 103; i++)
stackPanel3.Children.Add(CreateButton("" + i, 50 + 500 * random.NextFloat(), "random button number " + i));
stackPanel4 = new StackPanel { Orientation = Orientation.Vertical, ItemVirtualizationEnabled = true };
for (var i = 0; i < 5; i++)
stackPanel4.Children.Add(CreateButton("" + i, i * 30, "random button number "));
currentStackPanel = stackPanel1;
scrollViewer = new ScrollViewer { Name = "sv", Content = currentStackPanel, ScrollMode = ScrollingMode.Vertical };
UIComponent.Page = new Engine.UIPage { RootElement = scrollViewer };
}
private void SetCurrentContent(StackPanel newContent)
{
currentStackPanel = newContent;
scrollViewer.Content = currentStackPanel;
}
public void TestItemVirtualizedMeasure()
{
var measureSize = new Vector3(100, 200, 300);
var stackPanel = new StackPanel { ItemVirtualizationEnabled = true, Orientation = Orientation.Vertical };
stackPanel.Children.Add(new UniformGrid { Width = 10, Height = 40 });
stackPanel.Children.Add(new UniformGrid { Width = 20, Height = 30 });
stackPanel.Children.Add(new UniformGrid { Width = 30, Height = 20 });
stackPanel.Measure(measureSize);
Assert.AreEqual(new Vector3(30, 90, 0), stackPanel.DesiredSizeWithMargins);
}
private static void TestScrollPosition(bool virtualizeChildren)
{
var stackSize = new Vector3(100, 200, 300);
var childSize1 = new Vector3(50, 150, 250);
var childSize2 = new Vector3(150, 250, 350);
var childSize3 = new Vector3(250, 250, 350);
var childSize4 = new Vector3(350, 250, 350);
var stackPanel = new StackPanel { Size = stackSize, Orientation = Orientation.Horizontal, ItemVirtualizationEnabled = virtualizeChildren};
Assert.AreEqual(0f, stackPanel.ScrollPosition);
var child1 = new StackPanel { Size = childSize1 };
var child2 = new StackPanel { Size = childSize2 };
var child3 = new StackPanel { Size = childSize3 };
var child4 = new StackPanel { Size = childSize4 };
stackPanel.Children.Add(child1);
stackPanel.Children.Add(child2);
stackPanel.Children.Add(child3);
stackPanel.Children.Add(child4);
float referencePosition = 0;
stackPanel.ScrolllToElement(referencePosition);
stackPanel.Arrange(Vector3.Zero, false);
Assert.AreEqual(referencePosition, stackPanel.ScrollPosition);
referencePosition = 1;
stackPanel.ScrolllToElement(referencePosition);
stackPanel.Arrange(Vector3.Zero, false);
Assert.AreEqual(referencePosition, stackPanel.ScrollPosition);
referencePosition = 2;
stackPanel.ScrolllToElement(referencePosition);
stackPanel.Arrange(Vector3.Zero, false);
Assert.AreEqual(referencePosition, stackPanel.ScrollPosition);
referencePosition = 2.3f;
stackPanel.ScrolllToElement(referencePosition);
stackPanel.Arrange(Vector3.Zero, false);
Assert.AreEqual(referencePosition, stackPanel.ScrollPosition);
stackPanel.ScrollToEnd(Orientation.Horizontal);
referencePosition = 3 + (childSize4.X - stackSize.X) / childSize4.X;
stackPanel.Arrange(Vector3.Zero, false);
Assert.IsTrue(Math.Abs(referencePosition - stackPanel.ScrollPosition) < MathUtil.ZeroTolerance);
}
public void TestCanScroll()
{
var stackPanel = new StackPanel();
stackPanel.Orientation = Orientation.Horizontal;
AssertCanScroll(stackPanel);
}
public void TestPropagateEvent()
{
// create a hierarchy of UIElements
// (00)
// |
// (10)
// / \
// (20) (21)
// | / \
// (30) (31) (32)
var element00 = new ContentControlTest();
var element10 = new StackPanel();
var element20 = new ContentControlTest();
var element21 = new StackPanel();
var element30 = new UIElementLayeringTests();
var element31 = new UIElementLayeringTests();
var element32 = new UIElementLayeringTests();
element00.Content = element10;
element10.Children.Add(element20);
element10.Children.Add(element21);
element20.Content = element30;
element21.Children.Add(element31);
element21.Children.Add(element32);
var elements = new List<UIElement> { element00, element10, element20, element21, element30, element31, element32 };
// create routed events
var tunnelingEvent = EventManager.RegisterRoutedEvent<RoutedEventArgs>("TestTuneling", RoutingStrategy.Tunnel, typeof(UIElementLayeringTests));
var bubblingEvent = EventManager.RegisterRoutedEvent<RoutedEventArgs>("TestBubbling", RoutingStrategy.Bubble, typeof(UIElementLayeringTests));
var directEvent = EventManager.RegisterRoutedEvent<RoutedEventArgs>("TestDirect", RoutingStrategy.Direct, typeof(UIElementLayeringTests));
// test propagation direction, propagation bounds and sender values
foreach (var uiElement in elements)
{
uiElement.AddHandler(tunnelingEvent, TestAddSenderToList);
uiElement.AddHandler(bubblingEvent, TestAddSenderToList);
uiElement.AddHandler(directEvent, TestAddSenderToList);
}
// tunneling test 1
senderList.Clear();
element20.RaiseEvent(new RoutedEventArgs(tunnelingEvent));
Assert.AreEqual(3, senderList.Count);
Assert.AreEqual(element00, senderList[0]);
Assert.AreEqual(element10, senderList[1]);
Assert.AreEqual(element20, senderList[2]);
// tunneling test 2
senderList.Clear();
element31.RaiseEvent(new RoutedEventArgs(tunnelingEvent));
Assert.AreEqual(4, senderList.Count);
Assert.AreEqual(element00, senderList[0]);
Assert.AreEqual(element10, senderList[1]);
Assert.AreEqual(element21, senderList[2]);
Assert.AreEqual(element31, senderList[3]);
// direct test
senderList.Clear();
element10.RaiseEvent(new RoutedEventArgs(directEvent));
Assert.AreEqual(1, senderList.Count);
Assert.AreEqual(element10, senderList[0]);
// tunneling test 1
senderList.Clear();
element30.RaiseEvent(new RoutedEventArgs(bubblingEvent));
Assert.AreEqual(4, senderList.Count);
Assert.AreEqual(element30, senderList[0]);
Assert.AreEqual(element20, senderList[1]);
Assert.AreEqual(element10, senderList[2]);
Assert.AreEqual(element00, senderList[3]);
// tunneling test 2
senderList.Clear();
element20.RaiseEvent(new RoutedEventArgs(bubblingEvent));
Assert.AreEqual(3, senderList.Count);
Assert.AreEqual(element20, senderList[0]);
Assert.AreEqual(element10, senderList[1]);
Assert.AreEqual(element00, senderList[2]);
// test with another type of handler
var eventMyTestHandler = EventManager.RegisterRoutedEvent<MyTestRoutedEventArgs>("TestMyTestHandler", RoutingStrategy.Direct, typeof(UIElementLayeringTests));
AddHandler(eventMyTestHandler, TestMyTestHandler);
RaiseEvent(new MyTestRoutedEventArgs(eventMyTestHandler));
Assert.AreEqual(true, testMyTestHandlerCalled);
// test Handled and EventHandledToo
foreach (var uiElement in elements)
{
uiElement.RemoveHandler(bubblingEvent, TestAddSenderToList);
uiElement.AddHandler(bubblingEvent, TestHandledHandler);
}
senderList.Clear();
element00.AddHandler(bubblingEvent, TestEventHandledHandler, true);
element32.RaiseEvent(new RoutedEventArgs(bubblingEvent));
Assert.AreEqual(1, senderList.Count);
Assert.AreEqual(element32, senderList[0]);
Assert.AreEqual(true, testEventHandledTooCalled);
// test class handlers basic working
foreach (var uiElement in elements)
uiElement.RemoveHandler(bubblingEvent, TestHandledHandler);
EventManager.RegisterClassHandler(typeof(ContentControl), bubblingEvent, TestAddSenderToClassHandlerList);
element30.RaiseEvent(new RoutedEventArgs(bubblingEvent));
Assert.AreEqual(2, classHandlerSenderList.Count);
Assert.AreEqual(element20, classHandlerSenderList[0]);
Assert.AreEqual(element00, classHandlerSenderList[1]);
// test that class handlers are called before instance handlers + test handledEventToo for class handlers
senderList.Clear();
classHandlerSenderList.Clear();
EventManager.RegisterClassHandler(typeof(ContentControl), bubblingEvent, TestClassHandlerHandled);
EventManager.RegisterClassHandler(typeof(StackPanel), bubblingEvent, TestClassHandlerEventHandled, true);
foreach (var uiElement in elements)
uiElement.AddHandler(bubblingEvent, TestAddSenderToList);
element20.RaiseEvent(new RoutedEventArgs(bubblingEvent));
Assert.AreEqual(1, classHandlerSenderList.Count);
Assert.AreEqual(element20, classHandlerSenderList[0]);
Assert.AreEqual(0, senderList.Count);
Assert.AreEqual(true, testClassHandlerEventHandledTooCalled);
}
private void AssertCanScroll(StackPanel stackPanel)
{
for (int i = 0; i < 3; i++)
Assert.AreEqual(i==(int)stackPanel.Orientation, stackPanel.CanScroll((Orientation)i));
}
public void TestBasicInvalidations()
{
var stackPanel = new StackPanel();
// - test the properties that are supposed to invalidate the object measurement
UIElementLayeringTests.TestMeasureInvalidation(stackPanel, () => stackPanel.Orientation = Orientation.InDepth);
}