#usage "en: Output of a <b>Sch</b>ematic (or Board) as "
"<b>W</b>indows <b>M</b>eta <b>F</b>ile "
"for convenient embedding into office documents and searchable strings in resulting PDFs<p>\n"
"Only visible layers will be processed.<p>"
"Command-line arguments are: [arguments] [filename]<br>\n"
"Possible arguments see SCH2WMF.TXT.\n"
"<hr>"
"<author>Author: <A href='mailto:henrik.haftmann@e-technik.tu-chemnitz.de'"
">Henrik Haftmann</A>,<br>"
"latest version: <A href=http://www.tu-chemnitz.de/~heha/hs_freeware/sch2wmf/"
">TU Chemnitz</A></author>",
"de: Ausgabe eines <b>Sch</b>altplanes (oder Boards) als "
"<b>W</b>indows-<b>M</b>eta-Datei (<b>F</b>ile) "
"für bequemen Dokument-Import sowie String-Suchmöglichkeit in PDFs<p>\n"
"Es werden nur die gerade sichtbaren Layer ausgegeben.<br>"
"Kommandozeilenargumente: [Argumente] [Dateiname]<br>\n"
"Argumente siehe SCH2WMF.TXT.\n"
"<hr>"
"<author>Autor: <A href=mailto:henrik.haftmann@e-technik.tu-chemnitz.de>"
"henrik.haftmann@e-technik.tu-chemnitz.de</A>, <br>"
"URL: <A href='http://www.tu-chemnitz.de/~heha/hs_freeware/sch2wmf/'>"
"http://www.tu-chemnitz.de/~heha/hs_freeware/sch2wmf/</A></author>"
#require 6.00
string I18N[] = {
"en de",
"+Ok +Ok",
"-Cancel -Abbrechen",
/*3*/ "Using vector font results in a <b style=color:darkgreen>perfectly scaleable</b> output file.<p>"
"But the resulting file is <b style=color:darkred>much larger in size</b> "
"and texts are <b style=color:darkred>not searchable</b> because vectorized.<p>"
"The settings <b>Bold</b> and <b>Italic</b> are not applicable.\t"
"Die Vektor-Schriftart ergibt <b style=color:darkgreen>layout-treue</b> Ausgabedateien.<p>"
"Allerdings ist die WMF-Datei <b style=color:darkred>wesentlich größer</b> "
"und <b style=color:darkred>nicht durchsuchbar</b> nach Text.<p>"
"Die Einstellungen <b>Fett</b> und <b>Kursiv</b> sind wirkungslos.",
"Vector Vektor",
"Bold Fett",
"Italic Kursiv",
/*7*/ "(transparent) (transparent)",
/*8*/ "(opaque) (deckend)",
/*9*/ "EMF export options EMF-Export-Optionen",
/*10*/ "file name: <b>%s</b> Dateiname: <b>%s</b>",
/*11*/ "Output colors (see Eagle palette) Ausgabe-&Farben (siehe Eagle-Palette)",
"Black on white (for monochrome printers) Schwarz auf Weiß (Schwarzweiß)",
"Colors on black Bunt auf Schwarz",
"Colors on white Bunt auf Weiß",
"Colors on colored background Bunt auf farbigem Hintergrund",
/*16*/ "Font &replacement (used fonts are listed here) "
"Schrift-&Ersetzung (verwendete Schriften gelistet)",
/*17*/ "<b>Note:</b> Vector font on copper will be never replaced "
"<b>Hinweis:</b> Vektorschrift auf Kupfer wird niemals ersetzt.",
/*18*/ "&Hatch style (%d hatched layer(s) present) "
"Füll&muster (%d schraffierte(r) Layer vorhanden)",
/*19*/ "Filled Ausgefüllt",
/*20*/ "Windows hatch style (6 predefined: = || // \\\\\\\\ ++ xx) "
"Windows-Füllmuster (hat nur 6 Muster: = || // \\\\\\\\ ++ xx)",
/*21*/ "Exact hatch like in Eagle "
"Exakte Füllmuster wie in Eagle",
/*22*/ "Page %d Layer %d (%s) "
"Seite %d Layer %d (%s)",
/*23*/ "Layer %d (%s) "
"Layer %d (%s)"
};
int Language = strstr(I18N[0], language()) / 3;
string tr(string s) {
string t = lookup(I18N, s, Language);
return t ? t : s;
}
string LoadString(int n) {
string a[];
n=strsplit(a,I18N[n],'\t');
return a[Language<n?Language:0];
}
string LoadStringS(int n, string subst) {
string ret=LoadString(n);
sprintf(ret,ret,subst);
return ret;
}
string LoadStringI(int n, int i1) {
string ret=LoadString(n);
sprintf(ret,ret,i1);
return ret;
}
string LoadStringII(int n, int i1, int i2) {
string ret=LoadString(n);
sprintf(ret,ret,i1,i2);
return ret;
}
string LoadStringIS(int n, int i1,string s2) {
string ret=LoadString(n);
sprintf(ret,ret,i1,s2);
return ret;
}
string LoadStringIIS(int n, int i1, int i2,string s3) {
string ret=LoadString(n);
sprintf(ret,ret,i1,i2,s3);
return ret;
}
// Hinweis: WMF-Dateien können mit Internet Explorer 6+ direkt im WWW als Bild
// angezeigt werden (das wird wohl die Mac-Version nicht betreffen).
// Leider druckt der IE das WMF als Klötzchengrafik (wie auch bei verkleinerten
// Rasterbilddateien). Man kann sie auch nicht im Browser skalieren.
// Ordentliche Betrachter, bspw. ACDSee, skalieren und drucken WMFs sauber als
// Vektorgrafik.
// Zur Analyse von WMF- und EMF-Dateien habe ich im Zuge von SCH2WMF das Programm
// WMFVIEW geschrieben, welches auf meiner Freeware-Seite zur Verfügung steht.
// (Suchmaschinen-Stichworte: haftmann freeware wmfview)
// Versionsgeschichte:
// Oktober 2005: SCH2CGM (Computer Graphics Metafile, kann in MS Office
// importiert werden, sofern Importfilter installiert
// August 2006: SCH2EMF gescheitert
// Oktober 2006: SCH2WMF funktionsfähig
// Dezember 2006: experimentelle BRD-Unterstützung
// Juli 2007: Bugfix: ausgeblendete Ebenen sichtbar bei Schwarzweiß-Ausgabe
// Abschaffung der zwei Läufe (schneller)
// Korrektur bei Bögen, brauchbare Funktion im .BRD
// Mai 2008: Hinweis: Proportional-Schrift in Kupfer wird niemals ersetzt
// Warnung, wenn kein RATSNEST
// Ausgabe pseudotransparent (nur Board)
// Bugfix: Fehlermeldung bei TCREAM
// exakte Füllmuster, Textlayer (nicht: Text) obenauf (Board)
// Juni 2008: Schraffuren beim Spiegeln umgedreht
// Ausstanzen von Löchern, Hintergrundfüllung
// im Board stets lagenweise Ausgabe (auch bei Schwarzweiß)
// Überstreichungen entsprechend Eagle 5
// Löcher und Bohrsymbole
// Schraffierte Linien als Achtecke, schraffierte Polygonränder
// Schraffierte Bögen, Bohrsymbole
// LastLayers, Kommandozeile, erweiterter Dialog (d=2)
// Oktober 2008: Bugfix bei Schaltplanausgabe mit schraffiertem Layer
// Umgestaltung der Recordausgabe, kürzere Createfont-Records
// Ausgabe Layer 93 (Pins), selektierbare Ausgabe
// Symbolzeichenausgabe via Symbol-Schriftart
// Symbolischer Dateiname "*" in Kommandozeile
// November 2008: Bugfix: Kreise mit Strichstärke Null sind ausgefüllt
// Bugfix: SMDs mit Abrundungen ausgeben (beides Guido Clausner)
// Dezember 2009: Bugfix: Löcher-Darstellung
// Februar 2012: Bugfix: Eagle6-Kompatibilität, Total-Commander-und-IE-Kompatibilität
// FlatArcReplace: Verhältnis zwischen Strichbreite und Bogenradius
// April 2016: Spiegelung vertikal und Rotation dazu (für Board, nur bei d=2 zu sehen).
// Damit können alle 8 denkbaren Ausrichtungen ausgespuckt werden.
// Mai 2016: Rechtsbündiger Text mit Ohm-Zeichen nun korrekt
// PROBLEM: pseudotransparente Ausgabe auf Bildschirm prima, beim PDF Murks
// PROBLEM: Einfügen in .docx führt zu falscher Farbwiedergabe,
// bei Betrieb von Winword im Kompatibilitätsmodus (.doc) alles korrekt.
// PDF-Ausgabe pseudotransparenter Board-Layer: Falschfarben
// Oktober 2021: Bugfix: Ausschlüsse im Supply-Layer
// Zur problemspezifischen Anpassung des Dialogs
int NumSheet; // Anzahl Seiten des Schaltplans
int NumHatched; // Anzahl gestrichelte Layer (bei Schaltplan üblich: Null)
int NumExact; // Anzahl gestrichelte Layer _ohne_ Windows-Entsprechung
int NumFont[]; // Anzahl Vorkommen von Vektor/Prop/Fixed-Fonts
int NumCopperVector; // Anzahl Vorkommen Vektorfonts im Kupfer (nur Board)
int NumFlatArc; // Anzahl Bögen mit flachen Enden (außer Tortenstücke)
int NumPieced; // Anzahl Strichellinien (auch Bögen)
string SName; // Schaltplan- oder Board-Name (ohne Pfad)
// **** Dialog ****
// Voreinstellungen
int Debug=0; // Kreis am Text-Ursprung
int PaletteType=palette(-1)+1; // Farbmodell, 2. Parameter für palette()
// PaletteType=0 bedeutet Schwarzweiß-Ausgabe (1 Layer)
int HatchType=1; // Füllstil für gestrichelt definierte Layer (!Polygone)
int AllPages=0; // Automatisch alle Seiten generieren (mehrseitige Schaltpläne)
int Flipped=0; // gespiegelt (Bit 0: an X-Achse, Bit 1: an Y-Achse, Bit 2: X/Y-Tausch, nur für Board)
int Trans=0; // Transparenz-Simulation (mittels ROP-Kodes, wie Eagle<5)
int OutBkgnd=0; // Hintergrund ausgeben
int DoNegate=0; // Negationen (bei Strings) ausgeben
int LineReplace=1; // Schraffierte Linien durch (längliche) Achtecke ersetzen
real FlatArcReplace=0.8;// Bögen mit flachen Enden ersetzen ab Verhältnis Breite:Radius
// (Ab Verhältnis 1,9 wird stets ein Tortenstück ausgegeben)
int PiecedReplace=1; // Strichellinien-Ersetzung (Standard: nur ersetzte Polygone Eagle-stricheln)
int Dialog=1; // =2: Erweiterter Dialog (nur für Füchse), 0 = kein Dialog
int GroupOnly=0; // Gruppe ausgeben
string LastLayers; // Zuletzt auszugebende Layer (stets deckend, nur Board)
string FName; // Dateiname (ggf. Kommandozeilenargument)
real Scale=1; // Ausgabe-(Fehl-)Skalierung (besonders für Total Commander und Internet Explorer)
// Die Vorgabe-Schriftersetzung ist, Vektor-Schrift durch Arial fett
// ersetzen zu lassen, um die Ausgabedatei klein und durchsuchbar zu machen.
// Beim ULP-Start wird der Schaltplan nach speziellen Zeichen im Vektorfont,
// bspw. dem Omega-Zeichen, durchsucht.
// (Die meisten Eagle-Anwender werden's wohl gar nicht wissen:-)
// In diesem Fall erfolgt die Ausgabe in Symbol-Schriftart.
// Bei Zeichen, die nicht in der Symbol-Schriftart enthalten sind
// (Rahmenzeichen; extrem selten verwendet) erfolgt standardmäßig
// keine Schriftersetzung, sondern schnöde Linienausgabe.
// Das ist der Nachteil, wenn man WMF (und kein EMF - Unicode) ausgibt!
int FontSel[]={1,1,2}; // Font-Nr. für Vektor-Proportional-Fixed
int FontBold[]={1,0,0};
int FontItalic[]={0,0,0};
string FontSrc[]={"Vektor","Proportional","Fixed"}; // Eagle-Namen
string FontName[]={"Vektor","Arial","Courier New","Times New Roman","Symbol"};
string FontLabel[];
// Um die 32-bit-Koordinaten von Eagle ins .WMF zu pressen (16-bit-Koordinaten),
// müssen alle Koordinatenangaben durch einen gemeinsamen Teiler dividiert werden.
real Teiler=25.4; // µm pro Pixel, Vorgabe: 1 mil WMF-Raster: max. Seitengröße 32767mil=0,83m
real MinBreite=50.8; // Minimale Linienbreite für Ersetzungsvorgänge in µm
// * Strichellinien durch Eagle-Strichelung
// * Schraffierte Linien und Polygonränder durch Achtecke
// * Bögen mit ENDCAP_FLAT durch Polygone
// berechnet aus String LastLayers das Char-Array LastLayers(!)
// meckert und liefert 0 bei Fehler, sonst !=0
int CalcLastLayers(void) {
string A;
int i,j,layer,layere;
for (i=j=0; LastLayers[i]; i++) {
// Startwert einlesen
layer=strtol(strsub(LastLayers,i));
if (layer<=0 || layer>255) break; // Fehler
while ('0'<=LastLayers[i] && LastLayers[i]<='9') i++;
// ggf. Endwert einlesen
if (LastLayers[i]=='-') {
i++;
layere=strtol(strsub(LastLayers,i));
if (layere<=0 || layere>255) break; // Fehler
while ('0'<=LastLayers[i] && LastLayers[i]<='9') i++;
}else layere=layer;
// auf- oder absteigend LastLayers füllen
if (layer<=layere) for (; layer<=layere; layer++) A[j++]=layer;
else for (; layer>=layere; layer--) A[j++]=layer;
// Folgezeichen auswerten
if (!LastLayers[i]) break; // Ende
if (LastLayers[i]!=','
|| !LastLayers[i+1]) break; // Fehler, wenn kein Komma oder ",\0"
}
A[j]=0; // terminieren
if (LastLayers[i]) { // Nicht am Ende angekommen?
string s;
sprintf(s,"!Falsche Syntax für Layer-Angabe!<pre style=color:red><b>%s\n%*s^---hier!",
LastLayers,i,"");
dlgMessageBox(s);
return 0;
}
LastLayers=A;
return 1;
}
/***********************
*** Dialog-Routinen ***
***********************/
// globale Variablen: Farben und Füllstile sowie Name per Layer
int col[],fil[];
string nam[];
// liefert TRUE, wenn Layers aktiv sind, die von unten zu sehen sind
// (d.h. solche, auf denen platzierter Text tatsächlich gespiegelt erscheint)
int AnyBottomLayers() {
return col[LAYER_BOTTOM]
+ col[LAYER_BPLACE]
+ col[LAYER_BORIGINS]
+ col[LAYER_BNAMES]
+ col[LAYER_BVALUES]
+ col[LAYER_BSTOP]
+ col[LAYER_BCREAM]
+ col[LAYER_BFINISH]
+ col[LAYER_BGLUE]
+ col[LAYER_BTEST]
+ col[LAYER_BKEEPOUT]
+ col[LAYER_BRESTRICT]
+ col[LAYER_BDOCU];
}
// Font-Namen nur für SetFontLabel (Leerzeichen führen zu Fehlern)
string FontSty[]={"Verdana","Arial","Courier","Times"};
void SetFontLabel(void) {
for (int idx=0; idx<3; idx++) sprintf(FontLabel[idx],
"<span style=font-family:%s;font-weight:%d;font-style:%s>%s</span>:",
FontSty[FontSel[idx]],
FontBold[idx]?700:400,
FontItalic[idx]?"italic":"normal",
FontSrc[idx]);
}
void FontSubstLine(int idx) {
dlgCell(idx,0) {dlgLabel(FontLabel[idx],1); dlgSpacing(10);}
dlgCell(idx,1) {
dlgComboBox(FontName,FontSel[idx]) {
if (!FontSel[0]) dlgMessageBox(
"Die Vektor-Schriftart ergibt <b style=color:darkgreen>layout-treue</b> Ausgabedateien.<p>"+
"Allerdings ist die WMF-Datei <b style=color:darkred>wesentlich größer</b> "+
"und <b style=color:darkred>nicht durchsuchbar</b> nach Text.<p>"+
"Die Einstellungen <b>Fett</b> und <b>Kursiv</b> sind wirkungslos.");
SetFontLabel();
}
dlgSpacing(10);
}
dlgCell(idx,2) dlgCheckBox("Fett",FontBold[idx]) SetFontLabel();
dlgCell(idx,3) dlgCheckBox("Kursiv",FontItalic[idx]) SetFontLabel();
dlgCell(idx,4) dlgStretch(1);
}
void OnSetPaletteType(void) {
switch (PaletteType) {
case 1: {
OutBkgnd=1;
if (board) Trans=1; // voreinstellen wie Eagle
if (NumExact) HatchType=2;
}break;
case 3: {
OutBkgnd=!Trans; // voreinstellen wie Eagle (wenn Trans=0)
}break;
}
}
// Hilfsvariablen zum Zusammensetzen von Flipped
int TopDown;
int Rotated;
int DialogBox(void) {
string DeckLabel=Trans?"(transparent)":"(deckend)";
status("Dialog");
return dlgDialog("WMF-Export-Optionen") {
dlgLabel("Dateiname: <b>"+SName+"</b>");
if (FName) dlgLabel("Ausgabe-Datei: <b>"+filename(FName)+"</b>");
if (Dialog>1) dlgGridLayout{
dlgCell(0,0) dlgLabel("WMF-Einheit (alles 16-Bit-Koordinaten): ");
dlgCell(0,1) dlgRealEdit(Teiler,1,300);
dlgCell(0,2) dlgLabel(" µm");
dlgCell(1,0) dlgLabel("Minimale Linienbreite für Ersetzungen: ");
dlgCell(1,1) dlgRealEdit(MinBreite,0.1,3000);
dlgCell(1,2) dlgLabel(" µm");
dlgCell(2,0) dlgLabel("Ausgabe-Skalierung (»falsche« DPI-Angabe): ");
dlgCell(2,1) dlgRealEdit(Scale,0.1,100);
}
dlgGroup("Ausgabe-&Farben (siehe Eagle-Palette)") {
dlgRadioButton("Schwarz auf Weiß (Schwarzweiß)",PaletteType) OnSetPaletteType();
dlgRadioButton("Bunt auf Schwarz",PaletteType) OnSetPaletteType();
dlgRadioButton("Bunt auf Weiß",PaletteType) OnSetPaletteType();
dlgRadioButton("Bunt auf farbigem Hintergrund",PaletteType) OnSetPaletteType();
}
dlgGroup("Schrift-&Ersetzung (verwendete Schriften gelistet)") {
dlgGridLayout{
SetFontLabel();
for (int i=0; i<3; i++) if (NumFont[i]) FontSubstLine(i);
}
if (NumCopperVector) {
dlgSpacing(4);
dlgLabel("<b>Hinweis:</b> Vektorschrift auf Kupfer wird niemals ersetzt.");
}
}
if (Dialog>1) {
if (NumFlatArc) {
string s;
sprintf(s,"Behandlung von %d B%sgen mit flachen Enden",
NumFlatArc, NumFlatArc==1?"o":"ö");
dlgGroup(s) {
dlgHBoxLayout{
dlgLabel("als Polygon interpolieren ab Breite:Radius: ");
dlgRealEdit(FlatArcReplace,0,2);
}
dlgLabel("<b>0</b> = immer (größere Datei), <b>2</b> = nie (sichtbare »Wurst-Enden«)");
}
}
if (NumPieced) {
string s;
sprintf(s,"Behandlung von %d Strichellinie%s",
NumPieced,NumPieced==1?"":"n");
dlgGroup(s) {
dlgRadioButton("Linien mit Windows-Strichelung ausgeben",PiecedReplace);
dlgRadioButton("Windows für Linien und Bögen, Eagle für Polygone",PiecedReplace);
dlgRadioButton("Eagle-Strichelung verwenden (Einzelsegmente)",PiecedReplace);
}
}
}
if (NumHatched) {
string s;
sprintf(s,"Füll&muster (%d schraffierte%s Layer vorhanden)",
NumHatched,NumHatched==1?"r":"");
dlgGroup(s) {
dlgRadioButton("Ausgefüllt",HatchType) if (Dialog>1) LineReplace=0;
dlgRadioButton("Windows-Füllmuster (hat nur 6 Muster: = || // \\\\\\\\ ++ xx)",HatchType);
dlgHBoxLayout{
dlgRadioButton("Exakte Füllmuster wie in Eagle",HatchType);
dlgLabel(DeckLabel,1); // "transparent" oder "deckend"
dlgStretch(1);
}
// Vorher ermitteln, ob überhaupt problematische Linien oder Polygone
// mit Strichbreite>0 vorhanden sind!?
if (Dialog>1) {
dlgSpacing(4);
dlgGroup("Ersetzung von schraffierten &Linien und Bögen") {
dlgRadioButton("Keine Ersetzung (dann ausgefüllt, nicht schraffiert)", LineReplace);
dlgRadioButton("Linien und Bögen durch Polygone ersetzen", LineReplace);
dlgRadioButton("Auch Polygonränder ersetzen", LineReplace);
}
}
}
}
if (board) {
if (AnyBottomLayers() || Dialog>1) {
dlgCheckBox("&Gespiegelt (an Y-Achse, zur Seite)",Flipped);
}
if (Dialog>1) {
dlgCheckBox("Na&ch unten gespiegelt (an X-Achse)",TopDown);
dlgCheckBox("&90° nach links rotiert (nach den Spiegelungen)",Rotated);
}
dlgCheckBox("Simulierte Tr&ansparenz (mit Rasteroperationskodes)",Trans) {
DeckLabel=Trans?"(transparent)":"(deckend)";
if (Trans) switch (PaletteType) {
case 3: dlgMessageBox(
"Bei »Bunt auf farbigem Hintergrund« gibt es in Eagle < 5 keine Transparenz.<p>"
"Hier werden Komplementärfarben ausgegeben.<p>"+
"Hässliches Aussehen bei PostScript- und PDF-Weiterverarbeitung (Windows-Bug)");
break;
}
}
if (Dialog>1 || LastLayers) { // Nur bei "Dialog=2" oder LastLayer-Vorgabe
dlgGroup("&Umordnung der Layer-Ausgabe") {
dlgHBoxLayout{
dlgLabel("Zuletzt ausgeben (stets deckend):");
dlgSpacing(4);
dlgStringEdit(LastLayers);
}
}
}
}
if (DoNegate)
dlgCheckBox("&Negationsstriche (sonst »!«)",DoNegate);
if (GroupOnly==1) dlgCheckBox("Selektierte G&ruppe (sonst ganze Seite)",GroupOnly);
else GroupOnly=0;
dlgCheckBox("&Hintergrund ausmalen (Vektorgrafik nicht transparent)",OutBkgnd);
if (NumSheet>1) {
dlgSpacing(4);
dlgCheckBox("&Alle Seiten (mehrere Dateien)",AllPages) {
if (AllPages) GroupOnly=0;
}
}
dlgSpacing(4);
dlgHBoxLayout {
dlgPushButton(FName?"+O&K":"+&Weiter, zum Speichern ...") {
if (Dialog<2 || CalcLastLayers()) dlgAccept(1);
}
dlgPushButton("Abbrechen") dlgReject();
}
};
}
/* Die Vektor-Schriftart und die (später) möglichen Zeichen-Ersetzungen
Kode Zeichen (CP1252) CP437 Symbol Unicode
80 128 ?
81 129 Raster B1 177
82 130 ?
83 131 ?
84 132 ?
85 133 ?
86 134 ?
87 135 ?
88 136 ?
89 137 ?
8A 138 ?
8B 139 ?
8C 140 ?
8D 141 Rahmen:0-0-1-1 DA 218 U+250C
8E 142 ?
8F 143 größer-gleich F2 242 B3 179
90 144 Block oben DF 223
91 145 ?
92 146 ?
93 147 ?
94 148 ?
95 149 ?
96 150 ?
97 151 ?
98 152 ?
99 153 ?
9A 154 ?
9B 155 ?
9C 156 ?
9D 157 Rahmen:0-0-2-2 C9 201 U+2554
9E 158 ?
9F 159 ?
A0 160 _ (anderer Kode)
A1 161 ¡
A2 162 Rahmen:1-2-0-0 BD 189 U+255C
A3 163 £
A4 164 Rahmen:2-1-2-0 D0 208 U+2567
A5 165 Rahmen:2-1-0-0 BE 190 U+255B
A6 166 Block rechts? DE 222
A7 167 Integral untere Hälfte F5 245
A8 168 Block? unten DC 220
A9 169 Rahmen:2-0-0-1 B8 184 U+2555
AA 170 ª
AB 171 «
AC 172 ¬
AD 173 identisch F0 240 BA 186
AE 174 umgekehrte Negation A9 169
AF 175 Element-von EE 238 CE 206
B0 176 °
B1 177 ±
B2 178 ²
B3 179 hochgestelltes n FC 252
B4 180 Schnittmenge EF 239 C7 199
B5 181 µ
B6 182 Integral obere Hälfte F4 244
B7 183 · (aber tiefer)
B8 184 Rund (zwei Wellen) F7 247 BB 187
B9 185 Wurzel FB 251 D6 214
BA 186 º
BB 187 »
BC 188 ¼
BD 189 ½
BE 190 kleiner-gleich F3 243 A3 163
BF 191 ¿
C0 192 Rahmen:1-0-0-2 B7 183 U+2556
C1 193 Rahmen:2-1-0-1 B5 181 U+2561
C2 194 Rahmen:1-2-0-2 B6 182 U+2562
C3 195 Rahmen:0-2-1-2 C7 199 U+255F
C4 196 Ä
C5 197 Å
C6 198 Æ
C7 199 Ç
C8 200 Rahmen:0-1-2-0 D4 212 U+2558
C9 201 É
CA 202 Rahmen:1-0-1-2 D2 210 U+2565
CB 203 Rahmen:0-2-1-0 D3 211 U+2559
CC 204 Block rechts? DE 222
CD 205 Rahmen:0-0-1-2 D6 214 U+2553
CE 206 Rahmen:1-2-1-2 D7 215 U+256B
CF 207 Rahmen:2-1-2-1 D8 216 U+256A
D0 208 Rahmen:2-0-2-1 D1 209 U+2564
D1 209 Ñ
D2 210 pi E3 227 70 112
D3 211 alpha E0 224 61 97
D4 212 Gamma E2 226 47 71
D5 213 rho E5 229 73 115
D6 214 Ö
D7 215 Peseta 9D?
D8 216 Ø
D9 217 delta EB 235 64 100
DA 218 Theta E9 233 51 81
DB 219 Ohm EA 234 57 87
DC 220 Ü
DD 221 ø (anderer Kode!) ED? 198
DE 222 Phi E8 232 46 70
DF 223 ß
E0 224 à
E1 225 á
E2 226 â
E3 227 Rahmen:0-1-2-1 C6 198 U+255E
E4 228 ä
E5 229 å
E6 230 æ
E7 231 ç
E8 232 è
E9 233 é
EA 234 ê
EB 235 Leerzeichen "nbsp"
EC 236 ì
ED 237 í
EE 238 î
EF 239 ï
F0 240 Rahmen:1-2-1-0 D0 208 U+2568
F1 241 ñ
F2 242 ò
F3 243 ó
F4 244 ô
F5 245 Sigma E4 228 53 83
F6 246 ö
F7 247 ÷
F8 248 ø
F9 249 ù
FA 250 ú
FB 251 û
FC 252 ü
FD 253 unendlich EC 236 A5 165
FE 254 tau E7 231 74 116
FF 255 ÿ
*/
string Problem160= // Ausrufezeichen bei Problemstellen,
"!¡!£!!¦!!!ª«¬º!ΰ±²!ǵ!·»Öº»¼½£¿" // ungleiche Zeichen bei Einsatz
+"!!!!ÄÅÆÇ!É!!!!!!!ÑpaGsÖ!ØdQWÜÆFß" // der Schriftart „Symbol“
+"àáâ!äåæçèéê ìíîï!ñòóôSö÷øùúûü¥tÿ";
int ProblemChars(string s) {
int len=strlen(s);
for (int i=0; i<len; i++) {
char c=s[i];
if (c<32) return 1;
if (c>=128 && c<160 && c!=143) return 1; //immer Problem
if (c>=160 && Problem160[c-160]=='!') return 1; // bspw. Rahmenzeichen
}
return 0;
}
/* liefert TRUE bei problematischem Text:
* Schriftart == Vector
UND Ersatzschrift != Vector
UND enthält Zeichen im Nicht-Latin1-Font
* Ersatzschrift != Vector
UND (Schrift gespiegelt XOR Ausgabe nicht gespiegelt)
UND im Board
--- WMF erlaubt leider keine Ausgabe von gespiegeltem Text ---
*/
int ProblemText(UL_TEXT O) {
if (O.font==FONT_VECTOR/*0*/
&& FontSel[0]
&& ProblemChars(O.value)) return 1;
// Zweiter Fall nicht implementiert
return 0;
}
// Kode für „Symbol“-Zeichensatz ermitteln, 0 wenn keine Symbol-Ersetzung
int GetSymbolChar(char c) {
if (c==143) return 179;
if (c>=160) {
char r=Problem160[c-160];
if (r!='!' && r!=c) return r;
}
return 0;
}
// Test des Strings auf Symbol-Zeichenersetzung
int HasSymbolChars(string s) {
int len=strlen(s);
for (int i=0; i<len; i++) {
if (GetSymbolChar(s[i])) return 1;
}
return 0;
}
string strrev(string s) {
string ret="";
for (int i=strlen(s);i;) ret+=s[--i];
return ret;
}
// liefert einen „Lauf“ gleicher Zeichentypen aus <s> ab <pos>.
// Ist <symb>!=0, dann SYMBOL-Zeichensatz, sonst ANSI-Zeichensatz
// Bei Symbol-Zeichensatz liefert die Funktion die Kodes
// des Symbol-Zeichensatzes.
string GetCharRun(string s, int pos, int symb) {
string ret="";
if (symb) for (;;) {
char c=GetSymbolChar(s[pos++]);
if (!c) break;
ret+=c;
}else for (;;) {
char c=s[pos++];
if (!c) break;
if (GetSymbolChar(c)) break;
ret+=c;
}
return ret;
}
void CountFont(UL_TEXT O) {
if (!col[O.layer]) return; // unsichtbare Schrift nicht mitzählen
if (!strlen(O.value)) return; // Leere Strings nicht mitzählen
NumFont[O.font]++;
if (ProblemText(O)) FontSel[0]=0; // Vektor-Schrift voreinstellen (Default: Arial)
if (O.font==FONT_VECTOR && FontSel[0] && FontSel[0]==FontSel[1] && HasSymbolChars(O.value)) {
FontBold[0]=FontBold[1]; // Vorgabe: Soll gleich aussehen (typisch für Ohm-Zeichen)
FontItalic[0]=FontItalic[1];
}
if (!DoNegate) {
int i=strchr(O.value,'!'); // Schnellsuche (unexakt)
if (i!=-1 && i!=strlen(O.value)-1) DoNegate++; // Wenigstens Ausrufezeichen am Ende nicht beachten
}
}
int IsPie(UL_ARC O) {
return O.cap==CAP_FLAT && O.width>O.radius*1.9;
}
void CountFlatArc(UL_WIRE O) {
if (O.cap==CAP_FLAT && O.arc && !IsPie(O.arc)) NumFlatArc++;
if (O.style!=WIRE_STYLE_CONTINUOUS) NumPieced++;
}
/* Suche nach verwendeten Text-Fonts, zur Vorbereitung des Dialogs */
// Weiterhin wird (beim Vektor-Font) nach problematischen Zeichen gesucht.
// Bei Problemen wird die Voreinstellung für Vektor-Font
// von "Arial" auf "Vektor" zurückgesetzt.
// (Für alle, die nicht wissen, worum es geht:
// Eagle unterstützt bspw. das Omega-Zeichen, aber nur in der Vector-Schrift.)
// In nicht-westeuropäischen Windows-Versionen sind größere Teile der
// Vector-Schriftart problematisch ...
// Außerdem wird nach Bögen mit CAP_FLAT gesucht
void SchCountFonts(UL_SCHEMATIC O) {
O.sheets(O){
string e;
sprintf(e,"Seite %d",O.number);
status(e);
NumSheet++;
O.busses(O) {
O.segments(O) {
O.texts(O) CountFont(O);
O.wires(O) CountFlatArc(O);
}
}
O.nets(O) {
O.segments(O) {
O.texts(O) CountFont(O);
O.wires(O) CountFlatArc(O);
}
}
O.parts(O) {
O.instances(O) {
O.gate.symbol.pins(O) {
O.texts(O) CountFont(O);
O.wires(O) CountFlatArc(O);
}
O.gate.symbol.frames(O) O.texts(O) CountFont(O);
O.gate.symbol.dimensions(O) O.texts(O) CountFont(O);
O.gate.symbol.texts(O) CountFont(O);
O.gate.symbol.wires(O) CountFlatArc(O);
O.texts(O) CountFont(O);
}
}
O.texts(O) CountFont(O);
O.wires(O) CountFlatArc(O);
}
}
// das gleiche für's Board
void BrdCountFonts(UL_BOARD O) {
O.elements(O) {
O.texts(O) CountFont(O);
O.package.texts(O) CountFont(O);
O.package.wires(O) CountFlatArc(O);
}
O.signals(O) O.wires(O) CountFlatArc(O);
O.texts(O) { // Vektor-Schrift im Kupfer wird NICHT gezählt (bleibt stets Vektor)
if (O.layer>LAYER_BOTTOM || O.font!=FONT_VECTOR) CountFont(O);
else if (col[O.layer]) NumCopperVector++;
}
O.wires(O) CountFlatArc(O);
}
int IsRatsnestPoly(UL_POLYGON O) {
O.fillings(O) return 1;
return 0;
}
// Prüft auf Vorhandensein sichtbarer, nicht geRATSNESTer Polygone (nur Kupfer)
int BrdAreRipupPolys(UL_BOARD O) {
O.signals(O) O.polygons(O)
if (O.layer<=LAYER_BOTTOM
&& col[O.layer]
&& !IsRatsnestPoly(O)) return 1;
return 0;
}
// **** globale Variablen ****
/* für den WMF-Kopf */
int nWords; // Länge WMF-Datei
int nMaxRecSize;// Länge längster WMF-Record
int nHandles;
/* WMF-Daten (Ansammlung im RAM, WORD-Array) */
int FileData[];
int CurLayer;
int LayerColor; // Windows-RGB
int LayerFill; // Windows-Füllstil (Low-Nibble, High-Nibble)
int LayerRop; // aktueller Windows-Rasteroperationskode
int LastX,LastY; // (kleinere Datei, schnelleres Rendern)
int TextColor;
int TextAlign;
int BackgroundColor;
int DrawHoles=0; // Löcher statt Pads/Vias zeichnen
/* Ausgabe 2 Byte in Intel-Notation (Little Endian) */
void PrintWord(int w) {
printf("%c%c",w&0xFF,(w>>8)&0xFF);
}
/* Ausgabe 2 oder 4 Byte in Intel-Notation in Datenpuffer */
void OutWord(int w) {
FileData[nWords++]=w;
}
void OutDword(int d) {
FileData[nWords++]=d;
FileData[nWords++]=d>>16;
}
// <term>=1: String garantiert nullterminieren, sonst nicht zwangsweise nullterminiert
void OutString(string s, int term) {
int i, len=strlen(s)+term;
for (i=0; i<len; i+=2) {
OutWord(s[i]&0xFF|s[i+1]<<8);
}
}
int nRecordStart;
void BeginRecord(int recordtype) {
nRecordStart=nWords; // Anfang merken
nWords+=2; // Platz für Länge lassen
OutWord(recordtype);
}
void EndRecord(void) {
int b=nWords-nRecordStart; // Länge in WORDs
if (nMaxRecSize<b) nMaxRecSize=b;
FileData[nRecordStart]=b; // Länge eintragen
FileData[nRecordStart+1]=b>>16;
}
int Mass(int eaglepixel) {
// 1 Eagle-Pixel sind 1/320 µm (8128000 dpi), damit gibts Probleme mit 16 bit.
// Division durch 8128 ergibt 25,4 µm als Ersatzraster, 1/1000 Zoll = 1 mil, ergibt 1000 dpi,
// das scheint für alle gängigen Schaltpläne (und auch Boards) ausreichend zu sein.
// Die Maximalausdehnung wäre dann 1 mil * 32767 ~ 83 cm
// Für 1200 dpi (Laserdrucker) müsste der Teiler 6773,3 sein.
return round(u2mic(eaglepixel)/Teiler);
}
void OutMassX(int eaglepixel) {
OutWord(Mass(Flipped&1?-eaglepixel:eaglepixel));
}
void OutMassY(int eaglepixel) {
OutWord(Mass(Flipped&2?eaglepixel:-eaglepixel));
}
void OutXY(int x, int y) {
if (Flipped&4) {int t=x; x=y; y=t;}
OutMassY(y); // im WMF verkehrherum weil's auf Pascal-Aufrufkonvention basiert
OutMassX(x);
}
// Ausgabe für Polygone: „richtigherum“, gleich mit Koordinatentransformation
real poly_mx=0; // Verschiebung
real poly_my=0;
real poly_c=1; // Drehmatrix-Elemente | +cos +sin |
real poly_s=0; // | -sin +cos |
void SetPolyTr(real mx,real my,real angle/*in Grad*/) {
angle*=PI/180;
poly_mx=mx;
poly_my=my;
poly_c=cos(angle);
poly_s=sin(angle);
}
void OutPolyXY(real x, real y) {
int xx=poly_mx+poly_c*x-poly_s*y;
int yy=poly_my+poly_s*x+poly_c*y;
if (Flipped&4) {x=xx;xx=yy;yy=x;}
OutMassX(xx); // In richtiger Reihenfolge ausgeben
OutMassY(yy);
}
void OutPolyRA(real r, real a) {
a*=PI/180;
OutPolyXY(r*cos(a),r*sin(a));
}
void OutRop(int NewRop) {
if (NewRop==LayerRop) return;
BeginRecord(0x0104/*META_SETROP2*/);
OutWord(NewRop);
EndRecord();
LayerRop=NewRop;
}
// die Füllstile könnten auch per CreatePatternBrush exakt angepasst werden
// Da jedoch Schaltpläne äußerst selten Gebrauch davon machen, werden hier
// nur die Standard-Windows-Füllstile verwendet.
int FillStyles[]={ // bestmögliche Annäherung an Windows-Füllstile
1/*BS_NULL*/, // 0 Eagle-Füllung:
0/*BS_SOLID*/, // 1
0x02/*HS_HORIZONTAL*/, // 2 breite === 50%
0x32/*HS_BDIAGONAL*/, // 3 dünne /// 10%
0x32/*HS_BDIAGONAL*/, // 4 breite /// 50%
0x22/*HS_FDIAGONAL*/, // 5 breite \\\ 50%
0x22/*HS_FDIAGONAL*/, // 6 dünne \\\\ 10%
0x42/*HS_CROSS*/, // 7 dünne +++ 30%
0x52/*HS_DIAGCROSS*/, // 8 dünne xxx 30%
0x12/*HS_VERTICAL*/, // 9 Punkte 50%
0x12/*HS_VERTICAL*/, // A Punkte 10%
0x12/*HS_VERTICAL*/, // B Punkte 30%
0x02/*HS_HORIZONTAL*/, // C dünne === 50%
0x02/*HS_HORIZONTAL*/, // D dünne === 50%
0x02/*HS_HORIZONTAL*/, // E dünne === 50%
0x02/*HS_HORIZONTAL*/};// F dünne === 50%
// Für genauere Füllstil-Simulation muss man entsprechende Bitmaps laden
// Bei PostScript-Ausgabe werden unschön große Schraffuren ausgegeben
int EaglePattern[]={ // ab Index 2
0xFF,0x00,0x00,0xFF,0xFF,0x00,0x00,0xFF, // breite waagerechte Linien
0x04,0x08,0x10,0x20,0x40,0x80,0x01,0x02, // HS_BDIAGONAL
0xE0,0xC1,0x83,0x07,0x0E,0x1C,0x38,0x70, // // dick
0x1C,0x0E,0x07,0x83,0xC1,0xE0,0x70,0x38, // \\ dick
0x80,0x40,0x20,0x10,0x08,0x04,0x02,0x01, // HS_FDIAGONAL
0x11,0x11,0x11,0xFF,0x11,0x11,0x11,0xFF, // ++
0x48,0x84,0x03,0x03,0x84,0x48,0x30,0x30, // xx
0xAA,0x55,0xAA,0x55,0xAA,0x55,0xAA,0x55, // Schachbrett
0x00,0x10,0x00,0x01,0x00,0x10,0x00,0x01, // Punkte dünn
0x00,0x44,0x00,0x11,0x00,0x44,0x00,0x11, // Punkte dichter
0x00,0xAA,0x00,0xAA,0x00,0xAA,0x00,0xAA, // Punkte angeordnet
0x00,0x55,0x00,0x55,0x00,0x55,0x00,0x55,
0x55,0x00,0x55,0x00,0x55,0x00,0x55,0x00,
0xAA,0x00,0xAA,0x00,0xAA,0x00,0xAA,0x00};
// Bei PostScript-Ausgabe erscheint eine grobe Klötzchenfüllung.
// Umwandeln RGB in Windows-Farbe
int rgb2bgr(int rgb) {
return ((rgb&0xFF)<<16)|(rgb&0xFF00)|((rgb>>16)&0xFF);
}
int odd(int v) {
while (v&~1) v=v&1^(v>>=1);
return v;
}
// Füllstil-Code für Layer <n> berechnen
int CalcFill(int n) {
int ret;
switch (HatchType) {
case 0: ret=0; break;
case 1: {
ret=FillStyles[fil[n]];
if (odd(Flipped&3)) switch (ret) {
case 0x22/*HS_FDIAGONAL*/:
case 0x32/*HS_BDIAGONAL*/: ret^=0x32^0x22; // Richtungen tauschen
}
}break;
case 2: switch (fil[n]) {
case 0: ret=1/*BS_NULL*/; break;
case 1: ret=0/*BS_SOLID*/; break;
default: ret=((fil[n]-2)<<4)|3;
}break;
}
return ret;
}
// Funktion liefert 0 (FALSE) wenn Eagle-Layer <n> unsichtbar
int SetLayer(int n) {
int c=col[n]; // c=0 wenn Layer nicht sichtbar
if (c) {
int rop=13/*R2_COPYPEN = P*/;
if (Trans) switch (PaletteType) {
case 0:
case 2: rop=9/*R2_MASKPEN = DPa*/; break;
case 1: rop=15/*R2_MERGEPEN = DPo*/; break;
case 3: rop=3/*R2_MASKNOTPEN = DPna*/; break; // Komplementärfarben
}
OutRop(rop); // Für Schrift ist die ROP-Einstellung irrelevant!
int rgb=PaletteType?palette(c,PaletteType-1):0;
if (rop==3 && !rgb) rgb=0xFFFFFF;
LayerColor=rgb2bgr(rgb);
LayerFill=CalcFill(n);
}
return c;
}
// globale Variablen zur Verwaltung der sogenannten GDI-Objekte
// Die Arrays wachsen mit der Verwendung verschiedener Pinsel, Stifte und Schriften.
int OD_type[];
int OD_param1[];
int OD_param2[];
int OD_color[];
int FindObj(int type, int p1, int p2, int color) {
int j;
for (j=0; j<nHandles; j++) {
if (type==OD_type[j]
&& p1==OD_param1[j]
&& p2==OD_param2[j]
&& color==OD_color[j]) return j; // vorhandenes Objekt benutzen
}
OD_type[j] =type; // neues Objekt vermerken (j == nHandles)
OD_param1[j]=p1;
OD_param2[j]=p2;
OD_color[j] =color;
return j;
}
void OutSelectObject(int idx) {
BeginRecord(0x12D/*META_SELECTOBJECT*/);
OutWord(idx);
EndRecord();
}
void OutDeleteObject(int idx) {
BeginRecord(0x1F0/*META_DELETEOBJECT*/);
OutWord(idx);
EndRecord();
}
int ObjInUse[]; // Momentanes verwendetes Objekt aus den drei u.g. Typen
enum {ObjPen,ObjBrush,ObjFont};
void ClearObjects(void) {
// Handletabelle löschen, sonstige GDI-Attribute invalidieren
nHandles=0;
TextColor=-1;
TextAlign=-1;
LastX=INT_MAX; // ungültige Position
LayerRop=13/*R2_COPYPEN*/;
}
// Liefert Index in Handle-Tabelle (für schnelle WMF-Darstellung),
// liefert -1, wenn kein neues CreateXxx erforderlich ist.
int GetNewHandleIndex(int objtype, int h1, int h2, int color) {
int j=FindObj(objtype,h1,h2,color);
if (j==nHandles) { // nicht gefunden: neues Objekt
ObjInUse[objtype]=j;
nHandles++;
return j;
} // gefunden: ggf. als aktuelles Objekt aktivieren
if (ObjInUse[objtype]!=j) {
OutSelectObject(j);
ObjInUse[objtype]=j;
}
return -1;
}
void SetPen(int style, int width, int color) {
width=Mass(width);
if (style==5) width=color=0; // PS_NULL: keine Breite, keine Farbe
int idx=GetNewHandleIndex(ObjPen,style,width,color);
if (idx<0) return;
BeginRecord(0x02FA/*META_CREATEPENINDIRECT*/);
OutWord(style);
OutWord(width);
OutWord(width);
OutDword(color);
EndRecord();
OutSelectObject(idx);
}
void SetTextColor(int color) {
if (TextColor!=color) {
BeginRecord(0x0209/*META_SETTEXTCOLOR*/);
OutDword(color);
EndRecord();
TextColor=color;
}
}
void SetBrush(int style, int hatch, int color) {
if (style<2) hatch=0; // BS_SOLID,BS_NULL: kein Muster
if (style==1) color=0; // BS_NULL: keine Farbe
int idx=GetNewHandleIndex(ObjBrush,style,hatch,color);
if (idx<0) return;
if (style<3) {
BeginRecord(0x02FC/*META_CREATEBRUSHINDIRECT*/);
OutWord(style);
OutDword(color);
OutWord(hatch);
EndRecord();
}else{
int i;
BeginRecord(0x01F9/*META_CREATEPATTERNBRUSH*/);
OutWord(0/*BitmapType ??*/);
OutWord(8); // Breite
OutWord(8); // Höhe
OutWord(2); // Breite in Bytes (muss geradzahlig sein)
OutWord(0x0101); // Planes und Bit pro Pixel
for (i=0; i<11; i++) OutWord(0); // reservierte WORDs
for (i=0; i<8; i++) OutWord(~EaglePattern[hatch*8+(odd(Flipped&3)?7-i:i)]);
EndRecord();
SetTextColor(color);
}
OutSelectObject(idx);
}
void SetFont(int font, int size, int angle, int color, int align) {
int sel=4;
if (font&4) { // Symbol-Bit gesetzt?
font&=~4;
}else{
sel=FontSel[font];
}
if (!sel) return; // VEKTOR - das geht hier nicht!
size=Mass(size*1.6);
int idx=GetNewHandleIndex(ObjFont,
sel|FontBold[font]<<8|FontItalic[font]<<9,size,angle);
if (idx>=0) {
BeginRecord(0x02FB/*META_CREATEFONTINDIRECT*/);
OutWord(size);
OutWord(0);
OutWord(angle);
OutWord(angle); // wird von Win16 ignoriert
OutWord(FontBold[font]?700:400);
OutWord(FontItalic[font]);
OutWord(sel==4?0x200:0); // HIBYTE = LF_CHARSET
OutWord(4/*OUT_TT_PRECIS*/); // sonst kleine Schriften immer 0°
OutWord(0/*FontFamily[font]<<8*/);
OutString(FontName[sel],1);
EndRecord();
OutSelectObject(idx);
}
SetTextColor(color);
if (TextAlign!=align) {
BeginRecord(0x012E/*META_SETTEXTALIGN*/);
OutWord(align);
EndRecord();
TextAlign=align;
}
}
// Koordinaten sortieren und zwei Punktkordinaten ausgeben
void OutRect(int left, int top, int right, int bottom) {
if (!(Flipped&1) && left>right
|| Flipped&1 && left<right) {int t=left; left=right; right=t;}
if (!(Flipped&2) && top<bottom
|| Flipped&2 && top>bottom) {int t=top; top=bottom; bottom=t;}
OutXY(right,bottom);
OutXY(left,top); // rclBox
}
// Gedrehtes Rechteck ausgeben
void OutRectangle(int mx, int my, int x, int y, real angle) {
int w=angle*10;
x/=2; y/=2; // jetzt Abstand vom Ursprung
switch (w) {
case 0:
case 900:
case 1800:
case 2700: {
BeginRecord(0x041B/*META_RECTANGLE*/);
if (w==0 || w==1800) {
OutRect(mx-x,my-y,mx+x,my+y);
}else{ // 90° / 270°:
OutRect(mx-y,my-x,mx+y,my+x);
}
}break;
default: {
// Für Board: vollständige Koordinatentransformation und Ausgabe eines Polygons!
BeginRecord(0x0324/*META_POLYGON*/);
OutWord(4);
SetPolyTr(mx,my,angle);
OutPolyXY( x, y); // I.
OutPolyXY(-x, y); // II.
OutPolyXY(-x,-y); // III.
OutPolyXY( x,-y); // IV. Quadrant
}
}
EndRecord();
}
// Gedrehtes RoundRect ausgeben (r!=0), nur für Board, SMDs
void OutRoundRect(int mx, int my, int x, int y, int r, real angle) {
int w=angle*10;
x/=2; y/=2; // jetzt Abstand vom Ursprung
switch (w) {
case 0:
case 900:
case 1800:
case 2700: {
BeginRecord(0x061C/*META_ROUNDRECT*/);
OutWord(Mass(2*r));
OutWord(Mass(2*r));
if (w==0 || w==1800) {
OutRect(mx-x,my-y,mx+x,my+y);
}else{ // 90° / 270°:
OutRect(mx-y,my-x,mx+y,my+x);
}
}break;
default: {
// Polygonausgabe mit Kreisapproximation: als Zwölfeck (sollte reichen)
real z=1-sin(PI/4); // 45°
BeginRecord(0x0324/*META_POLYGON*/);
OutWord(12);
SetPolyTr(mx,my,angle);
OutPolyXY( x , y-r );
OutPolyXY( x-r*z, y-r*z);
OutPolyXY( x-r , y );
OutPolyXY(-x+r , y );
OutPolyXY(-x+r*z, y-r*z);
OutPolyXY(-x , y-r );
OutPolyXY(-x ,-y+r );
OutPolyXY(-x+r*z,-y+r*z);
OutPolyXY(-x+r ,-y );
OutPolyXY( x-r ,-y );
OutPolyXY( x-r*z,-y+r*z);
OutPolyXY( x ,-y+r );
}
}
EndRecord();
}
// Gedrehten(:-) Kreis ausgeben
void OutCircle(int mx, int my, int r) {
BeginRecord(0x0418/*META_ELLIPSE*/);
OutRect(mx-r,my-r,mx+r,my+r);
EndRecord();
}
// Gedrehtes Achteck ausgeben (für Pads), type=0: normal, type=1: lang, type=2:exzentrisch
void OutOctagon(int mx, int my, real d, real angle, int type) {
d/=2;
int i;
real x[],y[];
real j=tan(22.5*PI/180);
x[0]=d*j; y[0]=d; // Achteck im Uhrzeigersinn bauen
x[1]=d; y[1]=d*j;
x[2]=d; y[2]=-d*j;
x[3]=d*j; y[3]=-d;
x[4]=-d*j; y[4]=-d;
x[5]=-d; y[5]=-d*j;
x[6]=-d; y[6]=d*j;
x[7]=-d*j; y[7]=d;
if (type) for (i=0; i<4; i++) x[i]+=2*d; // lang machen (für Typ 1 und 2)
if (type==1) for (i=0; i<8; i++) x[i]-=d; // zentrieren (für Typ 1)
BeginRecord(0x0324/*META_POLYGON*/);
OutWord(8);
SetPolyTr(mx,my,angle);
for (i=0; i<8; i++) OutPolyXY(x[i],y[i]);
EndRecord();
}
/* Abarbeitung von Eagle-Zeichenprimitiven */
int DontProcess(int ElemLayer) {
if (PaletteType || board) return ElemLayer!=CurLayer; // Farbmodus
else return !col[ElemLayer]; // Schwarzweiß-Modus
}
// wie SetBrush(), jedoch mit _einem_ Füllstil-Attribut
void SetBrush2(int Fill) {
SetBrush(Fill&0x0F,Fill>>4,LayerColor);
}
// Zum angegebenen Layer passenden Stift (minimale Strichbreite) erzeugen
void SetLayerPen() {
SetPen(0/*PS_SOLID*/,0,LayerColor);
}
// Zum angegebenen Layer passenden Pinsel erzeugen
void SetLayerBrush() {
SetBrush2(LayerFill);
}
void HandleCircle(UL_CIRCLE O) {
if (DontProcess(O.layer)) return;
SetPen(0/*PS_SOLID*/,O.width,LayerColor);
if (O.width) SetBrush(1/*BS_NULL*/,0,0);
else SetLayerBrush();
OutCircle(O.x,O.y,O.radius);
}
void HandleJunction(UL_JUNCTION O) {
if (DontProcess(LAYER_NETS)) return;
SetLayerPen();
SetLayerBrush();
OutCircle(O.x,O.y,O.diameter/2);
}
// Längliches Achteck anstelle Linie ausgeben (schraffierte Linien)
// Keine Unterstützung für gestrichelte Linien!
void OutOctLine(int x1, int y1, int x2, int y2, int d) {
BeginRecord(0x0324/*META_POLYGON*/);
d/=2;
int i;
real x[],y[];
real j=tan(22.5*PI/180); // Achteck-Ecken
real c=x2-x1; // (c,s) = Richtungsvektor und
real s=y2-y1; // zu real casten (Überlauf beim Quadrieren vermeiden)
real l=sqrt(c*c+s*s); // Länge (Pythagoras)
x[0]=l+d*j; y[0]=d; // Achteck nach rechts bauen
x[1]=l+d; y[1]=d*j;
x[2]=l+d; y[2]=-d*j;
x[3]=l+d*j; y[3]=-d;
x[4]=-d*j; y[4]=-d;
x[5]=-d; y[5]=-d*j;
x[6]=-d; y[6]=d*j;
x[7]=-d*j; y[7]=d;
OutWord(8);
SetPolyTr(x1,y1,0);
poly_c=c/l; // Hier: Mit möglicher Skalierung ohne Winkelangabe
poly_s=s/l;
for (i=0; i<8; i++) OutPolyXY(x[i],y[i]);
EndRecord();
}
void HandlePolygon(UL_POLYGON O) {
// Polygone mit Kurven-Begrenzung können mit WMF nicht (oder höchstens
// näherungsweise) unterstützt werden.
if (DontProcess(O.layer)) return;
int ExtraBorder=LayerFill && LineReplace>=2 && u2mic(O.width)>=MinBreite;
if (ExtraBorder) SetLayerPen(); // dünner Rand
else SetPen(0/*PS_SOLID*/,O.width,LayerColor);
if (O.pour==POLYGON_POUR_HATCH) SetBrush(2,4/*HS_CROSS*/,LayerColor);
else{
int Fill=0;
if (board) Fill=LayerFill;
SetBrush2(Fill);
}
int np=0,nk[],n=0,x0,y0;
nk[0]=0;
O.contours(W) {
// Hoppla! "contours" macht aus Bögen Geradenstücke, auch im Schaltplan!
// Das erspart hier eine Menge Arbeit.
if (!nk[np]) x0=W.x1, y0=W.y1; // Linienzug-Anfang
nk[np]++; // Kanten abzählen (per Polygon)
n++; // Kanten abzählen (Gesamtanzahl)
if (x0==W.x2 && y0==W.y2) nk[++np]=0; // Linienzug-Ende am Anfang
}
// if (!first) return; // Ende != Anfang (sollte in Eagle nicht vorkommen)
// if (nk[0]<3) return; // Entartetes Polygon (sollte auch nie vorkommen)
if (np==1) {
BeginRecord(0x0324/*META_POLYGON*/);
OutWord(n); // cptl
}else{
BeginRecord(0x0538/*META_POLYPOLYGON*/);
OutWord(np); // Anzahl Einzelpolygone
for (n=0; n<np; n++) OutWord(nk[n]); // Punktzahl der Einzelpolygone
}
SetPolyTr(0,0,0);
O.contours(W) OutPolyXY(W.x1,W.y1); // aptl
EndRecord();
if (ExtraBorder) O.contours(W) {
OutOctLine(W.x1,W.y1,W.x2,W.y2,O.width);
}
}
void HandleRectangle(UL_RECTANGLE O) {
if (DontProcess(O.layer)) return;
SetLayerPen();
SetLayerBrush();
OutRectangle((O.x1+O.x2)/2,(O.y1+O.y2)/2,O.x2-O.x1,O.y2-O.y1,O.angle);
}
void OutLineTo(int x, int y) {
BeginRecord(0x0213/*META_LINETO*/);
OutXY(x,y);
EndRecord();
LastX=x; LastY=y;
}
void OutMoveTo(int x, int y) {
if (LastX!=x || LastY!=y) {
BeginRecord(0x0214/*META_MOVETO*/);
OutXY(x,y);
EndRecord();
}
}
void OutLine(int x1, int y1, int x2, int y2) {
OutMoveTo(x1,y1);
OutLineTo(x2,y2);
}
// Sinus und Kosinus mit Winkelgrad
real Cos(real scale, real angle) {
return scale*cos(angle*PI/180);
}
real Sin(real scale, real angle) {
return scale*sin(angle*PI/180);
}
// Bogen als Polygon-Näherung ausgeben
void OutPolyArc(UL_ARC O) {
real INCREMENT=5; // Grad Schrittweite
int n=ceil((O.angle2-O.angle1-0.1)/INCREMENT); // 1 Bogen ohne Ende
int NumPoints=n+1; // Endpunkt dazu
if (O.cap!=CAP_FLAT) NumPoints+=4; // Achteck-Ende dazu
NumPoints*=2; // beide Seiten
BeginRecord(0x0324/*META_POLYGON*/);
OutWord(NumPoints);
real a,b;
real rad=O.width*0.5412; // Radius für "runde" Enden
int i;
int r=O.radius-O.width/2; // innerer Bogen (entgegen Uhrzeiger)
SetPolyTr(O.xc,O.yc,0);
for (a=O.angle1, i=0; i<n; a+=INCREMENT, i++) {
OutPolyRA(r,a);
}
OutPolyRA(r,O.angle2); // Endpunkt innen
SetPolyTr(O.x2,O.y2,O.angle2);
if (O.cap!=CAP_FLAT) for (b=157.5; b>0; b-=45) {
OutPolyRA(rad,b);
}
r+=O.width; // äußerer Bogen (Uhrzeiger)
SetPolyTr(O.xc,O.yc,0);
OutPolyRA(r,O.angle2); // Endpunkt außen
do{
a-=INCREMENT; // Stützpunkte gegenüberstehend!
OutPolyRA(r,a);
}while(--i);
SetPolyTr(O.x1,O.y1,O.angle1);
if (O.cap!=CAP_FLAT) for (b=-22.5; b>-180; b-=45) {
OutPolyRA(rad,b);
}
EndRecord();
}
void HandleWire(UL_WIRE O) {
if (DontProcess(O.layer)) return;
int st;
switch (O.style) {
case WIRE_STYLE_CONTINUOUS: st=0/*PS_SOLID*/; break;
case WIRE_STYLE_LONGDASH: st=1/*PS_DASH*/; break;
case WIRE_STYLE_SHORTDASH: st=2/*PS_DOT*/; break;
case WIRE_STYLE_DASHDOT: st=3/*PS_DASHDOT*/; break;
}
if (O.arc) {
// Die Ausgabe von Bögen ist bei großen Strichbreiten unbefriedigend,
// weil bei Eagle glatte Kurvenenden gezeichnet werden (PS_ENDCAP_FLAT);
// WMF (Windows 3.1) unterstützt nur PS_ENDCAP_ROUND.
// In diesem Fall ist ein „Tortenstück“ (Pie) die bessere Ausgabe.
// TODO:
// Die Bogenausgabe für gestrichelte Layer erfordert
// Polygonausgabe mit einer großen Anzahl Stützstellen.
// Das ENDCAP-Problem ist hierbei keins.
int rad;
if (IsPie(O.arc)) {
SetLayerPen();
SetLayerBrush();
BeginRecord(0x081A/*META_PIE*/);
rad=O.arc.radius+O.width/2;
}else if (u2mic(O.width)>=MinBreite && (
O.arc.cap==CAP_FLAT && O.arc.width>=FlatArcReplace*O.arc.radius || LayerFill && LineReplace)) {
SetLayerPen();
SetLayerBrush();
if (PiecedReplace && O.style!=WIRE_STYLE_CONTINUOUS)
O.pieces(W) OutPolyArc(W.arc);
else OutPolyArc(O.arc);
return;
}else{
SetPen(st,O.width,LayerColor);
BeginRecord(0x0817/*META_ARC*/);
rad=O.arc.radius;
}
if (odd(Flipped&7)) {
OutXY(O.arc.x1,O.arc.y1);
OutXY(O.arc.x2,O.arc.y2);
}else{
OutXY(O.arc.x2,O.arc.y2);
OutXY(O.arc.x1,O.arc.y1);
}
OutRect(O.arc.xc-rad,O.arc.yc-rad,
O.arc.xc+rad,O.arc.yc+rad);
EndRecord();
}else{
if (LayerFill && LineReplace && u2mic(O.width)>=MinBreite) {
SetLayerPen();
SetLayerBrush();
if (PiecedReplace && O.style!=WIRE_STYLE_CONTINUOUS)
O.pieces(W) OutOctLine(W.x1,W.y1,W.x2,W.y2,W.width);
else OutOctLine(O.x1,O.y1,O.x2,O.y2,O.width);
}else if (PiecedReplace>=2 && O.style!=WIRE_STYLE_CONTINUOUS
&& u2mic(O.width)>=MinBreite) {
SetPen(0,O.width,LayerColor);
O.pieces(W) OutLine(W.x1,W.y1,W.x2,W.y2);
}else{
SetPen(st,O.width,LayerColor);
OutLine(O.x1,O.y1,O.x2,O.y2);
}
}
}
// Textfarbe dunkler machen (auffälliger bei transparenter Ausgabe)
int DarkerColor(int col) {
int rgb[];
rgb[0]=col&0xFF;
rgb[1]=(col>>8)&0xFF;
rgb[2]=(col>>16)&0xFF;
rgb[0]>>=2; // vierteln
rgb[1]>>=2;
rgb[2]>>=2;
return (rgb[2]<<16)|(rgb[1]<<8)|rgb[0];
}
string CharWidth[]={
"8<>OOlY0<<AR8<88OOOOOOOOOO88RRROvYY]]YTb]8KYOg]bYb]YT]YuXXT888FO<OOKOO8OO34L3hOOOO<K8OK]KII<6<R`O`3O<uOO<vY<u`T``33<<>Ou9uK<p`IY8<OOOO6O<_?OR<_OBO<<<QN8<<?OgggTYYYYYYu]YYYY8888]]bbbbbRb]]]]YYTOOOOOOlKOOOO8888OOOOOOOOTOOOOKOK",
"",
"5;CJJfa.<<JO5;57JJJJJJJJJJ77OOOFm]XX]SO]]<B\Rk]]O]XOS]]o]]S<6<GJ<EJEJE=IJ78I7_JJJJ<A7JI\JHEH/HMaJa<JFtJK<tO<kaSaa<<FE=Jt<rA<]aE]5;JJJJ/J>`7HO;`JAN99;PF599;H___E]]]]]]iXSSSS<<<<]]]]]]]O]]]]]]OJEEEEEEXEEEEE7777JJJJJJJNJJJJJJJJ"};
int GetVectorLineWidth(UL_TEXT O) {
O.wires(W) return W.width;
}
// Entfernt Ausrufezeichen sowie Escape-Rückwärtsstriche,
// malt die Überstreichungs-Striche möglichst genau über die (proportionalen,
// True-Type-) Buchstaben in der Linienbreite der alternativen Vektorschrift
string HandleNegation(UL_TEXT O, real angle, int textalign) {
if (!DoNegate) return O.value;
string s=O.value;
int i,j,n; // n gerade wenn kein Strich
int sel=FontSel[O.font]; // muss !=0 sein!
real mult=O.size*1.6/96;
real x,xx[],y; // laufende Pixel, Pixel für Linie, Höhe
char c;
// Modifizieren des Strings, Finden der Überstreichpositionen
for (i=j=x=n=0; c=s[i]; i++) {
switch (c) {
case '\\': {
c=s[++i]; // Folgezeichen buchstäblich nehmen
if (!c) {
--i;
continue; // Backslash herausnehmen
}
}break;
case '!': if (!(n&1)) {
switch (s[i+1]) { // Folgezeichen untersuchen
case 0:
case ' ':
case '!':
case '\'':
case '"':
case ')':
case ']':
case '}': break;
default: n++;
}
if (n&1) {
xx[n-1]=x; // Startposition vermerken
continue; // Ausrufezeichen herausnehmen
}
}else{
xx[n++]=x; // Endposition vermerken
continue; // Ausrufezeichen herausnehmen
}break;
case ',': if (n&1) {
xx[n++]=x; // Endposition vermerken
}break;
}
s[j++]=c;
if (sel==2) x+=53*mult; // Zeichenbreite für 96 Punkt "Courier New"
else if (c<32) x+=40*mult; // falls Sonderzeichen auftauchen (falsches UTF-8)
else x+=(CharWidth[sel-1][c-32]-32)*mult; // Stringbreite in Pixel mitschneiden
}
if (n&1) xx[n++]=x;
s[j]=0; // Ziel (nie länger als Quelle) abhacken
if (n) {
// Striche malen
angle*=PI/180;
real c=cos(angle); // Drehmatrix-Elemente | +cos +sin |
real s=sin(angle); // | -sin +cos |
real x0=O.x;
real y0=O.y;
if (textalign&2/*TA_RIGHT*/) {
x0-=x*c;
y0-=x*s;
}
if (textalign&24/*TA_BASELINE*/) y=O.size*1.25; // empirischer Abstand
else y=O.size*0.25;
x0-=y*s;
y0+=y*c;
SetPen(0/*PS_SOLID*/,GetVectorLineWidth(O),LayerColor);
for (i=0; i<n; i+=2) {
int x1=x0+xx[i]*c;
int y1=y0+xx[i]*s;
int x2=x0+xx[i+1]*c;
int y2=y0+xx[i+1]*s;
OutLine(x1,y1,x2,y2);
}
}
return s;
}
void HandleText(UL_TEXT O) {
// Sehr schade: Win16 kann keinen gespiegelten Text (für Board) ausgeben!
// Auf dem Schaltplan hat O.mirror eine andere Bedeutung als auf dem Board.
if (DontProcess(O.layer)) return;
if (O.value==" ") return; // unterdrückte Values bei Bauelementen
if (!FontSel[O.font] // Ersetzung durch Vektor gewünscht
|| O.font==FONT_VECTOR && O.layer<=LAYER_BOTTOM // Vektorfont auf Kupfer
|| board && odd(Flipped&7) && !O.mirror // gespiegelten Text stets als Vektoren
|| board && !odd(Flipped&7) && O.mirror) { // auch gespiegelt
// Hier sollte eigentlich Eagle die Überstreichungen generieren, ist das so?
O.wires(W) HandleWire(W); // Text als Striche ausgeben
return;
}
// Hier ggf. auf Symbol-Zeichensatz umschalten und mit TA_UPDATECP arbeiten!
if (ProblemText(O)) dlgMessageBox(
"Problematischer Text: »"+O.value+"«<p>Zeichen werden falsch wiedergegeben.");
real w=O.angle;
int a;
switch (O.align) {
case 0/*ALIGN_BOTTOM_LEFT*/ : a=0x08; break; // TA_LEFT|TA_BOTTOM
case 1/*ALIGN_BOTTOM_CENTER*/: a=0x0E; break; // TA_CENTER|TA_BOTTOM
case 2/*ALIGN_BOTTOM_RIGHT*/ : a=0x0A; break; // TA_RIGHT|TA_BOTTOM
case 3/*ALIGN_CENTER_LEFT*/ : a=0x18; break; // TA_LEFT|TA_BASELINE
case 4/*ALIGN_CENTER*/ : a=0x1E; break; // TA_CENTER|TA_BASELINE
case 5/*ALIGN_CENTER_RIGHT*/ : a=0x1A; break; // TA_RIGHT|TA_BASELINE
case 6/*ALIGN_TOP_LEFT*/ : a=0x00; break; // TA_LEFT|TA_TOP
case 7/*ALIGN_TOP_CENTER*/ : a=0x06; break; // TA_CENTER|TA_TOP
case 8/*ALIGN_TOP_RIGHT*/ : a=0x02; break; // TA_RIGHT|TA_TOP
}
// Nur für Schaltplan:
if (schematic && O.mirror) {
if (w==90 || w==270) a^=8; // TA_TOP <-> TA_BOTTOM
else a^=2; // TA_LEFT <-> TA_RIGHT
}
if (!O.spin && w>90 && w<=270) { // Änderung von Ausrichtung bei spin=0?
w-=180; if (w<0) w+=360; // (für Ausführung im Board)
a^=8^2; // Ausrichtung genau anders herum
}
if (Debug) OutCircle(O.x,O.y,mil2u(20)); // Radius: 20 mil = 0,5 mm
real dy=0; // Y-Verschiebung
if (a&16) dy=-0.5; // vertikale Zentrierung? Halbe Schriftgröße nach unten
else if (!(a&8)) dy=0.28; // TA_TOP? Etwas nach oben korrigieren
int mx=O.x-O.size*Sin(dy,w);
int my=O.y+O.size*Cos(dy,w);
if (Flipped&2) w+=180; // huh? Reicht das?
if (Flipped&4) w+=90;
string s=HandleNegation(O,w,a);
int l=strlen(s);
if (!l) return;
int col=LayerColor;
if (Trans && PaletteType==3 && CurLayer>=21) col=DarkerColor(col);
if (a&0x04) a|=0x06; // Alignment-Wert für Windows korrigieren
if (a&0x18) a|=0x18; // Aus TA_BOTTOM stets TA_BASELINE machen
if (O.font==FONT_VECTOR && HasSymbolChars(s)) {
a|=1/*TA_UPDATECP*/;
OutMoveTo(mx,my);
string s1;
int pos=0, sublen;
int font=O.font;
if (a&2) s=strrev(s); // TA_RIGHT
for(;;) {
s1=GetCharRun(s,pos,font&4);
sublen=strlen(s1);
if (pos && !sublen) break; // abbrechen bei Ende
if (sublen) {
if (a&2) s1=strrev(s1); // TA_RIGHT
SetFont(font,O.size,w*10,col,a);
BeginRecord(0x0521/*META_TEXTOUT*/);
OutWord(sublen);
OutString(s1,0);
OutDword(0); // Position hier nicht ausgewertet!
// Ohne diese Null hat der F3-Viewer von Total Commander ein ernstes Problem!
// Ansonsten kann man diese auch weglassen.
EndRecord();
}
font^=4; // umschalten Symbol<->ANSI-Schriftart
pos+=sublen;
}
LastX=INT_MAX; // Position ungültig
return;
}
SetFont(O.font,O.size,w*10,col,a);
BeginRecord(0x0521/*META_TEXTOUT*/);
OutWord(l);
OutString(s,0);
OutXY(mx,my);
EndRecord();
}
/* Nur für Schaltplan */
string DirNames[]={"Nc","In","Out","Io","Oc","Pwr","Pas","Hiz","Sup"};
void HandlePin(UL_PIN O) {
if (DontProcess(LAYER_PINS)) return;
SetLayerPen();
SetBrush(1/*BS_NULL*/,0,0);
OutCircle(O.x,O.y,mic2u(1016));
int w=O.angle;
int a=8|2/*TA_BOTTOM|TA_RIGHT*/;
if (w>=180) {
w-=180;
a^=2/*TA_RIGHT*/;
}
SetFont(1/*Proportional*/,mic2u(950),w*10,LayerColor,a);
string s;
BeginRecord(0x0521/*META_TEXTOUT*/);
OutWord(sprintf(s,"%s %d",DirNames[O.direction],O.swaplevel));
OutString(s,0);
OutXY(O.x,O.y);
EndRecord();
}
/* Nur für Boards: */
void OutDrillSymbol(int x, int y, int type) {
int D=mil2u(40);
switch (type) {
case 0: OutLine(x-D,y-D,x+D,y+D); OutCircle(x,y,D); break; // Ø
case 1: OutLine(x-D,y,x+D,y); OutLine(x,y-D,x,y+D); break; // +
case 2: OutLine(x-D,y-D,x+D,y+D); OutLine(x-D,y+D,x+D,y-D); break; // x
case 3: OutLine(x,y,x,y+D); OutRectangle(x,y,D*2,D*2,0); break;
case 4: OutLine(x,y,x,y+D); OutLineTo(x-D,y); OutLineTo(x,y-D); OutLineTo(x+D,y); OutLineTo(x,y+D); break;
case 5: OutLine(x-D,y-D,x+D,y+D); OutLineTo(x-D,y+D); OutLineTo(x+D,y-D); OutLineTo(x-D,y-D); break;
case 6: OutLine(x-D,y+D,x+D,y-D); OutLineTo(x+D,y+D); OutLineTo(x-D,y-D); OutLineTo(x-D,y+D); break;
case 7: OutLine(x-D,y,x+D,y); OutLineTo(x,y+D); OutLineTo(x,y-D); OutLineTo(x-D,y); break;
case 8: OutLine(x-D,y,x+D,y); OutLineTo(x,y-D); OutLineTo(x,y+D); OutLineTo(x-D,y); break;
case 9: OutLine(x-D,y+D,x+D,y-D); OutLine(x,y-D,x,y+D); OutLine(x+D,y+D,x-D,y-D); break;
case 10: OutLine(x-D,y,x+D,y); OutLine(x+D,y+D,x-D,y-D); OutLine(x-D,y+D,x+D,y-D); break;
case 11: OutLine(x,y-D,x,y); OutLineTo(x+D,y+D); OutLineTo(x-D,y+D); OutLineTo(x,y); break;
case 12: OutLine(x,y+D,x,y); OutLineTo(x+D,y-D); OutLineTo(x-D,y-D); OutLineTo(x,y); break;
case 13: OutLine(x-D,y,x,y); OutLineTo(x+D,y+D); OutLineTo(x+D,y-D); OutLineTo(x,y); break;
case 14: OutLine(x+D,y,x,y); OutLineTo(x-D,y-D); OutLineTo(x-D,y+D); OutLineTo(x,y); break;
case 16: OutCircle(x,y,D/2); /*nobreak;*/
case 15: OutLine(x-D,y,x+D,y); OutLine(x,y+D,x,y-D); OutCircle(x,y,D); break;
case 18: OutRectangle(x,y,D,D,0); /*nobreak;*/
case 17: OutLine(x-D,y,x+D,y); OutLine(x,y+D,x,y-D); OutRectangle(x,y,D*2,D*2,0); break;
}
}
// Die Wärmefallen im Supply-Layer werden wesentlich von den Entwurfsregeln bestimmt.
// Da ist aus ULP-Sicht IMHO kein Zugriff möglich.
// Daher sind hier die Wärmefallen nur Demo und nicht produktionstauglich.
void OutThermal(int x, int y, int r) {
OutOctagon(x-r,y,r>>2,90,1);
OutOctagon(x+r,y,r>>2,90,1);
OutOctagon(x,y-r,r>>2,0,1);
OutOctagon(x,y+r,r>>2,0,1);
}
void DrawHole(int x, int y, int d) {
if (DrawHoles) {
SetPen(5/*PS_NULL*/,0,0);
SetBrush(0/*BS_SOLID*/,0,BackgroundColor);
OutCircle(x,y,d/2);
}
}
int SupplyLayer() {
return 2<=CurLayer && CurLayer<=15 && nam[CurLayer][0]=='$';
}
// ermittelt Bezug zum zu verwendenden Layer für PADs
// Liefert 0 für "don't process"
int GetPadLayer(int flags) {
if (SupplyLayer()) return CurLayer;
switch (CurLayer) {
case LAYER_TSTOP:
case LAYER_BSTOP: if (flags&PAD_FLAG_STOP) return CurLayer; break;
case LAYER_PADS: return LAYER_TOP;
}
return 0;
}
void HandlePad(UL_PAD O) {
if (!O) return;
if (CurLayer==LAYER_DRILLS) {
SetPen(0/*PS_SOLID*/,3*254,LayerColor);
SetBrush(1/*BS_NULL*/,0,0);
OutDrillSymbol(O.x,O.y,O.drillsymbol);
return;
}
int d=0, PadLayer=GetPadLayer(O.flags);
if (!PadLayer) return;
d=O.diameter[PadLayer];
if (!d) return; // raus wenn null geblieben
if (!DrawHoles) {
SetLayerPen();
SetLayerBrush();
switch (O.shape[PadLayer]) {
// im LAYER_PADS ist O.shape immer PAD_SHAPE_ROUND, dann von LAYER_TOP nehmen
case PAD_SHAPE_SQUARE: OutRectangle(O.x,O.y,d,d,O.angle); break;
// hier künftig ARC ausgeben! (aber nur, wenn Layer SOLID)
case PAD_SHAPE_ROUND: OutCircle(O.x,O.y,d/2); break;
case PAD_SHAPE_OCTAGON: OutOctagon(O.x,O.y,d,O.angle,0); break;
case PAD_SHAPE_LONG: OutOctagon(O.x,O.y,d,O.angle,1); break;
case PAD_SHAPE_OFFSET: OutOctagon(O.x,O.y,d,O.angle,2); break;
case PAD_SHAPE_ANNULUS: OutCircle(O.x,O.y,d/2); break;
case PAD_SHAPE_THERMAL: OutThermal(O.x,O.y,d/2); break;
default: dlgMessageBox("??");
}
}
if (PadLayer==LAYER_TOP) DrawHole(O.x,O.y,O.drill);
}
// ermittelt Bezug zum zu verwendenden Layer für PADs
// Liefert 0 für "don't process"
int GetViaLayer(int flags) {
if (SupplyLayer()) return CurLayer;
switch (CurLayer) {
case LAYER_TSTOP:
case LAYER_BSTOP: if (flags&VIA_FLAG_STOP) return CurLayer; break;
case LAYER_VIAS: return LAYER_TOP;
}
return 0;
}
void HandleVia(UL_VIA O) {
if (!O) return;
if (CurLayer==LAYER_DRILLS) {
SetPen(0/*PS_SOLID*/,3*254,LayerColor);
SetBrush(1/*BS_NULL*/,0,0);
OutDrillSymbol(O.x,O.y,O.drillsymbol);
return;
}
int d=0, ViaLayer=GetViaLayer(O.flags);
if (!ViaLayer) return;
d=O.diameter[ViaLayer];
if (!d) return; // raus wenn null geblieben
if (!DrawHoles) {
SetLayerPen();
SetLayerBrush();
switch (O.shape[ViaLayer]) {
case VIA_SHAPE_SQUARE: OutRectangle(O.x,O.y,d,d,0); break;
// hier künftig ARC ausgeben! (aber nur, wenn Layer SOLID)
case VIA_SHAPE_ROUND: OutCircle(O.x,O.y,d/2); break;
case VIA_SHAPE_OCTAGON: OutOctagon(O.x,O.y,d,0,0); break;
case VIA_SHAPE_ANNULUS: OutCircle(O.x,O.y,d/2); break;
case VIA_SHAPE_THERMAL: OutThermal(O.x,O.y,d/2); break;
default: dlgMessageBox("???");
}
}
if (ViaLayer==LAYER_TOP) DrawHole(O.x,O.y,O.drill);
}
int GetSmdLayer(int SmdLayer, int flags) {
switch (SmdLayer) {
case LAYER_BOTTOM: switch (CurLayer) { // SMD-Pad unten
case LAYER_BSTOP: if (flags&SMD_FLAG_STOP) return LAYER_BSTOP; break;
case LAYER_BCREAM: if (flags&SMD_FLAG_CREAM) return LAYER_BCREAM; break;
case LAYER_BOTTOM: return LAYER_BOTTOM;
}break;
case LAYER_TOP: switch (CurLayer) { // SMD-Pad oben
case LAYER_TSTOP: if (flags&SMD_FLAG_STOP) return LAYER_TSTOP; break;
case LAYER_TCREAM: if (flags&SMD_FLAG_CREAM) return LAYER_TCREAM; break;
case LAYER_TOP: return LAYER_TOP;
}break;
}
return 0;
}
void HandleSmd(UL_SMD O) {
if (!O) return;
int SmdLayer=GetSmdLayer(O.layer,O.flags);
if (!SmdLayer) return;
int dx=O.dx[SmdLayer], dy=O.dy[SmdLayer];
if (!dx) return; // raus wenn null geblieben
SetLayerPen();
SetLayerBrush();
if (O.roundness) { // Angabe in Prozent der kürzeren Seite
if (O.roundness==100 && dx==dy) OutCircle(O.x,O.y,dx/2);
else{
int r=dx<dy?dx:dy; // kürzere der beiden Seiten
r=r*O.roundness/200; // Radius der Abrundung
OutRoundRect(O.x,O.y,dx,dy,r,O.angle);
}
}else OutRectangle(O.x,O.y,dx,dy,O.angle);
}
void HandleHole(UL_HOLE O) {
switch (CurLayer) {
case LAYER_DRILLS:
case LAYER_HOLES: {
SetPen(0/*PS_SOLID*/,3*254,LayerColor);
SetBrush(1/*BS_NULL*/,0,0);
OutDrillSymbol(O.x,O.y,O.drillsymbol);
}break;
case LAYER_DIMENSION: {
SetLayerPen();
SetBrush(1/*BS_NULL*/,0,0);
OutCircle(O.x,O.y,O.drill/2);
}break;
default: if (SupplyLayer()) {
int d=O.diameter[LAYER_TSTOP]; // Kein Zugriff auf Spacing von den Entwurfsregeln
if (!d) d=O.diameter[LAYER_BSTOP];
if (!d) d=O.drill;
SetLayerPen();
SetLayerBrush();
OutCircle(O.x,O.y,d/2);
}
}
}
void HandleAttribute(UL_ATTRIBUTE O) {
if (O.display) HandleText(O.text);
}
void HandleDimension(UL_DIMENSION O) {
O.texts(O) HandleText(O);
O.wires(O) HandleWire(O);
}
void HandleFrame(UL_FRAME O) {
O.texts(O) HandleText(O);
O.wires(O) HandleWire(O);
}
void HandleLabel(UL_LABEL O) {
HandleText(O.text);
O.wires(O) HandleWire(O); // nur bei xref
}
void HandleSymbol(UL_SYMBOL O) {
O.circles(O) HandleCircle(O);
O.dimensions(O) HandleDimension(O);
O.frames(O) HandleFrame(O);
O.rectangles(O) HandleRectangle(O);
O.pins(O) {
O.circles(O) HandleCircle(O);
O.texts(O) HandleText(O);
O.wires(O) HandleWire(O);
}
O.polygons(O) HandlePolygon(O);
O.texts(O) HandleText(O); // Unsmashed UND smashed (Bug in Eagle 6)
O.wires(O) HandleWire(O);
}
/* Abarbeitung eines Layers (schwarzweiß: alle) */
void SchWalkLayer(UL_SHEET O) {
status(LoadStringIIS(22,O.number,CurLayer,nam[CurLayer]));
O.busses(O) {
O.segments(O) {
O.labels(O) HandleLabel(O);
O.wires(O) HandleWire(O);
}
}
O.circles(O) HandleCircle(O);
O.dimensions(O) HandleDimension(O);
O.frames(O) HandleFrame(O);
O.parts(O) { // Dokumentationsfehler!
O.instances(O) {
O.attributes(O) HandleAttribute(O);
HandleSymbol(O.gate.symbol);
// O.texts(O) HandleText(O); // Smashed - kommt sonst 2x
O.xrefs(O) HandleSymbol(O.symbol);
}
}
O.nets(O) {
O.segments(O) {
O.junctions(O) HandleJunction(O);
O.labels(O) HandleLabel(O);
O.wires(O) HandleWire(O);
}
}
O.polygons(O) HandlePolygon(O);
O.rectangles(O) HandleRectangle(O);
O.texts(O) HandleText(O);
O.wires(O) HandleWire(O);
}
void BrdWalkLayer(UL_BOARD O) {
status(LoadStringIS(23,CurLayer,nam[CurLayer]));
O.circles(O) HandleCircle(O);
O.dimensions(O) HandleDimension(O);
O.elements(O) {
O.attributes(O) HandleAttribute(O);
O.package.circles(O) HandleCircle(O);
O.package.contacts(O) {
HandlePad(O.pad);
HandleSmd(O.smd);
}
O.package.dimensions(O) HandleDimension(O);
O.package.frames(O) HandleFrame(O);
O.package.holes(O) HandleHole(O);
O.package.polygons(O) HandlePolygon(O);
O.package.rectangles(O) HandleRectangle(O);
O.package.texts(O) HandleText(O); // unsmashed
O.package.wires(O) HandleWire(O);
O.texts(O) HandleText(O); // smashed
}
O.frames(O) HandleFrame(O);
O.holes(O) HandleHole(O);
O.polygons(O) HandlePolygon(O);
O.rectangles(O) HandleRectangle(O);
O.signals(O) {
O.polygons(O) {
if (IsRatsnestPoly(O)) HandlePolygon(O);
}
O.vias(O) HandleVia(O);
O.wires(O) HandleWire(O);
}
O.texts(O) HandleText(O);
O.wires(O) HandleWire(O);
}
/* Abarbeitung layer-weise von hinten nach vorn, wenn bunt (sonst unexakte Darstellung) */
void SchWalkLayers(UL_SHEET O) {
if (PaletteType) for (CurLayer=255; CurLayer>=0; CurLayer--) {
if (SetLayer(CurLayer)) SchWalkLayer(O);
}else SchWalkLayer(O); // Schwarzweiß NICHT im Sandwich-Betrieb abarbeiten (schneller)
}
void BrdWalkLayer2(UL_BOARD O, int DoLast) {
if (!SetLayer(CurLayer)) return;
if (!DoLast && strchr(LastLayers,CurLayer)>=0) return; // überspringen
BrdWalkLayer(O);
// Zweiter Durchlauf für die Löcher (In einem einzelnen Durchlauf würde,
// wegen der vielen Kontextumschaltungen, die .WMF-Datei viel größer werden.)
if (CurLayer==LAYER_VIAS || CurLayer==LAYER_PADS) {
DrawHoles=1;
OutRop(13/*R2_COPYPEN*/); // Löcher zum Hintergrund "durchstanzen"
BrdWalkLayer(O);
DrawHoles=0;
}
}
/* Abarbeitung layer-weise, sogar wenn schwarz-weiß */
void BrdWalkLayers(UL_BOARD O) {
// Eagle gibt die Kupferlagen von unten nach oben aus
if (Trans) {
// Löcher ausstanzen lassen, bevor Kupferlinien hineingezogen werden (wie Eagle)
for (CurLayer=17; CurLayer<21; CurLayer++) BrdWalkLayer2(O,0);
for (CurLayer=16; CurLayer>=1; CurLayer--) BrdWalkLayer2(O,0);
}else{
for (CurLayer=16; CurLayer>=1; CurLayer--) BrdWalkLayer2(O,0);
for (CurLayer=17; CurLayer<21; CurLayer++) BrdWalkLayer2(O,0);
}
for (CurLayer=29; CurLayer<51; CurLayer++) BrdWalkLayer2(O,0);
for (CurLayer=53; CurLayer<256; CurLayer++) BrdWalkLayer2(O,0);
//Typische Text-Layer zuletzt
for (CurLayer=51; CurLayer<53; CurLayer++) BrdWalkLayer2(O,0);
for (CurLayer=21; CurLayer<29; CurLayer++) BrdWalkLayer2(O,0);
Trans=0; // Transparenz für LastLayers ausschalten
for (int i=0; CurLayer=LastLayers[i]; i++) BrdWalkLayer2(O,1);
}
int Area[]; // Bereich (X1,Y1,X2,Y2; sortiert), in WMF-Einheiten
void FatalExit(string s) {
dlgMessageBox(s);
exit(EXIT_FAILURE);
}
void FatalExit1(string format, string info) {
string s;
sprintf(s,format,info);
FatalExit(s);
}
void OutStart(UL_AREA O) {
Area[0]=Mass(O.x1);
Area[1]=Mass(O.y1);
Area[2]=Mass(O.x2);
Area[3]=Mass(O.y2);
if (Flipped&4) {int t=Area[0]; Area[0]=Area[1]; Area[1]=t; t=Area[2]; Area[2]=Area[3]; Area[3]=t;} //X<->Y tauschen (zuerst!)
if (!(Flipped&2)) {int t=Area[1]; Area[1]=-Area[3]; Area[3]=-t;} // Y tauschen und Vorzeichenwechsel (WMF zählt von unten)
if (Flipped&1) {int t=Area[0]; Area[0]=-Area[2]; Area[2]=-t;} // X tauschen und Vorzeichenwechsel
if (max(Area[2]-Area[0],Area[3]-Area[1])>32767) // Notbremse! Dateileiche bleibt liegen.
FatalExit("Teiler zu klein; resultierende Abmessungen übersteigen 16 bit!");
nWords=0; // Kopf beginnen
nMaxRecSize=0;
ClearObjects();
// Normalen Windows-Metafile-Kopf ausgeben
OutWord(2); // FileType = Disk
OutWord(9); // HeaderSize
OutWord(0x0100); // Version
nWords=8; // noch unbekannte WORDs überspringen
OutWord(0); // NumOfParams
// Ohne die 3 folgenden Records haben Total Commander sowie Internet Explorer ein Problem!
BeginRecord(0x0103/*META_SETMAPMODE*/);
OutWord(8/*MM_ANISOTROPIC*/);
EndRecord();
BeginRecord(0x020B/*META_SETWINDOWORG*/);
OutWord(Area[1]);
OutWord(Area[0]);
EndRecord();
BeginRecord(0x020C/*META_SETWINDOWEXT*/);
OutWord(Area[3]-Area[1]+1);
OutWord(Area[2]-Area[0]+1);
EndRecord();
BeginRecord(0x0102/*META_SETBKMODE*/);
OutWord(1/*TRANSPARENT*/); // für Schrift und normale Schraffur
EndRecord();
if (HatchType==2) {
BeginRecord(0x0201/*META_SETBKCOLOR*/);
int col=BackgroundColor;
if (Trans && PaletteType==3) col^=0xFFFFFF;
OutDword(col); // für Pattern-Schraffur (ist immer deckend - leider!)
EndRecord();
}
if (OutBkgnd) {
SetPen(5/*PS_NULL*/,0,0); // Hintergrundrechteck mit leichtem Übermaß zeichnen
SetBrush(0/*BS_SOLID*/,0,BackgroundColor);
BeginRecord(0x041B/*META_RECTANGLE*/);
int o=mil2u(10);
OutRect(O.x1-o,O.y1-o,O.x2+o,O.y2+o);
EndRecord();
}
}
void OutWrite() {
int PHeader[]; // Vorhaltung zur Berechnung der Prüfsumme
int i;
BeginRecord(0/*META_EOF*/);
EndRecord();
status("Datei-Ausgabe ("+FName+")");
// Aldus-Placeable-Metafile-Kopf ausgeben
PHeader[0]=0xCDD7; // DWORD Key
PHeader[1]=0x9AC6;
/*0*/ // WORD Handle
PHeader[3]=Area[0]; // SHORT Left
PHeader[4]=Area[1]; // SHORT Top
PHeader[5]=Area[2]+1; // SHORT Right
PHeader[6]=Area[3]+1; // SHORT Bottom
// Manche Programme interpretieren diese Grenzen als inklusive,
// manche andere als exklusive unteren rechten Rand.
// Das +1 vermeidet Abschneideprobleme.
PHeader[7]=round(25400/Teiler/Scale); // ergibt 1:1-Import in Word
// Beim Standard-Teiler von 25,4 µm/Pixel ergibt das 1000 dpi
// Eagle <6 hat 254000 dpi, also 256 dot per mil und 10 dot per mm
// Eagle 6 hat 8128000 dpi, das 32-fache von Eagle <6
// Die Angaben im SDK scheinen allesamt irreführend zu sein!
// Richtig (und auch logisch) scheint: <inch> WMF-Einheiten ergeben 1 Zoll.
// Schaltpläne sehen damit im IE6 (und .CHM-Dateien) unansehnlich aus.
/*0,0*/ // DWORD Reserved
/*0*/ // WORD Checksum
for (i=0; i<10; i++) PHeader[10]^=PHeader[i]; // Prüfsumme ermitteln
for (i=0; i<11; i++) PrintWord(PHeader[i]);
// Windows-Metafile-Kopfdaten ergänzen
FileData[3]=nWords&0xFFFF; // FileSize
FileData[4]=nWords>>16;
FileData[5]=nHandles; // NumOfObjects
FileData[6]=nMaxRecSize&0xFFFF;// MaxRecordSize
FileData[7]=nMaxRecSize>>16;
for (i=0; i<nWords; i++) PrintWord(FileData[i]); // Daten ausspucken
}
/* Ausgabe einer Metadatei */
void SchPrintMF(UL_SHEET O) {
OutStart(O.area);
SchWalkLayers(O);
OutWrite();
}
void BrdPrintMF(UL_BOARD O) {
OutStart(O.area);
BrdWalkLayers(O);
OutWrite();
}
// Einen Schriftart-Parameter parsen
// Dieser muss den regexp-Aufbau haben: (Vector|Arial|Courier|Times)(,b?i?)?
// oder [VACT][,bi]*
void ParseFont(int idx, string val) {
int p=strchr(val,',');
if (strlen(val)<=3) p=1; // in der Kurzform ohne Komma zulässig
string suffix;
if (p>=0) {
suffix=strsub(val,p);
val=strsub(val,0,p);
}
if (val=="") ; // ohne Schriftname Voreinstellung lassen
else if (val=="Vector" || val=="V") FontSel[idx]=0;
else if (val=="Arial" || val=="A") FontSel[idx]=1;
else if (val=="Courier" || val=="C") FontSel[idx]=2;
else if (val=="Times" || val=="T") FontSel[idx]=3;
else FatalExit1("Unbekannte Schriftartbezeichnung %s!",val);
FontBold[idx]=0;
FontItalic[idx]=0;
for (p=0; p<strlen(suffix); p++) switch (suffix[p]) {
case 'b': FontBold[idx]=1; break;
case 'i': FontItalic[idx]=1; break;
case ',': break;
default:
FatalExit1("Unbekannter Schriftstil %s! (Nur »b« [fett] oder »i« [kursiv])",""+suffix[p]);
}
}
int CheckRipupPoly=0; // Prüfung auf nicht geRATSNESTe Signal-Polygone
string GetWorkFileName(void) {
if (schematic) schematic(S) return S.name;
if (board) board(B) return B.name;
}
string AutomaticFileName(void) {
string e;
if (board) {
int i=strrchr(SName,'.');
if (i<0) i=strlen(SName);
if (isalpha(SName[i-1])) e="-"; // Bindestrich um es vom Dateinamen abzugrenzen
e+=odd(Flipped&7)?"b":"t"; // "b" für "bottom" und "t" für "top", später "d" für "Drill"
}
e+=".wmf";
return filesetext(SName,e);
}
// Die Kommandozeile ist an AWK-Syntax angelegt:
// Entweder <dateiname> oder <variable>=<wert>.
// Nur ein <dateiname> ist erlaubt, der kein '=' enthalten darf.
// Alle im Dialog einstellbaren Variablennamen sind erlaubt.
// Der Dateiname "*" spezifiziert den Standard-Dateinamen.
void ParseCommandLine(void) {
int i,j,p;
string arg,key,val;
for (i=1; i<argc; i++) {
arg=argv[i];
p=strchr(arg,'=');
if (p>=0) { // normales Argument
key=strsub(arg,0,p);
val=strsub(arg,p+1);
if (key=="Debug") Debug=strtol(val);
else if (key=="WMF-Unit") Teiler=strtod(val);
else if (key=="MinWidth") MinBreite=strtod(val);
else if (key=="PaletteType" || key=="p") {
PaletteType=strtol(val);
OnSetPaletteType();
}else if (key=="HatchType" || key=="h") HatchType=strtol(val);
else if ((key=="AllPages" || key=="a") && schematic) AllPages=strtol(val);
else if ((key=="Flipped" || key=="f") && board) Flipped=strtol(val);
else if (key=="Trans" || key=="t") Trans=strtol(val);
else if (key=="OutBkgnd" || key=="b") OutBkgnd=strtol(val);
else if (key=="DoNegate" || key=="n") DoNegate=strtol(val);
else if (key=="LineReplace" || key=="l") LineReplace=strtol(val);
else if (key=="FlatArcReplace" || key=="c") FlatArcReplace=strtod(val);
else if (key=="PiecedReplace") PiecedReplace=strtol(val);
else if (key=="Dialog" || key=="d") Dialog=strtol(val);
else if ((key=="LastLayers" || key=="y") && board) LastLayers=val;
else if (key=="Vector" || key=="V") ParseFont(0,val);
else if (key=="Proportional" || key=="P") ParseFont(1,val);
else if (key=="Fixed" || key=="F") ParseFont(2,val);
else if ((key=="CheckRipupPoly" || key=="r") && board) CheckRipupPoly=strtol(val);
else if (key=="Group" || key=="g") GroupOnly=strtol(val);
else if (key=="Scale" || key=="s") Scale=strtod(val);
else FatalExit1("Unbekannte Variable %s!",key);
}else{ // Dateiname
if (FName) FatalExit1("Mehrere Dateinamen (%s) sind nicht möglich!",arg);
if (arg=="*") FName=AutomaticFileName();
else{
FName=arg;
if (FName[0]!='\\' && FName[0]!='/' && FName[1]!=':')
// Relative Pfade sollen sich aufs Schaltplan- bzw. Board-Verzeichnis beziehen.
// Ohne diese Aktion wäre es relativ zum Eagle/bin-Verzeichnis.
FName=filedir(GetWorkFileName())+FName;
}
}
}
if (!Dialog && !CalcLastLayers()) exit(EXIT_FAILURE);
}
/* Hauptprogramm */
if (!schematic && !board) {
FatalExit("Muss aus Schaltplan oder Board gestartet werden!");
}
// Informationen über Schaltplan und Layer einsammeln
if (schematic) {
schematic(S) {
S.layers(L) if (L.visible) {
col[L.number]=L.color; // Layer vermerken
fil[L.number]=L.fill; // Füll-Stile (1 = komplett gefüllt)
nam[L.number]=L.name; // Name (für Status-Anzeige)
if (L.fill!=1) NumHatched++;
}
SName=filename(S.name);
SchCountFonts(S);
}
HatchType=0;
Scale=1.3888888;
// ausprobiert für gute 1:1-Bildschirmdarstellung, bspw. im IE6
// Beim Standard-Teiler von 25,4 µm/Pixel ergibt das 720 dpi
}else board(B) {
B.layers(L) if (L.visible) {
col[L.number]=L.color; // Layer vermerken
fil[L.number]=L.fill; // Füll-Stile (1 = komplett gefüllt)
nam[L.number]=L.name; // Name (für Status-Anzeige und Supply-Layer)
if (L.fill!=1) NumHatched++;
if (L.fill==2 || L.fill==4 || L.fill==5 || L.fill>=9) NumExact++;
}
SName=filename(B.name);
BrdCountFonts(B);
CheckRipupPoly=1;
// diese Layer sind wesentliches Kriterium zur Voreinstellung
Flipped=col[LAYER_BPLACE] && !col[LAYER_TPLACE];
}
if (NumExact) HatchType=2; // Vorgabe wenn solche Schraffuren sichtbar (nur Board)
OnSetPaletteType();
// Kommandozeile auswerten
ParseCommandLine();
if (CheckRipupPoly) board(B) if (BrdAreRipupPolys(B)) switch (dlgMessageBox(
"!Es sind Signal-Polygone vorhanden, die nur als Außenkontur "+
"(nicht freigerechnet) erscheinen.\n"+
"Für korrekte Polygondarstellung vorher RATSNEST ausführen!",
"&RATSNEST starten","Polygone &ignorieren", "&Abbrechen")) {
case 0: exit("RATSNEST;run "+strjoin(argv,' ')); break;
case 2: exit(0); break;
}
// Nutzer-Dialog anzeigen
Rotated=Flipped>>2&1;
TopDown=Flipped>>1&1;
Flipped&=1;
if (Dialog && DialogBox()!=1) exit(EXIT_FAILURE);
if (TopDown) Flipped|=2;
if (Rotated) Flipped^=5; // Rotation nach links (nach Spiegelung)
// Hintergrundfarbe (für Löcher!) einstellen
if (!PaletteType || PaletteType==3 && Trans) BackgroundColor=0xFFFFFF;
else BackgroundColor=rgb2bgr(palette(0,PaletteType-1));
// Dateiname erfragen; Vorgabe für Boards ist Suffix "t" (TOP) oder "b" (BOTTOM)
if (!FName) {
FName=AutomaticFileName();
FName=dlgFileSave("Speichern Windows-Metadatei",FName,"*.wmf");
}
if (!FName) exit(EXIT_FAILURE);
if (AllPages) {
schematic(O) O.sheets(O) {
string e;
sprintf(e,"-%d%s",O.number,fileext(FName));
output(filesetext(FName,e),"wb") SchPrintMF(O);
}
}else{
if (board) board(O) {
output(FName,"wb") BrdPrintMF(O);
}else sheet(O) {
output(FName,"wb") SchPrintMF(O);
}
}
| Detected encoding: ANSI (CP1252) | 4
|
|
|