Beispiel #1
0
        protected override bool OnBackButtonPressed()
        {
            Type t = actualPage.GetType();

            if (t == typeof(AddTask))
            {
                loadHomeDetail();
            }
            else
            {
                if (t == typeof(ContentHomePage))
                {
                    //Navigation.PopAsync();
                }
                else
                {
                    if (t == typeof(EditTask))
                    {
                        loadHomeDetail();
                    }
                    else
                    {
                        if (t == typeof(ContactPage))
                        {
                            loadHomeDetail();
                        }
                        else
                        {
                            if (t == typeof(DetailContactPage))
                            {
                                loadContactsDetail();
                            }
                            else
                            {
                            }
                        }
                    }
                }
            }
            return(true);
        }
        public void WhenRequestNavigateAwayOnBindingContextRejectsThroughCallback_ThenNavigationDoesNotProceed()
        {
            // Prepare
            var region = new Region();

            var view1BindingContextMock = new Mock <IConfirmRegionNavigationRequest>();

            view1BindingContextMock
            .Setup(ina => ina.ConfirmNavigationRequest(It.IsAny <INavigationContext>(), It.IsAny <Action <bool> >()))
            .Callback <INavigationContext, Action <bool> >((nc, c) => c(false))
            .Verifiable();

            var view1Mock = new Mock <View>();
            var view1     = view1Mock.Object;

            view1.BindingContext = view1BindingContextMock.Object;

            var view2 = new StackLayout();

            region.Add(view1);
            region.Add(view2);

            region.Activate(view1);

            var navigationUri = new Uri(view2.GetType().Name, UriKind.Relative);

            var containerMock = new Mock <IContainerExtension>();

            containerMock.Setup(x => x.Resolve(typeof(IRegionNavigationJournalEntry))).Returns(new RegionNavigationJournalEntry());

            IContainerExtension container    = containerMock.Object;
            var contentLoader                = new Mock <RegionNavigationContentLoader>(container).Object;
            IRegionNavigationJournal journal = Mock.Of <IRegionNavigationJournal>();

            var target = new RegionNavigationService(container, contentLoader, journal)
            {
                Region = region
            };

            // Act
            var navigationFailed = false;

            target.RequestNavigate(navigationUri, nr => { navigationFailed = nr.Result == false; });

            // Verify
            view1BindingContextMock.VerifyAll();
            Assert.True(navigationFailed);
            Assert.Equal(new object[] { view1 }, region.ActiveViews.ToArray());
        }
        public void WhenNavigatingFromActiveViewWithNavigatinAwareDataConext_NotifiesContextOfNavigatingFrom()
        {
            // Arrange
            var region = new Region();

            var mockBindingContext = new Mock <IRegionAware>();

            var view1Mock = new Mock <View>();
            var view1     = view1Mock.Object;

            view1.BindingContext = mockBindingContext.Object;

            region.Add(view1);

            var view2 = new StackLayout();

            region.Add(view2);

            region.Activate(view1);

            var containerMock = new Mock <IContainerExtension>();

            containerMock.Setup(x => x.Resolve(typeof(IRegionNavigationJournalEntry))).Returns(new RegionNavigationJournalEntry());

            var navigationUri                = new Uri(view2.GetType().Name, UriKind.Relative);
            IContainerExtension container    = containerMock.Object;
            var contentLoader                = new Mock <RegionNavigationContentLoader>(container).Object;
            IRegionNavigationJournal journal = Mock.Of <IRegionNavigationJournal>();

            var target = new RegionNavigationService(container, contentLoader, journal)
            {
                Region = region
            };

            // Act
            target.RequestNavigate(navigationUri, nr => { });

            // Verify
            mockBindingContext.Verify(v => v.OnNavigatedFrom(It.Is <INavigationContext>(ctx => ctx.Uri == navigationUri && ctx.Parameters.Count() == 0)));
        }
Beispiel #4
0
        /// <summary>
        /// This is the method that actually does the work.
        /// </summary>
        /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param>
        protected override void SolveInstance(IGH_DataAccess DA)
        {
            List <string>           props = new List <string>();
            List <GH_ObjectWrapper> vals  = new List <GH_ObjectWrapper>();
            List <GH_ObjectWrapper> ctrls = new List <GH_ObjectWrapper>();

            DA.GetDataList(0, props);
            DA.GetDataList(1, vals);
            DA.GetDataList(2, ctrls);

            StackLayout stack = new StackLayout()
            {
                Size = new Size(60, 40),
            };

            for (int i = 0; i < props.Count; i++)
            {
                string n = props[i];
                object val;
                try { val = vals[i].Value; }
                catch (ArgumentOutOfRangeException)
                {
                    AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "P, V should correspond each other");
                    return;
                }

                if (n.ToLower() == "spacing")
                {
                    if (val is GH_Integer ghi)
                    {
                        stack.Spacing = ghi.Value;
                    }
                    else if (val is GH_String ghstr)
                    {
                        if (int.TryParse(ghstr.Value, out int v))
                        {
                            stack.Spacing = v;
                        }
                    }
                    else
                    {
                        try { Util.SetProp(stack, "Spacing", Util.GetGooVal(val)); }
                        catch (Exception ex) { AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, ex.Message); }
                    }
                }
                else if (n.ToLower() == "orientation")
                {
                    if (val is GH_String ghstr)
                    {
                        switch (ghstr.Value.ToLower())
                        {
                        case "horizontal":
                            stack.Orientation = Orientation.Horizontal;
                            break;

                        case "vertical":
                            stack.Orientation = Orientation.Vertical;
                            break;

                        case "h":
                            stack.Orientation = Orientation.Horizontal;
                            break;

                        case "v":
                            stack.Orientation = Orientation.Vertical;
                            break;

                        default:
                            break;
                        }
                    }
                    else if (val is GH_Integer ghi)
                    {
                        if (ghi.Value == 0)
                        {
                            stack.Orientation = Orientation.Horizontal;
                        }
                        else if (ghi.Value == 1)
                        {
                            stack.Orientation = Orientation.Vertical;
                        }
                    }
                    else if (val is Orientation or)
                    {
                        stack.Orientation = or;
                    }
                    else
                    {
                        try { Util.SetProp(stack, "Orientation", Util.GetGooVal(val)); }
                        catch (Exception ex) { AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, ex.Message); }
                    }
                }
                else if (n.ToLower() == "padding")
                {
                    if (val is GH_Integer ghi)
                    {
                        stack.Padding = new Padding(ghi.Value);
                    }
                    else if (val is GH_Number ghn)
                    {
                        stack.Padding = new Padding((int)ghn.Value);
                    }
                    else if (val is GH_String ghstr)
                    {
                        string s = ghstr.Value;
                        if (!s.Contains(","))
                        {
                            try { Util.SetProp(stack, "Padding", Util.GetGooVal(val)); }
                            catch (Exception ex) { AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, ex.Message); }
                        }
                        else
                        {
                            string[] nums = s.Split(',');
                            if (nums.Length == 2)
                            {
                                bool a = int.TryParse(nums[0], out int na);
                                bool b = int.TryParse(nums[1], out int nb);
                                if (a && b)
                                {
                                    stack.Padding = new Padding(na, nb);
                                }
                            }
                            else if (nums.Length == 4)
                            {
                                bool a = int.TryParse(nums[0], out int na);
                                bool b = int.TryParse(nums[1], out int nb);
                                bool c = int.TryParse(nums[2], out int nc);
                                bool d = int.TryParse(nums[3], out int nd);
                                if (a && b && c && d)
                                {
                                    stack.Padding = new Padding(na, nb, nc, nd);
                                }
                            }
                            else
                            {
                                AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, " couldn't parse padding integers");
                            }
                        }
                    }
                    else if (val is Padding pad)
                    {
                        stack.Padding = pad;
                    }
                    else if (val is GH_Rectangle grec)
                    {
                        int x = (int)grec.Value.X.Length;
                        int y = (int)grec.Value.Y.Length;
                        stack.Padding = new Padding(x, y);
                    }
                    else if (val is GH_ComplexNumber gcomp)
                    {
                        int x = (int)gcomp.Value.Real;
                        int y = (int)gcomp.Value.Imaginary;
                        stack.Padding = new Padding(x, y);
                    }
                    else
                    {
                        try { Util.SetProp(stack, "Padding", Util.GetGooVal(val)); }
                        catch (Exception ex) { AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, ex.Message); }
                    }
                }
                else if (n.ToLower() == "size")
                {
                    if (val is GH_Point pt)
                    {
                        Size size = new Size((int)pt.Value.X, (int)pt.Value.Y);
                        stack.Size = size;
                    }
                    else if (val is GH_Vector vec)
                    {
                        Size size = new Size((int)vec.Value.X, (int)vec.Value.Y);
                        stack.Size = size;
                    }
                    else if (val is GH_String sstr)
                    {
                        string[] xy = sstr.Value.Split(',');
                        bool     xp = int.TryParse(xy[0], out int x);
                        bool     yp = int.TryParse(xy[1], out int y);
                        if (xp && yp)
                        {
                            stack.Size = new Size(x, y);
                        }
                    }
                    else if (val is GH_Rectangle grec)
                    {
                        int x = (int)grec.Value.X.Length;
                        int y = (int)grec.Value.Y.Length;
                        stack.Size = new Size(x, y);
                    }
                    else if (val is GH_ComplexNumber gcomp)
                    {
                        int x = (int)gcomp.Value.Real;
                        int y = (int)gcomp.Value.Imaginary;
                        stack.Size = new Size(x, y);
                    }
                    else
                    {
                        try { Util.SetProp(stack, "Size", Util.GetGooVal(val)); }
                        catch (Exception ex) { AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, ex.Message); }
                    }
                }
                else
                {
                    try { Util.SetProp(stack, n, Util.GetGooVal(val)); }
                    catch (Exception ex) { AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, ex.Message); }
                }
            }

            foreach (GH_ObjectWrapper wrapped in ctrls)
            {
                if (wrapped.Value is Control ctrl)
                {
                    stack.Items.Add(ctrl);
                }
                else
                {
                    AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, " one or more object cannot be added\n are they non-Synapse components?");
                }
            }

            DA.SetData(1, new GH_ObjectWrapper(stack));

            PropertyInfo[] allprops  = stack.GetType().GetProperties();
            List <string>  printouts = new List <string>();

            foreach (PropertyInfo prop in allprops)
            {
                if (prop.CanWrite)
                {
                    printouts.Add(prop.Name + ": " + prop.PropertyType.ToString());
                }
            }
            DA.SetDataList(0, printouts);
        }
        public void WhenNavigationFailsBecauseBindingContextForActiveViewRejectsIt_ThenNavigationFailedIsRaised()
        {
            // Prepare
            var region = new Region {
                Name = "RegionName"
            };

            var viewModel1Mock = new Mock <IConfirmRegionNavigationRequest>();

            viewModel1Mock
            .Setup(ina => ina.ConfirmNavigationRequest(It.IsAny <INavigationContext>(), It.IsAny <Action <bool> >()))
            .Callback <INavigationContext, Action <bool> >((nc, c) => c(false))
            .Verifiable();

            var view1Mock = new Mock <View>();
            var view1     = view1Mock.Object;

            view1.BindingContext = viewModel1Mock.Object;

            var view2 = new StackLayout();

            region.Add(view1);
            region.Add(view2);

            region.Activate(view1);

            var navigationUri = new Uri(view2.GetType().Name, UriKind.Relative);

            var containerMock = new Mock <IContainerExtension>();

            containerMock.Setup(x => x.Resolve(typeof(IRegionNavigationJournalEntry))).Returns(new RegionNavigationJournalEntry());

            var contentLoaderMock = new Mock <IRegionNavigationContentLoader>();

            contentLoaderMock
            .Setup(cl => cl.LoadContent(region, It.IsAny <INavigationContext>()))
            .Returns(view2);

            var container     = containerMock.Object;
            var contentLoader = contentLoaderMock.Object;
            var journal       = Mock.Of <IRegionNavigationJournal>();

            var target = new RegionNavigationService(container, contentLoader, journal)
            {
                Region = region
            };

            RegionNavigationFailedEventArgs eventArgs = null;

            target.NavigationFailed += delegate(object sender, RegionNavigationFailedEventArgs e)
            {
                if (sender == target)
                {
                    eventArgs = e;
                }
            };

            // Act
            bool?isNavigationSuccessful = null;

            target.RequestNavigate(navigationUri, nr => isNavigationSuccessful = nr.Result);

            // Verify
            viewModel1Mock.VerifyAll();
            Assert.False(isNavigationSuccessful.Value);
            Assert.NotNull(eventArgs);
            Assert.Null(eventArgs.Error);
        }