Add implicit operators for compatibility with Drawable[][]

osu.Framework.Tests/Layout/TestSceneGridContainerLayout.cs

···
                     AutoSizeAxes = Axes.Both,
                     RowDimensions = new[] { new Dimension(GridSizeMode.AutoSize) },
                     ColumnDimensions = new[] { new Dimension(GridSizeMode.AutoSize) },
-                    Content = new GridContainerContent(new[]
+                    Content = new[]
                     {
                         new Drawable[]
                         {
···
                                 LifetimeStart = double.MaxValue
                             }
                         },
-                    })
+                    }
                 };
             });
 
···
                     AutoSizeAxes = Axes.Both,
                     RowDimensions = new[] { new Dimension(GridSizeMode.AutoSize) },
                     ColumnDimensions = new[] { new Dimension(GridSizeMode.AutoSize) },
-                    Content = new GridContainerContent(new[]
+                    Content = new[]
                     {
                         new Drawable[]
                         {
                             box = new Box { Size = new Vector2(200) }
                         },
-                    })
+                    }
                 };
             });
 
···
                     AutoSizeAxes = Axes.Both,
                     RowDimensions = new[] { new Dimension(GridSizeMode.AutoSize) },
                     ColumnDimensions = new[] { new Dimension(GridSizeMode.AutoSize) },
-                    Content = new GridContainerContent(new[]
+                    Content = new[]
                     {
                         new Drawable[]
                         {
                             box = new TestBox1 { Size = new Vector2(200) }
                         },
-                    })
+                    }
                 };
             });
 

osu.Framework.Tests/Visual/Audio/TestSceneSampleAmplitudes.cs

···
                 new GridContainer
                 {
                     RelativeSizeAxes = Axes.Both,
-                    Content = new GridContainerContent(new[]
+                    Content = new[]
                     {
                         new Drawable[]
                         {
···
                                               })
                             },
                         }
-                    })
+                    }
                 },
             };
         }

osu.Framework.Tests/Visual/Audio/TestSceneTrackAmplitudes.cs

···
                 new GridContainer
                 {
                     RelativeSizeAxes = Axes.Both,
-                    Content = new GridContainerContent(new[]
+                    Content = new[]
                     {
                         new Drawable[]
                         {
···
                                               })
                             },
                         }
-                    })
+                    }
                 },
             };
         }

osu.Framework.Tests/Visual/Bindables/TestSceneBindableNumbers.cs

···
             Child = new GridContainer
             {
                 RelativeSizeAxes = Axes.Both,
-                Content = new GridContainerContent(new[]
+                Content = new[]
                 {
                     new Drawable[]
                     {
···
                         new BindableDisplayContainer<float>(bindableFloat),
                         new BindableDisplayContainer<double>(bindableDouble),
                     }
-                })
+                }
             };
         }
 

osu.Framework.Tests/Visual/Containers/TestSceneSafeAreaContainer.cs

···
             {
                 Name = "Safe Contents",
                 RelativeSizeAxes = Axes.Both,
-                Content = new GridContainerContent(boxes),
+                Content = boxes,
             };
         }
 

osu.Framework.Tests/Visual/Input/TestSceneKeyBindingsGrid.cs

···
             Child = new GridContainer
             {
                 RelativeSizeAxes = Axes.Both,
-                Content = new GridContainerContent(new[]
+                Content = new[]
                 {
                     new Drawable[]
                     {
···
                         unique = new KeyBindingTester(SimultaneousBindingMode.Unique, KeyCombinationMatchingMode.Any),
                         all = new KeyBindingTester(SimultaneousBindingMode.All, KeyCombinationMatchingMode.Any)
                     },
-                })
+                }
             };
         }
 

osu.Framework.Tests/Visual/Layout/TestSceneGridContainer.cs

···
         public void TestSingleCellDistributedXy()
         {
             FillBox box = null;
-            AddStep("set content", () => grid.Content = new GridContainerContent(new[] { new Drawable[] { box = new FillBox() }, }));
+            AddStep("set content", () => grid.Content = new[] { new Drawable[] { box = new FillBox() }, });
             AddAssert("box is same size as grid", () => Precision.AlmostEquals(box.DrawSize, grid.DrawSize));
         }
 
···
             FillBox box = null;
             AddStep("set content", () =>
             {
-                grid.Content = new GridContainerContent(new[] { new Drawable[] { box = new FillBox() }, });
+                grid.Content = new[] { new Drawable[] { box = new FillBox() }, };
                 grid.RowDimensions = grid.ColumnDimensions = new[] { new Dimension(GridSizeMode.Absolute, size) };
             });
 
···
             FillBox box = null;
             AddStep("set content", () =>
             {
-                grid.Content = new GridContainerContent(new[] { new Drawable[] { box = new FillBox() }, });
+                grid.Content = new[] { new Drawable[] { box = new FillBox() }, };
                 grid.RowDimensions = grid.ColumnDimensions = new[] { new Dimension(GridSizeMode.Relative, size) };
             });
 
···
             FillBox box = null;
             AddStep("set content", () =>
             {
-                grid.Content = new GridContainerContent(new[] { new Drawable[] { box = new FillBox() }, });
+                grid.Content = new[] { new Drawable[] { box = new FillBox() }, };
                 grid.RowDimensions = new[] { new Dimension(GridSizeMode.Absolute, absolute_height) };
                 grid.ColumnDimensions = new[] { new Dimension(GridSizeMode.Relative, relative_width) };
             });
···
             FillBox box = null;
             AddStep("set content", () =>
             {
-                grid.Content = new GridContainerContent(new[] { new Drawable[] { box = new FillBox() }, });
+                grid.Content = new[] { new Drawable[] { box = new FillBox() }, };
                 grid.RowDimensions = new[] { new Dimension(GridSizeMode.Relative, height) };
             });
 
···
 
             AddStep("set content", () =>
             {
-                grid.Content = new GridContainerContent(new[]
+                grid.Content = new[]
                 {
                     new Drawable[] { boxes[0] = new FillBox(), boxes[1] = new FillBox(), boxes[2] = new FillBox() },
                     new Drawable[] { boxes[3] = new FillBox(), boxes[4] = new FillBox(), boxes[5] = new FillBox() },
                     new Drawable[] { boxes[6] = new FillBox(), boxes[7] = new FillBox(), boxes[8] = new FillBox() }
-                });
+                };
             });
 
             for (int i = 0; i < 9; i++)
···
 
             AddStep("set content", () =>
             {
-                grid.Content = new GridContainerContent(new[]
+                grid.Content = new[]
                 {
                     new Drawable[] { boxes[0] = new FillBox(), boxes[1] = new FillBox(), boxes[2] = new FillBox() },
                     new Drawable[] { boxes[3] = new FillBox(), boxes[4] = new FillBox(), boxes[5] = new FillBox() },
                     new Drawable[] { boxes[6] = new FillBox(), boxes[7] = new FillBox(), boxes[8] = new FillBox() }
-                });
+                };
 
                 grid.RowDimensions = grid.ColumnDimensions = dimensions;
             });
···
 
             AddStep("set content", () =>
             {
-                grid.Content = new GridContainerContent(new[]
+                grid.Content = new[]
                 {
                     new Drawable[] { boxes[0] = new FillBox(), boxes[1] = new FillBox(), boxes[2] = new FillBox() },
                     new Drawable[] { boxes[3] = new FillBox(), boxes[4] = new FillBox(), boxes[5] = new FillBox() },
                     new Drawable[] { boxes[6] = new FillBox(), boxes[7] = new FillBox(), boxes[8] = new FillBox() }
-                });
+                };
 
                 grid.RowDimensions = grid.ColumnDimensions = dimensions;
             });
···
 
             AddStep("set content", () =>
             {
-                grid.Content = new GridContainerContent(new[]
+                grid.Content = new[]
                 {
                     new Drawable[] { boxes[0] = new FillBox(), boxes[1] = new FillBox(), boxes[2] = new FillBox() },
                     new Drawable[] { boxes[3] = new FillBox(), boxes[4] = new FillBox(), boxes[5] = new FillBox() },
                     new Drawable[] { boxes[6] = new FillBox(), boxes[7] = new FillBox(), boxes[8] = new FillBox() }
-                });
+                };
 
                 grid.RowDimensions = grid.ColumnDimensions = dimensions;
             });
···
 
             AddStep("set content", () =>
             {
-                grid.Content = new GridContainerContent(new[]
+                grid.Content = new[]
                 {
                     new Drawable[] { boxes[0] = new FillBox(), null, boxes[1] = new FillBox(), null },
                     null,
                     new Drawable[] { boxes[2] = new FillBox(), null, boxes[3] = new FillBox(), null },
                     null
-                });
+                };
             });
 
             AddAssert("two extra rows and columns", () =>
···
 
             AddStep("set content", () =>
             {
-                grid.Content = new GridContainerContent(new[]
+                grid.Content = new[]
                 {
                     new Drawable[]
                     {
                         new GridContainer
                         {
                             RelativeSizeAxes = Axes.Both,
-                            Content = new GridContainerContent(new[]
+                            Content = new[]
                             {
                                 new Drawable[] { boxes[0] = new FillBox(), new FillBox(), },
                                 new Drawable[] { new FillBox(), boxes[1] = new FillBox(), },
-                            })
+                            }
                         },
                         new FillBox(),
                     },
···
                         new GridContainer
                         {
                             RelativeSizeAxes = Axes.Both,
-                            Content = new GridContainerContent(new[]
+                            Content = new[]
                             {
                                 new Drawable[] { boxes[2] = new FillBox(), new FillBox(), },
                                 new Drawable[] { new FillBox(), boxes[3] = new FillBox(), },
-                            })
+                            }
                         }
                     }
-                });
+                };
             });
 
             for (int i = 0; i < 4; i++)
···
 
             AddStep("set content", () =>
             {
-                grid.Content = new GridContainerContent(new[]
+                grid.Content = new[]
                 {
                     new[]
                     {
···
                             Size = new Vector2(50, 10)
                         },
                     },
-                });
+                };
 
                 grid.ColumnDimensions = new[] { new Dimension(GridSizeMode.AutoSize) };
                 grid.RowDimensions = new[]
···
                 gridParent.RelativeSizeAxes = Axes.Y;
                 gridParent.Width = 420;
 
-                grid.Content = new GridContainerContent(new[]
+                grid.Content = new[]
                 {
                     new Drawable[]
                     {
···
                         new FillBox(),
                         new FillBox(),
                     },
-                });
+                };
 
                 grid.ColumnDimensions = new[]
                 {
···
                 gridParent.RelativeSizeAxes = Axes.Y;
                 gridParent.Width = 230;
 
-                grid.Content = new GridContainerContent(new[]
+                grid.Content = new[]
                 {
                     new Drawable[]
                     {
                         new FillBox(),
                         new FillBox(),
                     },
-                });
+                };
 
                 grid.ColumnDimensions = new[]
                 {
···
                     new Dimension(GridSizeMode.AutoSize),
                     new Dimension()
                 };
-                grid.Content = new GridContainerContent(new[]
+                grid.Content = new[]
                 {
                     new Drawable[] { new FillBox(), transparentBox(alwaysPresent), new FillBox() },
                     new Drawable[] { new FillBox(), transparentBox(alwaysPresent), new FillBox() },
                     new Drawable[] { transparentBox(alwaysPresent), transparentBox(alwaysPresent), transparentBox(alwaysPresent) }
-                });
+                };
             });
 
             float desiredTransparentBoxSize = alwaysPresent ? 50 : 0;
···
             if (!row)
                 content = content.Invert();
 
-            grid.Content = new GridContainerContent(content);
+            grid.Content = content;
 
             if (dimensions == null)
                 return;

osu.Framework.Tests/Visual/Sprites/TestSceneAnimationLayout.cs

···
             Child = new GridContainer
             {
                 RelativeSizeAxes = Axes.Both,
-                Content = new GridContainerContent(new[]
+                Content = new[]
                 {
                     new Drawable[]
                     {
···
                             }
                         }
                     },
-                }),
+                },
                 RowDimensions = new[] { new Dimension(GridSizeMode.AutoSize) }
             }
         };

osu.Framework.Tests/Visual/Sprites/TestSceneBufferedContainerView.cs

···
                     new GridContainer
                     {
                         RelativeSizeAxes = Axes.Both,
-                        Content = new GridContainerContent(new[]
+                        Content = new[]
                         {
                             new Drawable[]
                             {
···
                                     })
                                 }
                             },
-                        }),
+                        },
                         RowDimensions = new[]
                         {
                             new Dimension(GridSizeMode.Absolute, 20),

osu.Framework.Tests/Visual/Sprites/TestSceneVideoLayout.cs

···
             Child = new GridContainer
             {
                 RelativeSizeAxes = Axes.Both,
-                Content = new GridContainerContent(new[]
+                Content = new[]
                 {
                     new Drawable[]
                     {
···
                             }
                         }
                     },
-                }),
+                },
                 RowDimensions = new[] { new Dimension(GridSizeMode.AutoSize) }
             }
         };

osu.Framework/Graphics/Containers/GridContainerContent.cs

···
 
         public GridContainerContent(Drawable[][] drawables)
         {
+            source = drawables;
+
             _ = new ArrayWrapper<ArrayWrapper<Drawable>>
             {
                 _ = new ArrayWrapper<Drawable>[drawables?.Length ?? 0]
···
             }
         }
 
+        private readonly Drawable[][] source;
+
         private void onArrayElementChanged()
         {
             ContentChanged?.Invoke();
         }
 
         public ArrayWrapper<ArrayWrapper<Drawable>> _ { get; }
+
+        public static implicit operator Drawable[][](GridContainerContent content) => content.source;
+
+        public static implicit operator GridContainerContent(Drawable[][] drawables) => new GridContainerContent(drawables);
 
         public ArrayWrapper<Drawable> this[int index]
         {

osu.Framework/Graphics/Containers/Markdown/MarkdownTable.cs

···
             {
                 AutoSizeAxes = Axes.Y,
                 RelativeSizeAxes = Axes.X,
-                Content = new GridContainerContent(rows.Select(x => x.ToArray()).ToArray())
+                Content = rows.Select(x => x.ToArray()).ToArray()
             };
         }
 

osu.Framework/Graphics/Containers/TableContainer.cs

···
         /// </summary>
         private void updateContent()
         {
-            grid.Content = new GridContainerContent(getContentWithHeaders().ToJagged());
+            grid.Content = getContentWithHeaders().ToJagged();
 
             grid.ColumnDimensions = columns.Select(c => c.Dimension).ToArray();
             grid.RowDimensions = Enumerable.Repeat(RowSize, totalRows).ToArray();

osu.Framework/Graphics/UserInterface/BasicRearrangeableListContainer.cs

···
             InternalChild = new GridContainer
             {
                 RelativeSizeAxes = Axes.Both,
-                Content = new GridContainerContent(new[]
+                Content = new[]
                 {
                     new[]
                     {
···
                             Action = () => RequestRemoval?.Invoke(this),
                         },
                     },
-                }),
+                },
                 ColumnDimensions = new[]
                 {
                     new Dimension(GridSizeMode.AutoSize),

osu.Framework/Testing/Drawables/Sections/ToolbarRateSection.cs

···
                     new Dimension(GridSizeMode.AutoSize),
                     new Dimension(),
                 },
-                Content = new GridContainerContent(new[]
+                Content = new[]
                 {
                     new Drawable[]
                     {
···
                             Current = browser.PlaybackRate
                         },
                     }
-                })
+                }
             };
 
             rateAdjustSlider.Current.BindValueChanged(e => rateText.Text = e.NewValue.ToString("0%"), true);

osu.Framework/Testing/Drawables/TestBrowserToolbar.cs

···
                             new Dimension(),
                             new Dimension(GridSizeMode.AutoSize),
                         },
-                        Content = new GridContainerContent(new[]
+                        Content = new[]
                         {
                             new Drawable[]
                             {
···
                                     }
                                 },
                             }
-                        }),
+                        },
                     },
                 }
             };

osu.Framework/Testing/GridTestScene.cs

···
                     cells[r, c] = new Container { RelativeSizeAxes = Axes.Both };
             }
 
-            testContainer.Content = new GridContainerContent(cells.ToJagged());
+            testContainer.Content = cells.ToJagged();
         }
 
         protected Container Cell(int index) => (Container)cells[index / Cols, index % Cols];