private ConsoleBitmapDiffFrame PrepareDiffFrame(ConsoleBitmap bitmap) { ConsoleBitmapDiffFrame diff = new ConsoleBitmapDiffFrame(); diff.Diffs = new List <ConsoleBitmapPixelDiff>(); int changes = 0; for (int y = 0; y < bitmap.Height; y++) { for (int x = 0; x < bitmap.Width; x++) { var pixel = bitmap.GetPixel(x, y); if (pixel.HasChanged) { changes++; if (pixel.Value.HasValue) { diff.Diffs.Add(new ConsoleBitmapPixelDiff() { X = x, Y = y, Value = pixel.Value.Value }); } } } } return(diff); }
private void RenderDataPoint(ConsoleBitmap context, DataSeries series, DataPoint p, bool focused) { var x = ConvertXValueToPixel(p.X); var y = ConvertYValueToPixel(p.Y); if (focused) { context.Pen = new ConsoleCharacter(series.PlotCharacter, Application.Theme.FocusColor, Application.Theme.FocusColor); } else if (series.Threshold == null || series.Threshold.IsActive(p.Y) == false) { context.Pen = new ConsoleCharacter(series.PlotCharacter, series.PlotColor, Background); } else { context.Pen = new ConsoleCharacter(series.PlotCharacter, series.Threshold.ActiveColor, Background); } context.DrawPoint(x, y); while (series.ShowAreaUnderEachDataPoint && ++y <= YAxisBottom) { context.DrawPoint(x, y); } }
public void Clear() { Buffer = new ConsoleBitmap(0, 0, this.BufferWidth, this.WindowHeight); this.BufferWidth = Buffer.Width; this.CursorLeft = 0; this.CursorTop = 0; }
protected override void OnPaint(ConsoleBitmap context) { context.Pen = new ConsoleCharacter(' ', null, myFocusStackDepth == Application.FocusManager.StackDepth ? Theme.DefaultTheme.H1Color : Theme.DefaultTheme.DisabledColor); context.DrawLine(0, 0, Width, 0); context.DrawLine(0, Height - 1, Width, Height - 1); base.OnPaint(context); }
/// <summary> /// Creates a new console app given a set of boundaries /// </summary> /// <param name="w">The width of the app</param> /// <param name="h">The height of the app</param> public ConsoleApp(int w, int h) { this.Name = GetType().Name; this.console = ConsoleProvider.Current; this.lastConsoleWidth = this.console.BufferWidth; this.lastConsoleHeight = this.console.WindowHeight; this.observable = new ObservableObject(this); cycleRateMeter = new FrameRateMeter(); this.StartOfCycle.SubscribeForLifetime(Cycle, this); SetFocusOnStart = true; Bitmap = new ConsoleBitmap(w, h); LayoutRoot = new ConsolePanel { Width = w, Height = h }; FocusManager = new FocusManager(); LayoutRoot.Application = this; isFullScreen = false; FocusManager.SubscribeForLifetime(nameof(FocusManager.FocusedControl), () => Paint(), this); LayoutRoot.Controls.BeforeAdded.SubscribeForLifetime((c) => { c.Application = this; c.BeforeAddedToVisualTreeInternal(); }, this); LayoutRoot.Controls.BeforeRemoved.SubscribeForLifetime((c) => { c.BeforeRemovedFromVisualTreeInternal(); }, this); LayoutRoot.Controls.Added.SubscribeForLifetime(ControlAddedToVisualTree, this); LayoutRoot.Controls.Removed.SubscribeForLifetime(ControlRemovedFromVisualTree, this); WindowResized.SubscribeForLifetime(HandleDebouncedResize, this); this.LoopStarted.SubscribeOnce(() => _current = this); this.EndOfCycle.SubscribeForLifetime(DrainPaints, this); }
protected override void OnPaint(ConsoleBitmap context) { ScrollableContent.Paint(); for (int x = 0; x < Width; x++) { for (int y = 0; y < Height; y++) { int scrollX = x + HorizontalScrollUnits; int scrollY = y + VerticalScrollUnits; if (scrollX >= ScrollableContent.Width || scrollY >= ScrollableContent.Height) { continue; } var scrolledPixel = ScrollableContent.Bitmap.GetPixel(scrollX, scrollY); context.DrawPoint(scrolledPixel, x, y); } } verticalScrollbar.Paint(); horizontalScrollbar.Paint(); DrawScrollbar(verticalScrollbar, context); DrawScrollbar(horizontalScrollbar, context); }
/// <summary> /// paints the text box /// </summary> /// <param name="context"></param> protected override void OnPaint(ConsoleBitmap context) { var toPaint = textState.CurrentValue; var bgTransformed = new List <ConsoleCharacter>(); foreach (var c in toPaint) { if (c.BackgroundColor == ConsoleString.DefaultBackgroundColor && Background != ConsoleString.DefaultBackgroundColor) { bgTransformed.Add(new ConsoleCharacter(c.Value, Foreground, Background)); } else { bgTransformed.Add(c); } } context.DrawString(new ConsoleString(bgTransformed), 0, 0); if (blinkState) { char blinkChar = textState.CursorPosition >= toPaint.Length ? ' ' : toPaint[textState.CursorPosition].Value; context.Pen = new ConsoleCharacter(blinkChar, Application.Theme.FocusContrastColor, Application.Theme.FocusColor); context.DrawPoint(textState.CursorPosition, 0); } }
private void RenderThresholds(ConsoleBitmap context) { foreach (var series in ViewModel.DataSeriesCollection.OrderBy(s => s == ViewModel.FocusedDataSeries ? 1 : 0)) { RenderThreshold(context, series); } }
protected override void OnPaint(ConsoleBitmap context) { var fullSize = ScrollableContentSize; ConsoleBitmap fullyPaintedPanel = new ConsoleBitmap(0, 0, fullSize.Width, fullSize.Height); ScrollableContent.PaintTo(fullyPaintedPanel); for (int x = 0; x < Width; x++) { for (int y = 0; y < Height; y++) { int scrollX = x + HorizontalScrollUnits; int scrollY = y + VerticalScrollUnits; if (scrollX >= fullyPaintedPanel.Width || scrollY >= fullyPaintedPanel.Height) { continue; } var scrolledPixel = fullyPaintedPanel.GetPixel(scrollX, scrollY); if (scrolledPixel.Value.HasValue) { context.Pen = scrolledPixel.Value.Value; } else { context.Pen = new ConsoleCharacter(' ', backgroundColor: Background); } context.DrawPoint(x, y); } } base.OnPaint(context); }
private void RenderTitle(ConsoleBitmap context) { int yOffset = 0; foreach (var series in ViewModel.DataSeriesCollection) { var title = new ConsoleString(series.Title, series.PlotColor, Background); if (HasFocus && ViewModel.FocusedDataPointIndex >= 0 && ViewModel.FocusedDataPointIndex < series.DataPoints.Count && ViewModel.FocusedDataSeries == series) { var xValue = XAxisValueFormatter(series.DataPoints[ViewModel.FocusedDataPointIndex].X); var yValue = YAxisValueFormatter(series.DataPoints[ViewModel.FocusedDataPointIndex].Y); title += new ConsoleString(" ( " + xValue + ", " + yValue + " )", Application.Theme.FocusColor); } if (title.Length > MaxTitleLength) { title = title.Substring(0, MaxTitleLength) + ("_"); } var titleLeft = XAxisLeft + ((XAxisWidth / 2) - (title.Length / 2)); context.DrawString(title, titleLeft, YAxisTop + 1 + yOffset); yOffset++; } }
/// <summary> /// paints the text box /// </summary> /// <param name="context"></param> protected override void OnPaint(ConsoleBitmap context) { var toPaint = textState.CurrentValue; var offset = 0; if (toPaint.Length >= Width && textState.CursorPosition > Width - 1) { offset = (textState.CursorPosition + 1) - Width; toPaint = toPaint.Substring(offset); } var bgTransformed = new List <ConsoleCharacter>(); foreach (var c in toPaint) { if (c.BackgroundColor == ConsoleString.DefaultBackgroundColor && Background != ConsoleString.DefaultBackgroundColor) { bgTransformed.Add(new ConsoleCharacter(c.Value, Foreground, Background)); } else { bgTransformed.Add(c); } } context.DrawString(new ConsoleString(bgTransformed), 0, 0); if (blinkState && BlinkEnabled) { char blinkChar = textState.CursorPosition >= toPaint.Length ? ' ' : toPaint[textState.CursorPosition].Value; var pen = new ConsoleCharacter(blinkChar, DefaultColors.FocusContrastColor, DefaultColors.FocusColor); context.DrawPoint(pen, textState.CursorPosition - offset, 0); } }
protected override void OnPaint(ConsoleBitmap context) { ScrollableContent.Paint(); for (int x = 0; x < Width; x++) { for (int y = 0; y < Height; y++) { int scrollX = x + HorizontalScrollUnits; int scrollY = y + VerticalScrollUnits; if (scrollX >= ScrollableContent.Width || scrollY >= ScrollableContent.Height) { continue; } var scrolledPixel = ScrollableContent.Bitmap.GetPixel(scrollX, scrollY); if (scrolledPixel.Value.HasValue) { context.Pen = scrolledPixel.Value.Value; } else { context.Pen = new ConsoleCharacter(' ', backgroundColor: Background); } context.DrawPoint(x, y); } } }
protected override void OnPaint(ConsoleBitmap context) { base.OnPaint(context); if (HasFocus) { context.FillRectUnsafe(new ConsoleCharacter(' ', backgroundColor: DefaultColors.FocusColor), 0, 0, Width, Height); } }
/// <summary> /// Paints the diff on top of the given image which, unlike with raw frames, cannot be null, /// since a diff frame can only be applied to an existing image /// </summary> /// <param name="bitmap">the image to apply the diff to</param> /// <returns>the same image reference you passed in, updated with the diff</returns> public override ConsoleBitmap Paint(ref ConsoleBitmap bitmap) { foreach (var diff in Diffs) { bitmap.Pixels[diff.X][diff.Y] = diff.Value; } return(bitmap); }
protected override void OnPaint(ConsoleBitmap context) { RenderTitle(context); RenderXAxis(context); RenderYAxis(context); RenderThresholds(context); RenderDataPoints(context); }
/// <summary> /// Paints the diff on top of the given image which, unlike with raw frames, cannot be null, /// since a diff frame can only be applied to an existing image /// </summary> /// <param name="bitmap">the image to apply the diff to</param> /// <returns>the same image reference you passed in, updated with the diff</returns> public override ConsoleBitmap Paint(ref ConsoleBitmap bitmap) { foreach (var diff in Diffs) { bitmap.Pen = diff.Value; bitmap.DrawPoint(diff.X, diff.Y); } return(bitmap); }
protected override void OnPaint(ConsoleBitmap context) { base.OnPaint(context); if (HasFocus) { context.Pen = new ConsoleCharacter(' ', backgroundColor: Application.Theme.FocusColor); context.FillRect(0, 0, Width, Height); } }
private void DrawScrollbar(Scrollbar bar, ConsoleBitmap context) { for (int x = 0; x < bar.Width; x++) { for (int y = 0; y < bar.Height; y++) { context.DrawPoint(bar.Bitmap.GetPixel(x, y).Value.Value, x + bar.X, y + bar.Y); } } }
internal override void OnPaint(ConsoleBitmap context) { context.Pen = Foreground; RenderTitle(context); RenderXAxis(context); RenderYAxis(context); RenderThresholds(context); RenderDataPoints(context); }
/// <summary> /// Paints this control /// </summary> /// <param name="context">the drawing surface</param> protected override void OnPaint(ConsoleBitmap context) { foreach (var control in GetPaintOrderedControls()) { if (control.Width > 0 && control.Height > 0 && control.IsVisible) { Compose(control); } } }
public void CloneTo(ConsoleBitmap ret) { for (var x = 0; x < Width; x++) { for (var y = 0; y < Height; y++) { ret.Pen = this.GetPixel(x, y).Value.HasValue ? this.GetPixel(x, y).Value.Value : new ConsoleCharacter(' '); ret.DrawPoint(x, y); } } }
protected override void OnPaint(ConsoleBitmap context) { #if PROFILING using (new TimeProfiler("Grid.OnPaint")) { #endif PaintInternal(context); #if PROFILING } #endif }
internal override void OnPaint(ConsoleBitmap context) { base.OnPaint(context); int y = 0; foreach(var item in ViewModel.Items) { var displayString = this.HasFocus && y == ViewModel.SelectedIndex && ViewModel.IsSelectionEnabled ? new ConsoleString(item.DisplayText, this.FocusForeground.ForegroundColor) : item.RichDisplayText; context.DrawString(displayString, 0, y++); } }
/// <summary> /// Writes the given bitmap image as a frame to the stream. If this is the first image or more than half of the pixels have /// changed then a raw frame will be written. Otherwise, a diff frame will be written. /// /// This method uses the system's wall clock to determine the timestamp for this frame. The timestamp will be /// relative to the wall clock time when the first frame was written. /// </summary> /// <param name="bitmap">the image to write</param> /// <param name="desiredFrameTime">if provided, sstamp the frame with this time, otherwise stamp it with the wall clock delta from the first frame time</param> /// <param name="force">if true, writes the frame even if there are no changes</param> /// <returns>the same bitmap that was passed in</returns> public ConsoleBitmap WriteFrame(ConsoleBitmap bitmap, bool force = false, TimeSpan?desiredFrameTime = null) { if (pausedAt.HasValue) { return(bitmap); } var rawFrame = GetRawFrame(bitmap); var now = DateTime.UtcNow - TotalPauseTime; if (firstFrameTime.HasValue == false) { rawFrame.Timestamp = TimeSpan.Zero; firstFrameTime = now; } else { rawFrame.Timestamp = desiredFrameTime.HasValue ? desiredFrameTime.Value : now - firstFrameTime.Value; } if (lastFrame == null) { StreamHeader(bitmap); writer.Write(serializer.SerializeFrame(rawFrame)); FramesWritten++; } else { if (GetEffectiveWidth(bitmap) != lastFrame.Pixels.Length || GetEffectiveHeight(bitmap) != lastFrame.Pixels[0].Length) { throw new InvalidOperationException("Video frame has changed size"); } var diff = PrepareDiffFrame(lastFrame, bitmap); diff.Timestamp = rawFrame.Timestamp; var numPixels = GetEffectiveWidth(bitmap) * GetEffectiveHeight(bitmap); if (force || diff.Diffs.Count > numPixels / 2) { writer.Write(serializer.SerializeFrame(rawFrame)); FramesWritten++; } else if (diff.Diffs.Count > 0) { writer.Write(serializer.SerializeFrame(diff)); FramesWritten++; } } lastFrame = rawFrame; return(bitmap); }
/// <summary> /// Paints the entire frame onto the given bitmap. If the given bitmap is null then /// a new bitmap of the correct size will be created and assigned to the reference you /// have provided. The normal usage pattern is to pass null when reading the first frame, /// which will always be a raw frame. You can then pass this same bitmap to subsequent calls /// to Paint, and it will work whether the subsequent frames are raw frames or diff frames. /// /// </summary> /// <param name="bitmap">The bitmap to paint on or null to create a new bitmap from the raw frame</param> /// <returns>the same bitmap you passed in or one that was created for you</returns> public override ConsoleBitmap Paint(ref ConsoleBitmap bitmap) { bitmap = bitmap ?? new ConsoleBitmap(Pixels.Length, Pixels[0].Length); for (var x = 0; x < Pixels.Length; x++) { for (var y = 0; y < Pixels[0].Length; y++) { bitmap.Pixels[x][y] = Pixels[x][y]; } } return(bitmap); }
internal override void OnPaint(ConsoleBitmap context) { base.OnPaint(context); int y = 0; foreach (var item in ViewModel.Items) { var displayString = this.HasFocus && y == ViewModel.SelectedIndex && ViewModel.IsSelectionEnabled ? new ConsoleString(item.DisplayText, this.FocusForeground.ForegroundColor) : item.RichDisplayText; context.DrawString(displayString, 0, y++); } }
public void Do() { myTime = studio.CurrentFrame.FrameTime; myBitmap = studio.CurrentBitmap.Clone(); studio.animation.Frames.Insert(myIndex, new InMemoryConsoleBitmapFrame() { Bitmap = myBitmap, FrameTime = myTime }); studio.Refresh(); studio.CurrentFrameIndex = myIndex + 1; studio.frameList.SelectedRowIndex = myIndex + 1; }
protected virtual void Dispose(bool disposing) { if (disposing) { // free managed resources if (bitmap != null) { bitmap.Unlock(); bitmap = null; } } }
protected override void OnPaint(ConsoleBitmap context) { var drawState = new ConsoleString(); drawState = "[".ToConsoleString(CanFocus ? Application.Theme.H1Color : Application.Theme.DisabledColor, Background = Background); if (Text != null) { ConsoleColor fg, bg; if (HasFocus) { fg = Application.Theme.FocusContrastColor; bg = Application.Theme.FocusColor; } else if (CanFocus) { fg = Foreground; bg = Background; } else { fg = Application.Theme.DisabledColor; bg = Background; } drawState += new ConsoleString(Text, fg, bg); if (Shortcut != null) { if (Shortcut.Modifier.HasValue && Shortcut.Modifier == ConsoleModifiers.Alt) { drawState += new ConsoleString($" (ALT+{Shortcut.Key})", CanFocus ? Application.Theme.H1Color : Application.Theme.DisabledColor); } else if (Shortcut.Modifier.HasValue && Shortcut.Modifier == ConsoleModifiers.Shift) { drawState += new ConsoleString($" (SHIFT+{Shortcut.Key})", CanFocus ? Application.Theme.H1Color : Application.Theme.DisabledColor); } else if (Shortcut.Modifier.HasValue && Shortcut.Modifier == ConsoleModifiers.Control) { drawState += new ConsoleString($" (CTL+{Shortcut.Key})", CanFocus ? Application.Theme.H1Color : Application.Theme.DisabledColor); } else { drawState += new ConsoleString($" ({Shortcut.Key})", CanFocus ? Application.Theme.H1Color : Application.Theme.DisabledColor); } } } drawState += "]".ToConsoleString(CanFocus ? Application.Theme.H1Color : Application.Theme.DisabledColor, Background); Width = drawState.Length; context.DrawString(drawState, 0, 0); }
/// <summary> /// Loads a video from a given stream /// </summary> /// <param name="videoStream">the video stream</param> public void Load(Stream videoStream) { if (Application == null) { throw new InvalidOperationException("Can't load until the control has been added to an application"); } Task.Factory.StartNew(() => { try { var reader = new ConsoleBitmapStreamReader(videoStream); reader.ReadToEnd((videoWithProgressInfo) => { inMemoryVideo = inMemoryVideo ?? videoWithProgressInfo; this.duration = videoWithProgressInfo.Duration; Application.QueueAction(() => { if (this.CurrentFrame == null) { this.CurrentFrame = videoWithProgressInfo.Frames[0].Bitmap; playerProgressBar.ShowPlayCursor = true; playButton.CanFocus = true; seekToBeginningButton.CanFocus = true; seekBack10SButton.CanFocus = true; seekForward10SButton.CanFocus = true; seekToEndButton.CanFocus = true; State = PlayerState.Stopped; if (Application.FocusManager.FocusedControl == null) { Application.FocusManager.TrySetFocus(playButton); } } playerProgressBar.LoadProgressPosition = inMemoryVideo.LoadProgress; }); if (AfterFrameLoadDelay.HasValue) { Thread.Sleep(AfterFrameLoadDelay.Value); } }); } catch (Exception ex) { Application.QueueAction(() => { failedMessage = ex.Message; State = PlayerState.Failed; }); } }); }
/// <summary> /// Makes a copy of this bitmap /// </summary> /// <returns>a copy of this bitmap</returns> public ConsoleBitmap Clone() { var ret = new ConsoleBitmap(X, Y, Width, Height); for (var x = 0; x < Width; x++) { for (var y = 0; y < Height; y++) { ret.Pen = this.GetPixel(x, y).Value.HasValue ? this.GetPixel(x, y).Value.Value : new ConsoleCharacter(' '); ret.DrawPoint(x, y); } } return(ret); }
/// <summary> /// Draws the bitmap /// </summary> /// <param name="context">the pain context</param> protected override void OnPaint(ConsoleBitmap context) { if (Bitmap == null) { return; } for (var x = 0; x < Bitmap.Width && x < this.Width; x++) { for (var y = 0; y < Bitmap.Height && y < this.Height; y++) { ref var pixel = ref Bitmap.GetPixel(x, y); context.DrawPoint(pixel, x, y); } }
public ConsoleApp(int x, int y, int w, int h) { Bitmap = new ConsoleBitmap(x, y, w, h); LayoutRoot = new ConsolePanel { Width = w, Height = h }; LayoutRoot.Application = this; focusableControls = new List <ConsoleControl>(); focusIndex = -1; ExitOnEscapeCharacter = true; LayoutRoot.Controls.Added += (c) => { c.Application = this; if (c.CanFocus) { focusableControls.Add(c); } if (c is ConsolePanel) { var children = TraverseControlTree(c as ConsolePanel); focusableControls.AddRange(children.Where(child => child.CanFocus)); focusableControls = focusableControls.Distinct().ToList(); foreach (var child in children) { child.Application = this; } } }; LayoutRoot.Controls.Removed += (c) => { c.Application = null; if (c.CanFocus) { focusableControls.Remove(c); } if (c is ConsolePanel) { var children = TraverseControlTree(c as ConsolePanel); foreach (var child in children) { focusableControls.Remove(child); child.Application = null; } } }; }
internal override void OnPaint(ConsoleBitmap context) { foreach (var control in Controls) { Rectangle scope = context.GetScope(); try { context.Rescope(control.X, control.Y, control.Width, control.Height); control.Paint(context); } finally { context.Scope(scope); } } }
/// <summary> /// Creates a new console app given a set of boundaries /// </summary> /// <param name="x">The left position on the target console to bound this app</param> /// <param name="y">The right position on the target console to bound this app</param> /// <param name="w">The width of the app</param> /// <param name="h">The height of the app</param> public ConsoleApp(int x, int y, int w, int h) : base(ConsoleProvider.Current) { SetFocusOnStart = true; Theme = new Theme(); Bitmap = new ConsoleBitmap(x, y, w, h); LayoutRoot = new ConsolePanel { Width = w, Height = h }; FocusManager = new FocusManager(); LayoutRoot.Application = this; AutoFillOnConsoleResize = false; FocusManager.SubscribeForLifetime(nameof(FocusManager.FocusedControl), Paint, LifetimeManager); LayoutRoot.Controls.BeforeAdded.SubscribeForLifetime((c) => { c.Application = this; c.BeforeAddedToVisualTreeInternal(); }, LifetimeManager); LayoutRoot.Controls.BeforeRemoved.SubscribeForLifetime((c) => { c.BeforeRemovedFromVisualTreeInternal(); }, LifetimeManager); LayoutRoot.Controls.Added.SubscribeForLifetime(ControlAddedToVisualTree, LifetimeManager); LayoutRoot.Controls.Removed.SubscribeForLifetime(ControlRemovedFromVisualTree, LifetimeManager); WindowResized.SubscribeForLifetime(HandleDebouncedResize, LifetimeManager); }
public ConsoleApp(int x, int y, int w, int h) { Bitmap = new ConsoleBitmap(x,y, w, h); LayoutRoot = new ConsolePanel { Width = w, Height = h }; LayoutRoot.Application = this; focusableControls = new List<ConsoleControl>(); focusIndex = -1; ExitOnEscapeCharacter = true; LayoutRoot.Controls.Added += (c) => { c.Application = this; if (c.CanFocus) focusableControls.Add(c); if (c is ConsolePanel) { var children = TraverseControlTree(c as ConsolePanel); focusableControls.AddRange(children.Where(child => child.CanFocus)); focusableControls = focusableControls.Distinct().ToList(); foreach (var child in children) child.Application = this; } }; LayoutRoot.Controls.Removed += (c) => { c.Application = null; if (c.CanFocus) focusableControls.Remove(c); if (c is ConsolePanel) { var children = TraverseControlTree(c as ConsolePanel); foreach (var child in children) { focusableControls.Remove(child); child.Application = null; } } }; }
public PaintOnceContext(ConsoleBitmap bitmap) { this.bitmap = bitmap; bitmap.Lock(); }
protected override void OnPaint(ConsoleBitmap context) { for(int y = 0; y < lines.Count; y++) { if(y >= Height) { break; } var line = lines[y]; for(int x = 0; x < line.Count && x < Width; x++) { context.Pen = HasFocus ? new ConsoleCharacter(line[x].Value, Application.Theme.FocusContrastColor, Application.Theme.FocusColor) : line[x]; context.DrawPoint(x, y); } } }
/// <summary> /// paints the button /// </summary> /// <param name="context">drawing context</param> protected override void OnPaint(ConsoleBitmap context) { var drawState = new ConsoleString(); drawState = "[".ToConsoleString(CanFocus ? Application.Theme.H1Color : Application.Theme.DisabledColor, Background = Background); if (Text != null) { ConsoleColor fg, bg; if(HasFocus) { fg = Application.Theme.FocusContrastColor; bg = Application.Theme.FocusColor; } else if(CanFocus) { fg = Foreground; bg = Background; } else { fg = Application.Theme.DisabledColor; bg = Background; } drawState += new ConsoleString(Text, fg, bg); if(Shortcut != null) { if(Shortcut.Modifier.HasValue && Shortcut.Modifier == ConsoleModifiers.Alt) { drawState += new ConsoleString($" (ALT+{Shortcut.Key})", CanFocus ? Application.Theme.H1Color : Application.Theme.DisabledColor); } else if (Shortcut.Modifier.HasValue && Shortcut.Modifier == ConsoleModifiers.Shift) { drawState += new ConsoleString($" (SHIFT+{Shortcut.Key})", CanFocus ? Application.Theme.H1Color : Application.Theme.DisabledColor); } else if (Shortcut.Modifier.HasValue && Shortcut.Modifier == ConsoleModifiers.Control) { drawState += new ConsoleString($" (CTL+{Shortcut.Key})", CanFocus ? Application.Theme.H1Color : Application.Theme.DisabledColor); } else { drawState += new ConsoleString($" ({Shortcut.Key})", CanFocus ? Application.Theme.H1Color : Application.Theme.DisabledColor); } } } drawState += "]".ToConsoleString(CanFocus ? Application.Theme.H1Color : Application.Theme.DisabledColor, Background); Width = drawState.Length; context.DrawString(drawState, 0, 0); }
internal void PaintTo(ConsoleBitmap context) { OnPaint(context); }
protected override void OnPaint(ConsoleBitmap context) { base.OnPaint(context); }
internal virtual void OnPaint(ConsoleBitmap context) { }
internal void Paint(ConsoleBitmap context) { Rectangle scope = context.GetScope(); if (Background != ConsoleControl.TransparantColor) { context.Pen = Background; context.FillRect(0, 0, Width, Height); } try { context.Rescope(this.X, this.Y, this.Width, this.Height); context.Pen = this.Foreground; OnPaint(context); } finally { context.Scope(scope); } }
internal void Paint(ConsoleBitmap context) { if (IsVisible == false) { return; } if (TransparentBackground == false) { context.Pen = new ConsoleCharacter(' ', null, Background); context.FillRect(0, 0, Width, Height); } OnPaint(context); }
private void PaintInternal(ConsoleBitmap context) { if (this.Height < 5) { context.DrawString("Grid can't render in a space this small", 0, 0); return; } if (VisibleColumns.Count == 0) { context.DrawString(NoVisibleColumnsMessage.ToConsoleString(Application.Theme.H1Color), 0, 0); return; } List<ConsoleString> headers = new List<ConsoleString>(); List<List<ConsoleString>> rows = new List<List<ConsoleString>>(); List<ColumnOverflowBehavior> overflowBehaviors = new List<ColumnOverflowBehavior>(); if (VisibleColumns.Where(c => c.WidthPercentage != 0).Count() == 0) { foreach (var col in VisibleColumns) { col.WidthPercentage = 1.0 / VisibleColumns.Count; } } foreach (var header in VisibleColumns) { headers.Add(header.ColumnDisplayName); var colWidth = (int)(header.WidthPercentage * this.Width); if (header.OverflowBehavior is SmartWrapOverflowBehavior) { (header.OverflowBehavior as SmartWrapOverflowBehavior).MaxWidthBeforeWrapping = colWidth; } else if (header.OverflowBehavior is TruncateOverflowBehavior) { (header.OverflowBehavior as TruncateOverflowBehavior).ColumnWidth = colWidth; } overflowBehaviors.Add(header.OverflowBehavior); } int viewIndex = visibleRowOffset; foreach (var item in DataView.Items) { List<ConsoleString> row = new List<ConsoleString>(); int columnIndex = 0; foreach (var col in VisibleColumns) { var value = PropertyResolver(item, col.ColumnName.ToString()); var displayValue = value == null ? "<null>".ToConsoleString() : (value is ConsoleString ? (ConsoleString)value : value.ToString().ToConsoleString()); if (viewIndex == SelectedIndex) { if (this.SelectionMode == GridSelectionMode.Row || (this.SelectionMode == GridSelectionMode.Cell && columnIndex == selectedColumnIndex)) { displayValue = new ConsoleString(displayValue.ToString(), this.Background, HasFocus ? Application.Theme.FocusColor : Application.Theme.SelectedUnfocusedColor); } } row.Add(displayValue); columnIndex++; } viewIndex++; rows.Add(row); } ConsoleTableBuilder builder = new ConsoleTableBuilder(); ConsoleString table; #if PROFILING using (new TimeProfiler("Grid.FormatAsTable")) { #endif table = builder.FormatAsTable(headers, rows, RowPrefix.ToString(), overflowBehaviors, Gutter); #if PROFILING } #endif if (FilterText != null) { table = table.Highlight(FilterText, Application.Theme.HighlightContrastColor, Application.Theme.HighlightColor, StringComparison.InvariantCultureIgnoreCase); } if (DataView.IsViewComplete == false) { table += "Loading more rows...".ToConsoleString(Application.Theme.H1Color); } else if (DataView.IsViewEndOfData && DataView.Items.Count == 0) { table += NoDataMessage.ToConsoleString(Application.Theme.H1Color); } else if (DataView.IsViewEndOfData) { table += EndOfDataMessage.ToConsoleString(Application.Theme.H1Color); } else { table += "more data below".ToConsoleString(Application.Theme.H1Color); } context.DrawString(table, 0, 0); if (FilteringEnabled) { } }
/// <summary> /// You should override this method if you are building a custom control, from scratch, and need to control /// every detail of the painting process. If possible, prefer to create your custom control by deriving from /// ConsolePanel, which will let you assemble a new control from others. /// </summary> /// <param name="context">The scoped bitmap that you can paint on</param> protected virtual void OnPaint(ConsoleBitmap context) { }
protected override void OnPaint(ConsoleBitmap context) { context.Pen = new ConsoleCharacter(' ', null, myFocusStackDepth == Application.FocusManager.StackDepth ? Theme.DefaultTheme.H1Color : Theme.DefaultTheme.DisabledColor); context.DrawLine(0, 0, Width, 0); context.DrawLine(0, Height-1, Width, Height-1); base.OnPaint(context); }
protected override void OnPaint(ConsoleBitmap context) { base.OnPaint(context); context.Pen = Value; context.DrawPoint(0,0); }
/// <summary> /// paints the text box /// </summary> /// <param name="context"></param> protected override void OnPaint(ConsoleBitmap context) { var toPaint = textState.CurrentValue; var bgTransformed = new List<ConsoleCharacter>(); foreach(var c in toPaint) { if(c.BackgroundColor == ConsoleString.DefaultBackgroundColor && Background != ConsoleString.DefaultBackgroundColor) { bgTransformed.Add(new ConsoleCharacter(c.Value, Foreground, Background)); } else { bgTransformed.Add(c); } } context.DrawString(new ConsoleString(bgTransformed), 0, 0); if (blinkState) { char blinkChar = textState.CursorPosition >= toPaint.Length ? ' ' : toPaint[textState.CursorPosition].Value; context.Pen = new ConsoleCharacter(blinkChar, Application.Theme.FocusContrastColor, Application.Theme.FocusColor); context.DrawPoint(textState.CursorPosition, 0); } }