Exemple #1
0
        private void SetForegroundColor(ConsoleColor color)
        {
            if (!UseColors)
            {
                return;
            }

            // this.CheckFile(ref ResultLine);

            this.foregroundColor = color;

            if (FileStreamWriter != null)
            {
                String SetColorCommand = "\0foreground color=" + foregroundColor.ToString();
                FileStreamWriter.WriteLine(SetColorCommand);
            }
            else if (ResultLines != null)
            {
                String SetColorCommand = "\0foreground color=" + foregroundColor.ToString();
                ResultLines.Add(SetColorCommand);
            }
            else
            {
                Console.ForegroundColor = foregroundColor;
            }
        }
Exemple #2
0
        /// <summary>
        ///     Log a specific message by LogLevel. Won't log if the LogLevel is greater than the maxLogLevel set.
        /// </summary>
        /// <param name="message">The message to log. The current time will be prepended.</param>
        /// <param name="level">Optional. Default <see cref="LogLevel.Info" />.</param>
        /// <param name="color">Optional. Default is auotmatic</param>
        public void Write(string message, LogLevel level = LogLevel.Info, ConsoleColor color = ConsoleColor.Black)
        {
            // Remember to change to a font that supports your language, otherwise it'll still show as ???.
            Console.OutputEncoding = Encoding.UTF8;
            if (level > _maxLogLevel)
            {
                return;
            }

            var finalMessage = Logger.GetFinalMessage(message.Replace("NecroBot", "RocketBot"), level, color);

            Console.WriteLine(finalMessage);

            // Fire log write event.
            OnLogWrite?.Invoke(this, new LogWriteEventArgs {
                Message = finalMessage, Level = level, Color = color
            });

            // ReSharper disable once SwitchStatementMissingSomeCases
            Color _color = new Color();
            Dictionary <LogLevel, Color> colors = new Dictionary <LogLevel, Color>()
            {
                { LogLevel.Error, Color.Red },
                { LogLevel.Caught, Color.Green },
                { LogLevel.Info, Color.DarkCyan },
                { LogLevel.Warning, Color.FromArgb(255, 128, 128, 0) },
                { LogLevel.Pokestop, Color.Cyan },
                { LogLevel.Farming, Color.Magenta },
                { LogLevel.Sniper, Color.White },
                { LogLevel.Recycling, Color.DarkMagenta },
                { LogLevel.Flee, Color.FromArgb(255, 128, 128, 0) },
                { LogLevel.Transfer, Color.DarkGreen },
                { LogLevel.Evolve, Color.DarkGreen },
                { LogLevel.Berry, Color.FromArgb(255, 128, 128, 0) },
                { LogLevel.Egg, Color.FromArgb(255, 128, 128, 0) },
                { LogLevel.Debug, Color.Gray },
                { LogLevel.Update, Color.White },
                { LogLevel.New, Color.Green },
                { LogLevel.SoftBan, Color.Red },
                { LogLevel.LevelUp, Color.Magenta },
                { LogLevel.BotStats, Color.Magenta },
                { LogLevel.Gym, Color.Magenta },
                { LogLevel.GymDisk, Color.Cyan },
                { LogLevel.Service, Color.White }
            };

            _color = colors[level];

            if (string.IsNullOrEmpty(color.ToString()) || color.ToString() != "Black")
            {
                _color = FromColor(color);
            }

            if (string.IsNullOrEmpty(_color.ToString()))
            {
                _color = Color.White;
            }

            MainForm.ColoredConsoleWrite(_color, finalMessage);
        }
Exemple #3
0
        private static ConsoleColor ChooseColor()
        {
            var colors = Enum.GetNames(typeof(ConsoleColor));

            Console.WriteLine("Pick your color: ");
            foreach (var c in colors.Where(c => c != "Black"))
            {
                Console.WriteLine(c);
            }

            ConsoleColor color = ConsoleColor.Black;

            while (color == ConsoleColor.Black)
            {
                try
                {
                    color = (ConsoleColor)Enum.Parse(typeof(ConsoleColor), Console.ReadLine());
                    if (!colors.Contains(color.ToString()) || color == ConsoleColor.Black)
                    {
                        throw new Exception();
                    }
                }
                catch
                {
                    Console.WriteLine("INVALID SELECTION STUPID!");
                    color = ConsoleColor.Black;
                }
            }

            Console.ForegroundColor = color;
            Console.WriteLine("Your chats will all be {0}", color.ToString());
            return(color);
        }
Exemple #4
0
        /// <summary>
        /// Convert ConsoleColor to Color
        /// </summary>
        /// <param name="consoleColor"></param>
        /// <returns></returns>
        public static Color ToColor(this ConsoleColor consoleColor)
        {
            Color c = Color.FromName(consoleColor.ToString());

            if (c.IsNamedColor)
            {
                return(c);
            }
            throw new ArgumentException("Unknown color: " + consoleColor.ToString(), paramName: nameof(consoleColor));
        }
Exemple #5
0
    private static void ListEnum2()
    {
        //Loop never terminates, but should!
        ConsoleColor current = (ConsoleColor)0;

        for (int i = 0; (current.ToString() != i.ToString()); i++)
        {
            current = (ConsoleColor)i;
            Console.WriteLine("enum:" + current + ", i:" + i + ", condition:" + (current.ToString() != i.ToString()));
            Console.ReadLine();
        }
    }
Exemple #6
0
    private static void ListEnum1()
    {
        //Loop terminates, and should.
        ConsoleColor current = (ConsoleColor)0;
        bool         end     = current.ToString() == 0.ToString();

        for (int i = 0; !end; i++)
        {
            current = (ConsoleColor)i;
            end     = current.ToString() == i.ToString();
            Console.WriteLine("enum:" + current + ", i:" + i + ", condition:" + !end);
            Console.ReadLine();
        }
    }
Exemple #7
0
        private StatementAst CreateProcessedMessage(IScriptPosition position, ConsoleColor dashColor, Type astType)
        {
            ExpressionAst traceInvocation = InvokeMember(
                isStatic: true,
                Type(typeof(SequencePointTracer)),
                nameof(SequencePointTracer.TraceExpression),
                Variable("Host"),
                Member(Type(typeof(ConsoleColor)), dashColor.ToString(), isStatic: true),
                Type(astType),
                Variable(StackVariable),
                Constant(position.LineNumber),
                Constant(position.ColumnNumber),
                Index(
                    Array(
                        Pipeline(
                            CommandExpression(
                                ArrayLiteral(Variable(TempVariable))))),
                    Constant(0)),
                Variable("false"));

            return(Pipeline(CommandExpression(traceInvocation)));
            // var prefix = Add(CreateDashString(), String("< {0}"));
            // var message = Format(prefix, Variable(TempVariable));
            // return Pipeline(
            //     Command(
            //         WriteHost,
            //         message,
            //         CommandParameter("ForegroundColor"),
            //         String(dashColor.ToString())));
        }
Exemple #8
0
        private string GetHexColor(ConsoleColor clr)
        {
            var c      = Color.FromName(clr.ToString());
            var result = string.Format("#{0:x6}", c.ToArgb() & 0xFFFFFF);

            return(result);
        }
Exemple #9
0
        public void ConvertConsoleColorTest()
        {
            KnownColor form = KnownColor.DarkRed;

            ConsoleColor consoleColor = ConsoleColor.DarkRed;

            var l = (int)consoleColor;
            var m = (int)form;


            //foreach (FieldInfo fi in typeof(ConsoleColor).GetFields(BindingFlags.Public | BindingFlags.Static))
            //{
            foreach (FieldInfo fc in typeof(KnownColor).GetFields(BindingFlags.Public | BindingFlags.Static))
            {
                if (fc.Name == consoleColor.ToString())
                {
                    foreach (FieldInfo fi in typeof(ConsoleColor).GetFields(BindingFlags.Public | BindingFlags.Static))
                    {
                        //if (fi.n)
                    }
                    form = (KnownColor)consoleColor;
                }
            }
            //}
        }
        static void WriteThemeData(ConsoleColor foreground, ConsoleColor background)
        {
            string dataPath = @"Data/Theme.txt";

            File.WriteAllText(dataPath, foreground.ToString() + "\n");
            File.WriteAllText(dataPath, background.ToString());
        }
Exemple #11
0
        public void SetDoorColor(ConsoleColor newColor)
        {
            color = newColor;

            // rename door according to color
            name = "The " + color.ToString() + " Door";
        }
Exemple #12
0
        }   // end of ConvertColor method

        public void SaveScreen(string fileName)
        {
            FileStream   stream;
            StreamWriter textOut = null;

            try
            {
                stream  = new FileStream(fileName, FileMode.Create, FileAccess.Write);
                textOut = new StreamWriter(stream);

                textOut.WriteLine(backgroundColor.ToString());
                textOut.WriteLine(foregroundColor.ToString());

                for (int i = 0; i < screenText.Length; i++)
                {
                    textOut.WriteLine(screenText[i]);
                }
                textOut.Close();
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error Creating file: ");
                Console.WriteLine(ex.ToString());
                return;
            }
            finally
            {
                if (textOut != null)
                {
                    textOut.Close();
                }
            }
        }   // of of SaveScreen method
Exemple #13
0
        private static void EinstellungenMenuAktion(string iniVariable, string iniSchluessel, string aufforderungText, string aufforderungTitel, Typ eingabenTyp, int[] limitTypZahl = null)
        {
            bool   einstellungFertigBearbeitet = false;
            string rueckgabeAenderung          = "";

            Program.WriteAt(0, 0, " ");
            do
            {
                try {
                    if (eingabenTyp == Typ.Zahl && limitTypZahl != null && limitTypZahl.Length == 2 && limitTypZahl[0] < limitTypZahl[1])
                    {
                        rueckgabeAenderung = Microsoft.VisualBasic.Interaction.InputBox($"{aufforderungText} (Min: {limitTypZahl[0]}, Max: {limitTypZahl[1]})", aufforderungTitel, Einstellungen.ini.Read(iniVariable, iniSchluessel));
                    }
                    else
                    {
                        rueckgabeAenderung = Microsoft.VisualBasic.Interaction.InputBox(aufforderungText, aufforderungTitel, Einstellungen.ini.Read(iniVariable, iniSchluessel));
                    }

                    switch (eingabenTyp)
                    {
                    case Typ.Farbe:
                        ConsoleColor neueFarbe = (ConsoleColor)Enum.Parse(typeof(ConsoleColor), rueckgabeAenderung);
                        Einstellungen.ini.Write(iniVariable, neueFarbe.ToString(), iniSchluessel);
                        einstellungFertigBearbeitet = true;
                        break;

                    case Typ.Zahl:
                        int neueZahl = int.Parse(rueckgabeAenderung);
                        if (limitTypZahl != null && limitTypZahl.Length == 2 && limitTypZahl[0] < limitTypZahl[1])
                        {
                            if (neueZahl >= limitTypZahl[0] && neueZahl <= limitTypZahl[1])
                            {
                                Einstellungen.ini.Write(iniVariable, neueZahl.ToString(), iniSchluessel);
                                einstellungFertigBearbeitet = true;
                            }
                            else
                            {
                                einstellungFertigBearbeitet = false;
                            }
                        }
                        else
                        {
                            Einstellungen.ini.Write(iniVariable, neueZahl.ToString(), iniSchluessel);
                            einstellungFertigBearbeitet = true;
                        }
                        break;

                    case Typ.Text:
                        Einstellungen.ini.Write(iniVariable, rueckgabeAenderung, iniSchluessel);
                        einstellungFertigBearbeitet = true;
                        break;

                    default:
                        break;
                    }
                } catch (Exception) {
                    einstellungFertigBearbeitet = false;
                }
            } while (!einstellungFertigBearbeitet);
        }
Exemple #14
0
        public void WriteLine(string message, ConsoleColor textColor, bool isError)
        {
            outputMessages.Add(new OutputMessage(message, textColor, isError));

            // Dump to the console to assist debugging
            Console.WriteLine("IsError: {0}, TextColor: {1}, Message: {2}", isError, textColor.ToString(), message);
        }
        /// <summary>
        /// Prints list of all colours on the screen.
        /// </summary>
        /// <param name="message"></param>
        /// <returns>What the user has written. It's supposed to be the number of the colour in the given list. You can cast it to 'ConsoleColor'</returns>
        private string SelectColour(string message)
        {
            Console.Clear();
            Console.WriteLine("Please write the number of the colour you want to use and press 'Enter'");
            Console.WriteLine(message);
            ConsoleColor BackgroundColor = Console.BackgroundColor;
            ConsoleColor TextColor       = Console.ForegroundColor;

            for (int i = 0; i < Enum.GetNames(typeof(ConsoleColor)).Length; i++)
            {
                try
                {
                    ConsoleColor c = (ConsoleColor)i;
                    Console.ForegroundColor = c;
                    Console.WriteLine((i + 1) + "." + c.ToString());
                }
                catch (System.ArgumentException)
                {
                    i++;
                }
            }

            Console.BackgroundColor = BackgroundColor;
            Console.ForegroundColor = TextColor;
            string result = Console.ReadLine();

            return(result);
        }
Exemple #16
0
        public static ANSI_COLOR Color_Console_To_ANSI(ConsoleColor Color)
        {
            switch (Color)
            {
            case ConsoleColor.DarkYellow:
                return(ANSI_COLOR.YELLOW);

            case ConsoleColor.Yellow:
                return(ANSI_COLOR.YELLOW_BRIGHT);

            case ConsoleColor.DarkRed:
                return(ANSI_COLOR.RED);

            case ConsoleColor.Red:
                return(ANSI_COLOR.RED_BRIGHT);

            case ConsoleColor.DarkMagenta:
                return(ANSI_COLOR.MAGENTA_BRIGHT);

            case ConsoleColor.Magenta:
                return(ANSI_COLOR.MAGENTA_BRIGHT);

            case ConsoleColor.DarkGreen:
                return(ANSI_COLOR.GREEN_BRIGHT);

            case ConsoleColor.Green:
                return(ANSI_COLOR.GREEN_BRIGHT);

            case ConsoleColor.DarkCyan:
                return(ANSI_COLOR.CYAN);

            case ConsoleColor.Cyan:
                return(ANSI_COLOR.CYAN_BRIGHT);

            case ConsoleColor.DarkBlue:
                return(ANSI_COLOR.BLUE);

            case ConsoleColor.Blue:
                return(ANSI_COLOR.BLUE_BRIGHT);

            case ConsoleColor.White:
                return(ANSI_COLOR.WHITE_BRIGHT);

            case ConsoleColor.Gray:
                return(ANSI_COLOR.WHITE);

            case ConsoleColor.DarkGray:
                return(ANSI_COLOR.BLACK_BRIGHT);

            case ConsoleColor.Black:
                return(ANSI_COLOR.BLACK);

            default:
            {
                System.Diagnostics.Debugger.Break();
                throw new ArgumentOutOfRangeException($"{nameof(Color)}({Color.ToString()})");
            }
            }
        }
Exemple #17
0
        public static void Echo(
            this ConsoleColor obj,
            EchoEvaluationContext ctx)
        {
            var(@out, context, _) = ctx;
            if (context.EchoMap.MappedCall(obj, ctx))
            {
                return;
            }

            var smbcol = context.ShellEnv.Colors.HighlightSymbol;
            var str    = $" {smbcol}{GetCmd(EchoDirectives.b + "", obj.ToString().ToLower())}  {context.ShellEnv.Colors.Default}";

            @out.Echo(smbcol + "{");
            @out.Echo(context.ShellEnv.Colors.Default + obj.ToString() + " " + context.ShellEnv.Colors.Name + str);
            @out.Echo(smbcol + "}");
        }
Exemple #18
0
 public static void WriteLine(ConsoleColor c, string value, params object[] prms)
 {
     for (int i = 0; i < prms.Length; i++)
     {
         prms[i] = "<f=" + c.ToString().ToLower() + ">" + prms[i];
     }
     Write(String.Format(value, prms) + Environment.NewLine);
 }
Exemple #19
0
 public void Write(string message, LogLevel level = LogLevel.Info, ConsoleColor color = ConsoleColor.Black)
 {
     if (LogToUI != null && level != LogLevel.Debug)
     {
         message = Logger.GetFinalMessage(message, level, color);
         LogToUI(message, level, color.ToString());
     }
 }
 public override string ToString()
 {
     return($"Figure {GetType().Name}\n" +
            $"Location at ({_x},{_y})\n" +
            $"Color: {Color.ToString()}\n" +
            $"IsVisible: {_isVisible}\n" +
            $"Has area: {Area}");
 }
        /// <summary>
        /// Devuelve los datos del Automovil
        /// </summary>
        /// <returns></returns>
        public override string ConsultarDatos()
        {
            StringBuilder sb = new StringBuilder();

            sb.AppendLine(base.ToString());
            sb.AppendFormat("Color {0}\n", color.ToString());

            return(sb.ToString());
        }
        /// <summary>
        /// Gets the rgb color of a console color
        /// </summary>
        /// <returns>RGB color</returns>
        public static Color ToColor(this ConsoleColor color)
        {
            var c = Color.FromName(Enum.Parse(typeof(ConsoleColor), color.ToString() !).ToString() !);

            return(c.IsKnownColor switch
            {
                false => Color.FromArgb(255, 128, 128, 0),
                _ => c,
            });
        public void SwitchStatementOfEnum_WithNoCases_ReturnsEnumsStringRepresentatio()
        {
            ConsoleColor consoleColor             = ConsoleColor.DarkCyan;
            Func <ConsoleColor, string> @delegate = GetColorWithNoCases;
            var    func  = ExecuteLambda <Func <ConsoleColor, string> >(@delegate);
            string color = func(consoleColor);

            Assert.AreEqual(color, consoleColor.ToString());
        }
        public void SwitchStatementOfEnum_GivenASpecificValueOfTheEnum_ReturnsEnumsStringRepresentation()
        {
            ConsoleColor consoleColor             = ConsoleColor.DarkCyan;
            Func <ConsoleColor, string> @delegate = GetColor;
            var    func  = ExecuteLambda <Func <ConsoleColor, string> >(@delegate);
            string color = func(consoleColor);

            Assert.AreEqual(color, consoleColor.ToString());
        }
        public ColoredCharacter Get(char character, ConsoleColor color)
        {
            string key = character + color.ToString();

            if (!usedCharacters.ContainsKey(key))
            {
                usedCharacters.Add(key, new ColoredCharacter(character, color));
            }
            return(usedCharacters[key]);
        }
Exemple #26
0
        public Key(int x, int y, ConsoleColor keyColor)
        {
            X      = x;
            Y      = y;
            sprite = Constants.KEY;
            color  = keyColor;

            // name key according to color
            Name = "The " + color.ToString() + " Key";
        }
        /// <summary>
        /// Publica todos los datos del Producto.
        /// </summary>
        /// <returns>Devuelve un string con los datos del Producto</returns>
        public virtual string Mostrar()
        {
            StringBuilder str = new StringBuilder();

            str.AppendFormat("CODIGO DE BARRAS: {0}\r\n", codigoDeBarras);
            str.AppendFormat("MARCA          : {0}\r\n", marca.ToString());
            str.AppendFormat("COLOR EMPAQUE  : {0}\r\n", colorPrimarioEmpaque.ToString());
            str.AppendLine("---------------------");
            return(str.ToString());
        }
Exemple #28
0
        protected override string UtilesToString()
        {
            StringBuilder sb = new StringBuilder();

            sb.AppendLine(base.UtilesToString());
            sb.AppendLine("Color: " + _color.ToString());
            sb.AppendLine("Trazo: " + _trazo + "\n");

            return(sb.ToString());
        }
Exemple #29
0
        /// <summary>
        /// Writes Xml articulating the current state of the <see cref="StdConsoleObject">StdConsoleObject</see>.</summary>
        /// <param name="writer">The stream to which this object will
        /// be serialized.</param>
        public void WriteXml(System.Xml.XmlWriter writer)
        {
            writer.WriteAttributeString(string.Empty, "Name", string.Empty, _name);
            writer.WriteAttributeString(string.Empty, "Text", string.Empty, _text);
            writer.WriteAttributeString(string.Empty, "Length", string.Empty, _length.ToString());
            writer.WriteAttributeString(string.Empty, "ForeColour", string.Empty, _foreground.ToString());
            writer.WriteAttributeString(string.Empty, "BackColour", string.Empty, _background.ToString());

            ((IXmlSerializable)_location).WriteXml(writer);
        }
Exemple #30
0
        public static Color FromColor(ConsoleColor c)
        {
            switch (c)
            {
            case ConsoleColor.DarkYellow:
                return(Color.FromArgb(255, 128, 128, 0));

            default:
                return(Color.FromName(c.ToString()));
            }
        }
Exemple #31
0
 public static Color ProcessTerminalColor(ConsoleColor color)
 {
     switch (color)
     {
         case (ConsoleColor.DarkBlue):
             return Color.FromArgb(1, 0x24, 0x56);
         case (ConsoleColor.Green):
             return Color.LimeGreen;
         default:
             return Color.FromName(color.ToString());
     }
 }
Exemple #32
0
 public static string ProcessHtmlColor(ConsoleColor color)
 {
     switch (color)
     {
         case (ConsoleColor.DarkBlue):
             return "#012456";
         case (ConsoleColor.Green):
             return "Lime";
         default:
             return color.ToString();
     }
 }
Exemple #33
0
 public CrayonColor(ConsoleColor color) {
     this.OriginalName = color.ToString();
     this._consoleColor = color;
 }
 /// <summary>
 /// Get color mapping xml element without background color
 /// </summary>
 /// <returns>
 /// The color mapping.
 /// </returns>
 /// <param name="doc">
 /// Document.
 /// </param>
 /// <param name="level">
 /// Level.
 /// </param>
 /// <param name="foregroundColor">
 /// Foreground color.
 /// </param>
 private XmlElement GetColorMapping(XmlDocument doc, string level, ConsoleColor foregroundColor)
 {
     return this.GetColorMapping(doc, level, foregroundColor.ToString(), String.Empty);
 }
Exemple #35
0
 public static string ToString(ConsoleColor color)
 {
     return color.ToString();
 }
Exemple #36
0
        static Brush consoleColorToBrush(ConsoleColor consoleColor)
        {
            // Recognize default system color.
            if (consoleColor == Config.DefaultConsoleColor)
                return Config.SystemFontBrush;

            // Handle 'DarkYellow' which does not have a brush with a matching
            // name.
            if (consoleColor == ConsoleColor.DarkYellow)
                return Brushes.DarkGoldenrod;
            
            var colorStr = consoleColor.ToString();
            return new BrushConverter().ConvertFromString(colorStr) as Brush;
        }
Exemple #37
0
        public int Run()
        {
            normalForeColor = Console.ForegroundColor;
            normalBackColor = Console.BackgroundColor;
            highlightForeColor = ConsoleColor.Cyan;
            highlightBackColor = Console.BackgroundColor;
            errorForeColor = ConsoleColor.Red;
            errorBackColor = Console.BackgroundColor;

            if (args.Length == 0 || (args.Length > 0 && args[0].EqualsOneOf(StringComparison.InvariantCultureIgnoreCase, "/?", "/h", "/help"))) {
                DisplayUsage(args.Length > 1 ? args[1] : null);
                return 0;
            }
            if (args[0].EqualsOneOf(StringComparison.InvariantCultureIgnoreCase, "/hidden")) {
                DisplayUsage(null, true);
                return 0;
            }

            string cmdline;
            StringBuilder cmdlineBuilder;
            int result;

            // TODO change this project to use the Config settings.

            bool translateCR = false;
            bool translateLF = false;
            bool translateTab = false;
            bool wrapOutput = false;

            cmdlineBuilder = new StringBuilder();

            try {
                if (args.Length == 2 && (args[0].Equals("-s", StringComparison.CurrentCultureIgnoreCase) || args[0].Equals("-set", StringComparison.CurrentCultureIgnoreCase))) {
                    ConsoleColor tmpColor;
                    string arg;

                    arg = args[1];
                    if (arg.StartsWith("{") && arg.EndsWith("}")) {
                        arg = arg.Substring(1, arg.Length - 2);
                    }

                    // Convert old DOS colors to .net ConsoleColor
                    arg = ConvertDOSColors(arg); // TODO support bg

                    if (int.TryParse(arg, out result)
                            && result >= (int)ConsoleColor.Black && result <= (int)ConsoleColor.White) {
                        tmpColor = (ConsoleColor)result;
                    } else if (ConsoleColorNames.Contains(arg, StringComparison.InvariantCultureIgnoreCase)) {
                        tmpColor = (ConsoleColor)Enum.Parse(typeof(ConsoleColor), arg, true);
                    } else {
                        Console.ForegroundColor = ConsoleColor.Red;
                        Console.WriteLine("error in -s argument: invalid color specified");
                        Console.ForegroundColor = normalForeColor;
                        return 10;
                    }

                    try {
                        Console.ForegroundColor = tmpColor;
                    } catch (Exception) {
                        Console.ForegroundColor = ConsoleColor.Red;
                        Console.WriteLine("error in -s argument: invalid color specified");
                        Console.ForegroundColor = normalForeColor;
                        return 10;
                    }

                    return 0;
                }

                if (ConsoleEx.IsInputRedirected) {
                    // When piping text to pcolor, I'm assuming that there is only
                    // one argument for pcolor and that is a color.
                    cmdlineBuilder.Append(args[0]);
                    cmdlineBuilder.Append(Console.In.ReadToEnd());
                } else {
                    // Read all the content from the arguments.
                    for (int argsi = 0; argsi < args.Length; argsi++) {
                        string a = args[argsi];
                        string al = a.ToLowerInvariant();

                        if (al.Equals("-f") || al.Equals("-file")) {
                            if (argsi <= args.Length - 2) {
                                StringBuilder contents;

                                argsi++;
                                contents = new StringBuilder();

                                if (!File.Exists(args[argsi])) {
                                    Console.ForegroundColor = errorForeColor;
                                    WriteLine(ConsoleColor.Red, "-f    the file was not found");
                                    DisplayUsage("-f");
                                    Console.ForegroundColor = normalForeColor;
                                    return 4;
                                }

                                if (contents.LoadFromFile(args[argsi])) {
                                    cmdlineBuilder.Append(contents.ToString());
                                }
                            } else {
                                Console.ForegroundColor = errorForeColor;
                                WriteLine(ConsoleColor.Red, "-f    is missing its file name");
                                DisplayUsage("-f");
                                Console.ForegroundColor = normalForeColor;
                                return 4;
                            }

                        } else if (al.EndsWith("-escape") || al.EndsWith("-crlf") || al.EndsWith("-cr-lf") || al.EndsWith("-cr-lf-tab")) {
                            translateCR = true;
                            translateLF = true;
                            translateTab = true;
                        } else if (al.EndsWith("!escape") || al.EndsWith("!crlf") || al.EndsWith("!cr-lf") || al.EndsWith("!cr-lf-tab")) {
                            translateCR = false;
                            translateLF = false;
                            translateTab = false;

                        } else if (al.EndsWith("-cr")) {
                            translateCR = true;
                        } else if (al.EndsWith("!cr")) {
                            translateCR = false;
                        } else if (al.EndsWith("-lf")) {
                            translateLF = true;
                        } else if (al.EndsWith("!lf")) {
                            translateLF = false;
                        } else if (al.EndsWith("-tab")) {
                            translateTab = true;
                        } else if (al.EndsWith("!tab")) {
                            translateTab = false;

                        } else if (al.EndsWith("-wrap")) {
                            wrapOutput = true;
                        } else if (al.EndsWith("!wrap")) {
                            wrapOutput = false;

                        } else {
                            // Convert hand-typed/specific linefeeds and tabs
                            if (translateCR) {
                                a = a.Replace("\\r\\n", "\r\n");
                            }
                            if (translateLF) {
                                a = a.Replace("\\n", "\n");
                            }
                            if (translateTab) {
                                a = a.Replace("\\t", "\t");
                            }

                            if (wrapOutput) {
                                cmdlineBuilder.Append(Text.Wrap(a));
                            } else {
                                cmdlineBuilder.Append(a);
                            }

                            if (argsi < args.Length - 1 && !a.EndsWith("\n")) {
                                cmdlineBuilder.Append(" ");
                            }
                        }
                    }
                }

                cmdline = cmdlineBuilder.ToString();

                // Convert old DOS colors to .net ConsoleColor
                cmdline = ConvertDOSColors(cmdline);

                // Provide a default color.
                if (!cmdline.StartsWith("{")) {
                    cmdline = "{" + normalForeColor.ToString() + "/" + normalBackColor.ToString() + "}" + cmdline;
                }

                WriteColoredString(cmdline);

            } catch (Exception ex) {
                // do nothing
                Console.Write(ex.Message);
                return 1;
            }

            Console.ForegroundColor = normalForeColor;

            return 0;
        }
Exemple #38
0
 private static Color ConsoleColorToColor(ConsoleColor console)
 {
     return Color.FromName(console.ToString());
 }
		private TerminalColor ConvertColor(ConsoleColor color, TerminalColor defaultColor)
		{
			TerminalColor result;

			if(Enum.TryParse<TerminalColor>(color.ToString(), out result))
				return result;
			else
				return defaultColor;
		}
        /// <summary>
        /// Sets the console color to use for the specified event type.
        /// </summary>
        /// <param name="eventType">The TraceEventType to set the color for.</param>
        /// <param name="color">The ConsoleColor to use for outputing trace messages of the specified type.</param>
        /// <remarks>
        /// <para>
        /// When selecting colors note that PowerShell redefines DarkYellow and DarkMagenta and uses them
        /// as default colors, so best to to avoid those two colors because result is not consistent.
        /// </para>
        /// </remarks>
        public void SetConsoleColor(TraceEventType eventType, ConsoleColor color)
        {
            lock (_consoleLock)
            {
                if (!Enum.IsDefined(typeof (ConsoleColor), color))
                {
                    throw new ArgumentOutOfRangeException("color", Resource.InvalidConsoleColor);
                }

                var key = eventType.ToString() + "Color";
                Attributes[key] = color.ToString();
            }
        }
        private string GetColorWithNoCases(ConsoleColor consoleColor)
        {
            string color = string.Empty;

            switch (consoleColor)
            {
                default:

                    color = consoleColor.ToString();
                    break;
            }

            return color;
        }
        private string GetColor(ConsoleColor consoleColor)
        {
            string color = string.Empty;

            switch (consoleColor)
            {
                case ConsoleColor.DarkCyan:

                    color = consoleColor.ToString();
                    break;

                default:

                    throw new NotImplementedException();
            }

            return color;
        }