#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:

" 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 += "%s - sheet %d\n", encodeText(SCH.name), SH.number); printf("generated by eagle2svg %.1f, developed by http://www.nicai-systems.de\n", VERSION); } write_sheet_styles(); printf ("\n"); } //------------------------------------------------------ //write svg footer //------------------------------------------------------ void write_sheet_footer(UL_SHEET SH) { string footer = "\n"; footer += "\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 += "%s\n", encodeText(B.name)); printf("generated by eagle2svg %.1f, %s\n", VERSION, DESCR); write_board_styles(); printf ("\n"); } //------------------------------------------------------ //write svg board footer //------------------------------------------------------ void write_board_footer(UL_BOARD B) { string footer = "\n"; footer += "\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); }