public void New(Color foreground, Color background, int width, int height)
{
int renderWidth = Math.Min(MainScreen.Instance.InnerEmptyBounds.Width, width);
int renderHeight = Math.Min(MainScreen.Instance.InnerEmptyBounds.Height, height);
hotspotSurface = new BasicSurface(renderWidth, renderHeight, Settings.Config.ScreenFont);
// Create the new text surface
surface = new LayeredSurface(width, height, new Rectangle(0, 0, renderWidth, renderHeight), 1);
// Update metadata
LayerMetadata.Create("main", false, false, true, surface.GetLayer(0));
surface.SetActiveLayer(0);
surface.Font = Settings.Config.ScreenFont;
// Update the layer management panel
layerManagementPanel.SetLayeredSurface(surface);
// Set the text surface as the one we're displaying
// Update the border
if (MainScreen.Instance.ActiveEditor == this)
{
MainScreen.Instance.RefreshBorder();
}
}
public override async Task <IDisplayResult> EditAsync(ContentItem model, BuildEditorContext context)
{
var layerMetadata = model.As <LayerMetadata>();
if (layerMetadata == null)
{
layerMetadata = new LayerMetadata();
// Are we loading an editor that requires layer metadata?
if (await context.Updater.TryUpdateModelAsync(layerMetadata, "LayerMetadata", m => m.Zone, m => m.Position) &&
!String.IsNullOrEmpty(layerMetadata.Zone))
{
model.Weld(layerMetadata);
}
else
{
return(null);
}
}
return(Shape <LayerMetadataEditViewModel>("LayerMetadata_Edit", async shape =>
{
shape.LayerMetadata = layerMetadata;
shape.Layers = (await _layerService.GetLayersAsync()).Layers;
})
.Location("Content:before"));
}
void addNewLayerFromFile_Click(object sender, EventArgs e)
{
SelectFilePopup popup = new SelectFilePopup();
popup.Closed += (o2, e2) =>
{
if (popup.DialogResult)
{
BasicSurface newSurface = BasicSurface.Load(popup.SelectedFile);
if (newSurface.Width != surface.Width || newSurface.Height != surface.Height)
{
var tempSurface = new BasicSurface(surface.Width, surface.Height, surface.Font);
newSurface.Copy(tempSurface);
var newLayer = surface.Add(tempSurface);
LayerMetadata.Create("Loaded", true, true, true, newLayer);
}
else
{
var layer = surface.Add(newSurface);
LayerMetadata.Create("Loaded", true, true, true, layer);
}
surface.IsDirty = true;
RebuildListBox();
}
};
popup.CurrentFolder = Environment.CurrentDirectory;
popup.FileLoaderTypes = new FileLoaders.IFileLoader[] { new FileLoaders.BasicSurface() };
popup.Show(true);
popup.Center();
}
void addNewLayer_Click(object sender, EventArgs e)
{
var previouslySelected = layers.SelectedItem;
LayerMetadata.Create("new", true, true, true, surface.Add());
RebuildListBox();
layers.SelectedItem = previouslySelected;
surface.IsDirty = true;
}
private void RenderRegionPrimitive(Graphics g, PcbRegion region)
{
var brushColor = LayerMetadata.GetColor(region.Layer);
using (var brush = new SolidBrush(brushColor))
{
var outline = region.Outline.Select(coordxy => ScreenFromWorld(coordxy)).ToArray();
g.FillPolygon(brush, outline);
}
}
private void RenderComponentBodyPrimitive(Graphics g, PcbComponentBody body)
{
var brushColor = LayerMetadata.GetColor(body.Layer);
using (var brush = new HatchBrush(HatchStyle.ForwardDiagonal, brushColor, Color.Transparent))
using (var pen = CreatePen(brushColor, 0))
{
var outline = body.Outline.Select(coordxy => ScreenFromWorld(coordxy)).ToArray();
g.FillPolygon(brush, outline);
g.DrawPolygon(pen, outline);
}
}
private void RenderFillPrimitive(Graphics g, PcbFill fill)
{
var brushColor = LayerMetadata.GetColor(fill.Layer);
using (var brush = new SolidBrush(brushColor))
{
var worldRect = new CoordRect(fill.Corner1, fill.Corner2);
var worldPoints = worldRect.RotatedPoints(worldRect.Center, fill.Rotation);
var screenPoints = worldPoints.Select(cp => ScreenFromWorld(cp)).ToArray();
g.FillPolygon(brush, screenPoints);
}
}
private void RenderTrackPrimitive(Graphics g, PcbTrack track)
{
var penColor = LayerMetadata.GetColor(track.Layer);
var penWidth = ScaleCoord(track.Width);
using (var pen = CreatePen(penColor, penWidth))
{
g.DrawLine(pen,
ScreenFromWorld(track.Start.X, track.Start.Y),
ScreenFromWorld(track.End.X, track.End.Y));
}
}
public override async Task <IDisplayResult> UpdateAsync(ContentItem model, UpdateEditorContext context)
{
var layerMetadata = new LayerMetadata();
if (!await context.Updater.TryUpdateModelAsync(layerMetadata, "LayerMetadata", m => m.Zone, m => m.Position, m => m.RenderTitle, m => m.Title, m => m.Layer) ||
String.IsNullOrEmpty(layerMetadata.Zone))
{
return(null);
}
model.Apply(layerMetadata);
return(await EditAsync(model, context));
}
private void RenderTextPrimitive(Graphics g, PcbText text)
{
var location = ScreenFromWorld(text.Corner1.X, text.Corner1.Y);
var color = LayerMetadata.GetColor(text.Layer);
var height = ScaleCoord(text.Height);
var fontStyle = (text.FontItalic ? FontStyle.Italic : FontStyle.Regular) | (text.FontBold ? FontStyle.Bold : FontStyle.Regular);
float fontWidth;
float fontSize;
if (text.TextKind == PcbTextKind.Stroke)
{
fontWidth = ScaleCoord(text.Width);
fontSize = DrawingUtils.CalculateFontSizeForBaseline(g, StrokeFontFamily, fontStyle, height + fontWidth);
}
else
{
fontWidth = 0;
fontSize = DrawingUtils.CalculateFontSizeForHeight(g, StrokeFontFamily, fontStyle, height);
}
g.TranslateTransform(location.X, location.Y);
g.RotateTransform(-(float)text.Rotation);
using (var brush = new SolidBrush(color))
using (var fontFamily = new FontFamily(text.FontName))
using (var font = new Font(text.TextKind == PcbTextKind.Stroke ? StrokeFontFamily : fontFamily, fontSize, fontStyle))
{
var size = g.MeasureString(text.Text, font);
if (size.Height < 5)
{
using (var pen = new Pen(brush))
{
var rect = ScaleRect(text.CalculateRect(false));
g.DrawRectangle(pen, rect.Left, rect.Top, rect.Width, rect.Height);
}
}
else
{
if (text.Mirrored)
{
g.ScaleTransform(-1.0f, 1.0f);
}
DrawingUtils.DrawString(g, text.Text, font, brush, 0, fontWidth * 0.5f,
StringAlignmentKind.Tight, StringAlignment.Near, StringAlignment.Far);
}
}
g.ResetTransform();
}
public void New(Color foreground, Color background, int width, int height)
{
Reset();
int renderWidth = Math.Min(MainScreen.Instance.InnerEmptyBounds.Width, width);
int renderHeight = Math.Min(MainScreen.Instance.InnerEmptyBounds.Height, height);
surface = new SadConsole.Surfaces.LayeredSurface(width, height, SadConsoleEditor.Settings.Config.ScreenFont, new Rectangle(0, 0, renderWidth, renderHeight), 1);
LayerMetadata.Create("Root", true, false, true, surface.ActiveLayer);
var editor = new SurfaceEditor(surface);
editor.FillWithRandomGarbage();
layerManagementPanel.SetLayeredSurface(surface);
layerManagementPanel.IsCollapsed = true;
}
private void DrawPad(Graphics g, PcbPad pad, PcbPadPart padPart)
{
PcbPadShape shape;
int cornerRadiusPercent;
Color color;
// setup parameters according to the current padPart
switch (padPart)
{
case PcbPadPart.TopLayer:
shape = pad.ShapeTop;
cornerRadiusPercent = pad.CornerRadiusTop;
color = LayerMetadata.GetColor(pad.Layer);
break;
case PcbPadPart.BottomLayer:
shape = pad.ShapeBottom;
cornerRadiusPercent = pad.CornerRadiusBot;
color = LayerMetadata.GetColor(pad.Layer);
break;
case PcbPadPart.TopSolder:
shape = pad.ShapeTop;
cornerRadiusPercent = pad.CornerRadiusTop;
color = LayerMetadata.GetColor("TopSolder");
break;
case PcbPadPart.BottomSolder:
shape = pad.ShapeBottom;
cornerRadiusPercent = pad.CornerRadiusBot;
color = LayerMetadata.GetColor("BottomSolder");
break;
default:
return;
}
var rect = ScaleRect(pad.CalculatePartRect(padPart, false));
using (var brush = new SolidBrush(color))
{
switch (shape)
{
case PcbPadShape.Round:
DrawingUtils.FillRoundedRect(g, brush, rect, 100);
break;
case PcbPadShape.Rectangular:
DrawingUtils.FillRectangle(g, brush, rect);
break;
case PcbPadShape.Octogonal:
DrawingUtils.FillOctagon(g, brush, rect);
break;
case PcbPadShape.RoundedRectangle:
cornerRadiusPercent = cornerRadiusPercent > 0 ? cornerRadiusPercent : 100;
DrawingUtils.FillRoundedRect(g, brush, rect, cornerRadiusPercent);
break;
default:
return;
}
}
}
