public void Only_Calls_LayoutManager_InvalidateArrange_Once()
        {
            var target  = new Mock <ILayoutManager>();
            var control = new Decorator();
            var root    = new LayoutTestRoot
            {
                Child         = control,
                LayoutManager = target.Object,
            };

            root.Measure(Size.Infinity);
            root.Arrange(new Rect(root.DesiredSize));
            target.ResetCalls();

            control.InvalidateArrange();
            control.InvalidateArrange();

            target.Verify(x => x.InvalidateArrange(control), Times.Once());
        }
Beispiel #2
0
        public void Doesnt_Measure_Non_Invalidated_Root()
        {
            var control = new LayoutTestControl();
            var root    = new LayoutTestRoot {
                Child = control
            };

            root.LayoutManager.ExecuteInitialLayoutPass(root);
            root.Measured    = root.Arranged = false;
            control.Measured = control.Arranged = false;

            control.InvalidateMeasure();
            root.LayoutManager.ExecuteLayoutPass();

            Assert.False(root.Measured);
            Assert.False(root.Arranged);
            Assert.True(control.Measured);
            Assert.True(control.Arranged);
        }
        public void Arranges_InvalidateArranged_Control()
        {
            var target = new LayoutManager();

            using (Start(target))
            {
                var control = new LayoutTestControl();
                var root = new LayoutTestRoot { Child = control };

                target.ExecuteInitialLayoutPass(root);
                control.Measured = control.Arranged = false;

                control.InvalidateArrange();
                target.ExecuteLayoutPass();

                Assert.False(control.Measured);
                Assert.True(control.Arranged);
            }
        }
        public void Doesnt_Measure_Removed_Control()
        {
            var target = new LayoutManager();

            using (Start(target))
            {
                var control = new LayoutTestControl();
                var root = new LayoutTestRoot { Child = control };

                target.ExecuteInitialLayoutPass(root);
                control.Measured = control.Arranged = false;

                control.InvalidateMeasure();
                root.Child = null;
                target.ExecuteLayoutPass();

                Assert.False(control.Measured);
                Assert.False(control.Arranged);
            }
        }
        public void Measures_Parent_Of_Newly_Added_Control()
        {
            var target = new LayoutManager();

            using (Start(target))
            {
                var control = new LayoutTestControl();
                var root = new LayoutTestRoot();

                target.ExecuteInitialLayoutPass(root);
                root.Child = control;
                root.Measured = root.Arranged = false;

                target.ExecuteLayoutPass();

                Assert.True(root.Measured);
                Assert.True(root.Arranged);
                Assert.True(control.Measured);
                Assert.True(control.Arranged);
            }
        }
Beispiel #6
0
        public void LayoutManager_Should_Properly_Arrange_Visuals_Even_When_There_Are_Issues_With_Previous_Arranged()
        {
            var nonArrageableTargets = Enumerable.Range(1, 10).Select(_ => new LayoutTestControl()).ToArray();
            var targets = Enumerable.Range(1, 10).Select(_ => new LayoutTestControl()).ToArray();

            StackPanel panel;

            var root = new LayoutTestRoot
            {
                Child = panel = new StackPanel()
            };

            panel.Children.AddRange(nonArrageableTargets);
            panel.Children.AddRange(targets);

            root.LayoutManager.ExecuteInitialLayoutPass(root);

            foreach (var c in panel.Children.OfType <LayoutTestControl>())
            {
                c.Measured = c.Arranged = false;
                c.InvalidateMeasure();
            }

            foreach (var c in nonArrageableTargets)
            {
                c.DoArrangeOverride = (l, s) =>
                {
                    //emulate a problem in the logic of a control that triggers
                    //invalidate measure during arrange
                    c.InvalidateMeasure();
                    return(new Size(100, 100));
                };
            }

            root.LayoutManager.ExecuteLayoutPass();

            //altough nonArrageableTargets has rubbish logic and can't be measured/arranged properly
            //layoutmanager should process properly other visuals
            Assert.All(targets, c => Assert.True(c.Arranged));
        }
Beispiel #7
0
        public void Measures_In_Correct_Order()
        {
            var target = new LayoutManager();

            using (Start(target))
            {
                LayoutTestControl control1;
                LayoutTestControl control2;
                var root = new LayoutTestRoot
                {
                    Child = control1 = new LayoutTestControl
                    {
                        Child = control2 = new LayoutTestControl(),
                    }
                };


                var order = new List <ILayoutable>();
                Size MeasureOverride(ILayoutable control, Size size)
                {
                    order.Add(control);
                    return(new Size(10, 10));
                }

                root.DoMeasureOverride     = MeasureOverride;
                control1.DoMeasureOverride = MeasureOverride;
                control2.DoMeasureOverride = MeasureOverride;
                target.ExecuteInitialLayoutPass(root);

                control2.InvalidateMeasure();
                control1.InvalidateMeasure();
                root.InvalidateMeasure();

                order.Clear();
                target.ExecuteLayoutPass();

                Assert.Equal(new ILayoutable[] { root, control1, control2 }, order);
            }
        }
        public void Measures_Root_With_Infinity()
        {
            var target = new LayoutManager();

            using (Start(target))
            {
                var root = new LayoutTestRoot();
                var availableSize = default(Size);

                // Should not measure with this size.
                root.MaxClientSize = new Size(123, 456);

                root.DoMeasureOverride = (_, s) =>
                {
                    availableSize = s;
                    return new Size(100, 100);
                };

                target.ExecuteInitialLayoutPass(root);

                Assert.Equal(Size.Infinity, availableSize);
            }
        }
Beispiel #9
0
        public void Arranges_Root_With_DesiredSize()
        {
            var root = new LayoutTestRoot
            {
                Width  = 100,
                Height = 100,
            };

            var arrangeSize = default(Size);

            root.DoArrangeOverride = (_, s) =>
            {
                arrangeSize = s;
                return(s);
            };

            root.LayoutManager.ExecuteInitialLayoutPass(root);
            Assert.Equal(new Size(100, 100), arrangeSize);

            root.Width = 120;

            root.LayoutManager.ExecuteLayoutPass();
            Assert.Equal(new Size(120, 100), arrangeSize);
        }