#usage "Eagle schematic exporting tool version 1.3 \n"
"
"
"This ULP can convert an Eagle CAD schematics into SVG files."
"
"
"Load any schematic and execute the ULP in the eagle."
"
"
"For drill holes to show up correctly enable DRILLS layer, and set its color to white (light gray)"
"
"
"For dimensions to show up correctly change its color to anything but white (light gray), and set its wire width to non-zero."
"
"
"Author: xtitoris
"
"based on eagle2svg by nils.springob@nicai-systems.de
"
"
"
"Known issues in board export:
"
"- elongated pads are not supported"
"
- non vector-text is not rotated correctly"
"
- layers are not placed correctly"
"
"
real VERSION = 1.3;
string DESCR = "";
/*
* CHANGELOG================================================
* 1.3 (02.07.2012): Fixed pads output, added dimensions output for Eagle 6
* 1.2 (29.11.2010): Fixed drill holes, optimized stylesheet generation
* 1.1 (??.04.2008): SVG export for board files
* 1.0 (16.04.2008): Some bugfixes
* 0.2 (11.04.2008): Using CSS for layer-styles
* 0.1 (08.03.2008): Initial version
*
*/
/* ==========================================================================
* License: This file is released under the license of the GNU Public license
* Version 2.
* ==========================================================================*/
int g_monochrome = 0;
int g_only_visible = 1;
int g_used_layers[];
int current_layer = 0;
//------------------------------------------------------
// generate html color code
//------------------------------------------------------
string htmlcolor(int col)
{
string result;
sprintf(result, "#%06x", col);
return result;
}
//------------------------------------------------------
// replace xml reserved chars and build 2-byte utf-8 characters
//------------------------------------------------------
string encodeText(string strText)
{
string newText = "";
int i=0;
while (strText[i])
{
char c = strText[i++];
switch(c)
{
case '<': newText += "<"; break;
case '>': newText += ">"; break;
case '&': newText += "&"; break;
case '°': newText += "°"; break;
default:
if (c>=0xc0)
{
newText += char(0xc3);
newText += char(c-0x40);
}
else if (c>=0x80)
{
newText += char(0xc2);
newText += char(c);
}
else
{
newText += c;
}
}
}
return newText;
}
//------------------------------------------------------
// SVG output functions
//------------------------------------------------------
string svgLineStyle(int width, int cap)
{
string lineCap="round";
switch (cap)
{
case CAP_FLAT: lineCap = "butt"; break;
case CAP_ROUND: lineCap = "round"; break;
default: lineCap = "round"; break;
}
string style;
sprintf(style, "stroke-width:%f; stroke-linecap:%s",
u2mm(width), lineCap);
return style;
}
string svgTransform(int x, int y, real angle)
{
string trans, rot, res;
sprintf(trans, "translate(%f,%f)", u2mm(x), u2mm(-y));
sprintf(rot, "rotate(%f)", -angle);
return "transform='"+trans+" "+rot+"'";
}
void svgWriteLine(int x1, int y1, int x2, int y2, int layer, string style)
{
printf("\n",
layer,
u2mm(x1), u2mm(-y1),
u2mm(x2), u2mm(-y2),
style);
}
void svgWriteArc(int x1, int y1, int x2, int y2, int radius, char longpath, int layer, string style)
{
printf("\n",
layer,
u2mm(x1), u2mm(-y1),
u2mm(radius), u2mm(radius),
longpath,
u2mm(x2), u2mm(-y2),
style);
}
void svgWriteRect(int x1, int y1, int x2, int y2, real angle, int layer)
{
if (g_used_layers[layer]==0)
{
return;
}
string rotation="";
if (angle!=0.0)
{
sprintf(rotation, " transform='rotate(%f,%f,%f)'",
-angle,
u2mm(x1+x2)/2.0, u2mm(-y1-y2)/2.0);
}
printf("\n",
layer,
u2mm(x1), u2mm(-y2),
u2mm(x2-x1), u2mm(y2-y1),
rotation);
}
void svgWriteRectCenter(int x, int y, int dx, int dy, real angle, int layer)
{
if (g_used_layers[layer]==0)
{
return;
}
string rotation = svgTransform(x, y, angle);
printf("\n",
layer,
u2mm(-dx/2), u2mm(-dy/2),
u2mm(dx), u2mm(dy),
rotation);
}
void svgWriteOctCenter(int x, int y, int dx, int dy, real angle, int layer)
{
if (g_used_layers[layer]==0)
{
return;
}
string rotation = svgTransform(x, y, angle);
real x1 = u2mm(dx)/2;
real y1 = u2mm(dy)/2;
real x2 = u2mm(dx)/(2*(1+1.414213562));
real y2 = u2mm(dy)/(2*(1+1.414213562));
printf("\n",
layer,
-x1, -y2,
-x2, -y1,
x2, -y1,
x1, -y2,
x1, y2,
x2, y1,
-x2, y1,
-x1, y2,
rotation);
}
void svgWriteRoundRectCenter(int x, int y, int w, int h, int roundness, real angle, int layer)
{
if (g_used_layers[layer]==0)
{
return;
}
string rotation = svgTransform(x, y, angle);
if (w\n",
layer,
u2mm(-w/2), u2mm(-h/2),
u2mm(w), u2mm(h),
u2mm(roundness),
rotation);
}
void svgWriteCircle(int x, int y, int radius, int lwidth, int layer)
{
if (g_used_layers[layer]==0) {
return;
}
printf("\n",
layer,
u2mm(x), u2mm(-y),
u2mm(radius),
u2mm(lwidth));
}
void svgWriteDot(int x, int y, int diameter, int layer)
{
if (g_used_layers[layer]==0)
{
return;
}
printf("\n",
layer,
u2mm(x), u2mm(-y),
u2mm(diameter)/2.0);
}
void svgWritePathStart(int layer, string style)
{
printf( "\n");
}
void svgWriteText(int x, int y, real angle, char align, string text, int size, int layer)
{
if (g_used_layers[layer]==0)
{
return;
}
string style;
sprintf(style, "font-size:%fpt;", u2mm(size)*1.1);
if (align=='e')
{
style += " text-anchor:end;";
}
if (angle==0.0)
{
printf( "%s\n",
layer,
u2mm(x), u2mm(-y),
style,
text);
}
else
{
printf( "%s\n",
layer,
style,
u2mm(x), u2mm(-y),
angle,
text);
}
}
//------------------------------------------------------
// write UL piece
//------------------------------------------------------
void write_piece(UL_WIRE W)
{
if (g_used_layers[W.layer]==0)
{
return;
}
string style = svgLineStyle(W.width, W.cap);
if (W.arc)
{
char longpath;
if( abs(W.arc.angle2-W.arc.angle1) < 180.0 )
{
longpath='0';
}
else
{
longpath='1';
}
svgWriteArc(W.arc.x1, W.arc.y1, W.arc.x2, W.arc.y2, W.arc.radius, longpath, W.layer, style);
}
else
{
svgWriteLine(W.x1, W.y1, W.x2, W.y2, W.layer, style);
}
}
//------------------------------------------------------
// write UL wire
//------------------------------------------------------
void write_wire(UL_WIRE W)
{
if (g_used_layers[W.layer]==0)
{
return;
}
if ( W.style == WIRE_STYLE_LONGDASH || W.style == WIRE_STYLE_SHORTDASH || W.style == WIRE_STYLE_DASHDOT )
{
W.pieces(P)
{
write_piece(P);
}
}
else if (W.arc)
{
string style = svgLineStyle(W.arc.width, W.cap);
char longpath;
if( abs(W.arc.angle2-W.arc.angle1) < 180.0 )
{
longpath='0';
}
else
{
longpath='1';
}
svgWriteArc(W.arc.x1, W.arc.y1, W.arc.x2, W.arc.y2, W.arc.radius, longpath, W.layer, style);
}
else
{
string style = svgLineStyle(W.width, W.cap);
svgWriteLine(W.x1, W.y1, W.x2, W.y2, W.layer, style);
}
}
//------------------------------------------------------
// write UL rectangle
//------------------------------------------------------
void write_rectangle(UL_RECTANGLE R)
{
if (g_used_layers[R.layer]==0)
{
return;
}
svgWriteRect(R.x1, R.y1, R.x2, R.y2, R.angle, R.layer);
}
//------------------------------------------------------
// write UL vector text
//------------------------------------------------------
void write_vector_text(UL_TEXT T)
{
/*
if (g_used_layers[T.layer]==0)
{ return; }
*/
int cnt=0;
T.wires(W)
{
string lineCap;
if (cnt==0)
{
string style = svgLineStyle(W.width, W.cap);
svgWritePathStart(W.layer, style);
}
svgWritePathSegment(W.x1, W.y1, W.x2, W.y2);
cnt++;
}
if (cnt>0)
{
svgWritePathEnd();
}
}
//------------------------------------------------------
// write UL proportional text
//------------------------------------------------------
void write_prop_text(UL_TEXT T)
{
/*
if (g_used_layers[T.layer]==0)
{ return; }
*/
string newText = encodeText(T.value);
int posX = T.x;
int posY = T.y;
int textAngle = T.angle;
int textSize = T.size;
char hmode, vmode, rmode;
if( T.mirror > 0 )
{
switch( textAngle )
{
case 0: vmode='e'; hmode='b'; rmode='0'; break;
case 90: vmode='b'; hmode='t'; rmode='9'; break;
case 180: vmode='b'; hmode='t'; rmode='0'; break;
case 270: vmode='e'; hmode='b'; rmode='9'; break;
}
}
else
{
switch( textAngle )
{
case 0: vmode='b'; hmode='b'; rmode='0'; break;
case 90: vmode='b'; hmode='b'; rmode='9'; break;
case 180: vmode='e'; hmode='t'; rmode='0'; break;
case 270: vmode='e'; hmode='t'; rmode='9'; break;
default: vmode='b'; hmode='-'; rmode='-'; break;
}
}
if (rmode=='-')
{
svgWriteText(posX, posY, -textAngle, vmode, newText, textSize, T.layer);
}
else
if (rmode=='0')
{
if (hmode=='t')
{
posY -= textSize;
}
svgWriteText(posX, posY, 0.0, vmode, newText, textSize, T.layer);
}
else
{
if (hmode=='t')
{
posX += textSize;
}
svgWriteText(posX, posY, -90.0, vmode, newText, textSize, T.layer);
}
}
//------------------------------------------------------
// write UL general text
//------------------------------------------------------
void write_text(UL_TEXT T)
{
if (g_used_layers[T.layer] == 0)// && (current_layer != 0 || T.layer != current_layer))
{ return; }
if (T.font==FONT_VECTOR)
{
write_vector_text(T);
}
else
{
write_prop_text(T);
}
}
//------------------------------------------------------
// write UL circle
//------------------------------------------------------
void write_circle(UL_CIRCLE C)
{
if (g_used_layers[C.layer]==0)
{
return;
}
svgWriteCircle(C.x, C.y, C.radius, C.width, C.layer);
}
//------------------------------------------------------
// write drillsymbol
//------------------------------------------------------
void write_drill(int x, int y, int drill, int layer)
{
if (g_used_layers[layer]==0)
{
return;
}
svgWriteDot(x, y, drill, layer);
}
//------------------------------------------------------
// write restring
//------------------------------------------------------
void write_restring(int x, int y, int diameter, int shape, int long, real angle, int layer)
{
/*
if (g_used_layers[layer]==0)
{ return; }
*/
switch(shape)
{
case PAD_SHAPE_SQUARE:
svgWriteRectCenter(x, y, diameter, diameter, angle, layer);
break;
case PAD_SHAPE_OCTAGON:
svgWriteOctCenter(x, y, diameter, diameter, angle, layer);
break;
case PAD_SHAPE_LONG:
svgWriteRoundRectCenter(x, y, (diameter*long)/100, diameter, 100, angle, layer);
break;
case PAD_SHAPE_OFFSET:
case PAD_SHAPE_ANNULUS:
case PAD_SHAPE_THERMAL:
case PAD_SHAPE_ROUND:
default:
svgWriteDot(x, y, diameter, layer);
}
}
//------------------------------------------------------
// write UL pad
//------------------------------------------------------
void write_pad(UL_PAD P)
{
int layer;
if (P.flags&PAD_FLAG_STOP)
{
write_restring(P.x, P.y, P.diameter[LAYER_TSTOP], P.shape[LAYER_TSTOP], 100+P.elongation, P.angle, LAYER_TSTOP);
write_restring(P.x, P.y, P.diameter[LAYER_BSTOP], P.shape[LAYER_BSTOP], 100+P.elongation, P.angle, LAYER_BSTOP);
}
for (layer=LAYER_TOP; layer<=LAYER_BOTTOM ; ++layer)
{
if (g_used_layers[layer])
{
write_restring(P.x, P.y, P.diameter[layer], P.shape[layer], 100+P.elongation, P.angle, layer);
}
}
if (g_used_layers[LAYER_PADS])
{
int diameter = P.diameter[LAYER_PADS];
//Hack for pads layer
if (diameter == 0)
{ diameter = P.diameter[LAYER_TOP]; }
write_restring(P.x, P.y, diameter, P.shape[layer], 100+P.elongation, P.angle, layer);
//printf("AAAAAAA\nx=%d; y=%d; d=%d; shape=%d; layer=%d\n",P.x, P.y, P.diameter[layer], P.shape[layer], layer);
}
write_drill(P.x, P.y, P.drill, LAYER_DRILLS);
}
//------------------------------------------------------
// write UL smd
//------------------------------------------------------
void write_smd(UL_SMD S)
{
if (S.layer==LAYER_TOP)
{
if (S.flags & SMD_FLAG_STOP)
{
svgWriteRoundRectCenter(S.x, S.y, S.dx[LAYER_TSTOP], S.dy[LAYER_TSTOP], S.roundness, S.angle, LAYER_TSTOP);
}
if (S.flags & SMD_FLAG_CREAM)
{
svgWriteRoundRectCenter(S.x, S.y, S.dx[LAYER_TCREAM], S.dy[LAYER_TCREAM], S.roundness, S.angle, LAYER_TCREAM);
}
svgWriteRoundRectCenter(S.x, S.y, S.dx[LAYER_TOP], S.dy[LAYER_TOP], S.roundness, S.angle, LAYER_TOP);
}
else if (S.layer==LAYER_BOTTOM)
{
if (S.flags & SMD_FLAG_STOP)
{
svgWriteRoundRectCenter(S.x, S.y, S.dx[LAYER_BSTOP], S.dy[LAYER_BSTOP], S.roundness, S.angle, LAYER_BSTOP);
}
if (S.flags & SMD_FLAG_CREAM)
{
svgWriteRoundRectCenter(S.x, S.y, S.dx[LAYER_BCREAM], S.dy[LAYER_BCREAM], S.roundness, S.angle, LAYER_BCREAM);
}
svgWriteRoundRectCenter(S.x, S.y, S.dx[LAYER_BOTTOM], S.dy[LAYER_BOTTOM], S.roundness, S.angle, LAYER_BOTTOM);
}
}
//------------------------------------------------------
// write UL via
//------------------------------------------------------
void write_via(UL_VIA V)
{
int layer;
if (V.flags&VIA_FLAG_STOP)
{
write_restring(V.x, V.y, V.diameter[LAYER_TSTOP], V.shape[LAYER_TSTOP], 100, 0.0, LAYER_TSTOP);
write_restring(V.x, V.y, V.diameter[LAYER_BSTOP], V.shape[LAYER_BSTOP], 100, 0.0, LAYER_BSTOP);
}
for (layer=V.start; layer<=V.end; ++layer)
{
if (g_used_layers[layer])
{
write_restring(V.x, V.y, V.diameter[layer], V.shape[layer], 100, 0.0, layer);
}
}
write_drill(V.x, V.y, V.drill, LAYER_DRILLS);
}
//------------------------------------------------------
// write UL hole
//------------------------------------------------------
void write_hole(UL_HOLE H)
{
svgWriteCircle(H.x, H.y, H.drill/2, 1, LAYER_DIMENSION);
write_drill(H.x, H.y, H.drill, LAYER_HOLES);
}
//------------------------------------------------------
// write UL segment
//------------------------------------------------------
void write_segment(UL_SEGMENT SEG)
{
int layer = 0;
SEG.wires(W)
{
layer = W.layer;
write_wire(W);
}
SEG.junctions(J)
{
svgWriteDot(J.x, J.y, J.diameter, layer);
}
SEG.texts(T)
{
write_text(T);
}
}
//------------------------------------------------------
// write UL polygon
//------------------------------------------------------
void write_polygon(UL_POLYGON P)
{
if (g_used_layers[P.layer]==0)
{
return;
}
int count = 0;
printf( "\n" );
}
//------------------------------------------------------
// write filled UL polygon
//------------------------------------------------------
void write_filled_polygon(UL_POLYGON P)
{
if (g_used_layers[P.layer]==0)
{ return; }
string style;
int first=1;
P.contours(W)
{
if (first)
{
string style = svgLineStyle(W.width, W.cap);
svgWritePathStart(P.layer, style);
first=0;
}
svgWritePathSegment(W.x1, W.y1, W.x2, W.y2);
}
P.fillings(W)
{
svgWritePathSegment(W.x1, W.y1, W.x2, W.y2);
}
svgWritePathEnd();
}
//------------------------------------------------------
// write UL bus
//------------------------------------------------------
void write_bus(UL_BUS B)
{
printf("BUS %s\n", encodeText(B.name));
B.segments(SEG) { write_segment(SEG); }
printf("\n");
}
//------------------------------------------------------
// write UL net
//------------------------------------------------------
void write_net(UL_NET N)
{
printf("NET %s\n", encodeText(N.name));
N.segments(SEG) { write_segment(SEG); }
printf("\n");
}
//------------------------------------------------------
//write UL signal
//------------------------------------------------------
void write_signal(UL_SIGNAL S)
{
S.polygons(P) {write_filled_polygon(P);}
S.wires(W) {write_wire(W);}
S.vias(V) {write_via(V);}
}
//------------------------------------------------------
//write UL pin
//------------------------------------------------------
void write_pin(UL_PIN P)
{
P.wires(W) {write_wire(W);}
P.circles(C) {write_circle(C);}
P.texts(T) {write_text(T);}
}
//------------------------------------------------------
//write UL symbol
//------------------------------------------------------
void write_symbol(UL_SYMBOL S)
{
S.polygons(P) {write_polygon(P);}
S.circles(C) {write_circle(C);}
S.rectangles(R) {write_rectangle(R);}
S.pins(P) {write_pin(P);}
S.wires(W) {write_wire(W);}
S.texts(T) {write_text(T);}
}
//------------------------------------------------------
//write UL gate
//------------------------------------------------------
void write_gate(UL_GATE G)
{
write_symbol(G.symbol);
}
//------------------------------------------------------
//write UL instance
//------------------------------------------------------
void write_instance(UL_INSTANCE I)
{
printf("PART %s\n", encodeText(I.name));
write_gate(I.gate);
I.texts(T) {write_text(T);}
printf("\n");
}
//------------------------------------------------------
//write UL part
//------------------------------------------------------
void write_part(UL_PART P)
{
P.instances(I)
{
write_instance(I);
}
}
//------------------------------------------------------
//write UL contact
//------------------------------------------------------
void write_contact(UL_CONTACT C)
{
if (C.pad)
write_pad(C.pad);
else if (C.smd)
write_smd(C.smd);
}
//------------------------------------------------------
//write UL package
//------------------------------------------------------
void write_package(UL_PACKAGE PKG)
{
PKG.polygons(P) {write_polygon(P);}
PKG.rectangles(R) {write_rectangle(R);}
PKG.wires(W) {write_wire(W);}
PKG.circles(C) {write_circle(C);}
PKG.texts(T) {write_text(T);}
PKG.contacts(C) {write_contact(C);}
PKG.holes(H) {write_hole(H);}
}
//------------------------------------------------------
//write UL element
//------------------------------------------------------
void write_element(UL_ELEMENT E)
{
printf("PART %s\n", encodeText(E.name));
E.texts(T) {write_text(T);}
write_package(E.package);
printf("\n");
}
//------------------------------------------------------
//write UL dimension
//------------------------------------------------------
void write_dimension(UL_DIMENSION D)
{
if (g_used_layers[D.layer] == 0)// && D.layer != layer)
{ return; }
printf("DIMENSION\n");
D.texts(T) {write_text(T);}
D.wires(W) {write_wire(W);}
printf("\n");
}
//------------------------------------------------------
//write layer stylesheet to svg file
//------------------------------------------------------
void write_svg_layerStyle (UL_LAYER L)
{
string color;
if (g_monochrome && L.color!=15) //White should stay white
color = htmlcolor(0);
else
color = htmlcolor(palette(L.color)&0x00ffffff);
printf ("path.l%d {stroke:%s; fill:none; }\n", L.number, color);
printf ("line.l%d {stroke:%s; fill:none; }\n", L.number, color);
printf ("circle.l%d {stroke:%s; fill:none; }\n", L.number, color);
printf ("circle.j%d {fill:%s; }\n", L.number, color);
printf ("rect.l%d {fill:%s; }\n", L.number, color);
printf ("text.l%d {font-family:sans-serif; fill:%s; }\n", L.number, color);
printf ("polygon.l%d {fill:%s; }\n", L.number, color);
}
void write_sheet_styles()
{
printf ("\n");
printf ("\n");
printf ("\n");
}
void update_used_sheet_layers(UL_SCHEMATIC SCH)
{
SCH.layers(L)
{
int used = L.used;
if (g_only_visible)
{
used &= L.visible;
}
g_used_layers[L.number]=used;
}
}
//------------------------------------------------------
//write svg header
//------------------------------------------------------
void write_sheet_header(UL_SHEET SH)
{
int t = time();
int pageCount = 0;
string header = "\n";
header += "\n";
printf(footer);
}
//------------------------------------------------------
//write whole sheet
//------------------------------------------------------
void write_svg_sheet(string fileName)
{
output(fileName, "Fwt")
{
if(sheet)
{
sheet(SH)
{
schematic(SCH)
{
update_used_sheet_layers(SCH);
}
write_sheet_header(SH);
SH.texts(T) {write_text(T);}
SH.wires(W) {write_wire(W);}
SH.nets(N) {write_net(N);}
SH.busses(B) {write_bus(B);}
SH.rectangles(R) {write_rectangle(R);}
SH.polygons(P) {write_polygon(P);}
SH.circles(C) {write_circle(C);}
SH.parts(P) {write_part(P);}
write_sheet_footer(SH);
}
}
}
}
void update_used_board_layers(UL_BOARD B)
{
B.layers(L)
{
int used = L.used;
if (g_only_visible)
{
used &= L.visible;
}
g_used_layers[L.number]=used;
}
}
//------------------------------------------------------
//write svg board styles
//------------------------------------------------------
void write_board_styles()
{
printf ("\n");
printf ("\n");
printf ("\n");
}
//------------------------------------------------------
//write svg board header
//------------------------------------------------------
void write_board_header(UL_BOARD B)
{
int t = time();
int pageCount = 0;
string header = "\n";
header += "\n";
printf(footer);
}
//------------------------------------------------------
//write whole board
//------------------------------------------------------
void write_svg_board(string fileName)
{
output(fileName, "Fwt")
{
if(board)
{
board(B)
{
update_used_board_layers(B);
write_board_header(B);
//B.layers(L)
{
//current_layer = L.number;
B.texts(T) {write_text(T);}
B.circles(C) {write_circle(C);}
B.rectangles(R) {write_rectangle(R);}
B.polygons(P) {write_filled_polygon(P);}
B.signals(S) {write_signal(S);}
B.wires(W) {write_wire(W);}
B.elements(E) {write_element(E);}
B.holes(H) {write_hole(H);}
B.dimensions(D) {write_dimension(D);}
}
write_board_footer(B);
}
}
}
}
//------------------------------------------------------
// Global mod_ and lib_name
//------------------------------------------------------
string sch_name;
//------------------------------------------------------
// Select the path where the schematic will be saved
//------------------------------------------------------
void openSchematicPath(string startPath)
{
string dirName = "";
string stringArray[];
dirName = dlgDirectory("Select a directory", startPath);
if( dirName != "" )
{
schematic(S)
{
int n = 0;
string tmpName = S.name;
int nr = strsplit(stringArray, tmpName, '/');
sch_name = dirName + "/" + stringArray[nr-1];
sch_name = strsub(sch_name , 0, strlen(sch_name) - 4) + ".ps";
}
}
}
int displayDialog(string titleStr)
{
int space = 10;
int result = dlgDialog(titleStr)
{
dlgVBoxLayout
{
dlgVBoxLayout
{
dlgHBoxLayout dlgSpacing(500);
dlgStretch(0);
dlgSpacing(space);
dlgLabel("Export to file:");
dlgStretch(0);
dlgHBoxLayout
{
dlgSpacing(space);
dlgStringEdit(sch_name);
dlgSpacing(space);
dlgPushButton("...") openSchematicPath("C:\\");
dlgSpacing(space);
}
dlgHBoxLayout
{
dlgVBoxLayout
{
dlgCheckBox("Monochrome", g_monochrome);
dlgCheckBox("Only visible", g_only_visible);
}
dlgVBoxLayout
{
//dlgLabel("READ USAGE INFO!");
}
}
dlgStretch(10);
dlgLabel("developed by xtitoris@gmail.com, based on eagle2svg by nils.springob@nicai-systems.de");
}
dlgStretch(0);
dlgHBoxLayout
{
dlgStretch(1);
dlgPushButton("+OK") dlgAccept();
dlgSpacing(space);
dlgPushButton("-Cancel") dlgReject();
dlgStretch(0);
dlgSpacing(space);
}
dlgStretch(10);
}
};
return result;
}
//------------------------------------------------------
// main program
//------------------------------------------------------
string ref;
string titleStr;
sprintf(titleStr, "Export Eagle sheet to SVG, Version: %.1f", VERSION);
if (schematic)
{
schematic(S)
{
sheet(SH)
{
sprintf(sch_name, "%s_p%d.svg", strsub(S.name, 0, strlen(S.name) - 4), SH.number);
}
}
if(displayDialog(titleStr))
{
write_svg_sheet(sch_name);
}
exit(EXIT_SUCCESS);
}
else if (board)
{
board(B)
{
sprintf(sch_name, "%s_brd.svg", strsub(B.name, 0, strlen(B.name) - 4));
}
if(displayDialog(titleStr))
{
write_svg_board(sch_name);
}
exit(EXIT_SUCCESS);
}
else
{
dlgMessageBox("Please run from schematic or board editor." );
exit(EXIT_FAILURE);
}