Пример #1
0
        public void Run(IFormRenderer <HTMLElement> renderer, Action atExit)
        {
            var panel = TwoPanelsWithResizerBuilder.BuildHorizontal(
                Hideability.First, true, renderer, SpacingPolicy.FirstWins);

            _onExit = () => {
                renderer.ClearMaster();
                atExit();
            };

            panel.FirstCanvas.LayoutMode = LayoutModeType.TitleExtra_Actions_Body;
            panel.First.ReplaceMaster(_menu);
            panel.SecondCanvas.LayoutMode = LayoutModeType.ExtraTitle_Body_Actions;
            panel.Second.ReplaceMaster(_content);
            renderer.ReplaceMasterWithAdapter(panel.Panel);

            _content.Ended += (x, outcome) => {
                switch (outcome)
                {
                case FlexibleLayoutContentForm.Outcome.LeftPanelLayoutChanged:
                    panel.FirstCanvas.LayoutMode = x.CurrentLayoutMode;
                    break;

                default: throw new Exception("unsupported outcome");
                }
            };
        }
Пример #2
0
        public void Run(IFormRenderer <HTMLElement> renderer, Action atExit)
        {
            var panels = TwoPanelsWithResizerBuilder.BuildHorizontal(
                Hideability.None, false, renderer, Tuple.Create((int?)522, (int?)null));

            panels.First.ReplaceMaster(_sender);
            panels.FirstCanvas.LayoutMode = LayoutModeType.TitleExtra_Actions_Body;

            panels.Second.ReplaceMaster(_listener);
            panels.SecondCanvas.LayoutMode = LayoutModeType.TitleExtra_Actions_Body;

            renderer.ReplaceMasterWithAdapter(panels.Panel);

            _sender.Ended += (x, outcome) => {
                renderer.ClearMaster();
                atExit();
            };
        }
Пример #3
0
        public void Run(IFormRenderer <HTMLElement> renderer, Action atExit)
        {
            renderer.AddPopup(_layoutChoice);

            _layoutChoice.Ended += (x, outcome) => {
                renderer.Remove(x);
                switch (outcome)
                {
                case CompletedOrCanceled.Canceled:
                    atExit();
                    break;

                case CompletedOrCanceled.Completed:
                    switch (x.ChosenValue)
                    {
                    case LayoutChoice.Horizontal: {
                        var panel = TwoPanelsWithResizerBuilder.BuildHorizontal(
                            Hideability.None, false, renderer, SpacingPolicy.FirstWins);
                        panel.First.ReplaceMaster(_headers);
                        panel.Second.ReplaceMaster(_details);
                        renderer.ReplaceMasterWithAdapter(panel.Panel);
                        break;
                    }

                    case LayoutChoice.Vertical: {
                        var panel = TwoPanelsWithResizerBuilder.BuildVertical(
                            Hideability.None, false, renderer, SpacingPolicy.Proportional);
                        panel.First.ReplaceMaster(_headers);
                        panel.Second.ReplaceMaster(_details);
                        renderer.ReplaceMasterWithAdapter(panel.Panel);
                        break;
                    }
                    }

                    renderer.AddPopup(_fetchData);
                    break;

                default: throw new Exception("unsupported EnumChoiceFormOutcome");
                }
            };

            _fetchData.Ended += (x, outcome) => {
                switch (outcome)
                {
                case RemoteActionsCallerForm.Outcome.Succeeded:
                    renderer.Remove(x);
                    break;

                case RemoteActionsCallerForm.Outcome.Canceled:
                case RemoteActionsCallerForm.Outcome.Interrupted:
                    renderer.Remove(x);
                    renderer.ClearMaster();
                    break;

                default: throw new Exception("unsupported outcome");
                }
            };

            _headers.Ended += (_, outcome) => {
                switch (outcome)
                {
                case HeadersForm.Outcome.ChoosenHeader:
                    var headerId = _headers.ChoosenHeader.Id;
                    _details.Details.Items.Replace(_detailItems.Where(x => headerId == x.ParentId));
                    break;

                case HeadersForm.Outcome.Canceled:
                    renderer.ClearMaster();
                    break;

                default: throw new Exception("unsupported outcome");
                }
            };
        }