public override void OnImportAsset(AssetImportContext ctx)
{
var dataFile = ScriptableObject.CreateInstance <SvgScriptable>();
var dataFileText = File.ReadAllText(ctx.assetPath);
SvgParser.LoadScriptableFromString(dataFile, dataFileText);
dataFile.Scale(new Vector2(1, -1) * this.Scale);
if (dataFile.SvgData.Count > 0 && CenterElements)
{
Vector2 maxCorner = dataFile.SvgData[0].Points[0];
Vector2 minCorner = maxCorner;
foreach (var pt in dataFile.AllPoints)
{
maxCorner.x = Mathf.Max(maxCorner.x, pt.x);
maxCorner.y = Mathf.Max(maxCorner.y, pt.y);
minCorner.x = Mathf.Min(minCorner.x, pt.x);
minCorner.y = Mathf.Min(minCorner.y, pt.y);
}
dataFile.Move((minCorner + maxCorner) / -2);
}
ctx.AddObjectToAsset("main obj", dataFile);
ctx.SetMainObject(dataFile);
}
private void importSelectedToolStripMenuItem_Click(object sender, EventArgs e)
{
if (listView3.SelectedItems.Count > 0)
{
QntDialog q = new QntDialog();
if (q.ShowDialog() == DialogResult.OK)
{
foreach (var item in listView3.SelectedItems)
{
var t = (item as ListViewItem).Tag as FileInfo;
var svg = SvgParser.LoadSvg(t.FullName);
int src = 0;
if (polygons.Any())
{
src = polygons.Max(z => z.source.Value) + 1;
}
for (int i = 0; i < q.Qnt; i++)
{
context.ImportFromRawDetail(svg, src);
}
}
UpdateList();
}
}
}
public static BoundsD NormalizeIcon(Icon icn, int size)
{
double max = icn.bounds.w > icn.bounds.h ? icn.bounds.w : icn.bounds.h;
float factor = size / (float)max;
BoundsD bounds = new BoundsD()
{
l = double.MaxValue,
t = double.MaxValue
};
foreach (var path in icn.arr_svgpath)
{
SvgParser parser = SvgParser.FromPath(path);
parser._scaler.OffsetXY((float)-icn.bounds.l, (float)-icn.bounds.t);
parser._scaler.Scale(factor);
if (parser._bounds.w > bounds.w)
{
bounds.w = parser._bounds.w;
}
if (parser._bounds.h > bounds.h)
{
bounds.h = parser._bounds.h;
}
if (parser._bounds.l < bounds.l)
{
bounds.l = parser._bounds.l;
}
if (parser._bounds.t < bounds.t)
{
bounds.t = parser._bounds.t;
}
}
return(bounds);
}
private void listView3_MouseDoubleClick(object sender, MouseEventArgs e)
{
if (listView3.SelectedItems.Count > 0)
{
var si = listView3.SelectedItems[0].Tag;
if (si is DirectoryInfo)
{
UpdateFilesList((si as DirectoryInfo).FullName);
}
if (si is FileInfo)
{
var f = (si as FileInfo);
QntDialog q = new QntDialog();
if (q.ShowDialog() == DialogResult.OK)
{
var svg = SvgParser.LoadSvg(f.FullName);
int src = 0;
if (polygons.Any())
{
src = polygons.Max(z => z.source.Value) + 1;
}
for (int i = 0; i < q.Qnt; i++)
{
context.ImportFromRawDetail(svg, src);
}
UpdateList();
}
}
}
}
public void LoadDataFromXml(string v)
{
var d = XDocument.Load(v);
var f = d.Descendants().First();
var gap = int.Parse(f.Attribute("gap").Value);
SvgNest.Config.spacing = gap;
foreach (var item in d.Descendants("sheet"))
{
var cnt = int.Parse(item.Attribute("count").Value);
var ww = int.Parse(item.Attribute("width").Value);
var hh = int.Parse(item.Attribute("height").Value);
for (int i = 0; i < cnt; i++)
{
AddSheet(ww, hh);
}
}
foreach (var item in d.Descendants("part"))
{
var cnt = int.Parse(item.Attribute("count").Value);
var path = item.Attribute("path").Value;
var r = SvgParser.LoadSvg(path);
var src = GetNextSource();
for (int i = 0; i < cnt; i++)
{
ImportFromRawDetail(r, src);
}
}
}
static List <List <Point> > GetPointListsFromSVGPath(string svgpath, bool _debug = false)
{
List <List <Point> > result = new List <List <Point> >();
SvgParser svgp = new SvgParser();
int pointcount = 0;
svgp.parsePath(svgpath);
foreach (List <float[]> f in svgp.originPathList)
{
List <Point> segments = new List <Point>();
if (_debug)
{
Console.WriteLine("_____________");
}
for (int i = 0; i < f.Count; i++)
{
Point e = new Point(f[i][0], f[i][1]);
segments.Add(e);
if (i > 0)
{
Point a = new Point(f[i - 1][0], f[i - 1][1]);
Point b = e;
//if (_debug)
//drawLine(a, b);
}
pointcount++;
if (_debug)
{
Console.WriteLine(e.X + " " + e.Y);
}
}
result.Add(segments);
}
return(result);
}
private void toolStripButton2_Click_1(object sender, EventArgs e)
{
SaveFileDialog sfd = new SaveFileDialog();
sfd.Filter = "Svgs files (*.svg)|*.svg";
if (sfd.ShowDialog() == DialogResult.OK)
{
SvgParser.Export(sfd.FileName, polygons.ToArray(), sheets.ToArray());
}
}
VgVisualDoc ReadSvgFile(string filename)
{
string svgContent = System.IO.File.ReadAllText(filename);
VgDocBuilder docBuidler = new VgDocBuilder();
SvgParser parser = new SvgParser(docBuidler);
WebLexer.TextSnapshot textSnapshot = new WebLexer.TextSnapshot(svgContent);
parser.ParseDocument(textSnapshot);
//TODO: review this step again
VgVisualDocBuilder builder = new VgVisualDocBuilder();
return(builder.CreateVgVisualDoc(docBuidler.ResultDocument, _vgVisualDocHost));
}
MemBitmap ParseAndRenderSvg(System.Text.StringBuilder svgContent)
{
//----------
//copy from HtmlRenderer's SvgViewer demo
//----------
var docBuilder = new VgDocBuilder();
var parser = new SvgParser(docBuilder);
TextSnapshot textSnapshot = new TextSnapshot(svgContent.ToString());
parser.ParseDocument(textSnapshot);
VgVisualDocBuilder builder = new VgVisualDocBuilder();
VgVisualElement vgVisElem = builder.CreateVgVisualDoc(docBuilder.ResultDocument, _vgDocHost).VgRootElem;
PixelFarm.CpuBlit.VertexProcessing.Q1RectD bounds = vgVisElem.GetRectBounds();
float actualXOffset = (float)-bounds.Left;
float actualYOffset = (float)-bounds.Bottom;
int bmpW = (int)Math.Round(bounds.Width);
int bmpH = (int)Math.Round(bounds.Height);
if (bmpW == 0 || bmpH == 0)
{
return(null);
}
MemBitmap memBitmap = new MemBitmap(bmpW, bmpH);
using (Tools.BorrowAggPainter(memBitmap, out var p))
using (Tools.More.BorrowVgPaintArgs(p, out var paintArgs))
{
float orgX = p.OriginX;
float orgY = p.OriginY;
p.SetOrigin(actualXOffset, actualYOffset);
p.Clear(PixelFarm.Drawing.Color.White);
p.FillColor = PixelFarm.Drawing.Color.Black;
double prevStrokeW = p.StrokeWidth;
vgVisElem.Paint(paintArgs);
p.StrokeWidth = prevStrokeW; //restore
p.SetOrigin(orgX, orgY); //restore
}
return(memBitmap);
}
//--------------------->First function points here
public void LoadInputData(string path, int count)
{
var dir = new DirectoryInfo(path);
foreach (var item in dir.GetFiles("*.svg"))
{
try {
var src = GetNextSource();
for (int i = 0; i < count; i++)
{
ImportFromRawDetail(SvgParser.LoadSvg(item.FullName), src);
}
} catch (Exception ex) {
Console.WriteLine("Error loading " + item.FullName + ". skip");
}
}
}
private void listView3_SelectedIndexChanged(object sender, EventArgs e)
{
if (listView3.SelectedItems.Count > 0 && listView3.SelectedItems[0].Tag is FileInfo)
{
try
{
var path = (FileInfo)listView3.SelectedItems[0].Tag;
var svg = SvgParser.LoadSvg(path.FullName);
Preview = svg;
}
catch (Exception ex)
{
Preview = null;
}
}
}
void ParseAndRenderSvgFile(string svgFile)
{
var docBuilder = new VgDocBuilder();
var svgParser = new SvgParser(docBuilder);
//TODO: ask file content from host,
string svgContent = System.IO.File.ReadAllText(svgFile);
WebLexer.TextSnapshot textSnapshot = new WebLexer.TextSnapshot(svgContent);
svgParser.ParseDocument(textSnapshot);
//
#if DEBUG
System.Diagnostics.Debug.WriteLine(svgFile);
#endif
var vgDocBuilder = new VgVisualDocBuilder();
VgVisualElement vgVisElem = vgDocBuilder.CreateVgVisualDoc(docBuilder.ResultDocument, _vgDocHost).VgRootElem;
var uiSprite = new UISprite(10, 10);
var evListener = new GeneralEventListener();
uiSprite.AttachExternalEventListener(evListener);
evListener.MouseDown += (s, e) =>
{
//hit on svg color- area
VgHitInfo hitInfo = uiSprite.FindRenderElementAtPos(e.X, e.Y, false);
#if DEBUG
if (hitInfo.hitElem != null)
{
SvgElement domElem = hitInfo.hitElem.DomElem;
if (domElem != null && domElem.ElemId != null)
{
Console.WriteLine(domElem.ElemId);
}
}
#endif
};
uiSprite.LoadVg(vgVisElem);
_backBoard.ClearChildren();
_backBoard.Add(uiSprite);
}
public static VgVisualElement CreateVgVisualElemFromSvgContent(string svgContent)
{
VgDocBuilder docBuidler = new VgDocBuilder();
SvgParser parser = new SvgParser(docBuidler);
WebLexer.TextSnapshot textSnapshot = new WebLexer.TextSnapshot(svgContent);
parser.ParseDocument(textSnapshot);//start document parsing
//TODO: review this step again
VgVisualDocBuilder builder = new VgVisualDocBuilder();
VgDocument svgDoc = docBuidler.ResultDocument;
//optional
svgDoc.OriginalContent = svgContent;
//-------------------------------------------------------------
VgVisualElement vgVisRootElem = builder.CreateVgVisualDoc(svgDoc, null).VgRootElem;
//
vgVisRootElem.OwnerDocument = svgDoc;//tmp
return(vgVisRootElem);
}
private SvgParser.SvgPath getSvgPath(string filePath)
{
return(SvgParser.SvgParse(File.ReadAllText(filePath)));
}
protected override void OnStartDemo(SampleViewport viewport)
{
PaintLab.Svg.SvgParser parser = new SvgParser();
_backBoard = new BackDrawBoardUI(400, 400);
_backBoard.BackColor = Color.White;
viewport.AddContent(_backBoard);
box1 = new LayoutFarm.CustomWidgets.SimpleBox(50, 50);
box1.BackColor = Color.Red;
box1.SetLocation(10, 10);
//box1.dbugTag = 1;
SetupActiveBoxProperties(box1);
_backBoard.AddChild(box1);
//----------------------
//load lion svg
string file = @"d:\\WImageTest\\lion.svg";
string svgContent = System.IO.File.ReadAllText(file);
WebLexer.TextSnapshot textSnapshot = new WebLexer.TextSnapshot(svgContent);
parser.ParseDocument(textSnapshot);
//
SvgRenderVx svgRenderVx = parser.GetResultAsRenderVx();
var uiSprite = new UISprite(10, 10);
uiSprite.LoadSvg(svgRenderVx);
_backBoard.AddChild(uiSprite);
//--------
rectBoxController.Init();
//------------
viewport.AddContent(rectBoxController);
//foreach (var ui in rectBoxController.GetControllerIter())
//{
// viewport.AddContent(ui);
//}
//--------
var evListener = new GeneralEventListener();
uiSprite.AttachExternalEventListener(evListener);
evListener.MouseDown += (e) =>
{
//e.MouseCursorStyle = MouseCursorStyle.Pointer;
////--------------------------------------------
//e.SetMouseCapture(rectBoxController.ControllerBoxMain);
rectBoxController.UpdateControllerBoxes(box1);
rectBoxController.Focus();
//System.Console.WriteLine("click :" + (count++));
};
rectBoxController.ControllerBoxMain.KeyDown += (s1, e1) =>
{
if (e1.Ctrl && e1.KeyCode == UIKeys.X)
{
//test copy back image buffer from current rect area
#if DEBUG
//test save some area
int w = rectBoxController.ControllerBoxMain.Width;
int h = rectBoxController.ControllerBoxMain.Height;
using (DrawBoard gdiDrawBoard = DrawBoardCreator.CreateNewDrawBoard(1, w, h))
{
gdiDrawBoard.OffsetCanvasOrigin(rectBoxController.ControllerBoxMain.Left, rectBoxController.ControllerBoxMain.Top);
_backBoard.CurrentPrimaryRenderElement.CustomDrawToThisCanvas(gdiDrawBoard, new Rectangle(0, 0, w, h));
var img2 = new ActualImage(w, h);
//copy content from drawboard to target image and save
gdiDrawBoard.RenderTo(img2, 0, 0, w, h);
img2.dbugSaveToPngFile("d:\\WImageTest\\ddd001.png");
}
#endif
}
};
}
protected override SciterXDef.LoadResult OnLoadData(SciterXDef.SCN_LOAD_DATA sld)
{
if (sld.uri.StartsWith("tmp:tmp.svg"))
{
var icn = Joiner._iconsByHash.ToList()[1200].Value;
var path = SvgParser.FromPath(icn.arr_svgpath[0]);
//path.NormalizeToSize(100);
string xml = SvgXML.FromSvgParser(path).ToXML();
byte[] bytes = Encoding.UTF8.GetBytes(xml);
_api.SciterDataReady(sld.hwnd, sld.uri, bytes, (uint)bytes.Length);
return(SciterXDef.LoadResult.LOAD_OK);
}
else if (sld.uri.StartsWith("svg:"))
{
if (sld.uri.Contains("?rnd="))
{
sld.uri = sld.uri.Split('?')[0];
}
int length = sld.uri.Length - 8;
string hash = sld.uri.Substring(4, length);
var icn = Joiner._iconsByHash[hash];
switch (icn.kind)
{
case EIconKind.COLLECTION:
try
{
byte[] bytess = File.ReadAllBytes(icn.path);
_api.SciterDataReady(sld.hwnd, sld.uri, bytess, (uint)bytess.Length);
}
catch (Exception)
{
}
break;
case EIconKind.LIBRARY:
string xml = SvgXML.FromIcon(icn).ToXML();
byte[] bytes = Encoding.UTF8.GetBytes(xml);
_api.SciterDataReady(sld.hwnd, sld.uri, bytes, (uint)bytes.Length);
break;
case EIconKind.STORE:
if (Store.IsIconLoaded(icn))
{
byte[] bytess = File.ReadAllBytes(icn.path);
_api.SciterDataReady(sld.hwnd, sld.uri, bytess, (uint)bytess.Length);
return(SciterXDef.LoadResult.LOAD_OK);
}
else
{
Store.LoadIcon(icn).ContinueWith((t) =>
{
if (t.Status == TaskStatus.RanToCompletion)
{
byte[] bytess = File.ReadAllBytes(icn.path);
_api.SciterDataReadyAsync(sld.hwnd, sld.uri, bytess, (uint)bytess.Length, sld.requestId);
}
});
return(SciterXDef.LoadResult.LOAD_DELAYED);
}
}
return(SciterXDef.LoadResult.LOAD_OK);
}
return(base.OnLoadData(sld));
}
public static void ParseAndRenderSvg(PixelFarm.Drawing.SvgBmpBuilderReq req)
{
//----------
//copy from HtmlRenderer's SvgViewer demo
//----------
var docBuilder = new VgDocBuilder();
var parser = new SvgParser(docBuilder);
TextSnapshot textSnapshot = new TextSnapshot(req.SvgContent.ToString());
parser.ParseDocument(textSnapshot);
VgVisualDocBuilder builder = new VgVisualDocBuilder();
VgVisualElement vgVisElem = builder.CreateVgVisualDoc(docBuilder.ResultDocument, _vgDocHost).VgRootElem;
PixelFarm.CpuBlit.VertexProcessing.Q1RectD bounds = vgVisElem.GetRectBounds();
float actualXOffset = (float)-bounds.Left;
float actualYOffset = (float)-bounds.Bottom;
//original svg width, height
int bmpW = (int)Math.Round(bounds.Width);
int bmpH = (int)Math.Round(bounds.Height);
if (bmpW == 0 || bmpH == 0)
{
return;
}
//scale svg to specific size
float scale_w = req.ExpectedWidth / bmpW;
//at this point, we have 2 options
//1) create bitmap with original svg size and scale it down to expected size
//2) scale svg to expected size and create a bitmap
//we choose 2)
int new_w = (int)Math.Round(bmpW * scale_w);
int new_h = (int)Math.Round(bmpH * scale_w);
MemBitmap memBitmap = new MemBitmap(new_w, new_h);
using (Tools.BorrowAggPainter(memBitmap, out var p))
using (Tools.More.BorrowVgPaintArgs(p, out VgPaintArgs paintArgs))
{
//pass by
Affine tx = Affine.NewScaling(scale_w);
paintArgs._currentTx = tx;
float orgX = p.OriginX;
float orgY = p.OriginY;
p.SetOrigin(actualXOffset * scale_w, actualYOffset * scale_w);
p.Clear(req.DefaultBgColor);
p.FillColor = PixelFarm.Drawing.Color.Black;
double prevStrokeW = p.StrokeWidth;
vgVisElem.Paint(paintArgs);
p.StrokeWidth = prevStrokeW; //restore
p.SetOrigin(orgX, orgY); //restore
}
#if DEBUG
//memBitmap.SaveImage("svg.png");
#endif
req.Output = memBitmap;
}
