Beispiel #1
0
        private void load(IFrameBasedClock framedClock)
        {
            Config = Dependencies.Get <RulesetConfigCache>().GetConfigFor(Ruleset);

            try
            {
                drawableRulesetWrapper = new DrawableEditRulesetWrapper <TObject>(CreateDrawableRuleset(Ruleset, EditorBeatmap.PlayableBeatmap))
                {
                    Clock = framedClock,
                    ProcessCustomClock = false
                };
            }
            catch (Exception e)
            {
                Logger.Error(e, "Could not load beatmap sucessfully!");
                return;
            }

            var layerBelowRuleset = drawableRulesetWrapper.CreatePlayfieldAdjustmentContainer().WithChildren(new Drawable[]
            {
                distanceSnapGridContainer = new Container {
                    RelativeSizeAxes = Axes.Both
                },
                new EditorPlayfieldBorder {
                    RelativeSizeAxes = Axes.Both
                }
            });

            var layerAboveRuleset = drawableRulesetWrapper.CreatePlayfieldAdjustmentContainer().WithChild(BlueprintContainer = CreateBlueprintContainer());

            layerContainers.Add(layerBelowRuleset);
            layerContainers.Add(layerAboveRuleset);

            InternalChild = new GridContainer
            {
                RelativeSizeAxes = Axes.Both,
                Content          = new[]
                {
                    new Drawable[]
                    {
                        new FillFlowContainer
                        {
                            Name             = "Sidebar",
                            RelativeSizeAxes = Axes.Both,
                            Padding          = new MarginPadding {
                                Right = 10
                            },
                            Children = new Drawable[]
                            {
                                new ToolboxGroup {
                                    Child = toolboxCollection = new RadioButtonCollection {
                                        RelativeSizeAxes = Axes.X
                                    }
                                }
                            }
                        },
                        new Container
                        {
                            Name             = "Content",
                            RelativeSizeAxes = Axes.Both,
                            Children         = new Drawable[]
                            {
                                layerBelowRuleset,
                                drawableRulesetWrapper,
                                layerAboveRuleset
                            }
                        }
                    },
                },
                ColumnDimensions = new[]
                {
                    new Dimension(GridSizeMode.Absolute, 200),
                }
            };

            toolboxCollection.Items = CompositionTools
                                      .Prepend(new SelectTool())
                                      .Select(t => new RadioButton(t.Name, () => toolSelected(t)))
                                      .ToList();

            setSelectTool();

            BlueprintContainer.SelectionChanged += selectionChanged;
        }
Beispiel #2
0
        private void load(IFrameBasedClock framedClock)
        {
            try
            {
                drawableRulesetWrapper = new DrawableEditRulesetWrapper <TObject>(CreateDrawableRuleset(Ruleset, workingBeatmap, Array.Empty <Mod>()))
                {
                    Clock = framedClock
                };
            }
            catch (Exception e)
            {
                Logger.Error(e, "Could not load beatmap sucessfully!");
                return;
            }

            var layerBelowRuleset = drawableRulesetWrapper.CreatePlayfieldAdjustmentContainer();

            layerBelowRuleset.Child = new EditorPlayfieldBorder {
                RelativeSizeAxes = Axes.Both
            };

            var layerAboveRuleset = drawableRulesetWrapper.CreatePlayfieldAdjustmentContainer();

            layerAboveRuleset.Child = blueprintContainer = new BlueprintContainer();

            layerContainers.Add(layerBelowRuleset);
            layerContainers.Add(layerAboveRuleset);

            RadioButtonCollection toolboxCollection;

            InternalChild = new GridContainer
            {
                RelativeSizeAxes = Axes.Both,
                Content          = new[]
                {
                    new Drawable[]
                    {
                        new FillFlowContainer
                        {
                            Name             = "Sidebar",
                            RelativeSizeAxes = Axes.Both,
                            Padding          = new MarginPadding {
                                Right = 10
                            },
                            Children = new Drawable[]
                            {
                                new ToolboxGroup {
                                    Child = toolboxCollection = new RadioButtonCollection {
                                        RelativeSizeAxes = Axes.X
                                    }
                                }
                            }
                        },
                        new Container
                        {
                            Name             = "Content",
                            RelativeSizeAxes = Axes.Both,
                            Children         = new Drawable[]
                            {
                                layerBelowRuleset,
                                drawableRulesetWrapper,
                                layerAboveRuleset
                            }
                        }
                    },
                },
                ColumnDimensions = new[]
                {
                    new Dimension(GridSizeMode.Absolute, 200),
                }
            };

            toolboxCollection.Items =
                CompositionTools.Select(t => new RadioButton(t.Name, () => blueprintContainer.CurrentTool = t))
                .Prepend(new RadioButton("Select", () => blueprintContainer.CurrentTool = null))
                .ToList();

            toolboxCollection.Items[0].Select();
        }
Beispiel #3
0
        private void load()
        {
            Config = Dependencies.Get <RulesetConfigCache>().GetConfigFor(Ruleset);

            try
            {
                drawableRulesetWrapper = new DrawableEditRulesetWrapper <TObject>(CreateDrawableRuleset(Ruleset, EditorBeatmap.PlayableBeatmap, new[] { Ruleset.GetAutoplayMod() }))
                {
                    Clock = EditorClock,
                    ProcessCustomClock = false
                };
            }
            catch (Exception e)
            {
                Logger.Error(e, "Could not load beatmap successfully!");
                return;
            }

            const float toolbar_width = 200;

            InternalChildren = new Drawable[]
            {
                new Container
                {
                    Name    = "Content",
                    Padding = new MarginPadding {
                        Left = toolbar_width
                    },
                    RelativeSizeAxes = Axes.Both,
                    Children         = new Drawable[]
                    {
                        // layers below playfield
                        drawableRulesetWrapper.CreatePlayfieldAdjustmentContainer().WithChild(LayerBelowRuleset),
                        drawableRulesetWrapper,
                        // layers above playfield
                        drawableRulesetWrapper.CreatePlayfieldAdjustmentContainer()
                        .WithChild(BlueprintContainer = CreateBlueprintContainer())
                    }
                },
                new FillFlowContainer
                {
                    Name             = "Sidebar",
                    RelativeSizeAxes = Axes.Y,
                    Width            = toolbar_width,
                    Padding          = new MarginPadding {
                        Right = 10
                    },
                    Spacing  = new Vector2(10),
                    Children = new Drawable[]
                    {
                        new ToolboxGroup("toolbox (1-9)")
                        {
                            Child = toolboxCollection = new RadioButtonCollection {
                                RelativeSizeAxes = Axes.X
                            }
                        },
                        new ToolboxGroup("toggles (Q~P)")
                        {
                            Child = togglesCollection = new FillFlowContainer
                            {
                                RelativeSizeAxes = Axes.X,
                                AutoSizeAxes     = Axes.Y,
                                Direction        = FillDirection.Vertical,
                                Spacing          = new Vector2(0, 5),
                            },
                        }
                    }
                },
            };

            toolboxCollection.Items = CompositionTools
                                      .Prepend(new SelectTool())
                                      .Select(t => new RadioButton(t.Name, () => toolSelected(t), t.CreateIcon))
                                      .ToList();

            TernaryStates = CreateTernaryButtons().ToArray();
            togglesCollection.AddRange(TernaryStates.Select(b => new DrawableTernaryButton(b)));

            setSelectTool();

            EditorBeatmap.SelectedHitObjects.CollectionChanged += selectionChanged;
        }
Beispiel #4
0
        private void load()
        {
            Config = Dependencies.Get <RulesetConfigCache>().GetConfigFor(Ruleset);

            try
            {
                drawableRulesetWrapper = new DrawableEditRulesetWrapper <TObject>(CreateDrawableRuleset(Ruleset, EditorBeatmap.PlayableBeatmap))
                {
                    Clock = EditorClock,
                    ProcessCustomClock = false
                };
            }
            catch (Exception e)
            {
                Logger.Error(e, "Could not load beatmap successfully!");
                return;
            }

            const float toolbar_width = 200;

            InternalChildren = new Drawable[]
            {
                new Container
                {
                    Name    = "Content",
                    Padding = new MarginPadding {
                        Left = toolbar_width
                    },
                    RelativeSizeAxes = Axes.Both,
                    Children         = new Drawable[]
                    {
                        // layers below playfield
                        drawableRulesetWrapper.CreatePlayfieldAdjustmentContainer().WithChildren(new Drawable[]
                        {
                            LayerBelowRuleset,
                            new EditorPlayfieldBorder {
                                RelativeSizeAxes = Axes.Both
                            }
                        }),
                        drawableRulesetWrapper,
                        // layers above playfield
                        drawableRulesetWrapper.CreatePlayfieldAdjustmentContainer()
                        .WithChild(BlueprintContainer = CreateBlueprintContainer(HitObjects))
                    }
                },
                new FillFlowContainer
                {
                    Name             = "Sidebar",
                    RelativeSizeAxes = Axes.Y,
                    Width            = toolbar_width,
                    Padding          = new MarginPadding {
                        Right = 10
                    },
                    Spacing  = new Vector2(10),
                    Children = new Drawable[]
                    {
                        new ToolboxGroup("toolbox")
                        {
                            Child = toolboxCollection = new RadioButtonCollection {
                                RelativeSizeAxes = Axes.X
                            }
                        },
                        new ToolboxGroup("toggles")
                        {
                            ChildrenEnumerable = Toggles.Select(b => new SettingsCheckbox
                            {
                                Bindable  = b,
                                LabelText = b?.Description ?? "unknown"
                            })
                        }
                    }
                },
            };

            toolboxCollection.Items = CompositionTools
                                      .Prepend(new SelectTool())
                                      .Select(t => new RadioButton(t.Name, () => toolSelected(t), t.CreateIcon))
                                      .ToList();

            setSelectTool();

            EditorBeatmap.SelectedHitObjects.CollectionChanged += selectionChanged;
        }