/// <summary> /// Modifys the console window propertys /// </summary> private static void ModifyConsoleWindow() { //TODO: Linux support #if !__MonoCS__ // Setting screen or primary screen // Fullscreen if (Settings.Default.ConsoleFullscreenMode) { Screen screen = Screen.AllScreens.ElementAt(Settings.Default.ConsoleFullscreenDisplay); // Fullscreen screen connected -> restore fullscreen on screen if (screen != null) { // Move to wanted display ConsoleUtils.SetWindowPos(ConsoleUtils.GetConsoleWindow(), 0, screen.WorkingArea.Left, screen.WorkingArea.Top, Console.LargestWindowWidth, Console.LargestWindowHeight, 1); ConsoleUtils.ToggleConsoleFullscreenMode(); } // else -> write message after server startup else { SharedEvents.OnAfterCoreStartupCompleted += () => ConsoleOutput.WriteLine(ConsoleType.Warn, "Can't restore fullscreen mode in this session. Console use default settings instead."); } } // Normal console window else { Point savedPosition = Settings.Default.ConsoleLocation; Size ConsoleSize = Settings.Default.ConsoleSize; // Console position saved -> check if valid after screen changes || set position if (savedPosition.X != -1 && savedPosition.Y != -1) { // Saved on not connected screen -> message after server startup if (!Screen.AllScreens.Any(screen => screen.Bounds.Contains(savedPosition))) { ConsoleUtils.SetWindowPos(ConsoleUtils.GetConsoleWindow(), 0, 0, 0, ConsoleSize.Width, ConsoleSize.Height, 1); SharedEvents.OnAfterCoreStartupCompleted += () => ConsoleOutput.WriteLine(ConsoleType.Warn, "Can't restore saved console location. Saved location was on disconnected screen. Console use default location instead."); } // Valid saved position -> restore else { ConsoleUtils.SetWindowPos(ConsoleUtils.GetConsoleWindow(), 0, Settings.Default.ConsoleLocation.X, Settings.Default.ConsoleLocation.Y, ConsoleSize.Width, ConsoleSize.Height, 1); } } } #endif // Prepare submodules ConsoleOutput.PrepareConsoleOutput(); ConsoleError.PrepareConsoleError(); ConsoleCommandHandler.PrepareConsoleCommands(); }
public static void SaveConsolePos() { //TODO: Linux support #if __MonoCS__ ConsoleOutput.WriteLine(ConsoleType.Debug, "Currently only supported on Windows. See #23"); #else Point hWndLocation = Settings.Default.ConsoleLocation; ConsoleUtils.GetWindowRect(ConsoleUtils.GetConsoleWindow(), ref hWndLocation); Settings.Default.ConsoleLocation = hWndLocation; Settings.Default.Save(); ConsoleOutput.WriteLine(ConsoleType.Config, $"Saved the current console positon at {Settings.Default.ConsoleLocation}"); #endif }
/// <summary> /// Prepares the console comand routine. /// Binding events.. etc. /// </summary> public static void PrepareConsoleCommands() { SharedEvents.OnModuleLoaded += InspectModule; // Output for CIN | DATETIME | INPUT ConsoleInput.OnConsoleString += (consoleString, args) => { if (!args.Cancel) { ConsoleOutput.WriteLine(ConsoleType.ConsoleInput, consoleString); } }; // Parse input for commands ConsoleInput.OnConsoleString += ParseConsoleString; }
public static void Fullscreen(bool fullscreen, int display = -1) { // Fullscreen disabled -> Save, message & return; if (!fullscreen) { // Save settings Settings.Default.ConsoleFullscreenDisplay = -1; Settings.Default.ConsoleFullscreenMode = false; Settings.Default.Save(); ConsoleOutput.WriteLine(ConsoleType.Config, "Disabled fullscreen mode. ~b~Changes take effect on next Start."); return; } #if !__MonoCS__ // No display given -> Use current & message if (display == -1) { Point p = new Point(); ConsoleUtils.GetWindowRect(ConsoleUtils.GetConsoleWindow(), ref p); display = Screen.AllScreens.ToList() .FindIndex(screen => Equals(screen, Screen.FromPoint(new Point(p.X, p.Y)))); ConsoleOutput.WriteLine(ConsoleType.Info, $"No display given for fullscreen. Using the current display ~b~{display}~;~."); } #endif // invalid display given -> Warning & return; if (Screen.AllScreens.Length - 1 < display) { ConsoleOutput.WriteLine(ConsoleType.Warn, $"Invalid display ~o~{display}~;~. Available displays: 0 - {Screen.AllScreens.Length - 1}"); return; } // Save settings message Settings.Default.ConsoleFullscreenDisplay = display; Settings.Default.ConsoleFullscreenMode = true; Settings.Default.Save(); ConsoleOutput.WriteLine(ConsoleType.Config, $"Enabled fullscreen mode for display ~b~{display}~;~. " + $"~b~Changes take effect on next Start."); }
/// <summary> /// Parsing a file line by line to a new string. /// Adds ~n~ after each line. /// </summary> /// <param name="path">Path to the textfile</param> /// <param name="marginTopLines">Extra empty lines in top of the text file</param> /// <param name="marginBottomLines">Extra empty lines after the text file</param> /// <returns></returns> public static string ParseTextFileForConsole(string path, int marginTopLines = 0, int marginBottomLines = 0) { // File does not exist -> message & return; if (!File.Exists(path)) { ConsoleOutput.WriteLine(ConsoleType.Warn, $"Can't load the text file ~r~\"{path}\"~w~. File ignored."); return(string.Empty); } string returnString = string.Empty; int longestLineLength = 0; // Read file line by line string currentLine; StreamReader streamReader = new StreamReader(path); while ((currentLine = streamReader.ReadLine()) != null) { returnString += currentLine + "~n~"; if (currentLine.Length > longestLineLength) { longestLineLength = currentLine.Length; } } // MarginTop for (var i = 0; i < marginTopLines; i++) { returnString = string.Empty.PadRight(longestLineLength) + "~n~" + returnString; } // MarginTop for (var i = 0; i < marginBottomLines; i++) { returnString += string.Empty.PadRight(longestLineLength) + "~n~"; } streamReader.Close(); return(returnString); }
private void WriteHandler(string message) { bool gtMpMessage = ConsoleUtils.IsGtmpConsoleMessage(message); // Startup not completed -> return; if (!SharedEvents.StartUpCompleted) { return; } // Print Text as invalid console use. if (!gtMpMessage) { if (!_lastWasInvalid) { ConsoleOutput.WriteLine(ConsoleType.Warn, $"Use ConsoleOutput.* for writing to console!"); } _lastWasInvalid = true; } // Remove GtMp console tags if (gtMpMessage) { message = message.Substring(message.LastIndexOf(" | ", StringComparison.Ordinal) + 3); } if (!ConsoleUtils.OriginalWriterInUse) { // Write console line string[] newLines = message.Split('\n'); foreach (string line in newLines) { ConsoleOutput.WriteLine(gtMpMessage ? ConsoleType.GtMp : ConsoleType.ConsoleOutput, line); } } // Clear string Writer StringBuilder stringBuilder = GetStringBuilder(); stringBuilder.Remove(0, stringBuilder.Length); }
public static void ViewHelpInformations(string commandName) { ConsoleCommand command = ConsoleCommandHandler.GetConsoleCommand(commandName); // Not command found -> message & return. if (command == null) { ConsoleOutput.WriteLine(ConsoleType.Help, $"No console command found for ~w~{commandName}~;~."); return; } // Show command help string commandParameter = string.Join(", ", command.MethodInfo.GetParameters() .Select(info => $"~m~{info.ParameterType}~;~ {info.Name} " + $"~l~{(info.IsOptional ? $" = [{info.DefaultValue}] " : "")}~;~")); ConsoleOutput.WriteLine(ConsoleType.Help, $"Command: ~w~{command.Command}~;~\n" + $"Aliase: ~w~{string.Join(", ", command.CommandAliases)}\n" + $"Usage: ~w~{command.Command} {commandParameter}"); }
/// <summary> /// Adding new command to the existings commands. /// Checks all command attributes, and give warns on duplicates. /// </summary> /// <param name="newCommand">The new command</param> /// <returns>true if new command is unique, else false (with console message)</returns> internal static bool AddToCommands(ConsoleCommand newCommand) { bool returnValue = true; string oldPrefix = ConsoleOutput.GetPrefix(); ConsoleOutput.SetPrefix(oldPrefix.Replace("> ", "\t")); try { // Already used command string -> message ConsoleCommand blockingCommand = Commands.FirstOrDefault(cmd => cmd.Command.ToLower() == newCommand.Command.ToLower()); if (blockingCommand != null) { ConsoleOutput.WriteLine(ConsoleType.Warn, $"Command duplicate: ~c~{blockingCommand.FullName()}"); returnValue = false; } // Already used alias command string -> message blockingCommand = Commands.FirstOrDefault(cmd => cmd.CommandAliases.Contains(newCommand.Command) || cmd.CommandAliases.Any(sa => newCommand.CommandAliases .Select(s => s.ToLower()).Contains(sa))); if (blockingCommand != null) { ConsoleOutput.WriteLine(ConsoleType.Warn, $"Alias duplicate: ~c~{blockingCommand.FullName()}"); returnValue = false; } Commands.Add(newCommand); return(returnValue); } finally { ConsoleOutput.SetPrefix(oldPrefix); } }
private static void ApplicationOnThreadException(object sender, ThreadExceptionEventArgs threadExceptionEventArgs) { ConsoleOutput.WriteLine(ConsoleType.Fatal, threadExceptionEventArgs.Exception.ToString()); ConsoleUtils.SafeSystemConsoleUse(() => throw threadExceptionEventArgs.Exception); }
public static void CloseConsole() { ConsoleOutput.WriteLine(ConsoleType.Core, "Shutting down!"); Thread.Sleep(1000); Environment.Exit(0); }
public static void ResetConsoleSettings() { Settings.Default.Reset(); Settings.Default.Save(); ConsoleOutput.WriteLine(ConsoleType.Config, "Console propertys reseted to default."); }
private static void ParseConsoleString(string consoleString, CancelEventArgs cancelEventArgs) { List <string> consoleStringParts = consoleString.Split(' ').ToList(); foreach (ConsoleCommand command in Commands) { // console string not command -> continue; if (command.Command.ToLower() != consoleStringParts[0].ToLower() && !command.CommandAliases.Select(ca => ca.ToLower()) .Contains(consoleStringParts[0].ToLower())) { continue; } // Cancle event cancelEventArgs.Cancel = true; // Remove command string enteredCommand = consoleStringParts[0]; consoleStringParts.Remove(enteredCommand); // Check for parameters List <object> parameterValues = new List <object>(); ParameterInfo[] commandParameters = command.MethodInfo.GetParameters(); string currentParameterString = string.Empty; for (int i = 0; i < commandParameters.Length; i++) { // No more string parameters -> break; if (consoleStringParts.FirstOrDefault() == null) { break; } // append or set string parameters currentParameterString += consoleStringParts.FirstOrDefault(); consoleStringParts.Remove(currentParameterString); // String argument with quote -> wait for end quote. if (currentParameterString.StartsWith("\"")) { if (!currentParameterString.EndsWith("\"")) { i--; continue; } // Remove quotes currentParameterString = currentParameterString .Remove(currentParameterString.Length - 1, 1) .Remove(0, 1); } // Try parse & reset string try { // Barse boolean parameter for Convert functions if (commandParameters[i].ParameterType == typeof(bool)) { if (currentParameterString == "1") { currentParameterString = "true"; } else if (currentParameterString == "0") { currentParameterString = "false"; } } object parameterValue = Convert.ChangeType(currentParameterString, commandParameters[i].ParameterType); currentParameterString = string.Empty; if (parameterValue == null) { break; } parameterValues.Add(parameterValue); } catch (InvalidCastException) { ConsoleOutput.WriteLine(ConsoleType.Error, $"The type ~w~{commandParameters[i].ParameterType}~;~ can't be used as command parameter!"); return; } catch { ConsoleOutput.WriteLine(ConsoleType.Error, $"Invalid type given for parameter {commandParameters[i].Name}."); return; } } // Not enough parameter values -> message & next; if (commandParameters.Count(info => !info.IsOptional) > parameterValues.Count) { ConsoleOutput.WriteLine(ConsoleType.ConsoleCommand, $"Incorrect parameter values for the command ~o~{enteredCommand}~;~. " + $"Type ~b~\"/help {enteredCommand}\"~;~ for more information."); return; } // Add optional parameters if not given, to parametersValues if (commandParameters.Length != parameterValues.Count) { for (int i = commandParameters.Length - parameterValues.Count; i < commandParameters.Length; i++) { parameterValues.Add(commandParameters[i].DefaultValue); } } //TODO: check for optional parameters needed // Invoke command command.MethodInfo.Invoke(command.ClassInstance, parameterValues.ToArray()); return; } ConsoleOutput.WriteLine(ConsoleType.Error, $"~w~No command found for ~r~\"{consoleStringParts[0]}\"~w~!"); }
/// <summary> /// Inspects a class for Commands. /// </summary> /// <param name="moduleInstance">The instance of the module wich should be inspected.</param> internal static void InspectModule(object moduleInstance) { List <ConsoleCommand> validCommands = new List <ConsoleCommand>(); List <ConsoleCommand> invalidCommands = new List <ConsoleCommand>(); // Parse commands direct in module ParseCommands(moduleInstance); // Parse all field & Property infos foreach (FieldInfo fieldInfo in moduleInstance.GetType().GetFields()) { ParseMemberInfo(null, fieldInfo, moduleInstance); } foreach (PropertyInfo propertyInfo in moduleInstance.GetType().GetProperties()) { ParseMemberInfo(propertyInfo, null, moduleInstance); } // Parse static commands ParseStaticCommands(); // Check for invalid commands & write message if given ParseInvalidCommands(); if (invalidCommands.Any()) { ConsoleOutput.SetPrefix(ConsoleOutput.GetPrefix().Replace(">", "~r~!")); foreach (ConsoleCommand invalidCommand in invalidCommands) { ConsoleOutput.WriteLine(ConsoleType.ConsoleCommand, "~r~" + invalidCommand.Command + "~c~ " + invalidCommand.FullName()); } ConsoleOutput.SetPrefix(ConsoleOutput.GetPrefix().Replace("~r~!", ">")); } // Register commands if (validCommands.Any()) { foreach (ConsoleCommand command in validCommands) { if (AddToCommands(command)) // On working command { ConsoleOutput.SetPrefix(ConsoleOutput.GetPrefix().Replace(">", "~g~+")); // Highlight important commands string commandColorCode = command.ImportantCommand ? "~#f66e00~" : "~g~"; // Command aliases string aliasString = $"{(command.CommandAliases.Any() ? $"~w~({commandColorCode}" : "")}{string.Join($"~w~, {commandColorCode}", command.CommandAliases)}{(command.CommandAliases.Any() ? "~w~)" : "")}"; ConsoleOutput.WriteLine(ConsoleType.ConsoleCommand, $"{commandColorCode}{command.Command} {aliasString} ~c~{command.FullName()}"); // Description if (!string.IsNullOrEmpty(command.Description)) { string currentPrefix = ConsoleOutput.GetPrefix(); ConsoleOutput.SetPrefix("\t\t~c~ > ~;~"); ConsoleOutput.WriteLine(ConsoleType.ConsoleCommand, command.Description); ConsoleOutput.SetPrefix(currentPrefix); } } else // on warnings { ConsoleOutput.SetPrefix(ConsoleOutput.GetPrefix().Replace(">", "~o~?")); ConsoleOutput.WriteLine(ConsoleType.ConsoleCommand, "~o~" + command.Command + "~c~ " + command.FullName()); } ConsoleOutput.SetPrefix(ConsoleOutput.GetPrefix().Replace("~g~+", ">").Replace("~o~?", ">")); } } void ParseInvalidCommands() { foreach (Type type in moduleInstance.GetType().Assembly.GetTypes()) { foreach (MethodInfo methodInfo in type.GetMethods()) { object[] attributes = methodInfo.GetCustomAttributes(typeof(ConsoleCommand), true); if (attributes.Length <= 0) { continue; } foreach (object commandObject in attributes) { // Method is registered as valid -> next. if (validCommands.Any(cmd => cmd.MethodInfo == methodInfo)) { continue; } ConsoleCommand command = (ConsoleCommand)commandObject; // Save MethodInfo and Class instance command.MethodInfo = methodInfo; invalidCommands.Add(command); } } } } void ParseStaticCommands() { foreach (Type type in moduleInstance.GetType().Assembly.GetTypes()) { foreach (MethodInfo methodInfo in type.GetMethods() .Where(info => info.IsStatic && info.IsPublic && !info.IsConstructor)) { object[] attributes = methodInfo.GetCustomAttributes(typeof(ConsoleCommand), true); if (attributes.Length <= 0) { continue; } foreach (object commandObject in attributes) { ConsoleCommand command = (ConsoleCommand)commandObject; // Save MethodInfo and Class instance command.MethodInfo = methodInfo; command.ClassInstance = null; validCommands.Add(command); } } } } void ParseCommands(object instance) { foreach (MethodInfo methodInfo in instance.GetType().GetMethods() .Where(info => !info.IsStatic && info.IsPublic && !info.IsConstructor)) { object[] attributes = methodInfo.GetCustomAttributes(typeof(ConsoleCommand), true); if (attributes.Length <= 0) { continue; } foreach (object commandObject in attributes) { ConsoleCommand command = (ConsoleCommand)commandObject; // Save MethodInfo and Class instance command.MethodInfo = methodInfo; command.ClassInstance = instance; validCommands.Add(command); } } } void ParseMemberInfo(PropertyInfo propertyInfo, FieldInfo fieldInfo, object classInstance) { object instance = propertyInfo?.GetValue(classInstance) ?? fieldInfo?.GetValue(classInstance); if (instance == null || instance.GetType().Assembly != moduleInstance.GetType().Assembly || !instance.GetType().IsClass) { return; } // Search for commands ParseCommands(instance); foreach (FieldInfo field in instance.GetType().GetFields()) { ParseMemberInfo(null, field, instance); } foreach (PropertyInfo property in instance.GetType().GetProperties()) { ParseMemberInfo(property, null, instance); } } }