示例#1
0
 private void load()
 {
     InternalChildren = new Drawable[]
     {
         new GridContainer
         {
             RelativeSizeAxes = Axes.Both,
             Content          = new[]
             {
                 new Drawable[]
                 {
                     new Container
                     {
                         RelativeSizeAxes = Axes.Both,
                         Padding          = new MarginPadding
                         {
                             Horizontal = 105,
                             Vertical   = 20
                         },
                         Child = new GridContainer
                         {
                             RelativeSizeAxes = Axes.Both,
                             RowDimensions    = new[]
                             {
                                 new Dimension(GridSizeMode.AutoSize),
                                 new Dimension(GridSizeMode.AutoSize),
                                 new Dimension(GridSizeMode.AutoSize),
                                 new Dimension(),
                             },
                             Content = new[]
                             {
                                 new Drawable[] { new Match.Components.Header() },
                                 new Drawable[]
                                 {
                                     participantsHeader = new OverlinedHeader("Participants")
                                     {
                                         ShowLine = false
                                     }
                                 },
                                 new Drawable[]
                                 {
                                     new Container
                                     {
                                         RelativeSizeAxes = Axes.X,
                                         AutoSizeAxes     = Axes.Y,
                                         Margin           = new MarginPadding {
                                             Top = 5
                                         },
                                         Child = new ParticipantsDisplay(Direction.Horizontal)
                                         {
                                             Details = { BindTarget = participantsHeader.Details }
                                         }
                                     }
                                 },
                                 new Drawable[]
                                 {
                                     new GridContainer
                                     {
                                         RelativeSizeAxes = Axes.Both,
                                         Content          = new[]
                                         {
                                             new Drawable[]
                                             {
                                                 new Container
                                                 {
                                                     RelativeSizeAxes = Axes.Both,
                                                     Padding          = new MarginPadding {
                                                         Right = 5
                                                     },
                                                     Child = new GridContainer
                                                     {
                                                         RelativeSizeAxes = Axes.Both,
                                                         Content          = new[]
                                                         {
                                                             new Drawable[] { new OverlinedPlaylistHeader(), },
                                                             new Drawable[]
                                                             {
                                                                 new DrawableRoomPlaylistWithResults
                                                                 {
                                                                     RelativeSizeAxes   = Axes.Both,
                                                                     Items              = { BindTarget = Playlist },
                                                                     SelectedItem       = { BindTarget = SelectedItem },
                                                                     RequestShowResults = item =>
                                                                     {
                                                                         Debug.Assert(roomId.Value != null);
                                                                         ParentScreen?.Push(new PlaylistsResultsScreen(null, roomId.Value.Value, item, false));
                                                                     }
                                                                 }
                                                             },
                                                         },
                                                         RowDimensions = new[]
                                                         {
                                                             new Dimension(GridSizeMode.AutoSize),
                                                             new Dimension(),
                                                         }
                                                     }
                                                 },
                                                 null,
                                                 new GridContainer
                                                 {
                                                     RelativeSizeAxes = Axes.Both,
                                                     Content          = new[]
                                                     {
                                                         new Drawable[] { new OverlinedHeader("Leaderboard"), },
                                                         new Drawable[] { leaderboard = new MatchLeaderboard {
                                                                              RelativeSizeAxes = Axes.Both
                                                                          }, },
                                                         new Drawable[] { new OverlinedHeader("Chat"), },
                                                         new Drawable[] { new MatchChatDisplay {
                                                                              RelativeSizeAxes = Axes.Both
                                                                          } }
                                                     },
                                                     RowDimensions = new[]
                                                     {
                                                         new Dimension(GridSizeMode.AutoSize),
                                                         new Dimension(),
                                                         new Dimension(GridSizeMode.AutoSize),
                                                         new Dimension(GridSizeMode.Relative, size: 0.4f, minSize: 120),
                                                     }
                                                 },
                                                 null
                                             },
                                         },
                                         ColumnDimensions = new[]
                                         {
                                             new Dimension(GridSizeMode.Relative, size: 0.5f, maxSize: 400),
                                             new Dimension(),
                                             new Dimension(GridSizeMode.Relative, size: 0.5f, maxSize: 600),
                                             new Dimension(),
                                         }
                                     }
                                 }
                             },
                         }
                     }
                 },
                 new Drawable[]
                 {
                     new Footer
                     {
                         OnStart      = onStart,
                         SelectedItem = { BindTarget = SelectedItem }
                     }
                 }
             },
             RowDimensions = new[]
             {
                 new Dimension(),
                 new Dimension(GridSizeMode.AutoSize),
             }
         },
         settingsOverlay = new PlaylistsMatchSettingsOverlay
         {
             RelativeSizeAxes = Axes.Both,
             EditPlaylist     = () => this.Push(new MatchSongSelect()),
             State            = { Value = roomId.Value == null ? Visibility.Visible : Visibility.Hidden }
         }
     };
 }
示例#2
0
        private void load()
        {
            Components.Header header;
            Info                 info;
            GridContainer        bottomRow;
            MatchSettingsOverlay settings;

            InternalChildren = new Drawable[]
            {
                new GridContainer
                {
                    RelativeSizeAxes = Axes.Both,
                    Content          = new[]
                    {
                        new Drawable[]
                        {
                            header = new Components.Header
                            {
                                Depth = -1,
                                RequestBeatmapSelection = () =>
                                {
                                    this.Push(new MatchSongSelect
                                    {
                                        Selected = item =>
                                        {
                                            Playlist.Clear();
                                            Playlist.Add(item);
                                        }
                                    });
                                }
                            }
                        },
                        new Drawable[] { info = new Info {
                                             OnStart = onStart
                                         } },
                        new Drawable[]
                        {
                            bottomRow = new GridContainer
                            {
                                RelativeSizeAxes = Axes.Both,
                                Content          = new[]
                                {
                                    new Drawable[]
                                    {
                                        leaderboard = new MatchLeaderboard
                                        {
                                            Padding = new MarginPadding
                                            {
                                                Left     = 10 + HORIZONTAL_OVERFLOW_PADDING,
                                                Right    = 10,
                                                Vertical = 10,
                                            },
                                            RelativeSizeAxes = Axes.Both
                                        },
                                        new Container
                                        {
                                            Padding = new MarginPadding
                                            {
                                                Left     = 10,
                                                Right    = 10 + HORIZONTAL_OVERFLOW_PADDING,
                                                Vertical = 10,
                                            },
                                            RelativeSizeAxes = Axes.Both,
                                            Child            = new MatchChatDisplay
                                            {
                                                RelativeSizeAxes = Axes.Both
                                            }
                                        },
                                    },
                                },
                            }
                        },
                    },
                    RowDimensions = new[]
                    {
                        new Dimension(GridSizeMode.AutoSize),
                        new Dimension(GridSizeMode.AutoSize),
                        new Dimension(GridSizeMode.Distributed),
                    }
                },
                new Container
                {
                    RelativeSizeAxes = Axes.Both,
                    Padding          = new MarginPadding {
                        Top = Components.Header.HEIGHT
                    },
                    Child = settings = new MatchSettingsOverlay {
                        RelativeSizeAxes = Axes.Both
                    },
                },
            };

            header.Tabs.Current.BindValueChanged(tab =>
            {
                const float fade_duration = 500;

                var settingsDisplayed = tab.NewValue is SettingsMatchPage;

                header.ShowBeatmapPanel.Value = !settingsDisplayed;
                settings.State.Value          = settingsDisplayed ? Visibility.Visible : Visibility.Hidden;
                info.FadeTo(settingsDisplayed ? 0 : 1, fade_duration, Easing.OutQuint);
                bottomRow.FadeTo(settingsDisplayed ? 0 : 1, fade_duration, Easing.OutQuint);
            }, true);

            beatmapManager.ItemAdded += beatmapAdded;
        }
示例#3
0
 private void load()
 {
     InternalChildren = new Drawable[]
     {
         new GridContainer
         {
             RelativeSizeAxes = Axes.Both,
             Content          = new[]
             {
                 new Drawable[]
                 {
                     new Container
                     {
                         RelativeSizeAxes = Axes.Both,
                         Padding          = new MarginPadding
                         {
                             Horizontal = 105,
                             Vertical   = 20
                         },
                         Child = new GridContainer
                         {
                             RelativeSizeAxes = Axes.Both,
                             Content          = new[]
                             {
                                 new Drawable[] { new Components.Header() },
                                 new Drawable[]
                                 {
                                     new Container
                                     {
                                         RelativeSizeAxes = Axes.Both,
                                         Padding          = new MarginPadding {
                                             Top = 65
                                         },
                                         Child = new GridContainer
                                         {
                                             ColumnDimensions = new[]
                                             {
                                                 new Dimension(minSize: 160),
                                                 new Dimension(minSize: 360),
                                                 new Dimension(minSize: 400),
                                             },
                                             RelativeSizeAxes = Axes.Both,
                                             Content          = new[]
                                             {
                                                 new Drawable[]
                                                 {
                                                     new Container
                                                     {
                                                         RelativeSizeAxes = Axes.Both,
                                                         Padding          = new MarginPadding {
                                                             Right = 5
                                                         },
                                                         Child = new OverlinedParticipants(Direction.Vertical)
                                                         {
                                                             RelativeSizeAxes = Axes.Both
                                                         }
                                                     },
                                                     new Container
                                                     {
                                                         RelativeSizeAxes = Axes.Both,
                                                         Padding          = new MarginPadding {
                                                             Horizontal = 5
                                                         },
                                                         Child = new OverlinedPlaylist(true) // Temporarily always allow selection
                                                         {
                                                             RelativeSizeAxes = Axes.Both,
                                                             SelectedItem     = { BindTarget = SelectedItem }
                                                         }
                                                     },
                                                     new Container
                                                     {
                                                         RelativeSizeAxes = Axes.Both,
                                                         Padding          = new MarginPadding {
                                                             Left = 5
                                                         },
                                                         Child = leaderboardChatDisplay = new LeaderboardChatDisplay()
                                                     }
                                                 },
                                             }
                                         }
                                     }
                                 }
                             },
                             RowDimensions = new[]
                             {
                                 new Dimension(GridSizeMode.AutoSize),
                                 new Dimension(),
                             }
                         }
                     }
                 },
                 new Drawable[]
                 {
                     new Footer
                     {
                         OnStart      = onStart,
                         SelectedItem = { BindTarget = SelectedItem }
                     }
                 }
             },
             RowDimensions = new[]
             {
                 new Dimension(),
                 new Dimension(GridSizeMode.AutoSize),
             }
         },
         settingsOverlay = new MatchSettingsOverlay
         {
             RelativeSizeAxes = Axes.Both,
             EditPlaylist     = () => this.Push(new MatchSongSelect()),
             State            = { Value = roomId.Value == null ? Visibility.Visible : Visibility.Hidden }
         }
     };
 }
示例#4
0
        public MatchSubScreen(Room room, Action <Screen> pushGameplayScreen)
        {
            this.room = room;
            this.pushGameplayScreen = pushGameplayScreen;

            bindings.Room = room;

            MatchChatDisplay chat;

            Components.Header header;
            Info                 info;
            GridContainer        bottomRow;
            MatchSettingsOverlay settings;

            Children = new Drawable[]
            {
                new GridContainer
                {
                    RelativeSizeAxes = Axes.Both,
                    Content          = new[]
                    {
                        new Drawable[] { header = new Components.Header(room)
                                         {
                                             Depth = -1
                                         } },
                        new Drawable[] { info = new Info(room)
                                         {
                                             OnStart = onStart
                                         } },
                        new Drawable[]
                        {
                            bottomRow = new GridContainer
                            {
                                RelativeSizeAxes = Axes.Both,
                                Content          = new[]
                                {
                                    new Drawable[]
                                    {
                                        leaderboard = new MatchLeaderboard
                                        {
                                            Padding          = new MarginPadding(10),
                                            RelativeSizeAxes = Axes.Both,
                                            Room             = room
                                        },
                                        new Container
                                        {
                                            Padding          = new MarginPadding(10),
                                            RelativeSizeAxes = Axes.Both,
                                            Child            = chat = new MatchChatDisplay(room)
                                            {
                                                RelativeSizeAxes = Axes.Both
                                            }
                                        },
                                    },
                                },
                            }
                        },
                    },
                    RowDimensions = new[]
                    {
                        new Dimension(GridSizeMode.AutoSize),
                        new Dimension(GridSizeMode.AutoSize),
                        new Dimension(GridSizeMode.Distributed),
                    }
                },
                new Container
                {
                    RelativeSizeAxes = Axes.Both,
                    Padding          = new MarginPadding {
                        Top = Components.Header.HEIGHT
                    },
                    Child = settings = new MatchSettingsOverlay(room)
                    {
                        RelativeSizeAxes = Axes.Both
                    },
                },
            };

            header.OnRequestSelectBeatmap = () => Push(new MatchSongSelect {
                Selected = addPlaylistItem
            });
            header.Tabs.Current.ValueChanged += t =>
            {
                const float fade_duration = 500;
                if (t is SettingsMatchPage)
                {
                    settings.Show();
                    info.FadeOut(fade_duration, Easing.OutQuint);
                    bottomRow.FadeOut(fade_duration, Easing.OutQuint);
                }
                else
                {
                    settings.Hide();
                    info.FadeIn(fade_duration, Easing.OutQuint);
                    bottomRow.FadeIn(fade_duration, Easing.OutQuint);
                }
            };

            chat.Exit += Exit;
        }
示例#5
0
            private void load()
            {
                MatchChatDisplay chat;

                Components.Header header;
                Info                 info;
                GridContainer        bottomRow;
                MatchSettingsOverlay settings;

                InternalChildren = new Drawable[]
                {
                    new GridContainer
                    {
                        RelativeSizeAxes = Axes.Both,
                        Content          = new[]
                        {
                            new Drawable[]
                            {
                                header = new Components.Header
                                {
                                    Depth = -1,
                                    RequestBeatmapSelection = () => RequestBeatmapSelection?.Invoke()
                                }
                            },
                            new Drawable[] { info = new Info {
                                                 OnStart = onStart
                                             } },
                            new Drawable[]
                            {
                                bottomRow = new GridContainer
                                {
                                    RelativeSizeAxes = Axes.Both,
                                    Content          = new[]
                                    {
                                        new Drawable[]
                                        {
                                            leaderboard = new MatchLeaderboard
                                            {
                                                Padding = new MarginPadding
                                                {
                                                    Left     = 10 + OsuScreen.HORIZONTAL_OVERFLOW_PADDING,
                                                    Right    = 10,
                                                    Vertical = 10,
                                                },
                                                RelativeSizeAxes = Axes.Both
                                            },
                                            new Container
                                            {
                                                Padding = new MarginPadding
                                                {
                                                    Left     = 10,
                                                    Right    = 10 + OsuScreen.HORIZONTAL_OVERFLOW_PADDING,
                                                    Vertical = 10,
                                                },
                                                RelativeSizeAxes = Axes.Both,
                                                Child            = chat = new MatchChatDisplay
                                                {
                                                    RelativeSizeAxes = Axes.Both
                                                }
                                            },
                                        },
                                    },
                                }
                            },
                        },
                        RowDimensions = new[]
                        {
                            new Dimension(GridSizeMode.AutoSize),
                            new Dimension(GridSizeMode.AutoSize),
                            new Dimension(GridSizeMode.Distributed),
                        }
                    },
                    new Container
                    {
                        RelativeSizeAxes = Axes.Both,
                        Padding          = new MarginPadding {
                            Top = Components.Header.HEIGHT
                        },
                        Child = settings = new MatchSettingsOverlay {
                            RelativeSizeAxes = Axes.Both
                        },
                    },
                };

                header.Tabs.Current.BindValueChanged(t =>
                {
                    const float fade_duration = 500;
                    if (t is SettingsMatchPage)
                    {
                        settings.Show();
                        info.FadeOut(fade_duration, Easing.OutQuint);
                        bottomRow.FadeOut(fade_duration, Easing.OutQuint);
                    }
                    else
                    {
                        settings.Hide();
                        info.FadeIn(fade_duration, Easing.OutQuint);
                        bottomRow.FadeIn(fade_duration, Easing.OutQuint);
                    }
                }, true);

                chat.Exit += () => RequestExit?.Invoke();

                beatmapManager.ItemAdded += beatmapAdded;
            }