Example #1
0
        void DisplayPlayers()
        {
            _Display.Clear();
            _Display.Add(new Button("header-1")
            {
                DisplayedString = _Host ? "Host Match" : "Remote Match"
            });
            _Display.Add(new Button("header-2")
            {
                DisplayedString = "Scenario"
            });
            _Display.Add(new GuiContainer <Pod>("regular")
            {
                _ScenarioSelect
            });
            _Display.Add(new Button("header-2")
            {
                DisplayedString = "Player Setup"
            });

            if (_Host)
            {
                if (_ScenarioSelect.Count() == 0)
                {
                    foreach (Scenario s in _Scenarios)
                    {
                        _ScenarioSelect.Add(new SelectionOption <Scenario>("match-lobby-player-section-select-option")
                        {
                            DisplayedString = s.Name,
                            Value           = s
                        });
                    }
                }
            }
            else
            {
                _ScenarioSelect.Clear();
                _ScenarioSelect.Add(new SelectionOption <Scenario>("match-lobby-player-section-select-option")
                {
                    DisplayedString = _Lobby.Scenario.Name,
                    Value           = _Lobby.Scenario
                });
            }
            _ScenarioSelect.Enabled = _Host;

            foreach (Player p in _Lobby.Players)
            {
                var section = new MatchLobbyPlayerSection(p, _Lobby, p == _Player);
                section.OnArmyConfigurationSelected += HandleArmyConfigurationSelected;
                section.OnPlayerReadyStateChanged   += HandlePlayerReadyStateChanged;
                _Display.Add(section);
            }
            _Dirty = false;

            OnPulse += HandlePulse;
            _Items.Add(_Pane);
        }
Example #2
0
        public void TestAdd_1()
        {
            var result = new String();

            result.Append("<mat-select-wrapper [dataSource]=\"[{");
            result.Append("'text':'a','value':'1'");
            result.Append("}]\"></mat-select-wrapper>");
            Assert.Equal(result.ToString(), GetResult(_component.Add("a", "1")));
        }
Example #3
0
        public void TestAdd_1()
        {
            var result = new String();

            result.Append("<mat-select-wrapper [dataSource]=\"[{");
            result.Append("&quot;text&quot;:&quot;a&quot;,&quot;value&quot;:&quot;1&quot;");
            result.Append("}]\"></mat-select-wrapper>");
            Assert.Equal(result.ToString(), GetResult(_component.Add("a", "1")));
        }
    private void FillForm()
    {
        Form = new Form();
        var select = new Select();

        select.Add("Price", "Price");
        select.Add("Calories", "Calories");
        select.Add("Fat", "Fat");
        select.Add("Sugar", "Sugar");
        select.Add("Salt", "Salt");
        Form.Add(select, "PropertySelect");
    }
Example #5
0
        public AttackPane(AttackOrder Attack)
            : base("attack-pane")
        {
            this.Attack       = Attack;
            Attack.OnChanged += UpdateDescription;

            _CloseButton.Position = new Vector2f(Size.X - _CloseButton.Size.X - LeftPadding.X * 2, 0);
            _CloseButton.OnClick += HandleClose;

            foreach (var target in Enum.GetValues(typeof(AttackTarget)).Cast <AttackTarget>())
            {
                _AttackTargetSelect.Add(new SelectionOption <AttackTarget>("attack-target-select-option")
                {
                    DisplayedString = ObjectDescriber.Describe(target),
                    Value           = target
                });
            }
            _AttackTargetSelect.SetValue(i => i.Value == Attack.Target);
            _AttackTargetSelect.OnChange += HandleAttackTargetChanged;
            _OrderButton.Position         = new Vector2f(0, Size.Y - _OrderButton.Size.Y - 32);
            _OrderButton.OnClick         += (sender, e) => { if (OnExecute != null)
                                                             {
                                                                 OnExecute(this, EventArgs.Empty);
                                                             }
            };
            _Description.Position = new Vector2f(0, _AttackTargetSelect.Size.Y + 24);

            Add(_CloseButton);
            Add(_Description);
            Add(_AttackTargetSelect);
            Add(_OrderButton);

            UpdateDescription(null, EventArgs.Empty);
        }
Example #6
0
        public void ViewCreateMotion(int n)
        {
            var hearing = DB.Appeals.FirstOrDefault(x => x.Id == n);

            if (hearing == null)
            {
                RespondRaw("Unknown hearing", 404);
                return;
            }
            if (hearing.Holding != null)
            {
                RespondRaw("Petition has been concluded, no motions may be added.", 400);
                return;
            }
            var list       = new Select(name: "types");
            var motionType = typeof(Motions);
            var fields     = motionType.GetFields();

            foreach (var type in fields)
            {
                if (type.Name == nameof(Motions.WritOfCertiorari))
                {
                    continue;
                }
                list.Add((string)type.GetValue(null), type.Name);
            }
            ReplyFile("newmotion.html", 200, new Replacements(hearing)
                      .Add("types", list));
        }
Example #7
0
        public Part AddSelect(string value, string name)
        {
            var part = new Part(value, name);

            Select.Add(part);
            return(part);
        }
Example #8
0
        public MatchLobbyPlayerSection(Player Player, MatchLobby Lobby, bool Enabled)
            : base("match-lobby-player-section")
        {
            this.Player = Player;

            var header = new Button("match-lobby-player-section-header")
            {
                DisplayedString = Player.Name
            };
            var select = new Select <ArmyConfiguration>("match-lobby-player-section-select");
            var ready  = new Checkbox("match-lobby-player-section-checkbox");

            select.Add(new SelectionOption <ArmyConfiguration>("match-lobby-player-section-select-option")
            {
                DisplayedString = "Spectator",
                Value           = null
            });
            foreach (ArmyConfiguration a in Lobby.Scenario.ArmyConfigurations)
            {
                select.Add(new SelectionOption <ArmyConfiguration>("match-lobby-player-section-select-option")
                {
                    DisplayedString = a.Faction.Name,
                    Value           = a
                });
            }
            if (Enabled)
            {
                select.OnChange += HandleArmyConfigurationSelected;
            }
            select.Position = new Vector2f(0, header.Size.Y + 6);
            select.Enabled  = Enabled && !Lobby.GetPlayerReady(Player);
            select.SetValue(i => i.Value == Lobby.GetPlayerArmy(Player));

            if (Enabled)
            {
                ready.OnChange += HandlePlayerReadyStateChanged;
            }
            ready.Position = new Vector2f(Size.X - ready.Size.X - 16, 0);
            ready.Value    = Lobby.GetPlayerReady(Player);
            ready.Enabled  = Enabled;

            Add(header);
            Add(select);
            Add(ready);
        }
Example #9
0
        public SelectPage(Menu menu, params SelectOption <Action>[] options) : base(menu)
        {
            Select = new Select <Action>();

            foreach (var option in options)
            {
                Select.Add(option);
            }
        }
Example #10
0
        public SqlBuilder AddSelect(string attrs)
        {
            if (Select == null)
            {
                Select = new List <string>();
            }

            Select.Add(attrs);

            return(this);
        }
Example #11
0
            public override SqlInfo[] ConvertToIndex(Expression?expression, int level, ConvertFlags flags)
            {
                var sql = ConvertToSql(expression, level, flags);

                if (sql[0].Index < 0)
                {
                    sql[0] = sql[0].WithIndex(sql[0].Query !.Select.Add(sql[0].Sql));
                }

                return(sql);
            }
Example #12
0
        public ScenarioBuilderArmySection(ArmyBuilder ArmyBuilder, IEnumerable <Faction> Factions)
            : base("scenario-builder-army-section")
        {
            this.ArmyBuilder = ArmyBuilder;

            foreach (Faction faction in Factions)
            {
                _FactionSelect.Add(
                    new SelectionOption <Faction>("scenario-builder-army-section-faction-select-option")
                {
                    DisplayedString = ObjectDescriber.Describe(faction),
                    Value           = faction
                });
            }
            _FactionSelect.SetValue(i => i.Value == ArmyBuilder.Parameters.Faction);

            _PointsInput.Value = ArmyBuilder.Parameters.Points.ToString();

            for (byte i = 1; i <= 3; ++i)
            {
                _TeamSelect.Add(
                    new SelectionOption <byte>("scenario-builder-army-section-team-select-option")
                {
                    DisplayedString = i.ToString(),
                    Value           = i
                });
            }
            _TeamSelect.SetValue(i => i.Value == ArmyBuilder.Parameters.Team);

            var removeButton = new Button("scenario-builder-army-section-remove-button")
            {
                DisplayedString = "X"
            };

            _FactionSelect.OnChange += HandleChange;
            _PointsInput.OnLeave    += HandleChange;
            _TeamSelect.OnChange    += HandleChange;
            removeButton.OnClick    += HandleRemove;

            Add(new GuiContainer <GuiItem>("scenario-builder-army-section-faction-cell")
            {
                _FactionSelect
            });
            Add(new GuiContainer <GuiItem>("scenario-builder-army-section-points-cell")
            {
                _PointsInput
            });
            Add(new GuiContainer <GuiItem>("scenario-builder-army-section-team-cell")
            {
                _TeamSelect
            });
            Add(removeButton);
        }
Example #13
0
 public void UpdateFromMap(Map Map)
 {
     _MapRegionSelect.Clear();
     foreach (MapRegion r in Map.Regions)
     {
         _MapRegionSelect.Add(new SelectionOption <MapRegion>("select-option")
         {
             DisplayedString = r.Name,
             Value           = r
         });
     }
 }
Example #14
0
 internal SQlQuery(string tableName)
 {
     if (Select == null)
     {
         Select = new List <Tuple <string, string, string> >();
     }
     Select.Add(new Tuple <string, string, string>(tableName, ".", "*"));
     RootTable       = tableName;
     QueryParameters = new List <QueryParameter>();
     JoinContidion   = new List <string>();
     WhereCondition  = new List <string>();
     OrderItems      = new List <string>();
 }
Example #15
0
        public void AddPage(DeploymentPage Page)
        {
            Page.Visible = false;
            _Pages.Add(Page);
            Insert(0, Page);

            var option = new SelectionOption <DeploymentPage>("select-option")
            {
                Value           = Page,
                DisplayedString = Page.Deployment.Configuration.UnitGroup.Name
            };

            _DeploymentPageSelect.Add(option);
        }
        internal void ListDraw(string s = "")
        {
            try
            {
                List <Station> Stations = GameManager.GetAllStations();
                foreach (var it in stas)
                {
                    Stations.Remove(it);
                }

                foreach (Control it in panList.Controls)
                {
                    StationList02 sl = it as StationList02;
                    if (sl.isSelect)
                    {
                        Select.Add(sl.s);
                    }
                }

                panList.Size     = new Size(730, 0);
                panList.Location = new Point(0, 0);
                foreach (Control it in panList.Controls)
                {
                    it.Dispose();
                }
                panList.Controls.Clear();
                tt.RemoveAll();
                np = 1;
                mp = 1;

                _ListDraw(Stations, s);

                if (panList.Controls.Count <= 9)
                {
                    panListBack.AutoScroll = false;
                    panListBack.Size       = new Size(730, panListBack.Height);
                }
                else
                {
                    panListBack.AutoScroll = true;
                    panListBack.Size       = new Size(750, panListBack.Height);
                }
            }
            catch (Exception ex)
            {
                RTCore.Environment.ReportError(ex, AccessManager.AccessKey);
            }
        }
Example #17
0
        public NewMapPane()
            : base("new-map-pane")
        {
            _CreateButton.Position = Size - new Vector2f(_CreateButton.Size.X + 32, _CreateButton.Size.Y + 32);
            _CancelButton.Position = _CreateButton.Position - new Vector2f(_CancelButton.Size.X + 4, 0);

            _CancelButton.OnClick += HandleCancelClicked;
            _CreateButton.OnClick += HandleCreateClicked;

            foreach (var matchSetting in GameData.MatchSettings.Values)
            {
                _MatchSettingsSelect.Add(
                    new SelectionOption <MatchSetting>("new-map-parameters-section-select-option")
                {
                    Value           = matchSetting,
                    DisplayedString = ObjectDescriber.Describe(matchSetting)
                });
            }

            _Display.Add(new Button("new-map-header-1")
            {
                DisplayedString = "New Map"
            });
            _Display.Add(new Button("new-map-header-2")
            {
                DisplayedString = "Height"
            });
            _Display.Add(_HeightInput);
            _Display.Add(new Button("new-map-header-2")
            {
                DisplayedString = "Width"
            });
            _Display.Add(_WidthInput);
            _Display.Add(new Button("new-map-header-2")
            {
                DisplayedString = "Random Map Generation"
            });
            _Display.Add(_GenerateRandomCheckbox);
            _Display.Add(new GuiContainer <Pod>("new-map-parameters-section")
            {
                _MatchSettingsSelect
            });

            Add(_CancelButton);
            Add(_CreateButton);
            Add(_Display);
        }
Example #18
0
        public SelectPane(string Title, IEnumerable <T> Items)
            : base("select-pane")
        {
            var header = new Button("select-pane-header")
            {
                DisplayedString = Title
            };

            Add(header);

            _UnitSelect.Position = new Vector2f(0, header.Size.Y + 6);
            foreach (T item in Items)
            {
                var option = new SelectionOption <T>("select-option")
                {
                    Value           = item,
                    DisplayedString = ObjectDescriber.Describe(item)
                };
                _UnitSelect.Add(option);
            }
            _UnitSelect.OnChange += HandleChange;
            Add(_UnitSelect);
        }
Example #19
0
            public static void Test()
            {
                print("Test3");

                print();
                print("Select Test");

                var select = new Select <Foo>("FooSelect")
                {
                    foo1, foo2, foo3
                };

                Event.On <SelectEvent <Foo> .Selected>(select, "*", e
                                                       => print(e.GetType().Name.PadRight(10), e.item, e.Type, e.Phase));

                Event.On <SelectEvent <Foo> .Change>(select, "*", e
                                                     => print(e.GetType().Name.PadRight(10), e.Type, string.Join <object>(",", e.select.GetLayer(e.Type).GetCurrentItems())));

                select.Enter(foo1);
                select.Enter(FooState.SelectedByPlayer, foo1);
                select.Enter(FooState.SelectedByPlayer, foo2);

                select.GetLayer(FooState.Targeted).layerMode = SelectLayerMode.Multiple;
                select.Enter(FooState.Targeted, foo1);
                select.Enter(FooState.Targeted, foo2, foo3);

                print();
                print(select.GetInfo());

                select.Remove(foo3);

                print();
                print(select.GetInfo());

                select.Add(foo4);
                select.Enter(FooState.Targeted, foo2, foo3);
            }
        public ScenarioBuilderScreen(Vector2f WindowSize, ScenarioBuilder ScenarioBuilder)
            : base(WindowSize, true)
        {
            this.ScenarioBuilder = ScenarioBuilder;

            var header = new Button("scenario-builder-header")
            {
                DisplayedString = "Custom Scenario"
            };

            _Pane.Add(header);
            _LeftDisplay.Position = new Vector2f(0, header.Size.Y);
            _ArmiesTable.Position = new Vector2f(_LeftDisplay.Size.X + 32, header.Size.Y);

            MakeSection("Year", _YearSelect, _LeftDisplay);
            _YearSelect.OnChange += HandleParametersChanged;
            for (uint i = 1939; i < 1946; ++i)
            {
                _YearSelect.Add(
                    new SelectionOption <uint>(
                        "scenario-builder-parameters-section-select-option")
                {
                    DisplayedString = i.ToString(),
                    Value           = i
                });
            }
            _YearSelect.SetValue(i => i.Value == ScenarioBuilder.Parameters.Year);

            MakeSection("Setting", _SettingSelect, _LeftDisplay);
            _SettingSelect.OnChange += HandleParametersChanged;
            foreach (MatchSetting setting in GameData.MatchSettings.Values)
            {
                _SettingSelect.Add(
                    new SelectionOption <MatchSetting>("scenario-builder-parameters-section-select-option")
                {
                    DisplayedString = ObjectDescriber.Describe(setting),
                    Value           = setting
                });
            }
            _SettingSelect.SetValue(i => i.Value == ScenarioBuilder.Parameters.Setting);

            MakeSection("Turns", _TurnsSelect, _LeftDisplay);
            _TurnsSelect.OnChange += HandleParametersChanged;
            for (byte i = 6; i <= 16; i += 2)
            {
                _TurnsSelect.Add(
                    new SelectionOption <byte>("scenario-builder-parameters-section-select-option")
                {
                    DisplayedString = i.ToString(),
                    Value           = i
                });
            }
            _TurnsSelect.SetValue(i => i.Value == ScenarioBuilder.Parameters.Turns);

            MakeSection("Fog of War", _FogOfWarCheckbox, _LeftDisplay);
            _FogOfWarCheckbox.OnChange += HandleParametersChanged;
            _FogOfWarCheckbox.Value     = ScenarioBuilder.Parameters.FogOfWar;

            MakeSection("Map Width", _MapWidthInput, _LeftDisplay);
            _MapWidthInput.OnChange += HandleParametersChanged;
            _MapWidthInput.Value     = ScenarioBuilder.Parameters.MapSize.X.ToString();

            MakeSection("Map Height", _MapHeightInput, _LeftDisplay);
            _MapHeightInput.OnChange += HandleParametersChanged;
            _MapHeightInput.Value     = ScenarioBuilder.Parameters.MapSize.Y.ToString();

            _Pane.Position = .5f * (WindowSize - _Pane.Size);

            var addArmyButton = new Button("scenario-builder-army-section-add-button")
            {
                DisplayedString = "+"
            };

            addArmyButton.OnClick += HandleArmyAdded;
            _ArmiesTable.Add(
                new TableRow("scenario-builder-army-section-header")
            {
                new Button("scenario-builder-army-section-faction-header")
                {
                    DisplayedString = "Faction"
                },
                new Button("scenario-builder-army-section-points-header")
                {
                    DisplayedString = "Points"
                },
                new Button("scenario-builder-army-section-team-header")
                {
                    DisplayedString = "Team"
                },
                addArmyButton
            });

            var finishedButton = new Button("large-button")
            {
                DisplayedString = "Finished"
            };

            finishedButton.Position = new Vector2f(0, _Pane.Size.Y - finishedButton.Size.Y - 32);
            finishedButton.OnClick += HandleFinished;

            _Pane.Add(finishedButton);
            _Pane.Add(_LeftDisplay);
            _Pane.Add(_ArmiesTable);
            _Items.Add(_Pane);
        }
Example #21
0
        public EditPane(Map Map)
            : base("edit-pane")
        {
            _ModeSelect.OnChange += PaneChange;
            _ModeSelect.Add(
                new SelectionOption <Pod>("select-option")
            {
                DisplayedString = "Base",
                Value           = _TileBasePage
            });
            _ModeSelect.Add(
                new SelectionOption <Pod>("select-option")
            {
                DisplayedString = "Overlay",
                Value           = _PathOverlayPage
            });
            _ModeSelect.Add(
                new SelectionOption <Pod>("select-option")
            {
                DisplayedString = "Edge", Value = _EdgePage
            });
            _ModeSelect.Add(
                new SelectionOption <Pod>("select-option")
            {
                DisplayedString = "Elevation",
                Value           = _ElevationPage
            });
            _ModeSelect.Add(
                new SelectionOption <Pod>("select-option")
            {
                DisplayedString = "Map Region",
                Value           = _MapRegionPage
            });

            var header = new Button("edit-header-1")
            {
                DisplayedString = "Edit"
            };

            _ModeSelect.Position        = new Vector2f(0, header.Size.Y);
            _TileBaseSelect.Position    = new Vector2f(0, _ModeSelect.Position.Y + _ModeSelect.Size.Y + 2);
            _PathOverlaySelect.Position = new Vector2f(0, _ModeSelect.Position.Y + _ModeSelect.Size.Y + 2);
            _EdgeSelect.Position        = new Vector2f(0, _ModeSelect.Position.Y + _ModeSelect.Size.Y + 2);
            _Elevation.Position         = new Vector2f(0, _ModeSelect.Position.Y + _ModeSelect.Size.Y + 2);
            _MapRegionSelect.Position   = new Vector2f(0, _ModeSelect.Position.Y + _ModeSelect.Size.Y + 2);

            foreach (TileBase t in Enum.GetValues(typeof(TileBase)).Cast <TileBase>().Where(i => i != TileBase.CLEAR))
            {
                _TileBaseSelect.Add(
                    new SelectionOption <TileBase>("select-option")
                {
                    DisplayedString = ObjectDescriber.Describe(t),
                    Value           = t
                });
            }

            foreach (TileEdge e in Enum.GetValues(typeof(TileEdge)).Cast <TileEdge>().Where(i => i != TileEdge.NONE))
            {
                _EdgeSelect.Add(new SelectionOption <TileEdge>("select-option")
                {
                    DisplayedString = ObjectDescriber.Describe(e),
                    Value           = e
                });
            }

            foreach (TilePathOverlay t in Enum.GetValues(typeof(TilePathOverlay))
                     .Cast <TilePathOverlay>().Where(i => i != TilePathOverlay.NONE))
            {
                _PathOverlaySelect.Add(new SelectionOption <TilePathOverlay>("select-option")
                {
                    DisplayedString = ObjectDescriber.Describe(t),
                    Value           = t
                });
            }

            UpdateFromMap(Map);

            _MapRegionAddButton.Position = new Vector2f(
                Size.X - _MapRegionAddButton.Size.X - 32, Size.Y - _MapRegionAddButton.Size.Y - 32);
            _MapRegionAddButton.OnClick    += HandleAddMapRegion;
            _MapRegionDeleteButton.Position = _MapRegionAddButton.Position
                                              - new Vector2f(_MapRegionDeleteButton.Size.X + 8, 0);
            _MapRegionDeleteButton.OnClick += HandleDeleteMapRegion;
            _MapRegionSelect.OnChange      += HandleSelectMapRegion;

            _ElevationPage.Add(_Elevation);
            _PathOverlayPage.Add(_PathOverlaySelect);
            _EdgePage.Add(_EdgeSelect);
            _TileBasePage.Add(_TileBaseSelect);
            _MapRegionPage.Add(_MapRegionAddButton);
            _MapRegionPage.Add(_MapRegionDeleteButton);
            _MapRegionPage.Add(_MapRegionSelect);

            Add(header);
            Add(_ElevationPage);
            Add(_PathOverlayPage);
            Add(_EdgePage);
            Add(_TileBasePage);
            Add(_MapRegionPage);
            Add(_ModeSelect);
        }
Example #22
0
        public ArmyBuilderScreen(
            Vector2f WindowSize,
            IEnumerable <UnitConfigurationLink> UnitConfigurations,
            ArmyParameters Parameters,
            UnitConfigurationRenderer Renderer)
            : base(WindowSize)
        {
            _Parameters = Parameters;
            _Links      = UnitConfigurations;

            _Pane.Position = .5f * (WindowSize - _Pane.Size);

            var header = new Button("army-builder-header")
            {
                DisplayedString =
                    string.Format(
                        "{0} - {1} - {2}",
                        ObjectDescriber.Describe(Parameters.Faction),
                        ObjectDescriber.Describe(Parameters.Parameters.Setting.Front),
                        Parameters.Parameters.Year)
            };

            _UnitClassSelect.Position = new Vector2f(0, header.Size.Y);

            _AvailableUnits = new UnitConfigurationTable(
                "army-builder-table",
                "army-builder-table-row",
                "army-builder-table-cell",
                _Parameters.Faction,
                Renderer,
                false);
            _AvailableUnits.Position            = new Vector2f(0, _UnitClassSelect.Position.Y + _UnitClassSelect.Size.Y + 16);
            _AvailableUnits.OnUnitClicked      += HandleAddUnit;
            _AvailableUnits.OnUnitRightClicked += HandleUnitInfoRequested;

            _PointTotalButton          = new Button("army-builder-point-total");
            _PointTotalButton.Position = new Vector2f(_AvailableUnits.Size.X + 16, header.Size.Y);
            SetPointTotal(0);

            _SelectedUnits = new UnitConfigurationTable(
                "army-builder-table",
                "army-builder-table-row",
                "army-builder-table-cell",
                _Parameters.Faction,
                Renderer,
                true);
            _SelectedUnits.Position =
                new Vector2f(_AvailableUnits.Size.X + 16, _PointTotalButton.Position.Y + _PointTotalButton.Size.Y + 16);
            _SelectedUnits.OnUnitRightClicked += HandleRemoveUnit;

            foreach (UnitClass c in Enum.GetValues(typeof(UnitClass)))
            {
                _UnitClassSelect.Add(
                    new SelectionOption <UnitClass>("army-builder-select-option")
                {
                    DisplayedString = ObjectDescriber.Describe(c),
                    Value           = c
                });
            }

            _UnitClassSelect.OnChange += FilterUnits;
            FilterUnits();

            var finishedButton = new Button("army-builder-large-button")
            {
                DisplayedString = "Finished"
            };

            finishedButton.Position = _Pane.Size - finishedButton.Size - new Vector2f(32, 32);
            finishedButton.OnClick += HandleFinished;

            _Pane.Add(header);
            _Pane.Add(_AvailableUnits);
            _Pane.Add(_SelectedUnits);
            _Pane.Add(_PointTotalButton);
            _Pane.Add(_UnitClassSelect);
            _Pane.Add(finishedButton);
            _Items.Add(_Pane);
        }