/// <summary>
/// Creates menu items for the specified MenuDefinitionEntryCollection.
/// </summary>
/// <param name="commandManager">The CommandManager to use.</param>
/// <param name="menuDefinitionEntryCollection">The MenuDefinitionEntryCollection to create menu items for.</param>
/// <returns>The menu items.</returns>
public static MenuItem[] CreateMenuItems(CommandManager commandManager, MenuType menuType, MenuDefinitionEntryCollection menuDefinitionEntryCollection)
{
ArrayList menuItemArrayList = new ArrayList();
for (int position = 0; position < menuDefinitionEntryCollection.Count; position++)
{
MenuItem[] menuItems = menuDefinitionEntryCollection[position].GetMenuItems(commandManager, menuType);
if (menuItems != null)
menuItemArrayList.AddRange(menuItems);
}
// remove leading, trailing, and adjacent separators
for (int i = menuItemArrayList.Count - 1; i >= 0; i--)
{
if (((MenuItem)menuItemArrayList[i]).Text == "-")
{
if (i == 0 || // leading
i == menuItemArrayList.Count - 1 || // trailing
((MenuItem)menuItemArrayList[i - 1]).Text == "-") // adjacent
{
menuItemArrayList.RemoveAt(i);
}
}
}
return (menuItemArrayList.Count == 0) ? null : (MenuItem[])menuItemArrayList.ToArray(typeof(MenuItem));
}
public MapEditorTabsLogic(Widget widget, WorldRenderer worldRenderer)
{
var tabContainer = widget.Get("MAP_EDITOR_TAB_CONTAINER");
var tilesTab = tabContainer.Get<ButtonWidget>("TILES_TAB");
tilesTab.IsHighlighted = () => menuType == MenuType.Tiles;
tilesTab.OnClick = () => { menuType = MenuType.Tiles; };
var overlaysTab = tabContainer.Get<ButtonWidget>("OVERLAYS_TAB");
overlaysTab.IsHighlighted = () => menuType == MenuType.Layers;
overlaysTab.OnClick = () => { menuType = MenuType.Layers; };
var actorsTab = tabContainer.Get<ButtonWidget>("ACTORS_TAB");
actorsTab.IsHighlighted = () => menuType == MenuType.Actors;
actorsTab.OnClick = () => { menuType = MenuType.Actors; };
var tileContainer = widget.Parent.Get<ContainerWidget>("TILE_WIDGETS");
tileContainer.IsVisible = () => menuType == MenuType.Tiles;
var layerContainer = widget.Parent.Get<ContainerWidget>("LAYER_WIDGETS");
layerContainer.IsVisible = () => menuType == MenuType.Layers;
var actorContainer = widget.Parent.Get<ContainerWidget>("ACTOR_WIDGETS");
actorContainer.IsVisible = () => menuType == MenuType.Actors;
}
public XisMenu(EA.Repository repository, EA.Diagram diagram, XisWidget parent, string name, MenuType type)
: base(repository, parent)
{
Element = XisWebHelper.CreateXisMenu(parent.Element, name, type);
Groups = new List<XisMenuGroup>();
Items = new List<XisMenuItem>();
}
public static CheckBox GetCheckbox(MenuType menuType, string uniqueName)
{
CheckBox checkbox = getMenu(menuType).Get<CheckBox>(uniqueName);
if (checkbox == null)
Console.WriteLine("Checkbox " + uniqueName + " does not exist under this menu type: " + menuType.ToString());
return checkbox;
}
public void Init(MenuType menuType, object obj, Action<object> acceptedCallback)
{
this.m_MenuType = menuType;
this.m_Object = obj;
this.m_AcceptedCallback = acceptedCallback;
this.m_IsInitialized = true;
}
public async Task NavigateAsync(MenuType id)
{
Page newPage;
if (!Pages.ContainsKey(id))
{
switch (id)
{
case MenuType.Dashboard:
DashboardPage dashboard = new DashboardPage ();
dashboard.BindingContext = new DashboardViewModel(){ Navigation = this.Navigation };
Pages.Add(id, new EmanagementNavigationPage(dashboard));
break;
}
}
newPage = Pages[id];
if(newPage == null)
return;
//pop to root for Windows Phone
if (Detail != null && Device.OS == TargetPlatform.WinPhone)
{
await Detail.Navigation.PopToRootAsync();
}
Detail = newPage;
if(Device.Idiom != TargetIdiom.Tablet)
IsPresented = false;
}
public async Task NavigateAsync(MenuType id)
{
Page newPage;
if (!Pages.ContainsKey(id))
{
switch (id)
{
case MenuType.About:
Pages.Add(id, new AppointyNavigationPage(new AboutPage()));
break;
case MenuType.Hanselminutes:
Pages.Add(id, new AppointyNavigationPage(new PodcastPage(id)));
break;
}
}
newPage = Pages[id];
if(newPage == null)
return;
//pop to root for Windows Phone
if (Detail != null && Device.OS == TargetPlatform.WinPhone)
{
await Detail.Navigation.PopToRootAsync();
}
Detail = newPage;
if(Device.Idiom != TargetIdiom.Tablet)
IsPresented = false;
}
public PodcastViewModel(MenuType item)
{
this.item = item;
image = "hm_full.jpg";
Title = "Blogs";
}
public ProfileOption(MenuType menuType, string id, OptionType type, string value)
{
MenuType = menuType;
Id = id;
Type = type;
Value = value;
}
public static void Add(MenuType Type)
{
if (Current != null)
Current.Visibility = Visibility.Hidden;
MenuStack.Push(Menus[Type]);
currentChanged();
}
// Method that parses the string 'type' into a valid MenuType.
// If 'type' is invalid, an error is printed in console and the
// application quits when escape is pressed (not yet implemented)
private void setMenuType(string type)
{
MenuType tempType;
if (Enum.TryParse(type, out tempType))
menuType = tempType;
/*else
IMPLEMENT ERROR CLASS AND PRINT TO CONSOLE
*/
}
public async Task NavigateAsync(MenuType id)
{
Page newPage;
if (!Pages.ContainsKey(id))
{
switch (id)
{
case MenuType.Sales:
Pages.Add(id, new CRMNavigationPage(new SalesDashboardPage
{
Title = TextResources.MainTabs_Sales,
Icon = new FileImageSource { File = "sales.png" }
}));
break;
case MenuType.Customers:
Pages.Add(id, new CRMNavigationPage(new CustomersPage
{
BindingContext = new CustomersViewModel(Navigation),
Title = TextResources.MainTabs_Customers,
Icon = new FileImageSource { File = "customers.png" }
}));
break;
case MenuType.Products:
Pages.Add(id, new CRMNavigationPage(new CategoryListPage
{
BindingContext = new CategoriesViewModel(navigation: Navigation),
Title = TextResources.MainTabs_Products,
Icon = new FileImageSource { File = "products.png" }
}));
break;
case MenuType.About:
Pages.Add(id, new CRMNavigationPage(new AboutPage
{
Title = "About",
Icon = new FileImageSource { File = "about.png" }
}));
break;
}
}
newPage = Pages[id];
if (newPage == null)
return;
//pop to root for Windows Phone
if (Detail != null && Device.OS == TargetPlatform.WinPhone)
{
await Detail.Navigation.PopToRootAsync();
}
Detail = newPage;
if (Device.Idiom != TargetIdiom.Tablet)
IsPresented = false;
}
internal void Navigate(MenuType type, bool gotoState)
{
switch (type)
{
case MenuType.Home:
SetPageTitle("Home");
SetActive(type);
SwapPage(new home());
break;
case MenuType.Imprint:
SetPageTitle("Impressum");
SetActive(type);
SwapPage(new ImprintPage());
break;
case MenuType.KopierService:
SetPageTitle("Kopierservice Werlsee");
if (gotoState)
{
VisualStateManager.GoToState(MenuKopierService, "MouseOver", true);
}
SetActive(type);
SwapPage(new KopierServicePage());
break;
case MenuType.Wasserbau:
if (gotoState)
{
VisualStateManager.GoToState(MenuNbw, "MouseOver", true);
}
SetPageTitle("Niederbarnimer Wasserbau");
SetActive(type);
SwapPage(new WasserbauPage());
break;
case MenuType.YachtCharter:
if (gotoState)
{
VisualStateManager.GoToState(MenuYachtCharter, "MouseOver", true);
}
SetPageTitle("Yachtcharter Süd/Ost");
SetActive(type);
SwapPage(new YachtCharterPage());
break;
case MenuType.Contact:
SetPageTitle("Kontakt");
SetActive(type);
SwapPage(new ContactPage());
break;
case MenuType.Services:
SetPageTitle("Übersicht");
SetActive(type);
SwapPage(new OverviewPage());
break;
default:
break;
}
}
public MasterView(MenuViewModel viewModel)
{
this.BindingContext = viewModel;
this.Title = "Title";
var layout = new StackLayout { Spacing = 0 };
var listView = new ListView();
var cell = new DataTemplate(typeof(ImageCell));
cell.SetBinding(TextCell.TextProperty, MenuViewModel.TitlePropertyName);
cell.SetBinding(ImageCell.ImageSourceProperty, "Icon");
listView.ItemTemplate = cell;
listView.ItemsSource = viewModel.MenuItems;
if (about == null)
about = new AboutView();
PageSelection = about;
listView.ItemSelected += (sender, args) =>
{
var menuItem = listView.SelectedItem as HomeMenuItem;
menuType = menuItem.MenuType;
switch (menuItem.MenuType)
{
case MenuType.Home:
if (home == null)
home = new HomeView();
PageSelection = home;
break;
case MenuType.About:
if (about == null)
about = new AboutView();
PageSelection = about;
break;
case MenuType.Feedback:
if (feedback == null)
feedback = new FeedbackView();
PageSelection = feedback;
break;
}
};
listView.SelectedItem = viewModel.MenuItems[0];
layout.Children.Add(listView);
this.Content = layout;
}
/// <summary>
/// 新增選單
/// </summary>
/// <returns></returns>
public ActionResult Create(Guid? parentId, MenuType typeOpt = MenuService.DefaultType)
{
var menu = new Menu()
{
Type = (int)typeOpt
};
ViewBag.infoList = GetSelect(null, parentId, typeOpt);
ViewBag.TypeOpt = typeOpt;
ViewBag.CurrentId = parentId;
return View(menu);
}
public MainMenuButtonsLogic(Widget widget)
{
rootMenu = widget;
rootMenu.IsVisible = () => Menu == MenuType.Main;
Game.modData.WidgetLoader.LoadWidget( new WidgetArgs(), Ui.Root, "PERF_BG" );
var versionLabel = Ui.Root.GetOrNull<LabelWidget>("VERSION_LABEL");
if (versionLabel != null)
versionLabel.GetText = WidgetUtils.ActiveModVersion;
widget.Get<ButtonWidget>("MAINMENU_BUTTON_JOIN").OnClick = () => OpenGamePanel("JOINSERVER_BG");
widget.Get<ButtonWidget>("MAINMENU_BUTTON_CREATE").OnClick = () => OpenGamePanel("CREATESERVER_BG");
widget.Get<ButtonWidget>("MAINMENU_BUTTON_DIRECTCONNECT").OnClick = () => OpenGamePanel("DIRECTCONNECT_BG");
widget.Get<ButtonWidget>("MAINMENU_BUTTON_SETTINGS").OnClick = () =>
{
Menu = MenuType.None;
Ui.OpenWindow("SETTINGS_MENU", new WidgetArgs()
{
{ "onExit", () => Menu = MenuType.Main }
});
};
widget.Get<ButtonWidget>("MAINMENU_BUTTON_MUSIC").OnClick = () =>
{
Menu = MenuType.None;
Ui.OpenWindow("MUSIC_MENU", new WidgetArgs()
{
{ "onExit", () => Menu = MenuType.Main }
});
};
widget.Get<ButtonWidget>("MAINMENU_BUTTON_MODS").OnClick = () =>
{
Menu = MenuType.None;
Ui.OpenWindow("MODS_PANEL", new WidgetArgs()
{
{ "onExit", () => Menu = MenuType.Main },
{ "onSwitch", RemoveShellmapUI }
});
};
widget.Get<ButtonWidget>("MAINMENU_BUTTON_REPLAY_VIEWER").OnClick = () =>
{
Menu = MenuType.None;
Ui.OpenWindow("REPLAYBROWSER_BG", new WidgetArgs()
{
{ "onExit", () => Menu = MenuType.Main },
{ "onStart", RemoveShellmapUI }
});
};
widget.Get<ButtonWidget>("MAINMENU_BUTTON_QUIT").OnClick = () => Game.Exit();
}
/// <summary>
/// Constructor.
/// </summary>
public MenuScreen(string menuTitle, MenuType type)
{
_menuTitle = menuTitle;
TransitionOnTime = TimeSpan.FromSeconds(0.7);
TransitionOffTime = TimeSpan.FromSeconds(0.7);
_menuType = type;
HasCursor = true;
//////////////////////////////
//MenuItem top margin
//////////////////////////////
_menuItemMarginTop = 30;
}
GameObject MenuGameObject(MenuType menu)
{
if (menu == MenuType.Game)
return GameMenu.gameObject;
else if (menu == MenuType.Leaderboard)
return LeaderboardMenu.gameObject;
else if (menu == MenuType.Settings)
return SettingsMenu.gameObject;
else if (menu == MenuType.Customize)
return CustomizeMenu.gameObject;
else
return MainMenu.gameObject;
}
Animation MenuTransitioning(MenuType menu)
{
if (menu == MenuType.Game)
return GameMenu.animation;
else if (menu == MenuType.Leaderboard)
return LeaderboardMenu.animation;
else if (menu == MenuType.Settings)
return SettingsMenu.animation;
else if (menu == MenuType.Customize)
return CustomizeMenu.animation;
else
return MainMenu.animation;
}
public XisMenu(EA.Repository repository, EA.Diagram diagram, EA.Package package, string name, MenuType type)
: base(repository)
{
if (type == MenuType.ContextMenu)
{
Element = XisWebHelper.CreateXisMenu(package, name, type);
Items = new List<XisMenuItem>();
}
else
{
throw new Exception("Unsupported constructor for XisMenu of type: " + type.ToString());
}
}
public PodcastPage(MenuType item)
{
InitializeComponent();
BindingContext = new PodcastViewModel(item);
listView.ItemTapped += (sender, args) =>
{
if (listView.SelectedItem == null)
return;
this.Navigation.PushAsync(new PodcastPlaybackPage
(listView.SelectedItem as FeedItem));
listView.SelectedItem = null;
};
}
private static Menu getMenu(MenuType type)
{
switch(type)
{
case MenuType.Debug:
return DebugMenu;
case MenuType.Main:
return mainMenu;
case MenuType.Dodge:
return DodgeMenu;
case MenuType.Draw:
return DrawMenu;
}
return null;
}
public static HtmlString SiteMapMenu(this HtmlHelper helper, SiteMapNode rootNode, IPage model, MenuType menutype)
{
HtmlString htmlReturn = new HtmlString(String.Empty);
switch (menutype)
{
case MenuType.TopMenu:
htmlReturn = CreateTopMenu(rootNode, helper.ViewContext, model);
break;
case MenuType.LeftMenu:
htmlReturn = CreateLeftMenu(rootNode, helper.ViewContext, model);
break;
}
return htmlReturn;
}
public static HtmlString SiteMapMenu(this HtmlHelper helper, IPage model, MenuType menutype)
{
switch (menutype)
{
case MenuType.Top:
return CreateTopMenu(FindRootNode(CurrentSiteMapProvider.RootNode), helper.ViewContext, model);
case MenuType.Left:
return CreateLeftMenu(FindRootNode(CurrentSiteMapProvider.RootNode), helper.ViewContext, model);
case MenuType.BreadCrumbs:
return CreateBreadCrumbs(FindRootNode(CurrentSiteMapProvider.RootNode), helper.ViewContext, model);
case MenuType.Full:
return CreateFullSiteMap(FindRootNode(CurrentSiteMapProvider.RootNode), helper.ViewContext, model);
}
return new HtmlString(String.Empty);
}
// Use this for initialization
void Start()
{
// override menuType if MGC has already set some (from splash screen)
// if returning from some other scene, the menuType will just get rewritten
// with the same value (if it's not changed, which is now also possible for better testing)
if(MGC.Instance.menuType != MenuType.None)
{
menuType = MGC.Instance.menuType;
}
else
{
MGC.Instance.menuType = menuType;
}
#if UNITY_STANDALONE
// clear KinectManager
MGC.Instance.ResetKinect();
#endif
MGC.Instance.sceneLoader.doFade = true;
switch (menuType)
{
case MenuType.Brain:
{
MGC.Instance.mainSceneName = brainMenuScene;
SceneManager.LoadScene(brainMenuScene);
break;
}
case MenuType.Tiles:
{
MGC.Instance.mainSceneName = tilesMenuScene;
SceneManager.LoadScene(tilesMenuScene);
break;
}
case MenuType.GSI:
{
MGC.Instance.mainSceneName = GSIMenuScene;
SceneManager.LoadScene(GSIMenuScene);
break;
}
default:
{
errorPanel.gameObject.SetActive(true);
break;
}
}
}
void NavigateTo(MenuType option)
{
if (previousItem == option)
return;
previousItem = option;
var displayPage = PageForOption(option);
displayPage.BarBackgroundColor = Helpers.AppColors.CONTENTBKGCOLOR;
displayPage.BarTextColor = Color.White;
Detail = displayPage;
IsPresented = false;
}
/// <summary>
/// List menu items
/// </summary>
/// <param name="menuType">Menu type items, footer or header for example.</param>
/// <returns>List of menu items</returns>
public IEnumerable<MenuItem> ListItems(MenuType menuType)
{
// Save the menu type
_menuType = menuType;
// Get current member roles
_currentMemberRoles = Roles.GetRolesForUser();
// Take the home page
var homePage = ((DynamicPublishedContentList)_helper.ContentAtRoot()).First();
// Search for the pages that current user has an access
var nodesList = homePage.Children.Where(UserHasAccess);
var menu = new List<MenuItem>();
foreach (var node in nodesList)
{
// 1st level items creation
var menuItem = new MenuItem
{
Label = node.GetPropertyValue<string>("menuItemName"),
ShouldOpenInTheNewTab = node.GetPropertyValue<bool>("openInTheNewTab"),
Url = node.Url
};
// 2nd level items creation
var subItems = node.Children.Where(UserHasAccess);
if (subItems.Any())
{
foreach (var subnode in node.Children.Where(UserHasAccess))
{
var subMenuItem = new MenuItem
{
Label = subnode.GetPropertyValue<string>("menuItemName"),
ShouldOpenInTheNewTab = subnode.GetPropertyValue<bool>("openInTheNewTab"),
Url = subnode.Url,
LinkType = subnode.GetPropertyValue<string>("NodeTypeAlias"),
FileUrl = subnode.GetPropertyValue<string>("file")
};
menuItem.Items.Add(subMenuItem);
}
}
menu.Add(menuItem);
}
return menu;
}
/// <summary>
/// Initializes a new instance of the CommandOwnerDrawMenuItem class.
/// </summary>
public CommandOwnerDrawMenuItem(MenuType menuType, Command command, string text) : base(menuType, text)
{
// Make sure the command is non-null.
Debug.Assert(command != null, "CommandOwnerDrawMenuItem - Command was null.");
if (command == null)
return;
Debug.Assert(text != null, "Text was null");
// Set the command.
this.command = command;
// Initialize the menu item.
if (menuType == MenuType.Main)
{
ShowShortcut = command.ShowShortcut;
Shortcut = command.Shortcut;
Visible = command.VisibleOnMainMenu;
}
else if (menuType == MenuType.Context)
{
ShowShortcut = false;
Shortcut = Shortcut.None;
Visible = command.VisibleOnContextMenu;
}
else if (menuType == MenuType.CommandBarContext)
{
ShowShortcut = command.ShowShortcut;
Shortcut = command.Shortcut;
Visible = command.VisibleOnContextMenu;
}
else
{
Trace.Assert(false, "CommandOwnerDrawMenuItem - MenuType is not supported.");
ShowShortcut = false;
Shortcut = Shortcut.None;
}
Enabled = command.Enabled;
// Add event handlers for the command events.
command.StateChanged += command_StateChanged;
command.VisibleOnContextMenuChanged += command_VisibleOnContextMenuChanged;
command.VisibleOnMainMenuChanged += command_VisibleOnMainMenuChanged;
}
/// <summary>
/// 获取装置菜单
/// </summary>
/// <param name="menuPath">菜单路径</param>
/// <param name="staName">站点名称</param>
/// <param name="equName">装置名称</param>
/// <returns></returns>
public static ItemType GetMenu(string menuPath, string staName, string equName) {
int iGet = 0;
ITEM_TYPE root = new ITEM_TYPE();
ItemType menu = new ItemType();
int size = Marshal.SizeOf(typeof(ITEM_TYPE));
try {
StringBuilder sbErr = new StringBuilder();
iGet = dse_get_ied_menu(menuPath, staName, equName, ref root, sbErr);
if (sbErr.ToString() != "") {
// MessageBox.Show("打开文件失败！");
return null;
}
menu = new MenuType(root);
} catch (Exception) {
}
return menu;
}
public Menu(Texture2D startTexture, Texture2D startTextureMouseHovering, Texture2D exitTexture, Texture2D exitTextureMouseHovering,
Texture2D creditTexture, Texture2D creditTextureMouseHovering, Texture2D mainMenu, Texture2D credits)
{
menuType = MenuType.StartMenu;
this.startTexture = startTexture;
this.startTextureMouseHovering = startTextureMouseHovering;
this.exitTexture = exitTexture;
this.exitTextureMouseHovering = exitTextureMouseHovering;
this.creditTexture = creditTexture;
this.creditTextureMouseHovering = creditTextureMouseHovering;
this.mainMenu = mainMenu;
this.credits = credits;
mainMenuRec = new Rectangle(0, -World.HUD, World.RoomWidth, World.RoomHeight + World.HUD);
startButton = new MenuButton(startTexture, startTextureMouseHovering, new Rectangle((World.RoomWidth - 530)/2 + 30, -110, 530, 196));
exitButton = new MenuButton(exitTexture, exitTextureMouseHovering, new Rectangle(80, 400, 329, 128));
creditButton = new MenuButton(creditTexture, creditTextureMouseHovering, new Rectangle(80, 200, 329, 128));
}
public void OnPause()
{
menuType = MenuType.PauseMenu;
SelectMenu(menuType);
Time.timeScale = 0;
}
public void SetMenu(MenuType menuType, bool isAction, bool isShop, Vector3 worldPos)
{
m_GameUI.SetMenu(menuType, isAction, isShop, worldPos);
}
NavigationPage PageForOption(MenuType option)
{
switch (option)
{
case MenuType.Dashboard:
{
if (dashboard != null)
{
return(dashboard);
}
var vm = new DashboardViewModel()
{
Navigation = Navigation
};
dashboard = new NavigationPage(new DashboardView(vm));
return(dashboard);
}
case MenuType.Accounts:
{
if (accounts != null)
{
return(accounts);
}
var vm = new AccountsViewModel()
{
Navigation = Navigation
};
accounts = new NavigationPage(new AccountsView(vm));
return(accounts);
}
case MenuType.Leads:
{
if (leads != null)
{
return(leads);
}
leads = new NavigationPage(new Leads.LeadsView(new ViewModels.Leads.LeadsViewModel()
{
Navigation = Navigation
}));
return(leads);
}
case MenuType.Contacts:
{
if (contacts != null)
{
return(contacts);
}
var vm = new ContactsViewModel();
contacts = new NavigationPage(new Contacts.ContactsView(vm));
return(contacts);
}
case MenuType.Catalog:
{
if (catalog != null)
{
return(catalog);
}
catalog = new NavigationPage(new Catalog.CatalogCarouselView());
return(catalog);
}
case MenuType.Settings:
{
if (settings != null)
{
return(settings);
}
settings = new NavigationPage(new Settings.UserSettingsView());
return(settings);
}
}
throw new NotImplementedException("Unknown menu option: " + option.ToString());
}
public MainMenuLogic(Widget widget, World world)
{
rootMenu = widget;
rootMenu.Get <LabelWidget>("VERSION_LABEL").Text = Game.ModData.Manifest.Mod.Version;
// Menu buttons
var mainMenu = widget.Get("MAIN_MENU");
mainMenu.IsVisible = () => menuType == MenuType.Main;
mainMenu.Get <ButtonWidget>("SINGLEPLAYER_BUTTON").OnClick = () => menuType = MenuType.Singleplayer;
mainMenu.Get <ButtonWidget>("MULTIPLAYER_BUTTON").OnClick = () =>
{
menuType = MenuType.None;
Ui.OpenWindow("MULTIPLAYER_PANEL", new WidgetArgs
{
{ "onStart", RemoveShellmapUI },
{ "onExit", () => menuType = MenuType.Main },
{ "directConnectHost", null },
{ "directConnectPort", 0 },
});
};
mainMenu.Get <ButtonWidget>("MODS_BUTTON").OnClick = () =>
{
// Switching mods changes the world state (by disposing it),
// so we can't do this inside the input handler.
Game.RunAfterTick(() =>
{
Game.Settings.Game.PreviousMod = Game.ModData.Manifest.Mod.Id;
Game.InitializeMod("modchooser", null);
});
};
mainMenu.Get <ButtonWidget>("SETTINGS_BUTTON").OnClick = () =>
{
menuType = MenuType.None;
Game.OpenWindow("SETTINGS_PANEL", new WidgetArgs
{
{ "onExit", () => menuType = MenuType.Main }
});
};
mainMenu.Get <ButtonWidget>("EXTRAS_BUTTON").OnClick = () => menuType = MenuType.Extras;
mainMenu.Get <ButtonWidget>("QUIT_BUTTON").OnClick = Game.Exit;
// Singleplayer menu
var singleplayerMenu = widget.Get("SINGLEPLAYER_MENU");
singleplayerMenu.IsVisible = () => menuType == MenuType.Singleplayer;
var missionsButton = singleplayerMenu.Get <ButtonWidget>("MISSIONS_BUTTON");
missionsButton.OnClick = () =>
{
menuType = MenuType.None;
Game.OpenWindow("MISSIONBROWSER_PANEL", new WidgetArgs
{
{ "onExit", () => menuType = MenuType.Singleplayer },
{ "onStart", RemoveShellmapUI }
});
};
var hasCampaign = Game.ModData.Manifest.Missions.Any();
var hasMissions = Game.ModData.MapCache
.Any(p => p.Status == MapStatus.Available && p.Map.Visibility.HasFlag(MapVisibility.MissionSelector));
missionsButton.Disabled = !hasCampaign && !hasMissions;
singleplayerMenu.Get <ButtonWidget>("SKIRMISH_BUTTON").OnClick = StartSkirmishGame;
singleplayerMenu.Get <ButtonWidget>("BACK_BUTTON").OnClick = () => menuType = MenuType.Main;
// Extras menu
var extrasMenu = widget.Get("EXTRAS_MENU");
extrasMenu.IsVisible = () => menuType == MenuType.Extras;
extrasMenu.Get <ButtonWidget>("REPLAYS_BUTTON").OnClick = () =>
{
menuType = MenuType.None;
Ui.OpenWindow("REPLAYBROWSER_PANEL", new WidgetArgs
{
{ "onExit", () => menuType = MenuType.Extras },
{ "onStart", RemoveShellmapUI }
});
};
extrasMenu.Get <ButtonWidget>("MUSIC_BUTTON").OnClick = () =>
{
menuType = MenuType.None;
Ui.OpenWindow("MUSIC_PANEL", new WidgetArgs
{
{ "onExit", () => menuType = MenuType.Extras },
{ "world", world }
});
};
extrasMenu.Get <ButtonWidget>("MAP_EDITOR_BUTTON").OnClick = () => menuType = MenuType.MapEditor;
var assetBrowserButton = extrasMenu.GetOrNull <ButtonWidget>("ASSETBROWSER_BUTTON");
if (assetBrowserButton != null)
{
assetBrowserButton.OnClick = () =>
{
menuType = MenuType.None;
Game.OpenWindow("ASSETBROWSER_PANEL", new WidgetArgs
{
{ "onExit", () => menuType = MenuType.Extras },
});
}
}
;
extrasMenu.Get <ButtonWidget>("CREDITS_BUTTON").OnClick = () =>
{
menuType = MenuType.None;
Ui.OpenWindow("CREDITS_PANEL", new WidgetArgs
{
{ "onExit", () => menuType = MenuType.Extras },
});
};
extrasMenu.Get <ButtonWidget>("BACK_BUTTON").OnClick = () => menuType = MenuType.Main;
// Map editor menu
var mapEditorMenu = widget.Get("MAP_EDITOR_MENU");
mapEditorMenu.IsVisible = () => menuType == MenuType.MapEditor;
var onSelect = new Action <string>(uid =>
{
RemoveShellmapUI();
LoadMapIntoEditor(Game.ModData.MapCache[uid].Map);
});
var newMapButton = widget.Get <ButtonWidget>("NEW_MAP_BUTTON");
newMapButton.OnClick = () =>
{
menuType = MenuType.None;
Game.OpenWindow("NEW_MAP_BG", new WidgetArgs()
{
{ "onSelect", onSelect },
{ "onExit", () => menuType = MenuType.MapEditor }
});
};
var loadMapButton = widget.Get <ButtonWidget>("LOAD_MAP_BUTTON");
loadMapButton.OnClick = () =>
{
menuType = MenuType.None;
Game.OpenWindow("MAPCHOOSER_PANEL", new WidgetArgs()
{
{ "initialMap", null },
{ "initialTab", MapClassification.User },
{ "onExit", () => menuType = MenuType.MapEditor },
{ "onSelect", onSelect },
{ "filter", MapVisibility.Lobby | MapVisibility.Shellmap | MapVisibility.MissionSelector },
});
};
mapEditorMenu.Get <ButtonWidget>("BACK_BUTTON").OnClick = () => menuType = MenuType.Extras;
var newsBG = widget.GetOrNull("NEWS_BG");
if (newsBG != null)
{
newsBG.IsVisible = () => Game.Settings.Game.FetchNews && menuType != MenuType.None;
newsPanel = Ui.LoadWidget <ScrollPanelWidget>("NEWS_PANEL", null, new WidgetArgs());
newsTemplate = newsPanel.Get("NEWS_ITEM_TEMPLATE");
newsPanel.RemoveChild(newsTemplate);
newsStatus = newsPanel.Get <LabelWidget>("NEWS_STATUS");
SetNewsStatus("Loading news");
var cacheFile = Platform.ResolvePath("^", "news.yaml");
var currentNews = ParseNews(cacheFile);
if (currentNews != null)
{
DisplayNews(currentNews);
}
var newsButton = newsBG.GetOrNull <DropDownButtonWidget>("NEWS_BUTTON");
if (newsButton != null)
{
if (!fetchedNews)
{
new Download(Game.Settings.Game.NewsUrl, cacheFile, e => { },
(e, c) => NewsDownloadComplete(e, cacheFile, currentNews,
() => newsButton.AttachPanel(newsPanel)));
}
newsButton.OnClick = () => newsButton.AttachPanel(newsPanel);
}
}
Game.OnRemoteDirectConnect += OnRemoteDirectConnect;
}
void OnRemoteDirectConnect(string host, int port)
{
menuType = MenuType.None;
Ui.OpenWindow("MULTIPLAYER_PANEL", new WidgetArgs
{
{ "onStart", RemoveShellmapUI },
{ "onExit", () => menuType = MenuType.Main },
{ "directConnectHost", host },
{ "directConnectPort", port },
});
}
void LoadMapIntoEditor(Map map)
{
ConnectionLogic.Connect(System.Net.IPAddress.Loopback.ToString(),
Game.CreateLocalServer(map.Uid),
"",
() => { Game.LoadEditor(map.Uid); },
() => { Game.CloseServer(); menuType = MenuType.MapEditor; });
}
void SetNewsStatus(string message)
{
message = WidgetUtils.WrapText(message, newsStatus.Bounds.Width, Game.Renderer.Fonts[newsStatus.Font]);
newsStatus.GetText = () => message;
}
public Pasta(int number, string name, string description, double price, MenuType menuType, bool isVegan, bool isOrganic, bool wholeGrain) : base(number, name, description, price, menuType, isVegan, isOrganic)
{
_wholeGrain = wholeGrain;
}
public void Menu()
{
menuType = MenuType.MainMenu;
SelectMenu(menuType);
}
private void Start()
{
InitLevelUI();
menuType = MenuType.MainMenu;
SelectMenu(menuType);
}
public MenuItemForClick(string _name, string _key, MenuType _miniprogram, List <IMenuItem> _sub_button = null) : base(_name, _miniprogram, _sub_button)
{
this.key = _key;
}
public MenuItemBase(string _name, MenuType _mtype = MenuType.Default, List <IMenuItem> _sub_button = null)
{
this.name = _name;
_type = _mtype == MenuType.Default ? null : _mtype.ToString();
this.sub_button = _sub_button;
}
public MainMenuLogic(Widget widget, World world)
{
rootMenu = widget;
rootMenu.Get <LabelWidget>("VERSION_LABEL").Text = Game.modData.Manifest.Mod.Version;
// Menu buttons
var mainMenu = widget.Get("MAIN_MENU");
mainMenu.IsVisible = () => menuType == MenuType.Main;
mainMenu.Get <ButtonWidget>("SINGLEPLAYER_BUTTON").OnClick = () => menuType = MenuType.Singleplayer;
mainMenu.Get <ButtonWidget>("MULTIPLAYER_BUTTON").OnClick = () =>
{
menuType = MenuType.None;
Ui.OpenWindow("SERVERBROWSER_PANEL", new WidgetArgs
{
{ "onStart", RemoveShellmapUI },
{ "onExit", () => menuType = MenuType.Main }
});
};
mainMenu.Get <ButtonWidget>("MODS_BUTTON").OnClick = () =>
{
Game.Settings.Game.PreviousMod = Game.modData.Manifest.Mod.Id;
Game.InitializeMod("modchooser", null);
};
mainMenu.Get <ButtonWidget>("SETTINGS_BUTTON").OnClick = () =>
{
menuType = MenuType.None;
Game.OpenWindow("SETTINGS_PANEL", new WidgetArgs
{
{ "onExit", () => menuType = MenuType.Main }
});
};
mainMenu.Get <ButtonWidget>("EXTRAS_BUTTON").OnClick = () => menuType = MenuType.Extras;
mainMenu.Get <ButtonWidget>("QUIT_BUTTON").OnClick = Game.Exit;
// Singleplayer menu
var singleplayerMenu = widget.Get("SINGLEPLAYER_MENU");
singleplayerMenu.IsVisible = () => menuType == MenuType.Singleplayer;
var missionsButton = singleplayerMenu.Get <ButtonWidget>("MISSIONS_BUTTON");
missionsButton.OnClick = () =>
{
menuType = MenuType.None;
Ui.OpenWindow("MISSIONBROWSER_PANEL", new WidgetArgs
{
{ "onExit", () => menuType = MenuType.Singleplayer },
{ "onStart", RemoveShellmapUI }
});
};
missionsButton.Disabled = !Game.modData.Manifest.Missions.Any();
singleplayerMenu.Get <ButtonWidget>("SKIRMISH_BUTTON").OnClick = StartSkirmishGame;
singleplayerMenu.Get <ButtonWidget>("BACK_BUTTON").OnClick = () => menuType = MenuType.Main;
// Extras menu
var extrasMenu = widget.Get("EXTRAS_MENU");
extrasMenu.IsVisible = () => menuType == MenuType.Extras;
extrasMenu.Get <ButtonWidget>("REPLAYS_BUTTON").OnClick = () =>
{
menuType = MenuType.None;
Ui.OpenWindow("REPLAYBROWSER_PANEL", new WidgetArgs
{
{ "onExit", () => menuType = MenuType.Extras },
{ "onStart", RemoveShellmapUI }
});
};
extrasMenu.Get <ButtonWidget>("MUSIC_BUTTON").OnClick = () =>
{
menuType = MenuType.None;
Ui.OpenWindow("MUSIC_PANEL", new WidgetArgs
{
{ "onExit", () => menuType = MenuType.Extras },
});
};
var assetBrowserButton = extrasMenu.GetOrNull <ButtonWidget>("ASSETBROWSER_BUTTON");
if (assetBrowserButton != null)
{
assetBrowserButton.OnClick = () =>
{
menuType = MenuType.None;
Game.OpenWindow("ASSETBROWSER_PANEL", new WidgetArgs
{
{ "onExit", () => menuType = MenuType.Extras },
});
}
}
;
extrasMenu.Get <ButtonWidget>("CREDITS_BUTTON").OnClick = () =>
{
menuType = MenuType.None;
Ui.OpenWindow("CREDITS_PANEL", new WidgetArgs
{
{ "onExit", () => menuType = MenuType.Extras },
});
};
extrasMenu.Get <ButtonWidget>("BACK_BUTTON").OnClick = () => menuType = MenuType.Main;
var newsBG = widget.GetOrNull("NEWS_BG");
if (newsBG != null)
{
newsBG.IsVisible = () => Game.Settings.Game.FetchNews && menuType != MenuType.None;
newsPanel = Ui.LoadWidget <ScrollPanelWidget>("NEWS_PANEL", null, new WidgetArgs());
newsTemplate = newsPanel.Get("NEWS_ITEM_TEMPLATE");
newsPanel.RemoveChild(newsTemplate);
newsStatus = newsPanel.Get <LabelWidget>("NEWS_STATUS");
SetNewsStatus("Loading news");
var cacheFile = Path.Combine(Platform.SupportDir, "news.yaml");
var currentNews = ParseNews(cacheFile);
if (currentNews != null)
{
DisplayNews(currentNews);
}
// Only query for new stories once per day
var cacheValid = currentNews != null && DateTime.Today.ToUniversalTime() <= Game.Settings.Game.NewsFetchedDate;
if (!cacheValid)
{
new Download(Game.Settings.Game.NewsUrl, cacheFile, e => { }, (e, c) => NewsDownloadComplete(e, c, cacheFile, currentNews));
}
var newsButton = newsBG.GetOrNull <DropDownButtonWidget>("NEWS_BUTTON");
newsButton.OnClick = () =>
{
newsButton.AttachPanel(newsPanel);
newsHighlighted = false;
};
newsButton.IsHighlighted = () => newsHighlighted && Game.LocalTick % 50 < 25;
}
}
void SetNewsStatus(string message)
{
message = WidgetUtils.WrapText(message, newsStatus.Bounds.Width, Game.Renderer.Fonts[newsStatus.Font]);
newsStatus.GetText = () => message;
}
public void LoadScene(int id)
{
SceneManager.LoadScene(id);
menuType = MenuType.Running;
SelectMenu(menuType);
}
public MainMenuLogic(Widget widget, World world, ModData modData)
{
rootMenu = widget;
rootMenu.Get <LabelWidget>("VERSION_LABEL").Text = modData.Manifest.Metadata.Version;
// Menu buttons
var mainMenu = widget.Get("MAIN_MENU");
mainMenu.IsVisible = () => menuType == MenuType.Main;
mainMenu.Get <ButtonWidget>("SINGLEPLAYER_BUTTON").OnClick = () => SwitchMenu(MenuType.Singleplayer);
mainMenu.Get <ButtonWidget>("MULTIPLAYER_BUTTON").OnClick = () =>
{
SwitchMenu(MenuType.None);
Ui.OpenWindow("MULTIPLAYER_PANEL", new WidgetArgs
{
{ "onStart", RemoveShellmapUI },
{ "onExit", () => SwitchMenu(MenuType.Main) },
{ "directConnectHost", null },
{ "directConnectPort", 0 },
});
};
mainMenu.Get <ButtonWidget>("CONTENT_BUTTON").OnClick = () =>
{
// Switching mods changes the world state (by disposing it),
// so we can't do this inside the input handler.
Game.RunAfterTick(() =>
{
var content = modData.Manifest.Get <ModContent>();
Game.InitializeMod(content.ContentInstallerMod, new Arguments(new[] { "Content.Mod=" + modData.Manifest.Id }));
});
};
mainMenu.Get <ButtonWidget>("SETTINGS_BUTTON").OnClick = () =>
{
SwitchMenu(MenuType.None);
Game.OpenWindow("SETTINGS_PANEL", new WidgetArgs
{
{ "onExit", () => SwitchMenu(MenuType.Main) }
});
};
mainMenu.Get <ButtonWidget>("EXTRAS_BUTTON").OnClick = () => SwitchMenu(MenuType.Extras);
mainMenu.Get <ButtonWidget>("QUIT_BUTTON").OnClick = Game.Exit;
// Singleplayer menu
var singleplayerMenu = widget.Get("SINGLEPLAYER_MENU");
singleplayerMenu.IsVisible = () => menuType == MenuType.Singleplayer;
var missionsButton = singleplayerMenu.Get <ButtonWidget>("MISSIONS_BUTTON");
missionsButton.OnClick = () =>
{
SwitchMenu(MenuType.None);
Game.OpenWindow("MISSIONBROWSER_PANEL", new WidgetArgs
{
{ "onExit", () => SwitchMenu(MenuType.Singleplayer) },
{ "onStart", RemoveShellmapUI }
});
};
var hasCampaign = modData.Manifest.Missions.Any();
var hasMissions = modData.MapCache
.Any(p => p.Status == MapStatus.Available && p.Visibility.HasFlag(MapVisibility.MissionSelector));
missionsButton.Disabled = !hasCampaign && !hasMissions;
singleplayerMenu.Get <ButtonWidget>("SKIRMISH_BUTTON").OnClick = StartSkirmishGame;
singleplayerMenu.Get <ButtonWidget>("BACK_BUTTON").OnClick = () => SwitchMenu(MenuType.Main);
// Extras menu
var extrasMenu = widget.Get("EXTRAS_MENU");
extrasMenu.IsVisible = () => menuType == MenuType.Extras;
extrasMenu.Get <ButtonWidget>("REPLAYS_BUTTON").OnClick = () =>
{
SwitchMenu(MenuType.None);
Ui.OpenWindow("REPLAYBROWSER_PANEL", new WidgetArgs
{
{ "onExit", () => SwitchMenu(MenuType.Extras) },
{ "onStart", RemoveShellmapUI }
});
};
extrasMenu.Get <ButtonWidget>("MUSIC_BUTTON").OnClick = () =>
{
SwitchMenu(MenuType.None);
Ui.OpenWindow("MUSIC_PANEL", new WidgetArgs
{
{ "onExit", () => SwitchMenu(MenuType.Extras) },
{ "world", world }
});
};
extrasMenu.Get <ButtonWidget>("MAP_EDITOR_BUTTON").OnClick = () => SwitchMenu(MenuType.MapEditor);
var assetBrowserButton = extrasMenu.GetOrNull <ButtonWidget>("ASSETBROWSER_BUTTON");
if (assetBrowserButton != null)
{
assetBrowserButton.OnClick = () =>
{
SwitchMenu(MenuType.None);
Game.OpenWindow("ASSETBROWSER_PANEL", new WidgetArgs
{
{ "onExit", () => SwitchMenu(MenuType.Extras) },
});
}
}
;
extrasMenu.Get <ButtonWidget>("CREDITS_BUTTON").OnClick = () =>
{
SwitchMenu(MenuType.None);
Ui.OpenWindow("CREDITS_PANEL", new WidgetArgs
{
{ "onExit", () => SwitchMenu(MenuType.Extras) },
});
};
extrasMenu.Get <ButtonWidget>("BACK_BUTTON").OnClick = () => SwitchMenu(MenuType.Main);
// Map editor menu
var mapEditorMenu = widget.Get("MAP_EDITOR_MENU");
mapEditorMenu.IsVisible = () => menuType == MenuType.MapEditor;
// Loading into the map editor
Game.BeforeGameStart += RemoveShellmapUI;
var onSelect = new Action <string>(uid => LoadMapIntoEditor(modData.MapCache[uid].Uid));
var newMapButton = widget.Get <ButtonWidget>("NEW_MAP_BUTTON");
newMapButton.OnClick = () =>
{
SwitchMenu(MenuType.None);
Game.OpenWindow("NEW_MAP_BG", new WidgetArgs()
{
{ "onSelect", onSelect },
{ "onExit", () => SwitchMenu(MenuType.MapEditor) }
});
};
var loadMapButton = widget.Get <ButtonWidget>("LOAD_MAP_BUTTON");
loadMapButton.OnClick = () =>
{
SwitchMenu(MenuType.None);
Game.OpenWindow("MAPCHOOSER_PANEL", new WidgetArgs()
{
{ "initialMap", null },
{ "initialTab", MapClassification.User },
{ "onExit", () => SwitchMenu(MenuType.MapEditor) },
{ "onSelect", onSelect },
{ "filter", MapVisibility.Lobby | MapVisibility.Shellmap | MapVisibility.MissionSelector },
});
};
mapEditorMenu.Get <ButtonWidget>("BACK_BUTTON").OnClick = () => SwitchMenu(MenuType.Extras);
var newsBG = widget.GetOrNull("NEWS_BG");
if (newsBG != null)
{
newsBG.IsVisible = () => Game.Settings.Game.FetchNews && menuType != MenuType.None && menuType != MenuType.SystemInfoPrompt;
newsPanel = Ui.LoadWidget <ScrollPanelWidget>("NEWS_PANEL", null, new WidgetArgs());
newsTemplate = newsPanel.Get("NEWS_ITEM_TEMPLATE");
newsPanel.RemoveChild(newsTemplate);
newsStatus = newsPanel.Get <LabelWidget>("NEWS_STATUS");
SetNewsStatus("Loading news");
}
Game.OnRemoteDirectConnect += OnRemoteDirectConnect;
// Check for updates in the background
var webServices = modData.Manifest.Get <WebServices>();
if (Game.Settings.Debug.CheckVersion)
{
webServices.CheckModVersion();
}
var updateLabel = rootMenu.GetOrNull("UPDATE_NOTICE");
if (updateLabel != null)
{
updateLabel.IsVisible = () => !newsOpen && menuType != MenuType.None &&
menuType != MenuType.SystemInfoPrompt &&
webServices.ModVersionStatus == ModVersionStatus.Outdated;
}
// System information opt-out prompt
var sysInfoPrompt = widget.Get("SYSTEM_INFO_PROMPT");
sysInfoPrompt.IsVisible = () => menuType == MenuType.SystemInfoPrompt;
if (Game.Settings.Debug.SystemInformationVersionPrompt < SystemInformationVersion)
{
menuType = MenuType.SystemInfoPrompt;
var sysInfoCheckbox = sysInfoPrompt.Get <CheckboxWidget>("SYSINFO_CHECKBOX");
sysInfoCheckbox.IsChecked = () => Game.Settings.Debug.SendSystemInformation;
sysInfoCheckbox.OnClick = () => Game.Settings.Debug.SendSystemInformation ^= true;
var sysInfoData = sysInfoPrompt.Get <ScrollPanelWidget>("SYSINFO_DATA");
var template = sysInfoData.Get <LabelWidget>("DATA_TEMPLATE");
sysInfoData.RemoveChildren();
foreach (var info in GetSystemInformation().Values)
{
var label = template.Clone() as LabelWidget;
var text = info.First + ": " + info.Second;
label.GetText = () => text;
sysInfoData.AddChild(label);
}
sysInfoPrompt.Get <ButtonWidget>("BACK_BUTTON").OnClick = () =>
{
Game.Settings.Debug.SystemInformationVersionPrompt = SystemInformationVersion;
Game.Settings.Save();
SwitchMenu(MenuType.Main);
LoadAndDisplayNews(webServices.GameNews, newsBG);
};
}
else
{
LoadAndDisplayNews(webServices.GameNews, newsBG);
}
}
void LoadAndDisplayNews(string newsURL, Widget newsBG)
{
if (newsBG != null)
{
var cacheFile = Platform.ResolvePath(Platform.SupportDirPrefix, "news.yaml");
var currentNews = ParseNews(cacheFile);
if (currentNews != null)
{
DisplayNews(currentNews);
}
var newsButton = newsBG.GetOrNull <DropDownButtonWidget>("NEWS_BUTTON");
if (newsButton != null)
{
if (!fetchedNews)
{
// Send the mod and engine version to support version-filtered news (update prompts)
newsURL += "?version={0}&mod={1}&modversion={2}".F(
Uri.EscapeUriString(Game.EngineVersion),
Uri.EscapeUriString(Game.ModData.Manifest.Id),
Uri.EscapeUriString(Game.ModData.Manifest.Metadata.Version));
// Append system profile data if the player has opted in
if (Game.Settings.Debug.SendSystemInformation)
{
newsURL += "&sysinfoversion={0}&".F(SystemInformationVersion)
+ GetSystemInformation()
.Select(kv => kv.Key + "=" + Uri.EscapeUriString(kv.Value.Second))
.JoinWith("&");
}
new Download(newsURL, cacheFile, e => { },
e => NewsDownloadComplete(e, cacheFile, currentNews,
() => OpenNewsPanel(newsButton)));
}
newsButton.OnClick = () => OpenNewsPanel(newsButton);
}
}
}
void OpenNewsPanel(DropDownButtonWidget button)
{
newsOpen = true;
button.AttachPanel(newsPanel, () => newsOpen = false);
}
void OnRemoteDirectConnect(string host, int port)
{
SwitchMenu(MenuType.None);
Ui.OpenWindow("MULTIPLAYER_PANEL", new WidgetArgs
{
{ "onStart", RemoveShellmapUI },
{ "onExit", () => SwitchMenu(MenuType.Main) },
{ "directConnectHost", host },
{ "directConnectPort", port },
});
}
void LoadMapIntoEditor(string uid)
{
ConnectionLogic.Connect(IPAddress.Loopback.ToString(),
Game.CreateLocalServer(uid),
"",
() => { Game.LoadEditor(uid); },
() => { Game.CloseServer(); SwitchMenu(MenuType.MapEditor); });
}
void SetNewsStatus(string message)
{
message = WidgetUtils.WrapText(message, newsStatus.Bounds.Width, Game.Renderer.Fonts[newsStatus.Font]);
newsStatus.GetText = () => message;
}
public MenuItemForMedia(string _name, string _key, string _media_id, MenuType _miniprogram, List <IMenuItem> _sub_button = null) : base(_name, _miniprogram, _sub_button)
{
this.key = _key;
this.media_id = _media_id;
}
public void Resume()
{
menuType = MenuType.Running;
SelectMenu(menuType);
Time.timeScale = 1;
}
public void OnMenuItemClick(MenuType menuType, string menuText, ITab tab) {
ShowMemoForm(tab.Address.Path, true);
}
/// <summary>
/// Event called when the currently focused menu is changed.
/// </summary>
protected virtual void OnMenuFocusChange(MenuType type)
{
this.IsFocused = (this.Type == type);
}
public async Task NavigateAsync(MenuType id)
{
if (Detail != null)
{
if (IsUWPDesktop || Device.Idiom != TargetIdiom.Tablet)
{
IsPresented = false;
}
if (Device.OS == TargetPlatform.Android)
{
await Task.Delay(300);
}
}
Page newPage;
if (!Pages.ContainsKey(id))
{
switch (id)
{
case MenuType.About:
Pages.Add(id, new HanselmanNavigationPage(new AboutPage()));
break;
case MenuType.Blog:
Pages.Add(id, new HanselmanNavigationPage(new BlogPage()));
break;
case MenuType.DeveloperLife:
Pages.Add(id, new HanselmanNavigationPage(new PodcastPage(id)));
break;
case MenuType.Hanselminutes:
Pages.Add(id, new HanselmanNavigationPage(new PodcastPage(id)));
break;
case MenuType.Ratchet:
Pages.Add(id, new HanselmanNavigationPage(new PodcastPage(id)));
break;
case MenuType.Twitter:
Pages.Add(id, new HanselmanNavigationPage(new TwitterPage()));
break;
}
}
newPage = Pages[id];
if (newPage == null)
{
return;
}
//pop to root for Windows Phone
if (Detail != null && Device.OS == TargetPlatform.WinPhone)
{
await Detail.Navigation.PopToRootAsync();
}
Detail = newPage;
}
public void OnMenuItemClick(MenuType menuType, string menuText, ITab tab)
{
}
public ContactViewModel(MenuType menuType, bool isAuthorized, IPrincipal user) : base(menuType, isAuthorized, user)
{
}
public Menu(MenuType type, string Header) // 0 for bodyText display, 1 for numbered options , 2 for string input, 3 for scroll input
{
this.type = (int)type;
headerPrompt = Header;
}
public long Insert(MenuType entity)
{
db.MenuType.Add(entity);
db.SaveChanges();
return(entity.ID);
}
public MainMenuButtonsLogic(Widget widget)
{
rootMenu = widget;
rootMenu.IsVisible = () => Menu == MenuType.Main;
var versionLabel = Ui.Root.GetOrNull <LabelWidget>("VERSION_LABEL");
if (versionLabel != null)
{
versionLabel.Text = Game.modData.Manifest.Mod.Version;
}
widget.Get <ButtonWidget>("MAINMENU_BUTTON_JOIN").OnClick = () => OpenGamePanel("JOINSERVER_BG");
widget.Get <ButtonWidget>("MAINMENU_BUTTON_CREATE").OnClick = () => OpenGamePanel("CREATESERVER_BG");
widget.Get <ButtonWidget>("MAINMENU_BUTTON_DIRECTCONNECT").OnClick = () => OpenGamePanel("DIRECTCONNECT_BG");
widget.Get <ButtonWidget>("MAINMENU_BUTTON_SETTINGS").OnClick = () =>
{
Menu = MenuType.None;
Game.OpenWindow("SETTINGS_PANEL", new WidgetArgs()
{
{ "onExit", () => Menu = MenuType.Main }
});
};
widget.Get <ButtonWidget>("MAINMENU_BUTTON_MUSIC").OnClick = () =>
{
Menu = MenuType.None;
Ui.OpenWindow("MUSIC_PANEL", new WidgetArgs()
{
{ "onExit", () => Menu = MenuType.Main }
});
};
widget.Get <ButtonWidget>("MAINMENU_BUTTON_MODS").OnClick = () =>
{
Menu = MenuType.None;
Ui.OpenWindow("MODS_PANEL", new WidgetArgs()
{
{ "onExit", () => Menu = MenuType.Main },
{ "onSwitch", RemoveShellmapUI }
});
};
widget.Get <ButtonWidget>("MAINMENU_BUTTON_CREDITS").OnClick = () =>
{
Menu = MenuType.None;
Ui.OpenWindow("CREDITS_PANEL", new WidgetArgs()
{
{ "onExit", () => Menu = MenuType.Main },
});
};
widget.Get <ButtonWidget>("MAINMENU_BUTTON_REPLAY_VIEWER").OnClick = () =>
{
Menu = MenuType.None;
Ui.OpenWindow("REPLAYBROWSER_BG", new WidgetArgs()
{
{ "onExit", () => Menu = MenuType.Main },
{ "onStart", RemoveShellmapUI }
});
};
var assetBrowserButton = widget.Get <ButtonWidget>("MAINMENU_BUTTON_ASSET_BROWSER");
assetBrowserButton.OnClick = () =>
{
Menu = MenuType.None;
Game.OpenWindow("ASSETBROWSER_BG", new WidgetArgs()
{
{ "onExit", () => Menu = MenuType.Main }
});
};
var quitButton = widget.Get <ButtonWidget>("MAINMENU_BUTTON_QUIT");
quitButton.OnClick = () => Game.Exit();
// Hide developer-specific buttons
if (Game.Settings.Debug.DeveloperMenu == false)
{
assetBrowserButton.IsVisible = () => false;
var offset = assetBrowserButton.Bounds.Y - quitButton.Bounds.Y;
quitButton.Bounds.Y += offset;
rootMenu.Bounds.Height += offset;
rootMenu.Bounds.Y -= offset / 2;
}
}
public VisitedPage Get(MenuType menuType)
{
return(VisitedPageList.Find(p => p.MenuType == menuType));
}
//Add a new dish
public void AddDish(Dish dish, MenuType menuType)
{
dish_DAO.Add(dish, menuType);
}
public static HtmlString SiteMapMenu(this HtmlHelper helper, SiteMapNode rootNode, IPage model, MenuType menutype)
{
HtmlString htmlReturn = new HtmlString(String.Empty);
switch (menutype)
{
case MenuType.TopMenu:
htmlReturn = CreateTopMenu(rootNode, helper.ViewContext, model);
break;
case MenuType.LeftMenu:
htmlReturn = CreateLeftMenu(rootNode, helper.ViewContext, model);
break;
}
return(htmlReturn);
}
public FrameworkElement GetMenu(MenuType callFrom, Func <object> commandParameter)
{
return(new PluginMenuItem("[DEBUG]Data Structure Breakdown", s_command, commandParameter, callFrom));
}
void Start()
{
_MenuType = MenuStartingPoint;
}
public SysMenuDto(bool isMenu, string id, string menuName, string parentId, string url, string icon, int sort, bool visible, string resourceCode, MenuType menuType = MenuType.菜单)
{
IsMenu = isMenu;
Id = id;
MenuName = menuName;
ParentId = parentId;
Url = url;
Icon = icon;
Sort = sort;
Visible = visible;
ResourceCode = resourceCode;
MenuType = menuType;
}
public FixCar(string name, MenuType menuType, Category category) : base(name, menuType, category)
{
}
public void LevelSelect()
{
menuType = MenuType.Levels;
SelectMenu(menuType);
}
