/* GEDRULE (GED) -- Layout Rule Definition Utility */
/* GEDRULE (GED) -- Layout Regelzuweisungsutility */
/*
// Copyright (c) 1998-2012 Oliver Bartels F+E, Muenchen
// Author: Roman Ludwig
// Changes History:
//	rl (120427) RELEASED FOR BAE V7.8.
//	rl (101019) RELEASED FOR BAE V7.6.
//	rl (100308) ENHANCEMENT:
//		Added PDF layer group functions.
//	rl (091027) RELEASED FOR BAE V7.4.
//	rl (081208) ENHANCEMENT:
//		Added layer stackup output file name extension support.
//	rl (081014) RELEASED FOR BAE V7.2.
//	rl (080424) BUGFIX:
//		Fixed problem with layer stackup layer move/delete functions.
//	rl (080306) ENHANCEMENT:
//		Added predicate set functions.
//	rl (071029) RELEASED FOR BAE V7.0.
//	rl (070812) ENHANCEMENT:
//		Added layer display order swap option.
//	rl (061107) ENHANCEMENT:
//		Added pattern button to rule name selection box.
//	rl (060926) RELEASED FOR BAE V6.8.
//	rl (060721) ENHANCEMENT:
//		Added page preselection for picked predicate attribute on
//		multipage predicate attribute lists.
//	rl (060620) ENHANCEMENT:
//		Added part predicate default values edit function.
//	rl (060222) ENHANCEMENT:
//		Added element specific DRC block number functions.
//	rl (060110) ENHANCEMENT:
//		Added element info to rule edit box.
//	rl (050906) RELEASED FOR BAE V6.6.
//	rl (050906) ENHANCEMENT:
//		Added part predicate edit function.
//	rl (040811) RELEASED FOR BAE V6.4.
//	rl (040330) ENHANCEMENT:
//		Added glue support functions.
//	rl (040313) ENHANCEMENT:
//		Added layer stackup layer comment field.
//		Added layer stackup export function.
//	rl (030912) RELEASED FOR BAE V6.2.
//	rl (030520) ENHANCEMENT:
//		Added layer stackup parameter function.
//	rl (021209) RELEASED FOR BAE V6.0.
//	rl (020618) RELEASED FOR BAE V5.4.
//	rl (020611) ENHANCEMENT:
//		Introduced enhanced rule selection dialog box.
//	rl (011213) ENHANCEMENT:
//		Added group rule manipulation functions.
//	rl (010625) RELEASED FOR BAE V5.0.
//	rl (000509) RELEASED FOR BAE V4.6.
//	rl (990803) RELEASED FOR BAE V4.4.
//	rl (980910) RELEASED FOR BAE V4.2.
//	mb (980710) ENHANCEMENT:
//		Pulldown menu delimiters introduced.
//	mb (980711) ENHANCEMENT:
//		Dynamic multi-language support introduced.
//	mb (980420) CHANGE:
//		Inline documentation changed.
//	rl (980310) ORIGINAL CODING.
//
// DESCRIPTION
//
// The gedrule User Language program is used to attach/detach rules
// to/from layout figure list elements. The rules should be defined
// using the RULECOMP Neural Rule System Compiler in order to avoid
// undefined rule system errors.
*/

// Includes
#include "pop.ulh"			// User Language popup utilities
#include "lay.ulh"			// User Language layout utilities
#include "sql.ulh"			// User Language SQL utilities

// Disable undo state request
#pragma ULCALLERNOUNDO

// Messages
string UPRABORT		= M_UPRABORT();
string UPRDONE		= M("&Fertig","D&one");
string UPRTOGGLE	= M("&Setzen/Loeschen","Set/Rese&t");
string UPRPATTERN	= M("&Muster","&Pattern");
string UPRPREDICATE	= M("Predikate :","Predicates :");
string UPRNPRED		= M("Neuer Wert fuer Predikat '%s' von %s ?",
			    "New Value for Predicate '%s' ?");
string UPRPREDSTR	= M("String","String");
string UPRPREDDBL	= M("Double","Double");
string UPRPREDINT	= M("Integer","Integer");
string UPRPREDFSET	= M("ein","on");
string UPRPREDFUSET	= M("aus","off");
string UPRPREDBITS	= M("Bitmaske ","Bit mask");
string UPRDPREDSTR	= M("Stringpredikat fuer %s selektieren",
			    "Select string predicate for %s");
string UPRDPREDDBL	= M("Doublepredikat fuer %s selektieren",
			    "Select double predicate for '%s'");
string UPRDPREDINT	= M("Integerpredikat fuer %s selektieren",
			    "Select integer predicate for '%s'");
string UPRSELETYP	= M("Elementtyp selektieren!","Select element type!");
string UPRSELE0		= M("&Flaechen","P&olygons");
string UPRSELE1		= M("&Leiterbahnen","T&races");
string UPRSELE2		= M("Bauteile/&Pins","&Parts/Pins");
string UPRSELE3		= M("&Vias/Pads","&Vias/Pads");
string UPRSELE4		= M("&Texte","&Texts");
string UPRSELE5		= M("&Bohrungen","&Drills");
string UPRSELE6		= M("%Pla&n","%Pla&n");
string UPRSELE7		= M("%&Gruppe","%&Group");
string UPRSELE8		= M("%Veran&kerung","%Gl&ue");
string UPRSELE9		= M("%L&agenaufbau","%&Layer Stackup");
string UPRSELE10	= M("%Ba&uteilattribute","%P&art Attributes");
string UPRSELE11	= M("%Kontext&funktionen","%Context &Functions");
string UPRSELE12	= M("%&Regelupdate","%Rul&e Update");
string UPRSELPOLY	= M("Flaeche selektieren!","Select polygon!");
string UPRSELPATH	= M("Leiterbahn selektieren!","Select trace!");
string UPRSELPART	= M("Bauteil selektieren!","Select part!");
string UPRSELNREF	= M("Bauteil/Pin selektieren!","Select part/pin!");
string UPRSELUREF	= M("Via/Pad selektieren!","Select via/pad!");
string UPRSELTEXT	= M("Text selektieren!","Select text!");
string UPRSELDRILL	= M("Bohrung selektieren!","Select drill!");
string UPRSELRULE0	= M("Regel setzen/loeschen (","Rule set/reset (");
#define UPRSELRULE1	") ? "
string UPRDRULEH	= M("Regeln fuer %s setzen/loeschen",
			    "%s rules set/reset");
string UPRDRTEXT	= M("Text '%s' %s","Text '%s' %s");
string UPRDRPATH	= M("Leiterbahn %s","Trace %s");
string UPRDRPART	= M("Bauteil '%s'/'%s'","Part '%s'/'%s'");
string UPRDRPIN		= M("Pin '%s'/'%s'","Pin '%s'/'%s'");
string UPRDRVIA		= M("Via '%s'","Via '%s'");
string UPRDRPAD		= M("Pad '%s' %s","Pad '%s' %s");
string UPRDRPTYPPC	= M("Kupferflaeche %s","Passive Copper %s");
string UPRDRPTYPKO	= M("Sperrflaeche %s","Keep Out Area %s");
string UPRDRPTYPDL	= M("Dokumentarlinie %s","Documentary Line %s");
string UPRDRPTYPDA	= M("Dokumentarflaeche %s","Documentary Area %s");
string UPRDRPTYPAC	= M("Potentialflaeche %s","Active Copper %s");
string UPRDRPTYPSP	= M("Geteilte Versorgungslage %s","Split Power Plane %s");
string UPRDRPTYPCF	= M("Fuellbereich %s","Copper Fill Area %s");
string UPRDRPTYPBO	= M("Umrandung","Board Outline");
string UPRDRDRILL	= M("Bohrung Klasse '%c'","Drill Class '%c'");
string UPRRULENAME	= M("Regelname :","Rule Name :");
string UPRRULESET	= M("Gesetzte Regeln :","Rules set :");
string UPRRULEPROJ	= M("Regeln in Projektdatei :",
			    "Rules in Project File :");
string UPRRULEDB	= M("Regeln in Datenbank :","Database Rules :");
string UPRRULE		= M("Regel ? ","Rule ? ");
string UPRRULEPAT	= M("Regelnamen(smuster) (<?>:Liste) ? ",
			    "Rule Name Pattern (<?>:Liste) ? ");
string UPRSELRG		= M("Regeln Gruppenfunktion selektieren!",
			    "Select rule group function!");
string UPRSELRG0	= M("Regeln &setzen","&Set Rules");
string UPRSELRG1	= M("Regeln &loeschen","&Delete Rules");
string UPRSELRG2	= M("Regeln sele&ktieren","Se&lect Rules");
string UPRSELRG3	= M("%PD&F-Farbe setzen","%Set PDF &Color");
string UPRSELRG4	= M("&PDF-Farbe selektieren","Select &PDF Color");
string UPRSELRG5	= M("PDF-&Ebene setzen","Set PDF La&yer");
string UPRSELRG6	= M("PDF-E&bene selektieren","S&elect PDF Layer");
string UPRSELGL		= M("Regeln Gruppenfunktion selektieren!",
			    "Select rule group function!");
string UPRSELGL0	= M("Bauteil(e) &verankern","&Glue Part(s)");
string UPRSELGL1	= M("Bauteil(e) &freigeben","&Unglue Part(s)");
string UPRSELGL2	= M("%Gruppenelemente v&erankern","%G&lue Group Elements");
string UPRSELGL3	= M("Gruppenelemente f&reigeben","U&nglue Group Elements");
string UPRSELGL4	= M("%&Selektieren verankert","%&Select Glued");
string UPRSELGL5	= M("&Deselektieren verankert","&Deselect Glued");
string UPRPDFCOLOR	= M("PDF-Farbe ? ","PDF Color ? ");
string UPRPDFLAY	= M("PDF-Ebene ? ","PDF Layer ? ");
string UPRBRWCOLOR	= M("BAE-Auswahl","BAE-Selection");
string UPRBRWCOLORP	= M("PDF-Farbe selektieren!","Select PDF Color!");
string UPRLAYSET	= M("Lagenaufbau [um]","Layer Stackup [um]");
string UPRLAYEPSR	= M("Epsilon r","Epsilon r");
string UPRLAYTAND	= M("tan delta","tan delta");
string UPRLAYTHICK	= M("Metall.","Metall");
string UPRLAYISO	= M("Isolation","Isolation");
string UPRLAYSUM	= M("Gesamtdicke","Total Thickness");
string UPRLAYSUMB	= M("Summe ->","Sum ->");
string UPRLAYSURF	= M("Oberflaeche","Surface");
string UPRLAYMAT	= M("Material","Material");
string UPRLAYNOMAT	= M("spezial","special");
string UPRLAYTOL	= M("Toleranz [%]","Tolerance [%]");
string UPRLAYCORE	= M("core","core");
string UPRLAYFILL	= M("Masse","Ground");
string UPRLAYCOMM	= M("Kommentar","Comment");
string UPRLAYFROM	= M("von","from");
string UPRLAYTO		= M("zu","to");
string UPRLAYMOVE	= M("&Verschieben","Mo&ve");
string UPRLAYADD	= M("&Hinzufuegen","&Add");
string UPRLAYDEL	= M("&Loeschen","&Delete");
string UPRLAYEXP	= M("&Export","&Export");
string UPRLAYIMP	= M("&Import","&Import");
string UPRLAYDUMP	= M("&Dump","Dum&p");
string UPRSELLAY	= M("Neue Lage auswaehlen","Select New Layer");
string UPRDELLAY	= M("Lage loeschen","Delete Layer");
string UPRDFILE		= M("!Zieldateiname ? ","!Destination File Name ? ");
string UPRSFILE		= M("Quelldateiname ? ","Source File Name ? ");
string UPRFEXISTS	= M("Ausgabedatei '%s' existiert bereits. Ueberschreiben ?",
			    "Output file '%s' already exits. Overwrite ?");
string UPRNEWTHICK	= M("Neue Gesamtdicke %sum eintragen ?",
			    "Use new total thickness %s um ?");
string UPRDIALFFUNC	= M("Kontextfunktionen","Context Functions");
string UPRITEMMOVDST	= M("Neue Position fuer Kontextfunktion '%s' selektieren",
			    "Select new position for context function '%s'");
string UPRDIALFEDIT	= M("Kontextfunktion %d","Context Function %d");
string UPRDFCTNAME	= M("Name :","Name :");
string UPRDFCTPROG	= M("Aufrufsequenz :","Calling sequence :");
string UPRULCPROG	= M("Programmname :","Program Name :");
string UPRMACSEL	= M("Makroauswahl","Macro Selection");
string UPRDEDIT		= M("&Aendern","&Edit");
string UPRDADDF		= M("Neue Menu&funktion","Add Menu &Item");
string UPRDADDM		= M("Neues &Makro","Add Ma&cro");
string UPRDADDU		= M("Neue &Anwenderfunktion ","Add &User Script");
string UPRDDEL		= M("&Loeschen","Dele&te");
string UPRDDELA		= M("Alle l&oeschen","Delete All");
string UPRDMOVE		= M("&Verschieben","&Move");
string UPRDDONE		= M("Fer&tig","&Done");
string UPRDADD		= M("&Hinzufuegen","&Add");
string UPRLOCK		= M("Sperren","Lock");
string UPRDEFAULT	= M("Default","Default");
string UPRBROWSE	= M("Browse","Browse");
string UPRLISTADD	= M("Liste anlegen","Add List");
string UPRLISTEDIT	= M("Liste aendern","Edit List");
string UPRATTRVAL	= M("Attributwert ? ","Attribut Value ? ");
string UPRDIALVALL	= M("Werte fuer '%s'","Values of '%s'");
string UPRVALMOVDST	= M("Neue Position fuer Wert '%s' selektieren",
			    "Select new position for value '%s'");
string UPRNEXTDIAL	= M("&>","&>");
string UPRPREVDIAL	= M("&<","&<");
string UPRSELATEXT	= M("Attributtext selektieren!",
			    "Select Attribute Text!");
string UPRDEFVAL	= M("Defaultwert fuer '%s' ? ",
			    "Default Value for '%s' ? ");
string UPRATTRVDIAL	= M("Defaultattributwerte von '%s':",
			    "Default attribute values of '%s'");
string UPRNOVAL		= M("&Kein Wert","N&o Value");
string UPRALLRES	= M("Alle &ruecksetzen","&Reset All");
string UPRALLDEF	= M("&Alle Default","Default &All");
string UPRPRED		= M("Predikatattribute von '%s' :",
			    "Predicate attributes of '%s' :");
string UPRPFILE		= M("Projektdateiname ? ","Project File Name ? ");
string UPRBRWFILENAME	= M("Browse","Browse");
string UPRLINKFILE	= M("Dokumentationsdatei/link:",
			    "Documentation file/link:");
string REPRULECOPY	= M("%d Regeln kopiert.","%d rules copied.");
string REPDBLLAY	= M("%s bereits verwendet!","%s already used!");
string REPCOLORSET	= M("PDF-Farbe '%s' %d Elementen zugewiesen.",
			    "Assigned PDF color '%s' to %d elements.");
string REPPDFLAYSET	= M("PDF-Ebene '%s' %d Elementen zugewiesen.",
			    "Assigned PDF layer '%s' to %d elements.");
string REPLAYL		= M("Lagenauswahl :","Layer Selection :");
string REPEXPDONE	= M("Lagenaufbau in Datei '%s' geschrieben.",
			    "Layer setup written to file '%s'.");
string REPIMPDONE	= M("Lagenaufbau aus Datei '%s' importiert.",
			    "Layer setup imported from file '%s'.");
string REPELEMSEL	= M("%d Element(e) hinzuselektiert. Jetzt %d Elemente in Gruppe.",
			    "%d element(s) selected. Now %d elements in group.");
string REPELEMDSEL	= M("%d Element(e) deselektiert. Jetzt %d Elemente in Gruppe.",
			    "%d element(s) deselected. Now %d elements in group.");
string REPGLUED		= M("%d Element(e) verankert.","%d element(s) glued.");
string REPUNGLUED	= M("%d Elementverankerungen geloest.",
			    "%d element(s) unglued.");
string REPPGLUED	= M("Bauteil/Pin '%s' verankert. Bauteil/Pin selektieren!",
			    "Part/Pin '%s' glued. Select part/pin!");
string REPPUNGLUED	= M("Bauteil/Pin '%s' Verankerung geloest. Bauteil/Pin selektieren!",
			    "Part '%s' unglued. Select part/pin!");
string REPDEFVAL	= M("Werte fuer Predikat %s:",
			    "Values for Predicate %s:");
string REPNILATT	= M("!nicht_gesetzt!","!not_set!");
string REPRULESET	= M("Regel '%s' an %d Elemente angehaengt.",
			    "Attached rule '%s' to %d elements.");
string REPRULEDEL	= M("Regel(n) '%s' von %d Elementen entfernt.",
			    "Detacged rule(s) '%s' from %d elements.");
string REPRULEREM	= M("Regeln von %d Elementen entfernt.",
			    "Detached rules from %d elements.");
string ERRNORULE	= M("Regel '%s' nicht definiert!",
			    "Rule '%s' not defined!");
string ERRNOATT		= M("Bauteil '%s' besitzt keine Predikatattribute!",
			    "Bauteil '%s' has no predicate attributes!");
string ERRNOMACRO	= M("Keine Makros definiert!","No Macros defined!");
string ERRNOMOVITEM	= M("Keine Kontextfunktion fuer die Verschiebung selektiert!",
			    "No move source context function selected!");
string ERRNOMOVVAL	= M("Kein Wert fuer die Verschiebung selektiert!",
			    "No move source value selected!");
string ERRPARTGLUED	= M("Bauteil '%s' ist verankert!",
			    "Part '%s' is glued!");
string ERRNOPRED	= M("Bauteil '%s' ('%s') besitzt keine Predikatattribute!",
			    "Part '%s' ('%s') has no predicate attributes!!");
string ERRINVCOLOR	= M("Ungueltige Farbauswahl!",
			    "Invalid color selection!");
string ERRBASELAY	= M("Abbruch: Signallage 1 ist nicht als Basislage verwendet!",
			    "Abort: Singal layer 1 is not used as base layer!");
string ERRNOPICK	= M_ERRNOPICK();
string ERRNOWIN		= M("Nur in Windowsumgebungen verfuegbar!",
			    "Windows Environment needed!");
string FMTHEADER	= M("Lagenaufbau\n\n","Layer Setup\n\n");
string FMTFILE		= M("Projekt ...: %s\n","Project ...: %s\n");
string FMTBOARD		= M("Platine ...: %s\n\n","Board .....: %s\n\n");
string FMTMETALL	= M("Lage '%s' Metallisierung %s %.1f um",
			    "Layer '%s' Metall %s %.1f um");
string FMTSHIELD	= M(" Masse"," Shield");
string FMTISOL		= M("Dielektrikum %.1f um, Epsr %.1f, tan delta %.3f\n",
			    "Isolation %.1f um, Epsr %.1f, tan delta %.3f\n");
#define FMTLAYENTRY	"%s%s%s%s%.1f%s%d%s%s%s%.1f%s%s%s%.2f%s%.3f%s%.1f%s%d\n"
#define FMTLAYDENTRY	"%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n"

// INI file parameter name definitions
#define PAR_LAYIML	"LAYIMATL_LAY"	// Layer material list
#define PAR_LAYITL	"LAYITOLL_LAY"	// Layer isolation tolerance list
#define PAR_LAYS	"LAYSURF_LAY"	// Default layer surface
#define PAR_LAYT	"LAYTHICK_LAY"	// Default layer thickness
#define PAR_LAYI	"LAYISO_LAY"	// Default layer isolation
#define PAR_ISOM	"LAYISOM_LAY"	// Default layer isolation material
#define PAR_ISOT	"LAYISOT_LAY"	// Default layer isolation tolerance
#define PAR_ISOC	"LAYISOC_LAY"	// Default layer isolation core flag
#define PAR_EPSR	"LAYEPSR_LAY"	// Default epsilon r
#define PAR_TAND	"LAYTAND_LAY"	// Default tangens delta
#define PAR_LAYF	"LAYFILL_LAY"	// Default layer fill flag
#define PAR_LAYSTKEXT	"LAYSTKEXT_LAY"	// Layer stackup file name extension
#define PAR_LAYSTKORD	"LAYSTKORD_LAY"	// Layer stackup file layer order
#define PAR_LAYSPROG	"LAYSPROG_LAY"	// User def. layer stackup program name
#define PAR_LISTDCNT	"MACRODCNT_STD"	// Max. dialog list items count
#define PAR_ATTRCOMMP	"ATTR_%s_STD"	// Attribute comment pattern
#define PAR_ATTRORDP	"ATTR_ORD_%s_STD"	// Attribute order pattern
#define PAR_DBAFEXT	"DBAFEXT_LAY"	// DBase ASCII file name ext.
#define PAR_DBFFSEP	"DBFFSEP_LAY"	// DBase ASCII file field seperator

// SQL command definitions
#define MN_SELECT	"select macname from macrotab where ptyp=%d AND midx=0;"

// Dialog box definitions
#define ED_WIDTHF	40.0		// Favorite param. edit field width
#define CCOLOFFFL	87.0		// Fav. list 2nd ctrl. column offset
#define CCOLOFFF	20.0		// Fav. param. 2nd ctrl. column offset
#define SELBOXWIDTHLS	70.0		// Value selection box width
#define MBUTWIDTH	8.0		// Menu action button width
#define MBUTXSTEP	10.0		// Menu action button x step
#define CCOLOFFPL	60.0		// Values 2nd ctrl. column offset
double BUTXSTEP	= bae_swconfig(3)==2 ? 2.0 : 0.0
					/* Menu action button x spacing */;
#define SELBOXWIDTHFS	95.0		// Favorite selection box width
int MAXMENULIST = bae_iniintval(PAR_LISTDCNT,12)
					/* Max. menu list length */;
#define MAXMENUITEM	28		// Max. menu item count

// Globals
#define GV_PROPCALL	"propcall"	// Property function call flag
#define GV_PROPX	"propx"		// Property query x coordinate
#define GV_PROPY	"propy"		// Property query y coordinate
#define UL_MACRO	"macro"		// ULP: Macro Management
double DEF_EPSR = bae_inidblval(PAR_EPSR,4.5);
					// Default epsilon r
double DEF_TAND = bae_inidblval(PAR_TAND,0.02);
					// Default tangens delta
double DEF_LAYT = bae_inidblval(PAR_LAYT,0.000070);
					// Default layer thickness
double DEF_LAYI = bae_inidblval(PAR_LAYI,0.0003);
					// Default layer isolation
int DEF_LAYF = bae_iniintval(PAR_LAYF,0);
					// Default layer fill flag
string DEF_LAYS = bae_inistrval(PAR_LAYS,"Cu");
					// Default layer surface
int DEF_ISOC = bae_iniintval(PAR_ISOC,1);
					// Default core flag value
double DEF_ISOT = bae_inidblval(PAR_ISOT,0.0);
					// Default isolation tolerance
string DEF_ISOM = bae_inistrval(PAR_ISOM,"");
					// Default isolation material
string LAYSTKEXT = bae_inistrval(PAR_LAYSTKEXT,"");
					// Layer stackup file name extension
int LAYSTKORD = bae_iniintval(PAR_LAYSTKORD,0);
					// Layer stackup file layer order
string CSVEXT = bae_inistrval(PAR_DBAFEXT,".csv");
					// CSV ASCII output file name ext.
string CSVFSEP = bae_inistrval(PAR_DBFFSEP,";");
					// CSV ASCII out. file field seperator
static string laysprog = bae_inistrval(PAR_LAYSPROG,"")
					/* Layer stackup done program call */;
static string BAEMACRODB = strgetconffilename(MACROVNAME,MACROFNAME,1);
static int IPTYP	= uliptype()	/* UL interpreter type */;
static string sqlcommand		/* SQL command string */;
static string macl[]			/* Macro name list */;
static int macn				/* Macro name count */;
struct cfctdes {			// Context function descriptor
	string menu			/* Menu text */;
	string seq			/* Function call sequence */;
	} cfctl[]			/* Context function list */;
int cfctn				/* Context function count */;
struct attrdes {			// Attribute descriptor
	string defvall[]		/* Attribute default value list */;
	int defvaln			/* Attribute default value count */;
	string val			/* Attribute value */;
	string valbak			/* Attribute value backup */;
	string name			/* Attribute name */;
	string disp			/* Attribute display name */;
	int ord				/* Attribute order */;
	int lock			/* Attribute locked flag */;
	} attl[]			/* Attribute data list */;
int attn		= 0		/* Attribute count */;
double ax, ay				/* Attribute pick search coord. */;
double amindist				/* Attribute pick min. distance */;
string aminname		= ""		/* Attribute pick min. name */;
STRINGS headl				/* Header string list */;
int headn		= 2		/* Header string count */;
struct laysdes {			// Layer stackup descriptor
	string comm			/* Layer commentary text */;
	int layer			/* Layer code */;
	double epsr			/* Epsilon r */;
	double tand			/* Tangens delta */;
	double cu			/* Copper thickness */;
	double iso			/* Isolation */;
	double tol			/* Isolation tolerance */;
	int core			/* Layer isolation core flag */;
	string surf			/* Layer surface type */;
	string mat			/* Layer isolation material type */;
	int fill			/* Layer fill flag */;
	};
struct laysdes layspl[]			/* Layer stackup parameter list */;
int layscnt	= 0			/* Layer stackup count */;
double thickness			/* PCB total thickness */;
struct matdes {				// Layer isolation material descriptor
	string name			/* Isolation material name */;
	double epsr			/* Epsilon r */;
	double tand			/* Tangens delta */;
	} matpl[]			/* Isolation material list */;
struct matdes defmatpl[] = {		// Default isolation material list
	{"FR4"    , 4.50,0.02  },
	{"RO 3003", 3.00,0.0013},
	{"RO 3203", 3.02,0.0016},
	{"RO 3006", 6.15,0.0025},
	{"RO 3010",10.20,0.0035},
	{"RO 4003", 3.38,0.0020},
	{"RO 4350", 3.48,0.0040},
	{"RO 4403", 3.20,0.0050}
	};
int matpn				/* Isolation material param. count */;
double tolpl[]				/* Isolation tolerance list */;
int tolpn				/* Isolation tolerance param. count */;

#define TYPINT		0x01		// Integer data type
#define TYPDBL		0x02		// Double data type
#define TYPSTR		0x03		// String data type
#define TYPINTBITS	0x01		// Bitmask data sub type
#define TYPINTSEL	0x02		// Selection data sub type
#define TYPDBLDIM	0x01		// Dimension data sub type
#define TYPSTRNAME	0x01		// Name data sub type
#define TYPSTRFILE	0x02		// File name data sub type
#define TYPSTRLINK	0x03		// Link/file name data sub type
#define LAYBIT		0x01		// Layout class mask bit
#define PRTBIT		0x02		// Layout part class mask bit
#define STKBIT		0x04		// Layout padstack class mask bit
#define PADBIT		0x08		// Layout pad class mask bit
#define POLYBIT		(1<<L_FIGPOLY)	// Polygon type bit
#define PATHBIT		(1<<L_FIGPATH)	// Path type bit
#define NREFBIT		(1<<L_FIGNREF)	// Named reference type bit
#define UREFBIT		(1<<L_FIGUREF)	// Unnamed reference type bit
#define TEXTBIT		(1<<L_FIGTEXT)	// Text type bit
#define DRILLBIT	(1<<L_FIGDRILL)	// Drill type bit
#define ANYELEMBIT	(POLYBIT|PATHBIT|NREFBIT|UREFBIT|TEXTBIT|DRILLBIT)
					// Any element bit
#define PLANTYP		30		// Plan type code
#define PLANBIT		(1<<PLANTYP)	// Current plan type bit
#define ATXTBIT		0x01		// Attribute text type bit
#define COPABIT		0x01		// Passive area polygon type bit
#define KOUTABIT	0x02		// Keepout area polygon type bit
#define OUTLBIT		0x04		// Board outline polygon type bit
#define ACOPABIT	0x08		// Active copper area polygon type bit
#define DLINEBIT	0x10		// Documentary line polygon type bit
#define DAREABIT	0x20		// Documentary area polygon type bit
#define COPFABIT	0x40		// Copperfill area polygon type bit
#define SPPOWBIT	0x80		// Split power area polygon type bit
#define SLAYBIT		0x01		// Signal layer type bit
#define PLAYBIT		0x02		// Power layer type bit
#define DLAYBIT		0x04		// Documentary layer type bit
#define OLAYBIT		0x08		// Board outline layer type bit
struct preddes {			// Predicate descriptor
	string name			/* Predicate name */;
	string delpat			/* Predicate rule deletion pattern */;
	string comm			/* Predicate comment */;
	string defsval			/* Predicate default string value */;
	double defdval			/* Predicate default double value */;
	int defival			/* Predicate default integer value */;
	int valtyp			/* Value type */;
	int valstyp			/* Value sub type */;
	int classmask			/* Element class mask */;
	int elaymask			/* Element layer type mask */;
	int etypmask			/* Element type mask */;
	int estypmask			/* Element sub type */;
	string namel[]			/* Value/bit names list */;
	};
struct preddes predl[] = {		// Predicate list
	{ /* attr_assign_dis */ RS_ATTADIS,"",
	  M("Bauteilattributzuweisung sperren",
	    "Lock part attribute assignment"),
	  "",0.0,0,TYPINTBITS,0,PRTBIT,0,TEXTBIT,ATXTBIT,{
	  M("Bauteilattributzuweisung sperren",
	    "Lock part attribute assignment")} },
	{ /* autoko */ RS_AUTOKO,"",
	  M("ID automatisch erzeugter Randsperrflaechen. NICHT aendern!",
	    "ID of automatically generated border keepout aeras. DON'T change!"),
	  "",0.0,0,TYPSTR,0,0,0,POLYBIT,KOUTABIT,{""} },
	{ /* drcblk */ RS_DRCBLOCK,"",
	  M("DRC-Block fuer dieses Element (-1 kein eigener DRC-Block)",
	    "DRC block to be used for this element (-1 no specific DRC block)"),
	  "",0.0,-1,TYPINT,0,LAYBIT,0,ANYELEMBIT,0,{""}},
	{ /* drcblk */ RS_DRCBLOCK,"",
	  M("DRC-Block fuer dieses Bauteilmakro (-1 kein eigener DRC-Block)",
	    "DRC block to be used for this part macro (-1 no specific DRC block)"),
	  "",0.0,-1,TYPINT,0,PRTBIT,0,PLANBIT,0,{""}},
	{ /* drcblk */ RS_DRCBLOCK,"",
	  M("DRC-Block fuer dieses Viapadstackmakro (-1 kein eigener DRC-Block)",
	    "DRC block to be used for this via padstack macro (-1 no specific DRC block)"),
	  "",0.0,-1,TYPINT,0,STKBIT,0,PLANBIT,0,{""}},
	{ /* drcblkname0 */ "drcblkname0","",
	  M("Name des DRC-Parameterblockes 0",
	    "Name of DRC parameter block 0"),
	  "",0.0,0,TYPSTR,0,LAYBIT,0,PLANBIT,0,{ "" } },
	{ /* drcblkname1 */ "drcblkname1","",
	  M("Name des DRC-Parameterblockes 1",
	    "Name of DRC parameter block 1"),
	  "",0.0,0,TYPSTR,0,LAYBIT,0,PLANBIT,0,{ "" } },
	{ /* drcblkname2 */ "drcblkname2","",
	  M("Name des DRC-Parameterblockes 2",
	    "Name of DRC parameter block 2"),
	  "",0.0,0,TYPSTR,0,LAYBIT,0,PLANBIT,0,{ "" } },
	{ /* drcblkname3 */ "drcblkname3","",
	  M("Name des DRC-Parameterblockes 3",
	    "Name of DRC parameter block 3"),
	  "",0.0,0,TYPSTR,0,LAYBIT,0,PLANBIT,0,{ "" } },
	{ /* drcblkname4 */ "drcblkname4","",
	  M("Name des DRC-Parameterblockes 4",
	    "Name of DRC parameter block 4"),
	  "",0.0,0,TYPSTR,0,LAYBIT,0,PLANBIT,0,{ "" } },
	{ /* drl_comment */ RS_DRLCOMM,"",
	  M("Von Sonder-ULC-Programmen ausgewerteter Bohrungskommentar",
	    "Drill tool comment evaluated by some special ULC programs"),
	  "",0.0,0,TYPSTR,0,0,0,DRILLBIT,0,{""} },
	{ /* drl_htmask */ RS_DRLHTMASK,"pldrl_htoff*",
	  M("Versorgungslagen Direktanschluss","Power layer direct connection"),
	  "",0.0,0,TYPINT,TYPINTBITS,0,0,DRILLBIT,0,{
	  M("Versorgungslage 1","Power layer 1"),
	  M("Versorgungslage 2","Power layer 2"),
	  M("Versorgungslage 3","Power layer 3"),
	  M("Versorgungslage 4","Power layer 4"),
	  M("Versorgungslage 5","Power layer 5"),
	  M("Versorgungslage 6","Power layer 6"),
	  M("Versorgungslage 7","Power layer 7"),
	  M("Versorgungslage 8","Power layer 8"),
	  M("Versorgungslage 9","Power layer 9"),
	  M("Versorgungslage 10","Power layer 10"),
	  M("Versorgungslage 11","Power layer 11"),
	  M("Versorgungslage 12","Power layer 12") } },
	{ /* drl_powlaymask */ RS_DRLPOWLMASK,"pldrl_via*",
	  M("Versorgungslagen Deaktivierung (aus = Verbindung)",
	    "Power layer deactivation (off = connection)"),
	  "",0.0,0,TYPINT,TYPINTBITS,0,0,DRILLBIT,0,{
	  M("Versorgungslage 1","Power layer 1"),
	  M("Versorgungslage 2","Power layer 2"),
	  M("Versorgungslage 3","Power layer 3"),
	  M("Versorgungslage 4","Power layer 4"),
	  M("Versorgungslage 5","Power layer 5"),
	  M("Versorgungslage 6","Power layer 6"),
	  M("Versorgungslage 7","Power layer 7"),
	  M("Versorgungslage 8","Power layer 8"),
	  M("Versorgungslage 9","Power layer 9"),
	  M("Versorgungslage 10","Power layer 10"),
	  M("Versorgungslage 11","Power layer 11"),
	  M("Versorgungslage 12","Power layer 12") } },
	{ /* drl_tolneg */ RS_DRLTOLNEG,"",
	  M("Von Sonder-ULC-Programmen ausgewertete negative Bohrungstoleranz",
	    "Negative drill tolerance evaluated by some special ULC programs"),
	  "",0.0,0,TYPSTR,0,0,0,DRILLBIT,0,{""} },
	{ /* drl_tolpos */ RS_DRLTOLPOS,"",
	  M("Von Sonder-ULC-Programmen ausgewertete positive Bohrungstoleranz",
	    "Positive drill tolerance evaluated by some special ULC programs"),
	  "",0.0,0,TYPSTR,0,0,0,DRILLBIT,0,{""} },
	{ /* editwide */ RS_EDITWIDE,"lay_edit_wide_*",
	  M("Leiterbahnen Editierdarstellung","Trace edit display mode"),
	  "",0.0,0,TYPINT,TYPINTSEL,LAYBIT|PRTBIT,0,PLANBIT,0,{
	  M("&Strichanzeige","&Line Display"),
	  M("&Fuellanzeige","&Filled Display"),
	  M("&Randanzeige","&Outline Display"),
	  M("Fuellen && &Distanz","Fill && &Distance"),
	  M("Fuellen && DR&C","Fill && DR&C"),
	  M("&Ausweich-DRC","DRC &Snap") } },
	{ /* envvar */ RS_ENVVAR,"",
	  M("Name einer Umgebungsvariable die bei Ausgaben auf den Textstring gesetzt wird",
	    "Name of an environment variable to be set to the text string for outputs"),
	  "",0.0,0,TYPSTR,0,0,0,TEXTBIT,0,{""} },
	{ /* fctname0 */ "fctname0","",
	  M("Name der 1. Kontextfunktion fuer dieses Element",
	    "Name of 1st context function of this element"),
	  "",0.0,0,TYPSTR,0,0,0,ANYELEMBIT,0,{ "" } },
	{ /* fctname0 */ "fctname0","",
	  M("Name der 1. Kontextfunktion fuer dieses Makro",
	    "Name of 1st context function of this macro"),
	  "",0.0,0,TYPSTR,0,0,0,PLANBIT,0,{ "" } },
	{ /* fctname1 */ "fctname1","",
	  M("Name der 2. Kontextfunktion fuer dieses Element",
	    "Name of 2nd context function of this element"),
	  "",0.0,0,TYPSTR,0,0,0,ANYELEMBIT,0,{ "" } },
	{ /* fctname1 */ "fctname1","",
	  M("Name der 2. Kontextfunktion fuer dieses Makro",
	    "Name of 2nd context function of this macro"),
	  "",0.0,0,TYPSTR,0,0,0,PLANBIT,0,{ "" } },
	{ /* fctname2 */ "fctname2","",
	  M("Name der 3. Kontextfunktion fuer dieses Element",
	    "Name of 3rd context function of this element"),
	  "",0.0,0,TYPSTR,0,0,0,ANYELEMBIT,0,{ "" } },
	{ /* fctname2 */ "fctname2","",
	  M("Name der 3. Kontextfunktion fuer dieses Makro",
	    "Name of 3rd context function of this macro"),
	  "",0.0,0,TYPSTR,0,0,0,PLANBIT,0,{ "" } },
	{ /* fctname3 */ "fctname3","",
	  M("Name der 4. Kontextfunktion fuer dieses Element",
	    "Name of 4th context function of this element"),
	  "",0.0,0,TYPSTR,0,0,0,ANYELEMBIT,0,{ "" } },
	{ /* fctname3 */ "fctname3","",
	  M("Name der 4. Kontextfunktion fuer dieses Makro",
	    "Name of 4th context function of this macro"),
	  "",0.0,0,TYPSTR,0,0,0,PLANBIT,0,{ "" } },
	{ /* fctname4 */ "fctname4","",
	  M("Name der 5. Kontextfunktion fuer dieses Element",
	    "Name of 5th context function of this element"),
	  "",0.0,0,TYPSTR,0,0,0,ANYELEMBIT,0,{ "" } },
	{ /* fctname4 */ "fctname4","",
	  M("Name der 5. Kontextfunktion fuer dieses Makro",
	    "Name of 5th context function of this macro"),
	  "",0.0,0,TYPSTR,0,0,0,PLANBIT,0,{ "" } },
	{ /* fctseq0 */ "fctseq0","",
	  M("Aufrufsequenz der 1. Kontextfunktion fuer dieses Element",
	    "Call sequence of 1st context function of this element"),
	  "",0.0,0,TYPSTR,0,0,0,ANYELEMBIT,0,{ "" } },
	{ /* fctseq0 */ "fctseq0","",
	  M("Aufrufsequenz der 1. Kontextfunktion fuer dieses Makro",
	    "Call sequence of 1st context function of this macro"),
	  "",0.0,0,TYPSTR,0,0,0,PLANBIT,0,{ "" } },
	{ /* fctseq1 */ "fctseq1","",
	  M("Aufrufsequenz der 2. Kontextfunktion fuer dieses Element",
	    "Call sequence of 2nd context function of this element"),
	  "",0.0,0,TYPSTR,0,0,0,ANYELEMBIT,0,{ "" } },
	{ /* fctseq1 */ "fctseq1","",
	  M("Aufrufsequenz der 2. Kontextfunktion fuer dieses Makro",
	    "Call sequence of 2nd context function of this macro"),
	  "",0.0,0,TYPSTR,0,0,0,PLANBIT,0,{ "" } },
	{ /* fctseq2 */ "fctseq2","",
	  M("Aufrufsequenz der 3. Kontextfunktion fuer dieses Element",
	    "Call sequence of 3rd context function of this element"),
	  "",0.0,0,TYPSTR,0,0,0,ANYELEMBIT,0,{ "" } },
	{ /* fctseq2 */ "fctseq2","",
	  M("Aufrufsequenz der 3. Kontextfunktion fuer dieses Makro",
	    "Call sequence of 3rd context function of this macro"),
	  "",0.0,0,TYPSTR,0,0,0,PLANBIT,0,{ "" } },
	{ /* fctseq3 */ "fctseq3","",
	  M("Aufrufsequenz der 4. Kontextfunktion fuer dieses Element",
	    "Call sequence of 4th context function of this element"),
	  "",0.0,0,TYPSTR,0,0,0,ANYELEMBIT,0,{ "" } },
	{ /* fctseq3 */ "fctseq3","",
	  M("Aufrufsequenz der 4. Kontextfunktion fuer dieses Makro",
	    "Call sequence of 4th context function of this macro"),
	  "",0.0,0,TYPSTR,0,0,0,PLANBIT,0,{ "" } },
	{ /* fctseq4 */ "fctseq4","",
	  M("Aufrufsequenz der 5. Kontextfunktion fuer dieses Element",
	    "Call sequence of 5th context function of this element"),
	  "",0.0,0,TYPSTR,0,0,0,ANYELEMBIT,0,{ "" } },
	{ /* fctseq4 */ "fctseq4","",
	  M("Aufrufsequenz der 5. Kontextfunktion fuer dieses Makro",
	    "Call sequence of 5th context function of this macro"),
	  "",0.0,0,TYPSTR,0,0,0,PLANBIT,0,{ "" } },
	{ /* fill_aangmode */ RS_POLYFILLAA,"",
	  M("Vom Flaechenfuellen fuer diesen Fuellbereich zu verwendender spitze Winkelmodus",
	    "Acute angle mode to be used by the copper fill functions for this fill area"),
	  "",0.0,(-1),TYPINT,TYPINTSEL,0,0,POLYBIT,COPFABIT,{
	  M("Keine Vorgabe","Use default"),M("flach","flat"),M("rund","round")} },
	{ /* fill_distmode */ RS_POLYFILLDM,"",
	  M("Fuellbereich fuer Alternativlage Abstandsmodus (-16384 - keine "+
	    "Vorgabe, 0 - DRC-Abstaende, 1 - keine DRC-Abstaende",
	    "Copper fill area alternate layer distance mode (-16384 - default,"+
	    "0- DRC distances, 1 - no DRC distances)"),
	  "",0.0,-16384,TYPINT,0,0,SLAYBIT,POLYBIT,COPFABIT,{""} },
	{ /* fill_dstlay */ RS_POLYFILLDL,"",
	  M("Fuellbereich Ziellage (-16384 - Quelllage"+
	    " oder Ziellagencodeangabe)",
	    "Copper fill area destination layer (-16384 -"+
	    " source layer or destination layer code)"),
	  "",0.0,-16384,TYPINT,0,0,SLAYBIT,POLYBIT,COPFABIT,{""} },
	{ /* fill_dsttyp */ RS_POLYFILLDT,"",
	  M("Fuellbereich fuer Alternativlage Zielflaechentyp (-16384 -"+
	    " Default oder Flaechentypangabe)",
	    "Copper fill area alternate layer destination aera type (-16384 -"+
	    " default or aera type code)"),
	  "",0.0,-16384,TYPINT,0,0,SLAYBIT,POLYBIT,COPFABIT,{""} },
	{ /* fill_isoldist */ RS_POLYFILLIS,"",
	  M("Vom Flaechenfuellen fuer diesen Fuellbereich zu verwendender Isolationsabstand"+" (-1.0 - keine Vorgabe)",
	    "Isolation distance to be used by the copper fill functions for this fill area"+ " (-1.0 - use default)"),
	  "",(-1.0),0,TYPDBL,TYPDBLDIM,0,0,POLYBIT,COPFABIT,{""} },
	{ /* fill_htcount */ RS_POLYFILLHC,"",
	  M("Vom Flaechenfuellen fuer diesen Fuellbereich zu verwendende max."+" Waermefallensteganzahl",
	    "Max. heat trap junction count to be used by the copper fill"+" functions for this fill area"),
	  "",0.0,(-1),TYPINT,TYPINTSEL,0,0,POLYBIT,COPFABIT,{
	  M("Keine Vorgabe","Use default"),M("",""),
	  M("Max. &1 Steg","Max. &1 Junction"),
	  M("Max. &2 Stege","Max. &2 Junctions"),
	  M("Max. &3 Stege","Max. &3 Junctions"),
	  M("Max. &4 Stege","Max. &4 Junctions")} },
	{ /* fill_htisol */ RS_POLYFILLHI,"",
	  M("Vom Flaechenfuellen fuer diesen Fuellbereich zu verwendende"+" Waermefallenisolation (-1.0 - keine Vorgabe)",
	    "Heat trap isolation distance to be used by the copper fill functions for this "+ " fill area (-1.0 - use default)"),
	  "",(-1.0),0,TYPDBL,TYPDBLDIM,0,0,POLYBIT,COPFABIT,{""} },
	{ /* fill_htmode */ RS_POLYFILLHT,"",
	  M("Vom Flaechenfuellen fuer diesen Fuellbereich zu verwendender"+" Waermefallenanschlussmodus",
	    "Heat trap creation mode to be used by the copper fill functions"+" for this fill area"),
	  "",0.0,(-1),TYPINT,0,0,0,POLYBIT,COPFABIT,{""} },
	{ /* fill_htwidth */ RS_POLYFILLHW,"",
	  M("Vom Flaechenfuellen fuer diesen Fuellbereich zu verwendende Waermefallenbreite"+" (-1.0 - keine Vorgabe)",
	    "Heat trap width to be used by the copper fill functions for this fill area"+ " (-1.0 - use default)"),
	  "",(-1.0),0,TYPDBL,TYPDBLDIM,0,0,POLYBIT,COPFABIT,{""} },
	{ /* fill_tracemode */ RS_POLYFILLTM,"",
	  M("Vom Flaechenfuellen fuer diesen Fuellbereich zu verwendende Bahnenaussparung",
	    "Trace cutout mode to be used by the copper fill functions for this fill area"),
	  "",0.0,(-1),TYPINT,TYPINTSEL,0,0,POLYBIT,COPFABIT,{
	  M("Keine Vorgabe","Use default"),M("&Rund Bahnen+Kreise","&Round Corners"),
	  M("Oktagon &Bahnen","Octagonal &Corners"),
	  M("Oktagon &Kreise","Octagonal C&ircles"),
	  M("&Oktagon Bahnen+Kreise","&Octagonal Corner+Circles")} },
	{ /* fill_minarea */ RS_POLYFILLMA,"",
	  M("Vom Flaechenfuellen fuer diesen Fuellbereich zu verwendende minimale Struktur"+"groesse (-1.0 - keine Vorgabe)",
	    "Min. structure size to be used by the copper fill functions for this fill area"+ " (-1.0 - use default)"),
	  "",(-1.0),0,TYPDBL,TYPDBLDIM,0,0,POLYBIT,COPFABIT,{""} },
	{ /* fill_part */ RS_POLYFILLPA,"",
	  M("Vom Flaechenfuellen fuer diesen Fuellbereich zu verwendendes"+" Netz aus Pin dieses Bauteils ableiten",
	    "Derive net to be used by the copper fill functions"+" for this fill area from pin of this part"),
	  "",0.0,(-1),TYPSTR,TYPSTRNAME,0,0,POLYBIT,COPFABIT,{""} },
	{ /* fill_pin */ RS_POLYFILLPI,"",
	  M("Vom Flaechenfuellen fuer diesen Fuellbereich zu verwendendes"+" Netz aus diesem Bauteilpin ableiten",
	    "Derive net to be used by the copper fill functions"+" for this fill area from this part pin"),
	  "",0.0,(-1),TYPSTR,TYPSTRNAME,0,0,POLYBIT,COPFABIT,{""} },
	{ /* fill_prio */ RS_POLYFILLPR,"",
	  M("Vom Flaechenfuellen fuer diesen Fuellbereich zu verwendende"+" Reihenfolgeprioritaet",
	    "Process order priority to be used by the copper fill functions"+" for this fill area"),
	  "",0.0,(-1),TYPINT,TYPINTSEL,0,0,POLYBIT,COPFABIT,{
	  M("Keine Vorgabe","Use default"),M("&0 (zuletzt)","&0 (last)"),
	  M("&1","&1"), M("&2","&2"), M("&3","&3"), M("&4","&4"),
	  M("&5 (zuerst)","&5 (first)")} },
	{ /* glued */ RS_GLUED,"", M("Elementverankerung","Element Glue"),
	  "",0.0,0,TYPINT,TYPINTBITS,0,0,ANYELEMBIT,0,{
	  M("Verankerung","Glue") }},
	{ /* grpname */ RS_GROUPNAME,"", M("Gruppenname","Group name"),
	  "",0.0,0,TYPSTR,0,0,0,ANYELEMBIT,0,{""} },
	{ /* height */ RS_HEIGHT,"",
	  M("Obere Hoehe fuer den Hoehen-DRC (0.0 - normale Sperrflaeche)",
	    "Upper height for the height DRC (0.0 - ordinary keepout area)"),
	  "",0.0,0,TYPDBL,TYPDBLDIM,0,DLAYBIT,POLYBIT,KOUTABIT,{""} },
	{ /* height */ RS_HEIGHT,"lay_part_attrheight",
	  M("Obere Hoehe fuer den Hoehen-DRC (0.0 - Hoehenangabe an den"+
	    " Dokumentarlagensperrflaechen selbst)",
	    "Upper height for the height DRC (0.0 - height defined at keepout areas)"),
	  "",0.0,0,TYPDBL,TYPDBLDIM,LAYBIT,0,NREFBIT,0,{""} },
	{ /* heightlim */ RS_HEIGHTLIM,"",
	  M("Hoehenlimit fuer den Hoehen-DRC",
	    "Height limit for the height DRC"),
	  "",0.0,0,TYPDBL,TYPDBLDIM,0,DLAYBIT,POLYBIT,KOUTABIT,{""} },
	{ /* heightlim */ RS_HEIGHTLIM,"",
	  M("Hoehenlimit fuer den Hoehen-DRC (0.0 - Hoehenangabe an den"+
	    " Dokumentarlagensperrflaechen selbst)",
	    "Height limit for the height DRC (0.0 - height defined at keepout areas)"),
	  "",0.0,0,TYPDBL,TYPDBLDIM,LAYBIT,0,NREFBIT,0,{""} },
	{ /* heightoff */ RS_HEIGHTOFF,"",
	  M("Untere Hoehe fuer den Hoehen-DRC",
	    "Lower height for the height DRC"),
	  "",0.0,0,TYPDBL,TYPDBLDIM,0,DLAYBIT,POLYBIT,KOUTABIT,{""} },
	{ /* heightoff */ RS_HEIGHTOFF,"",
	  M("Untere Hoehe fuer den Hoehen-DRC (0.0 - Hoehenangabe an den"+
	    " Dokumentarlagensperrflaechen selbst)",
	    "Lower height for the height DRC (0.0 - height defined at keepout areas)"),
	  "",0.0,0,TYPDBL,TYPDBLDIM,LAYBIT,0,NREFBIT,0,{""} },
	{ /* heightpcb */ RS_HEIGHTPCB,"",
	  M("Fuer den Hoehen-DRC Leiterkartendicke von der Hoehe abziehen",
	    "Subtract PCB thickness from height for height DRC"),
	  "",0.0,0,TYPINT,TYPINTBITS,0,DLAYBIT,POLYBIT,KOUTABIT,{
	  M("Fuer den Hoehen-DRC Leiterkartendicke von der Hoehe abziehen",
	    "Subtract PCB thickness from height for height DRC")} },
	{ /* inival */ RS_INIVAL,"",
	  M("Bauteilattribut Defaultwert","Part attribute default value"),
	  "",0.0,0,TYPSTR,0,PRTBIT,0,TEXTBIT,ATXTBIT,{""} },
	{ /* layer_pairs */ RS_LAYPAIR,"",
	  M("Paargenerierung: Parallellagenpaare, z.B. (1,2) (3,4)",
	    "Pair creation: parallel layer pairs, e.g. (1,2) (3,4)"),
	  "",0.0,0,TYPSTR,TYPSTRNAME,LAYBIT,0,PLANBIT,0,{""} },
	{ /* llnvis */ RS_LLNVIS,"lay_llname_*",
	  M("Text nur anzeigen wenn Bauteil diesen Wert fuer $llname"+
	    "(Symbolmakroname) besitzt",
	  "Display text only if $llname (symbol macro) for this part is set"+
	  " to this value"),
	  "",0.0,0,TYPSTR,TYPSTRNAME,PRTBIT,DLAYBIT,TEXTBIT,0,{""} },
	{ /* llnvis */ RS_LLNVIS,"lay_llname_*",
	  M("Dokumentargrafik nur anzeigen wenn Bauteil diesen Wert fuer"+
	    "$llname (Symbolmakroname) besitzt",
	  "Display documentary graphic only if $llname (symbol macro) for"+
	  " this part is set to this value"),
	  "",0.0,0,TYPSTR,TYPSTRNAME,PRTBIT,DLAYBIT,POLYBIT,DLINEBIT|DAREABIT,{""} },
	{ /* measureid */ RS_MEASUREID,"",
	  M("ID Distanzbemassungstext. NICHT aendern!",
	    "ID of distance measure text. DON'T change!"),
	  "",0.0,0,TYPSTR,0,0,0,TEXTBIT,0,{""} },
	{ /* measureid */ RS_MEASUREID,"",
	  M("ID Distanzbemassungsgrafik. NICHT aendern!",
	    "ID of distance measure graphic. DON'T change!"),
	  "",0.0,0,TYPSTR,0,0,0,POLYBIT,DLINEBIT|DAREABIT,{""} },
	{ /* mtextcol */ RS_MTEXTCOL,"",
	  M("Mehrzeilentext Teiltext Spaltenangabe. NICHT aendern!",
	    "Multiline text, column of subtext. DON'T change!"),
	  "",0.0,0,TYPINT,0,0,0,TEXTBIT,0,{""} },
	{ /* mtextid */ RS_MTEXTID,"", M("ID Mehrzeilentext. NICHT aendern!",
	  "ID multiline text. DON'T change!"),
	  "",0.0,0,TYPSTR,0,0,0,TEXTBIT,0,{""} },
	{ /* mtextls */ RS_MTEXTLS,"",
	  M("Mehrzeilentext relativer Zeilenabstand. NICHT aendern!",
	    "Multiline text, relativ row spacing. DON'T change!"),
	  "",1.0,0,TYPDBL,0,0,0,TEXTBIT,0,{""} },
	{ /* mtextrow */ RS_MTEXTROW,"",
	  M("Mehrzeilentext Teiltext Zeilenangabe. NICHT aendern!",
	    "Multiline text, row of subtext. DON'T change!"),
	  "",0.0,0,TYPINT,0,0,0,TEXTBIT,0,{""} },
	{ /* net_type */ RS_NETTYPE,"",
	  M("Netztypname zur Beschraenkung des Autoroutings innerhalb der Flaeche",
	    "Net type name for autorouting area control"),
	  "",0.0,0,TYPSTR,0,LAYBIT,SLAYBIT,POLYBIT,DAREABIT,{""} },
	{ /* nolayerscan */ RS_LAYSCANIGN,"lay_layerscan_ignore",
	  M("Element vom Lagenscan der CAM-Batchausgabe ausnehmen",
	    "Exclude element from the CAM batch output layer scan"),
	  "",0.0,0,TYPINT,TYPINTBITS,0,0,ANYELEMBIT,0,{
	  M("Element vom Lagenscan der CAM-Batchausgabe ausnehmen",
	    "Exclude element from the CAM batch output layer scan")} },
	{ /* nolayerscan */ RS_LAYSCANIGN,"",
	  M("Elemente auf diesem Makros vom Lagenscan der CAM-Batchausgabe ausnehmen",
	    "Exclude elements on this macro from the CAM batch output layer scan"),
	  "",0.0,0,TYPINT,TYPINTBITS,0,0,PLANBIT,0,{
	  M("Elemente dieses Makros vom Lagenscan der CAM-Batchausgabe ausnehmen",
	    "Exclude elements on this macro from the CAM batch output layer scan")} },
	{ /* pad_ftdflag */ RS_PADFTDFLAG,"lay_pad_*",
	  M("Flaechenfuellen Padanschlussmodus",
	    "Copper fill pin connection mode"),
	  "",0.0,0,TYPINT,TYPINTSEL,STKBIT,SLAYBIT,UREFBIT,0,{
	  M("Flaechenfuellen Defaultanschluss",
	    "Copper fill default connection"),
	  M("Flaechenfuellen immer Direktanschluss fuer dieses Pad",
	    "Copper fill always direct connect this pad"),
	  M("Flaechenfuellen immer Waermefallenanschluss fuer dieses Pad",
	    "Copper fill always heat trap connect this pad")} },
	{ /* pad_ftdflag */ RS_PADFTDFLAG,"lay_pad_*",
	  M("Flaechenfuellen Padanschlussmodus",
	    "Copper fill pin connection mode"),
	  "",0.0,0,TYPINT,TYPINTSEL,PRTBIT,0,NREFBIT,0,{
	  M("Flaechenfuellen Defaultanschluss",
	    "Copper fill default connection"),
	  M("Flaechenfuellen immer Direktanschluss fuer diesen Pin",
	    "Copper fill always direct connect this pin"),
	  M("Flaechenfuellen immer Waermefallenanschluss fuer diesen Pin",
	    "Copper fill always heat trap connect this pin")} },
	{ /* pad_ftdflag */ RS_PADFTDFLAG,"lay_pad_*",
	  M("Flaechenfuellen Padanschlussmodus",
	    "Copper fill pin connection mode"),
	  "",0.0,0,TYPINT,TYPINTSEL,LAYBIT,0,NREFBIT,0,{
	  M("Flaechenfuellen Defaultanschluss",
	    "Copper fill default connection"),
	  M("Flaechenfuellen immer Direktanschluss fuer dieses Bauteil",
	    "Copper fill always direct connect this part"),
	  M("Flaechenfuellen immer Waermefallenanschluss fuer dieses Bauteil",
	    "Copper fill always heat trap connect this part")} },
	{ /* pad_htwidth */ RS_PADHTWIDTH,"",
	  M("Flaechenfuellen Waeremfallenbreite fuer dieses Pad",
	    "Copper fill heat trap width for this pad"),
	  "",0.0,0,TYPDBL,TYPDBLDIM,STKBIT,SLAYBIT,UREFBIT,0,{""} },
	{ /* pad_htwidth */ RS_PADHTWIDTH,"",
	  M("Flaechenfuellen Waeremfallenbreite fuer diesen Pin",
	    "Copper fill heat trap width for this pin"),
	  "",0.0,0,TYPDBL,TYPDBLDIM,PRTBIT,0,NREFBIT,0,{""} },
	{ /* pad_htwidth */ RS_PADHTWIDTH,"",
	  M("Flaechenfuellen Waeremfallenbreite fuer dieses Bauteil",
	    "Copper fill heat trap width for this part"),
	  "",0.0,0,TYPDBL,TYPDBLDIM,LAYBIT,0,NREFBIT,0,{""} },
	{ /* pad_htwidth */ RS_PADHTWIDTH,"",
	  M("Flaechenfuellen Waeremfallenbreite fuer dieses Pad",
	    "Copper fill heat trap width for this pad"),
	  "",0.0,0,TYPDBL,TYPDBLDIM,STKBIT,SLAYBIT,UREFBIT,0,{""} },
	{ /* pairgrid */ RS_PAIRGRID,"",
	  M("Paargenerierung: Basisgrid der Viaanschluesse",
	    "Pair creation: via connection base grid"),
	  "",0.0,0,TYPDBL,TYPDBLDIM,LAYBIT,0,PLANBIT,0,{""} },
	{ /* pairstk1 */ RS_PAIRSTK1,"",
	  M("Paargenerierung: Padstackmakro fuer die Fortsetzung der eigenen Bahn",
	    "Pair creation: replacement padstack macro for own trace"),
	  "",0.0,0,TYPSTR,TYPSTRNAME,STKBIT,0,PLANBIT,0,{""} },
	{ /* pairstk2 */ RS_PAIRSTK2,"",
	  M("Paargenerierung: Padstackmakro fuer Bahn auf der anderen Lage",
	    "Pair creation: padstack macro for trace on other layer"),
	  "",0.0,0,TYPSTR,TYPSTRNAME,STKBIT,0,PLANBIT,0,{""} },
	{ /* part_defang */ RS_PARTDEFANG,"rot*",
	  M("Defaultwinkel fuer Bauteilplatzierungen auf dem Layout (<0.0 - Keine Vorgabe)",
	    "Default part angle for layout placement (<0.0 no default angle)"),
	  "",-1.0,0,TYPDBL,0,PRTBIT,0,PLANBIT,0,{""} },
	{ /* part_defang */ RS_PARTDEFANG,"rot*",
	  M("Defaultwinkel fuer Pinplatzierungen auf Bauteilen (<0.0 - Keine Vorgabe)",
	    "Default pin angle for part placement (<0.0 no default angle)"),
	  "",-1.0,0,TYPDBL,0,STKBIT,0,PLANBIT,0,{""} },
	{ /* part_defang */ RS_PARTDEFANG,"rot*",
	  M("Defaultwinkel fuer Padplatzierungen auf Padstacks (<0.0 - Keine Vorgabe)",
	    "Default pad angle for padstack placement (<0.0 no default angle)"),
	  "",-1.0,0,TYPDBL,0,PADBIT,0,PLANBIT,0,{""} },
	{ /* part_defmirr */ RS_PARTDEFMIRR,"mirror*",
	  M("Defaultspiegelung fuer Bauteilplatzierungen auf dem Layout",
	    "Default part mirror mode for layout placement"),
	  "",0.0,-1,TYPINT,TYPINTSEL,PRTBIT,0,PLANBIT,0,{
	  M("Keine Vorgabe","No Default"),
	  M("Ungespiegelt platzieren","place unmirrored"),
	  M("Gespiegelt platzieren","Place mirrored")} },
	{ /* part_defmirr */ RS_PARTDEFMIRR,"mirror*",
	  M("Defaultspiegelung fuer Pinplatzierungen auf Bauteilen",
	    "Default padstack mirror mode for part placement"),
	  "",0.0,-1,TYPINT,TYPINTSEL,STKBIT,0,PLANBIT,0,{
	  M("Keine Vorgabe","No Default"),
	  M("Ungespiegelt platzieren","place unmirrored"),
	  M("Gespiegelt platzieren","Place mirrored")} },
	{ /* part_defmirr */ RS_PARTDEFMIRR,"mirror*",
	  M("Defaultspiegelung fuer Padplatzierungen auf Padstacks",
	    "Default pad mirror mode for padstack placement"),
	  "",0.0,-1,TYPINT,TYPINTSEL,PADBIT,0,PLANBIT,0,{
	  M("Keine Vorgabe","No Default"),
	  M("Ungespiegelt platzieren","place unmirrored"),
	  M("Gespiegelt platzieren","Place mirrored")} },
	{ /* part_docu */ RS_PARTDOCU,"",
	  M("Referenz auf externe Bauteildokumentation",
	    "Reference to external part documention"),
	  "",0.0,0,TYPSTR,TYPSTRLINK,PRTBIT,0,PLANBIT,0,{""} },
	{ /* part_nomirr */ RS_PARTNOMIRR,"cammirroroff",
	  M("Bauteil im CAM-Prozessor bei gespiegelter Ausgabe nicht mitspiegeln",
	    "Don't mirror part in mirrored CAM processor outputs"),
	  "",0.0,0,TYPINT,TYPINTBITS,0,0,ANYELEMBIT,0,{
	  M("Bauteil im CAM-Prozessor bei gespiegelter Ausgabe nicht mitspiegeln",
	    "Don't mirror part in mirrored CAM processor outputs")} },
	{ /* partdrcexc */ RS_PARTDRCEXC,"",
	  M("Name eines anderen Bauteils, das im Bauteil-DRC"+
	    " nicht mit diesem Bauteil verglichen werden soll",
	    "Name of another part that should not be check against this"+
	    "part by the part DRC"),
	  "",0.0,0,TYPSTR,TYPSTRNAME,LAYBIT,0,NREFBIT,0,{""} },
	{ /* partheightoff */ RS_PHEIGHTOFF,"",
	  M("Hoehenoffset fuer auf diesem Bauteil platzierte"+
	    " Hoehen-DRC-Sperrflaechen",
	    "Height offset for height DRC keepout areas place on this part"),
	  "",0.0,0,TYPDBL,TYPDBLDIM,LAYBIT,0,NREFBIT,0,{""} },
	{ /* pcb_thick */ RS_PCBTHICK,"",
	  M("Gesamtdicke der Leiterkarte (0.0 keine Angabe)",
	    "Total width of PCB (0.0 unknown)"),
	  "",0.0,0,TYPDBL,TYPDBLDIM,LAYBIT,0,PLANBIT,0,{""} },
	{ /* picksel_dis */ RS_PICKDIS,"lay_picksel_disable",
	  M("Element von der Pickelementauswahl ausnehmen",
	    "Exclude element from pick element selections"),
	  "",0.0,0,TYPINT,TYPINTBITS,0,0,ANYELEMBIT,0,{
	  M("Element von der Pickelementauswahl ausnehmen",
	    "Exclude element from pick element selections")} },
	{ /* picksel_dis */ RS_PICKDIS,"lay_picksel_disable",
	  M("Platzierungen dieses Makros von der Pickelementauswahl ausnehmen",
	    "Exclude placements of this macro from pick element selections"),
	  "",0.0,0,TYPINT,TYPINTBITS,0,0,PLANBIT,0,{
	  M("Platzierungen dieses Makros von der Pickelementauswahl ausnehmen",
	    "Exclude placements of this macro from pick element selections")} },
	{ /* pin_move */ RS_PINMOVE,"lay_pin_move",
	  M("Freigabe Pinbewegung auf Layoutebene",
	    "Enable pin movement on layout level"),
	  "",0.0,0,TYPINT,TYPINTBITS,PRTBIT,0,NREFBIT,0,{
	  M("Pinbewegung auf Layoutebene freigeben",
	    "Enable pin movement on layout level")} },
	{ /* pin_move */ RS_PINMOVE,"lay_pin_move",
	  M("Freigabe Pinbewegung auf Layoutebene",
	    "Enable pin movement on layout level"),
	  "",0.0,0,TYPINT,TYPINTBITS,STKBIT,0,PLANBIT,0,{
	  M("Pinbewegung auf Layoutebene freigeben",
	    "Enable pin movement on layout level")} },
	{ /* plotfont */ RS_PLOTFONT,"lay_text_font_*",
	  M("Font fuer EPS/PDF-Ausgabe","Font for EPS/PDF output"),
	  "",0.0,-1,TYPINT,TYPINTSEL,0,0,ANYELEMBIT,0,{
	  M("Defaultfont","Default font"),M("BAE Vektorfont","BAE vector font"),
	  M("1. Postscript-/PDF-Font","1st Postscript/PDF font"),
	  M("2. Postscript-/PDF-Font","2nd Postscript/PDF font") } },
	{ /* plotrgb */ RS_PLOTRGB,"",
	  M("RGB-Werte fuer EPS/PDF/WRL-Ausgabe (schwarz: 0.0 0.0 0.0, weiss: 1.0 1.0 1.0)",
	  "RGB color values for EPS/PDF/WRL output (black: 0.0 0.0 0.0, white: 1.0 1.0 1.0)"),
	  "",0.0,0,TYPSTR,0,0,0,ANYELEMBIT,0,{""} },
	{ /* plotwidth */ RS_PLOTWIDTH,"",
	  M("Plotstrichstaerke (0.0 Standardlinienbreite)",
	    "Plot width (0.0 Default linbe width)"),
	  "",0.0,0,TYPDBL,TYPDBLDIM,0,0,TEXTBIT,0,{""} },
	{ /* plotwidth */ RS_PLOTWIDTH,"",
	  M("Plotstrichstaerke (0.0 Standardlinienbreite)",
	    "Plot width (0.0 Default)"),
	  "",0.0,0,TYPDBL,TYPDBLDIM,0,0,POLYBIT,DLINEBIT|SPPOWBIT,{""} },
	{ /* poly_dash */ RS_POLYDASH,"poly_dash*",
	  M("Dokumentarlinie Strichelungsmodus","Documentary line dash mode"),
	  "",0.0,0,TYPINT,TYPINTSEL,0,0,POLYBIT,DLINEBIT,{
	  M("Durchgezogene Linie","Straight line"),
	  M("gleichmaessig gestrichelte Linie","balanced dashed line"),
	  M("punktierte Linie","dotted line"),
	  M("lang kurz gestrichelte Linie","long short dashed line"),
	  M("lang lang gestrichelte Linie","long long dashed line"),
	  M("kurz kurz gestrichelte Linie","short short dashed line"),
	  M("doppelkurz kurz gestrichelte Linie",
	    "double short short dashed line")} },
	{ /* poly_dashlen */ RS_POLYDASHLEN,"",
	  M("Dokumentarlinie Strichelungsbasislaenge",
	    "Documentary line dash base length"),
	  "",0.002,0,TYPDBL,TYPDBLDIM,0,0,POLYBIT,DLINEBIT,{""} },
	{ /* poly_dashspc */ RS_POLYDASHSPC,"",
	  M("Dokumentarlinie Strichelungsfaktor [0.0,0.499]",
	    "Documentary line dash faktor [0.0,0.499]"),
	  "",0.002,0,TYPDBL,0,0,0,POLYBIT,DLINEBIT,{""} },
	{ /* poly_gridlesscheck */ RS_POLYGRLCHK,"poly_gridlesscheck",
	  M("Rasterfreies Autorouting auf Inhalt dieser Alle Lagen-Flaeche beschraenken",
	    "Restrict gridless autorouting to this all layer area"),
	  "",0.0,0,TYPINT,TYPINTBITS,LAYBIT,SLAYBIT,POLYBIT,DAREABIT,{
	  M("Rasterfreies Autorouting auf Inhalt dieser Alle Lagen-Flaeche beschraenken",
	    "Restrict gridless autorouting to this all layer area")} },
	{ /* poly_pheightignore */ RS_POLYPHIGN,"poly_partheightignore",
	  M("Bauteilhoehe fuer diese Flaeche nicht beruecksichtigen",
	    "Ignore part height for this area"),
	  "",0.0,0,TYPINT,TYPINTBITS,PRTBIT|STKBIT,DLAYBIT,POLYBIT,KOUTABIT,{
	  M("Bauteilhoehe fuer diese Flaeche nicht beruecksichtigen",
	    "Ignore part height for this area")} },
	{ /* poly_routbitmask */ RS_POLYROUTBITM,"poly_routerno*",
	  M("Sperrflaechentyp fuer das Autorouting",
	    "Keepout area type for autorouting"),
	  "",0.0,0,TYPINT,TYPINTBITS,LAYBIT,SLAYBIT,POLYBIT,DAREABIT,{
	  M("Keine Vias innerhalb dieser Flaeche auf dieser Lage",
	    "No vias inside this area/layer"),
	  M("Keine Leiterbahnen innerhalb dieser Flaeche auf dieser Lage",
	    "No traces inside this area/layer")} },
	{ /* poly_subtype */ RS_POLYSUBTYPE,"",
	  M("Untertyp Signallagensperrflaeche",
	    "Subtype signal layer keepout aera"),
	  "",0.0,0,TYPINT,TYPINTSEL,0,SLAYBIT,POLYBIT,KOUTABIT,{
	  M("&Standard","&Standard"),
	  M("Nur &Flaechenfuellen","Only &Copper Fill"),M("",""),M("",""),
	  M("Nur Auto&routing","Only Auto &Routing"),
	  M("&Nur Fuellen && Routen","&Only Fill && Routing"),
	  M("",""),M("","")} },
	{ /* poly_subtype */ RS_POLYSUBTYPE,"",
	  M("Untertyp Fuellbereich","Subtype copper fill area"),
	  "",0.0,0,TYPINT,TYPINTSEL,0,SLAYBIT,POLYBIT,COPFABIT,{
	  M("&Standard","&Standard"),
	  M("Immer &Flaechenfuellen","Always &Solid Fill"),
	  M("Immer &Schraffieren","Alway &Hatch Fill")} },
	{ /* poly_subtype */ RS_POLYSUBTYPE,"",
	  M("Untertyp Dokumentarlagensperrflaeche",
	    "Subtype documentary layer keepout aeras"),
	  "",0.0,0,TYPINT,TYPINTBITS,0,DLAYBIT,POLYBIT,KOUTABIT,{
	  M("Klasse &1","Class &1"),M("Klasse &2","Class &2"),
	  M("Klasse &3","Class &3"),M("Klasse &4","Class &4")} },
	{ /* pstk_ddflag0 */ "pstk_ddflag0","",
	  M("1. Padstack auf dieser Referenz ist als doppelte Bohrung fuer"+" die Ausgabe unterdrueckt",
	    "1st Padstack of this element is disabled for output as double drill"),
	  "",0.0,0,TYPINT,TYPINTBITS,LAYBIT,0,NREFBIT|UREFBIT,0,{
	  M("1. Padstack auf dieser Referenz ist als doppelte Bohrung fuer"+" die Ausgabe unterdrueckt",
	    "1st Padstack of this element is disabled for output as double drill")} },
	{ /* pstk_ddflag1 */ "pstk_ddflag1","",
	  M("2. Padstack auf dieser Referenz ist als doppelte Bohrung fuer"+" die Ausgabe unterdrueckt",
	    "2nd Padstack of this element is disabled for output as double drill"),
	  "",0.0,0,TYPINT,TYPINTBITS,LAYBIT,0,NREFBIT|UREFBIT,0,{
	  M("2. Padstack auf dieser Referenz ist als doppelte Bohrung fuer"+" die Ausgabe unterdrueckt",
	    "2nd Padstack of this element is disabled for output as double drill")} },
	{ /* pstk_ddflag2 */ "pstk_ddflag2","",
	  M("3. Padstack auf dieser Referenz ist als doppelte Bohrung fuer"+" die Ausgabe unterdrueckt",
	    "3rd Padstack of this element is disabled for output as double drill"),
	  "",0.0,0,TYPINT,TYPINTBITS,LAYBIT,0,NREFBIT|UREFBIT,0,{
	  M("3. Padstack auf dieser Referenz ist als doppelte Bohrung fuer"+" die Ausgabe unterdrueckt",
	    "3rd Padstack of this element is disabled for output as double drill")} },
	{ /* ref_rule */ RS_REFRULE,"lay_part_autorule",
	  M("Regel die beim Platzieren des Makros automatisch an die Referenz gehaengt wird",
	    "Rule that will be automatically attached to references of this macro"),
	  "",0.0,0,TYPSTR,TYPSTRNAME,PRTBIT|STKBIT|PADBIT,0,PLANBIT,0,{""} },
	{ /* trace_partcon */ RS_FORCETCON,"lay_trc_partcon",
	  M("Connectivity diese Leiterbahn zu anderen Leiterbahnen auf diesem Makro erzwingen",
	    "Force connectivity of this trace to other traces on this macro"),
	  "",0.0,0,TYPINT,TYPINTBITS,PRTBIT,0,PATHBIT,0,{
	  M("Connectivity diese Leiterbahn zu anderen Leiterbahnen auf diesem Makro erzwingen",
	    "Force connectivity of this trace to other traces on this macro")} },
	{ /* trace_ht */ RS_TRACEHT,"",
	  M("Vom Flaechenfuellen als Waermefallenleiterbahn markiert",
	    "Marked as heat trap trace by copper fill function"),
	  "",0.0,0,TYPINT,TYPINTBITS,LAYBIT,0,PATHBIT,0,{
	  M("Vom Flaechenfuellen als Waermefallenleiterbahn markiert",
	    "Marked as heat trap trace by copper fill function")} },
	{ /* trc_impedance */ RS_TRCIMP,"",
	  M("Vorgabe Leiterbahnimpedanz [Ohm] (0.0 keine Vorgabe)",
	    "Requested trace impedance [Ohm] (0.0 no requested impedance)"),
	  "",0.0,0,TYPDBL,0,LAYBIT|PRTBIT,0,PATHBIT,0,{""} },
	{ /* trc_shieldcover */ RS_TSCWIDTH,"trc_shield*",
	  M("Mindestbedeckung Leiterbahn durch Masseflaeche fuer HF-DRC (0.0 kein Check)",
	    "Minimum overlap of trace by ground plane for HF DRC (0.0 no check)"),
	  "",0.0,0,TYPDBL,TYPDBLDIM,LAYBIT,0,PATHBIT,0,{""} },
	{ /* uncon_drc */ RS_UNCONDRC,"", M("N.C. Netztyp","N.C. net type"),
	  "",0.0,0,TYPINT,TYPINTBITS,LAYBIT,0,PLANBIT,0,{
	  M("Typ std fuer N.C.-Kupfer","Type std for N.C. copper") }},
	{ /* uncon_nettype */ RS_NCNETTYPE,"", M("N.C. Netztyp","N.C. net type"),
	  "",0.0,0,TYPSTR,0,LAYBIT,0,ANYELEMBIT,0,{""} },
	{ /* vardocvis */ RS_VARDOCVIS,"vardocvis*",
	  M("Text nur anzeigen wenn Variante n aktiv (100 - immer, 103 -"+
	    " wenn Bauteil in aktiver Variante bestueckt, 101 - wenn unbestueckt)",
	  "Display text only in variant n (100 - always, 103 - if part"+
	  " placed in active variante, 101 - if not placed)"),
	  "",0.0,100,TYPINT,0,0,DLAYBIT,TEXTBIT,0,{""} },
	{ /* vardocvis */ RS_VARDOCVIS,"vardocvis*",
	  M("Dokumentargrafik nur anzeigen wenn Variante n aktiv (100 - immer, 103 -"+
	    " wenn Bauteil in aktiver Variante bestueckt, 101 - wenn unbestueckt)",
	  "Display documentary graphic only in variant n (100 - always, 103 -"+
	  " if part placed in active variante, 101 - if not placed)"),
	  "",0.0,100,TYPINT,0,0,DLAYBIT,POLYBIT,DLINEBIT|DAREABIT,{""} },
	{ /* variant */ RS_VARIANT,"lay_variant_*",
	  M("Nummer der aktiven Variante. Hier NICHT aendern!",
	    "Number of active variant. DON'T change here!"),
	  "",0.0,0,TYPINT,0,LAYBIT,0,PLANBIT,0,{""} },
	{ /* variant_name */ RS_VARNAME,"",
	  M("Name der aktiven Variante. Hier NICHT aendern!",
	    "Name of active variant. DON'T change here!"),
	  "",0.0,0,TYPSTR,0,LAYBIT,0,PLANBIT,0,{""} },
	{ /* viapad_trc */ RS_VIAPTRC,"lay_via_trcdist",
	  M("Auf diesem Layout Viapads im DRC mit den Bahnabstandsparametern pruefen",
	    "Perform DRC check of via pads with trace distance parameters on this layout"),
	  "",0.0,0,TYPINT,TYPINTBITS,0,0,PLANBIT,0,{
	  M("Auf diesem Layout Viapads im DRC mit den Bahnabstandsparametern pruefen",
	    "Perform DRC check of via pads with trace distance parameters on this layout")} },
	{ /* viachkrange */ RS_VIACHKRANGE,"",
	  M("Via Checkbereich","Via check range"),
	  "",0.0,0,TYPINT,TYPINTSEL,LAYBIT|PRTBIT,0,PLANBIT,0,{
	  M("&Kein Viacheck","&No Via Check"),
	  M("&1","&1"),M("&2","&2"),M("&3","&3"),M("&4","&4"),M("&5","&5") } },
	{ /* viafillnet */ RS_VIAFILLNET,"",
	  M("Flaechenfuellen Vianetzvorgabe wenn Via ohne Netzanschluss",
	    "Copper fill via net if via without net connection"),
	  "",0.0,0,TYPSTR,TYPSTRNAME,LAYBIT,0,UREFBIT,0,{""} },
	{ /* wrlattr */ RS_WRLATTR,"",
	  M("WRL-Ausgabe zusaetzliche Elementeigenschaften im WRL-Format",
	    "WRL output additional element properties in WRL format"),
	  "",0.0,0,TYPSTR,0,LAYBIT|PRTBIT|STKBIT,0,
	  POLYBIT|PATHBIT|NREFBIT|UREFBIT|DRILLBIT,0,{""} },
	{ /* wrlmodhoff */ RS_WRLHOFF,"",
	  M("WRL-Ausgabe Hoehenoffset des referenzierten Modells (0.0 - Kein Offset)",
	    "WRL output height offset for referenced model (0.0 - No offset)"),
	  "",0.0,0,TYPDBL,TYPDBLDIM,PRTBIT,0,TEXTBIT,0,{""} },
	{ /* wrlmodscale */ RS_WRLSCALE,"",
	  M("WRL-Ausgabe Skalierung des referenzierten Modells (0.0 - Defaultskalierung)",
	    "WRL output scale factor for referenced model (0.0 - Default scale factor)"),
	  "",0.0,0,TYPDBL,0,PRTBIT,0,TEXTBIT,0,{""} }
	};
int predidx				/* Predicate list index */;
int predn		= arylength(predl)	/* Predicate count */;
int seltyp				/* Selection element type */;
int subtyp				/* Selection element sub type */;
int valtyp				/* Predicate value type */;
int laytyp				/* Predicate layer type */;
string ruleprompt			/* Rule element prompt string */;
index L_FIGURE rulefig			/* Cur. rule edit figure list index */;
int ddbclass		= bae_planddbclass()
					/* Layout plan DDB class */;
int classmask		= 1<<(ddbclass-DDBCLLAY)	/* DDB class mask */;
int labidx		= (-1)		/* Label item idx. */;
int edidx		= (-1)		/* Edit box item idx. */;
string rsdatabase	= rs_database()	/* Rule system database file name */;
#define LAYSPACE	15.0		// Layer field spacing
#define SURFOFF		15.0		// Surface field offset
#define SURFWIDTH	6.0		// Surface field width
#define METOFF		22.0		// Metall field offset
#define METWIDTH	6.0		// Metall field width
#define ISOOFF		29.0		// Isolation field offset
#define ISOWIDTH	6.0		// Isolation field width
#define MATOFF		36.0		// Material field offset
#define MATWIDTH	9.0		// Material field width
#define EPSROFF		37.0		// Epsilon r field offset
#define EPSRWIDTH	5.0		// Epsilon r field width
#define TANDOFF		43.0		// Tangens delta field offset
#define TANDWIDTH	5.0		// Tangens delta field width
#define TOLOFF		49.0		// Isolation tolerance field offset
#define TOLWIDTH	7.0		// Isolation tolerance field width
#define COREOFF		57.0		// Core button offset
#define COREWIDTH	4.0		// Core field width
#define FILLOFF		61.0		// Fill button offset
#define FILLWIDTH	5.0		// Fill field width
#define COMMOFF		66.0		// Comment field offset
#define COMMWIDTH	20.0		// Comment field width
double ABUTXSTEP	= bae_swconfig(3)==2 ? 2.0 : 0.0
					/* Action button x step */;
#define FONTASP		(2.0/3.0)	// Font aspect ratio

string rulel[]				/* Rule list */;
int rulen				/* Rule count */;
string path_dis		= ","		/* Path items disable */;
string poly_dis		= ","		/* Polygon items disable */;
string nref_dis		= ","		/* Named reference items disable */;
string uref_dis		= ","		/* Unnamed reference items disable */;
string text_dis		= ","		/* Text items disable */;

// Main program
void main()
{
	index L_FIGURE fig		/* Figure list index */;
	index L_LINE path		/* Path index */;
	index L_POLY poly		/* Polygon index */;
	index L_NREF nref		/* Named reference index */;
	index L_UREF uref		/* Unnamed reference index */;
	index L_TEXT text		/* Text index */;
	index L_DRILL drill		/* Drill index */;
	string drill_dis = ","		/* Drill items disable */;
	string g_dis = ","		/* Group items disable */;
	string h_dis	= (bae_swconfig(0)==BAE_HighEnd && ddbclass==DDBCLLAY) ? "" : ","
					/* HighEnd functions disable */;
	string selmsg			/* Selection message string */;
	string name1, name2		/* Selection element names */;
	string ecolor			/* Element color string */;
	string scolor = ""		/* Selection color string */;
	int oldcol			/* Old color index */;
	int newcol			/* New color index */;
	double cy = DIAL_TOPMARG	/* Current y value */;
	double dialwidth		/* Dialog box width */;
	double dialheight		/* Dialog box height */;
	double baseheight		/* Dialog box base height */;
	int repflag = 1			/* Repeat flag */;
	int edtidx			/* Color edit field item index */;
	int cflag = 0			/* Change flag */;
	int cnt = 0			/* Selection count */;
	string msg			/* Message string */;
	string mrulel[]			/* Multiline text rule list */;
	int mrulen			/* Multiline text rule count */;
	string mtextid = ""		/* Multiline text ID */;
	string textid			/* Current text ID */;
	double linespc			/* Multiline text line spacing */;
	int col				/* Multiline text column */;
	int row				/* Multiline text row */;
	int i				/* Loop control variable */;
	string colstrings[]     = {     // Color index to red col. transform.
		"0 0 0",
		"0 0 0.6",
		"0 0.6 0",
		"0 0.6 0.6",
		"0.6 0 0",
		"0.6 0 0.6",
		"0.6 0.6 0",
		"0.8 0.8 0.8",
		"0.4 0.4 0.4",
		"0 0 1",
		"0 1 0",
		"0 1 1 ",
		"1 0 0",
		"1 0 1",
		"1 1 0",
		"1 1 1"
		};
	// Check the plan class
	if (ddbclass==DDBCLUNDEF)
		error_class();
	// Check if element type scan
	if (bae_iniintval(PAR_METYPSCAN,1)==1 && !bae_peekiact()) {
		forall (path) {
			path_dis="";
			break;
			}
		forall (poly) {
			poly_dis="";
			break;
			}
		forall (nref) {
			nref_dis="";
			break;
			}
		forall (uref) {
			uref_dis="";
			break;
			}
		forall (text) {
			text_dis="";
			break;
			}
		forall (fig where fig.GROUP) {
			g_dis="";
			break;
			}
		if (ddbclass==DDBCLLSTK)
			forall (drill) {
				drill_dis="";
				break;
				}
		}
	else {
		// Enable all menu items
		path_dis=poly_dis=nref_dis=uref_dis=text_dis=g_dis="";
		if (ddbclass==DDBCLLSTK)
			drill_dis="";
		}
	// Select the element type
	bae_defmenusel(-1);
	bae_promptdialog(UPRSELETYP);
	switch (bae_askmenu(15,poly_dis+UPRSELE0,path_dis+UPRSELE1,
	 nref_dis+UPRSELE2,uref_dis+UPRSELE3,text_dis+UPRSELE4,
	 drill_dis+UPRSELE5,UPRSELE6,UPRSELE7,UPRSELE8,h_dis+UPRSELE9,
	 nref_dis+UPRSELE10,UPRSELE11,UPRSELE12,UPRABORT)) {
		// Areas
		case 0 :
		seltyp=L_FIGPOLY;
		selmsg=UPRSELPOLY;
		break;
		// Traces
		case 1 :
		if (ddbclass!=DDBCLLAY && ddbclass!=DDBCLLPRT)
			error_class();
		seltyp=L_FIGPATH;
		selmsg=UPRSELPATH;
		break;
		// Named references
		case 2 :
		if (ddbclass!=DDBCLLAY && ddbclass!=DDBCLLPRT)
			error_class();
		seltyp=L_FIGNREF;
		selmsg=UPRSELNREF;
		break;
		case 3 :
		// Unnamed references
		if (ddbclass!=DDBCLLAY &&
		 ddbclass!=DDBCLLPRT && ddbclass!=DDBCLLSTK)
			error_class();
		seltyp=L_FIGUREF;
		selmsg=UPRSELUREF;
		break;
		// Texts
		case 4 :
		seltyp=L_FIGTEXT;
		selmsg=UPRSELTEXT;
		break;
		// Drills
		case 5 :
		if (ddbclass!=DDBCLLSTK)
			error_class();
		seltyp=L_FIGDRILL;
		selmsg=UPRSELDRILL;
		break;
		// Plan
		case 6 :
		seltyp=PLANTYP;
		break;
		// Group functions
		case 7 :
		bae_defmenusel(-1);
		bae_promptdialog(UPRSELRG);
		switch (bae_askmenu(8,g_dis+UPRSELRG0,g_dis+UPRSELRG1,
		 UPRSELRG2,g_dis+UPRSELRG3,UPRSELRG4,g_dis+UPRSELRG5,UPRSELRG6,
		 UPRABORT)) {
			// Attach rules to group elements
			case 0 :
			grpsetrules();
			break;
			// Detach rules from group elements
			case 1 :
			grpdelrules();
			break;
			// Select elements by rule name
			case 2 :
			grpselrules();
			break;
			// Set PDF color
			case 3 :
			bae_nameclr();
			// Loop for all elements
			forall (fig where fig.RULEOBJID>=0)
			    // Query plot color predicate
			    if (lay_rulequery(RS_OCFIG,fig,RS_PCBSUBJ,
			     RS_PLOTRGB,"?s",ecolor)>0 && ecolor!="")
				bae_nameadd(ecolor,"","","",2);
			if (bae_dialclr()) {
			    // Select color
			    bae_setintpar(16,3103);
			    if (bae_askname(scolor,UPRPDFCOLOR,MAXKEYLEN))
				// Aborted
				error_abort();
			    }
			else {
			    baseheight=DIAL_TOPMARG+DIAL_BUTVSTEP+
			     DIAL_CTRVSTEP+DIAL_SEPVSTEP;
			    do {
				bae_dialclr();
				dial_getboxsizemin(3103,dialwidth,dialheight,
				 DIAL_LEFTMARG+40.0+DIAL_RIGHTSMARG,
				 baseheight+16.0,DIAL_LEFTMARG+25.0+
				  DIAL_RIGHTSMARG,baseheight+1.0);
				cy=DIAL_TOPMARG;
				// Store the OK and abort button
				bae_dialaddcontrol(PA_OK,0,0,0,0.0,0.0,0.0,"",
				 0,DIAL_LEFTMARG,cy,0.0,"");
				bae_dialaddcontrol(PA_ABORT,0,0,0,0.0,0.0,0.0,
				 "",0,DIAL_LEFTMARG+5.0,cy,0.0,"");
				bae_dialaddcontrol(PA_ACT,0,1,0,0.0,0.0,0.0,"",
				 0,DIAL_LEFTMARG+12.0,cy,0.0,UPRBRWCOLOR);
				cy+=DIAL_BUTVSTEP;
				edtidx=bae_dialaddcontrol(PA_STR|PA_HBRDREL,0,0,
				 0,0.0,0.0,0.0,scolor,MAXKEYLEN,DIAL_LEFTMARG,
				 cy,DIAL_RIGHTSMARG,"");
				cy+=DIAL_CTRVSTEP;
				// Store list box
				bae_dialadvcontrol(
				 PA_LB|PA_OKSEL|PA_HBRDREL|PA_VBRDREL,
				 edtidx,0,(-1),0.0,0.0,0.0,"",0,DIAL_LEFTMARG,
				 cy,DIAL_RIGHTEMARG,DIAL_SEPVSTEP,"");
				// Store list box entries
				cnt=0;
				while (bae_nameget(cnt,scolor,"","","",0)==0) {
					bae_dialaddcontrol(PA_LBE,0,0,cnt,0.0,
					 0.0,0.0,"",0,0.0,0.0,0.0,scolor);
					cnt++;
					}
				cy+=dialheight-baseheight+DIAL_SEPVSTEP;
				bae_setintpar(16,3103);
				switch (bae_dialaskparams(
				 "!"+UPRPDFCOLOR,0,dialwidth,cy)) {
					// Done
					case 0 :
					bae_dialgetdata(edtidx,0,0.0,scolor);
					repflag=0;
					break;
					// Palette selection
					case 1 :
					// Process any redraw event
					bae_wsmouse(0.0,0.0,0);
					// Temp. use layer 90 for color query
					ged_setstrpar(8,UPRBRWCOLORP);
					oldcol=bae_getcolor(89);
					bae_setcolor(89,0);
					bae_clriactqueue();
					bae_storetextiact(1,"90");
					bae_storemouseiact(0,0.0,0.0,0,LMB);
					bae_storetextiact(1,"");
					bae_callmenu(108);
					ged_setstrpar(8,"");
					if ((newcol=bae_getcolor(89))>=0 &&
					 newcol<=15) {
					    scolor=colstrings[newcol];
					    }
					else if (newcol&32) {
					    scolor=bae_numstring(
					      ((newcol&0x0F0000)>>16)/15.0,3)+
					     " "+bae_numstring(
					      ((newcol&0x0F000)>>12)/15.0,3)+
					     " "+bae_numstring(
					      ((newcol&0x0F00)>>8)/15.0,3);
					    }
					else {
					    error(ERRINVCOLOR);
					    }
					// Restore layer 90 color
					bae_setcolor(89,oldcol);
					break;
					// Resize
					case (-2) :
					bae_dialgetdata(edtidx,0,0.0,scolor);
					break;
					default :
					error_abort();
					}
				// Stop if no further repeat requests
				} while (repflag);
			   }
			cnt=0;
			forall (fig where fig.GROUP) {
				// Save current state for undo
				if (cnt==0)
					bae_callmenu(MNU_BAESAVESTATE);
				// Assign the element color predicate rule
				rs_assfigstrpred(fig,RS_PLOTRGB,scolor,"","");
				cnt++;
				}
			sprintf(selmsg,REPCOLORSET,scolor,cnt);
			bae_prtdialog(selmsg);
			break;
			// Select PDF color
			case 4 :
			bae_nameclr();
			// Loop for all elements
			forall (fig where fig.RULEOBJID>=0)
				// Query plot color predicate
				if (lay_rulequery(RS_OCFIG,fig,RS_PCBSUBJ,
				 RS_PLOTRGB,"?s",ecolor)>0 && ecolor!="")
					bae_nameadd(ecolor,"","","",2);
			// Select color
			bae_setintpar(16,3103);
			if (bae_askname(scolor,UPRPDFCOLOR,MAXKEYLEN))
				// Aborted
				error_abort();
			// Loop for all elements
			forall (fig where fig.TYP!=C_FIGCON && !fig.GROUP) {
				// Query plot color predicate
				if (fig.RULEOBJID<0 || lay_rulequery(RS_OCFIG,
				 fig,RS_PCBSUBJ,RS_PLOTRGB,"?s",ecolor)<1)
					ecolor="";
				if (ecolor==scolor) {
					ged_elemgrpchg(fig,1);
					cnt++;
					}
				}
			// Report changes
			prtgrpcount(cnt,1);
			break;
			// Set PDF layer
			case 5 :
			bae_nameclr();
			// Loop for all elements
			forall (fig where fig.RULEOBJID>=0)
				// Query plot color predicate
				if (lay_rulequery(RS_OCFIG,fig,RS_PCBSUBJ,
				 RS_PDFLAY,"?s",ecolor)>0 && ecolor!="")
					bae_nameadd(ecolor,"","","",2);
			// Select layer
			bae_setintpar(16,3124);
			if (bae_askname(scolor,UPRPDFLAY,MAXKEYLEN))
				// Aborted
				error_abort();
			cnt=0;
			forall (fig where fig.GROUP) {
				// Save current state for undo
				if (cnt==0)
					bae_callmenu(MNU_BAESAVESTATE);
				// Assign the element PDF layer predicate rule
				rs_assfigstrpred(fig,RS_PDFLAY,scolor,"","");
				cnt++;
				}
			sprintf(selmsg,REPPDFLAYSET,scolor,cnt);
			bae_prtdialog(selmsg);
			break;
			// Select PDF layer
			case 6 :
			bae_nameclr();
			// Loop for all elements
			forall (fig where fig.RULEOBJID>=0)
				// Query plot color predicate
				if (lay_rulequery(RS_OCFIG,fig,RS_PCBSUBJ,
				 RS_PDFLAY,"?s",ecolor)>0 && ecolor!="")
					bae_nameadd(ecolor,"","","",2);
			// Select layer
			bae_setintpar(16,3124);
			if (bae_askname(scolor,UPRPDFLAY,MAXKEYLEN))
				// Aborted
				error_abort();
			// Loop for all elements
			forall (fig where !fig.GROUP) {
				// Query PDF layer predicate
				if (fig.RULEOBJID<0 || lay_rulequery(RS_OCFIG,
				 fig,RS_PCBSUBJ,RS_PDFLAY,"?s",ecolor)<1)
					ecolor="";
				if (ecolor==scolor) {
					ged_elemgrpchg(fig,1);
					cnt++;
					}
				}
			// Report changes
			prtgrpcount(cnt,1);
			break;
			// Abort
			case 7 :
			default :
			error_abort();
			}
		exit(0);
		// Glue functions
		case 8 :
		bae_defmenusel(-1);
		bae_promptdialog(UPRSELGL);
		switch (bae_askmenu(7,UPRSELGL0,UPRSELGL1,g_dis+UPRSELGL2,
		 g_dis+UPRSELGL3,UPRSELGL4,g_dis+UPRSELGL5,UPRABORT)) {
			// Glue selectable parts
			case 0 :
			if (ddbclass!=DDBCLLAY && ddbclass!=DDBCLLPRT)
				error_class();
			setglue(1,0);
			break;
			// Unglue selectebale parts
			case 1 :
			if (ddbclass!=DDBCLLAY && ddbclass!=DDBCLLPRT)
				error_class();
			setglue(0,0);
			break;
			// Glue group elements
			case 2 :
			setglue(1,1);
			break;
			// Unglue group elements
			case 3 :
			setglue(0,1);
			break;
			// Select glued elements
			case 4 :
			prtgrpcount(ged_groupselect(10,2,1),1);
			break;
			// Deselect glued elements
			case 5 :
			prtgrpcount(ged_groupselect(10,2,0),0);
			break;
			// Abort
			case 6 :
			default :
			error_abort();
			}
		exit(0);
		// Layer stackup
		case 9 :
		if (h_dis=="")
			layerstackup();
		exit(0);
		// Part predicate definitions
		case 10 :
		switch (ddbclass) {
			case DDBCLLAY :
			partpredicates();
			exit(0);
			case DDBCLLPRT :
			preddefvalset();
			exit(0);
			default :
			;
			}
		error_class();
		// Edit element context functions
		case 11 :
		elementfunctions();
		exit(0);
		// Rule update
		case 12 :
		updrules();
		exit(0);
		// Abort
		case 13 :
		default :
		exit(0);
		}
	// Check if plan rule
	if (seltyp==PLANTYP) {
		// Get the plan rules
		rulen=rs_getplanrules(rulel);
		// Edit the rules
		subtyp=0;
		editrules("","");
		// Save current state for undo
		bae_callmenu(MNU_BAESAVESTATE);
		// Attach/detach the rule list
		if (rulen) {
			if (lay_ruleplanatt(rulel))
				rs_error(-1);
			}
		else if (lay_getrulecnt(RS_OCPLAN,0)>0) {
			if (lay_ruleplandet())
				rs_error(-1);
			}
		// Redraw the screen
		bae_callmenu(MNU_BAEREDISPL);
		}
	else {
		// Loop while element picked
		bae_prtdialog(selmsg);
		while (ged_pickelem(rulefig,seltyp)==0) {
			// Get the rule count
			name1=name2="";
			rulen=rs_getfigrules(rulefig,rulel);
			switch (seltyp) {
				case L_FIGTEXT :
				subtyp=
				 (rulefig.TEXT.STR[0]=='$' ? ATXTBIT : 0);
				name1=rulefig.NAME;
				laytyp=getlaytyp(rulefig.LAYER);
				// Query the multiline text status
				if (rulefig.RULEOBJID<0 || lay_rulequery(
				 RS_OCFIG,rulefig,RS_PCBSUBJ,RS_MTEXTID,
				 "?s",mtextid)<=0)
					mtextid="";
				break;
				case L_FIGPATH :
				subtyp=0;
				laytyp=getlaytyp(rulefig.LAYER);
				break;
				case L_FIGPOLY :
				switch (rulefig.POLY.TYP) {
					case L_POLYDOCLINE :
					subtyp=DLINEBIT;
					break;
					case L_POLYDOCAREA :
					subtyp=DAREABIT;
					break;
					case L_POLYKEEPOUT :
					subtyp=KOUTABIT;
					break;
					case L_POLYCOPPASS :
					subtyp=COPABIT;
					break;
					case L_POLYCOPACT :
					subtyp=ACOPABIT;
					break;
					case L_POLYSPPAREA :
					subtyp=SPPOWBIT;
					break;
					case L_POLYBRDOUT :
					subtyp=OUTLBIT;
					break;
					case L_POLYCOPFILL :
					default :
					subtyp=COPFABIT;
					}
				laytyp=getlaytyp(rulefig.LAYER);
				break;
				case L_FIGNREF :
				switch (rulefig.NREF.MACRO.CLASS) {
					case DDBCLLAY :
					subtyp=LAYBIT;
					break;
					case DDBCLLPRT :
					subtyp=PRTBIT;
					break;
					case DDBCLLSTK :
					subtyp=STKBIT;
					break;
					case DDBCLLPAD :
					subtyp=PADBIT;
					break;
					default :
					subtyp=0;
					}
				name1=rulefig.NAME,
				name2=rulefig.NREF.MACRO.NAME;
				laytyp=0;
				break;
				case L_FIGUREF :
				switch (rulefig.UREF.MACRO.CLASS) {
					case DDBCLLAY :
					subtyp=LAYBIT;
					break;
					case DDBCLLPRT :
					subtyp=PRTBIT;
					break;
					case DDBCLLSTK :
					subtyp=STKBIT;
					break;
					case DDBCLLPAD :
					subtyp=PADBIT;
					break;
					default :
					subtyp=0;
					}
				name1=rulefig.UREF.MACRO.NAME;
				laytyp=getlaytyp(rulefig.UREF.LAYOFF);
				break;
				case L_FIGDRILL :
				subtyp=1<<rulefig.DRILL.CLASS;
				laytyp=0;
				break;
				default :
				subtyp=0;
				}
			// Edit the rules
			editrules(name1,name2);
			// Save current state for undo
			if (cflag==0) {
				bae_callmenu(MNU_BAESAVESTATE);
				cflag=1;
				}
			// Attach/detach the rule list
			if (rulen) {
				if (lay_rulefigatt(rulefig,rulel))
					rs_error(-1);
				}
			else if (lay_getrulecnt(RS_OCFIG,rulefig)>0) {
				if (lay_rulefigdet(rulefig))
					rs_error(-1);
				}
			// Check if multiline text rule transfer
			if (mtextid!="") {
				// Get the base rules
				mrulen=4;
				sprintf(mrulel[0],":%s:%s='%s';",
				 RS_PCBSUBJ,RS_MTEXTID,mtextid);
				for (i=0;i<rulen;i++) {
					msg=rulel[i];
					if (strmatch(msg,
					  ":pcb_rules:mtextid=*;") ||
					 strmatch(msg,
					  ":pcb_rules:mtextrow=*;") ||
					 strmatch(msg,
					  ":pcb_rules:mtextcol=*;") ||
					 strmatch(msg,
					  ":pcb_rules:mtextls=*;"))
						continue;
					mrulel[mrulen]=msg;
					mrulen++;
					}
				forall (rulefig where rulefig.TYP==L_FIGTEXT &&
				 rulefig.RULEOBJID>=0 &&
				 lay_rulequery(RS_OCFIG,rulefig,RS_PCBSUBJ,
				  RS_MTEXTID,"?s",textid)>0 &&
				 textid==mtextid) {
					// Get multiline text data
					if (lay_rulequery(RS_OCFIG,rulefig,
					 RS_PCBSUBJ,RS_MTEXTCOL,"?d",col)<1 ||
					 lay_rulequery(RS_OCFIG,rulefig,
					  RS_PCBSUBJ,RS_MTEXTROW,"?d",row)<1 ||
					 lay_rulequery(RS_OCFIG,rulefig,
					  RS_PCBSUBJ,RS_MTEXTLS,"?f",linespc)<1)
						continue;
					sprintf(mrulel[1],":%s:%s=%d;",
					 RS_PCBSUBJ,RS_MTEXTCOL,col);
					sprintf(mrulel[2],":%s:%s=%d;",
					 RS_PCBSUBJ,RS_MTEXTROW,row);
					sprintf(mrulel[3],":%s:%s=%.2f;",
					 RS_PCBSUBJ,RS_MTEXTLS,linespc);
					if (lay_rulefigatt(rulefig,mrulel))
						rs_error(-1);
					}
				}
			// Redraw the screen
			bae_callmenu(MNU_BAEREDISPL);
			// Prompt for next element
			bae_prtdialog(selmsg);
			}
		}
}

static void grpsetrules()
// Set group element rules
{
	index L_FIGURE fig		/* Figure list index */;
	string rulename	= ""		/* Rule name */;
	string rn	= ""		/* Rule scan name */;
	string msg			/* Message buffer */;
	int cnt = 0			/* Change count */;
	char c				/* Rule name character buffer */;
	int i,j				/* Loop control variables */;
	// Build rule name list
	bae_nameclr();
	while (scanddbenames(rsdatabase,DDBCLRULE,rn)==1)
		if (!strmatch(rn,"scm_*") && !strmatch(rn,"lay_variant*"))
			// Add the commented rule name
			bae_nameadd(
			 ddbcelemname(rsdatabase,rn,DDBCLRULE,1),"","","",2);
	// Get the rule name
	bae_setintpar(16,3125);
	if (bae_askname(rulename,UPRRULE,MAXKEYLEN))
		// Aborted
		error_abort();
	for (i=0;(c=rulename[i])!='\0';i++)
		if (c==' ')
			break;
	if (c==' ')
		rulename=strextract(rulename,0,i-1);
	// Loop for all group elements
	forall (fig where fig.GROUP) {
		// Save current state for undo
		if (cnt==0)
			bae_callmenu(MNU_BAESAVESTATE);
		// Get the rule count
		rulen=rs_getfigrules(fig,rulel);
		// Clear any previous rule definition
		for (i=rulen-1;i>=0;i--)
			if (rulel[i]==rulename) {
				// Delete the old rule
				for (j=i;j<rulen-1;j++)
					rulel[j]=rulel[j+1];
				rulen--;
				rulel[rulen]="";
				cnt--;
				}
		// Add the new rule
		rulel[rulen++]=rulename;
		cnt++;
		// Attach the rule list
		if (lay_rulefigatt(fig,rulel))
			rs_error(-1);
		}
	// Report process count
	sprintf(msg,REPRULESET,rulename,cnt);
	bae_prtdialog(msg);
}

static void grpdelrules()
// Delete group element rules
{
	index L_FIGURE fig		/* Figure list index */;
	string rulename			/* Rule name */;
	string msg			/* Message buffer */;
	int cnt = 0			/* Change count */;
	int cflag = 0			/* Change flag */;
	int i,j				/* Loop control variables */;
	// Get the rule name or pattern
	if ((rulename=askstr(UPRRULEPAT,MAXKEYLEN))=="" ||
	 rulename==UINPOPABORT)
		error_abort();
	// Query the rule name
	if (rulename=="?" &&
	 bae_askddbename(rulename,rsdatabase,DDBCLRULE,UPRRULE))
		error_abort();
	// Check if all rules pattern
	if (rulename=="*") {
		// Loop for all group elements
		forall (fig where fig.GROUP && fig.RULEOBJID>=0) {
			// Save current state for undo
			if (cnt==0)
				bae_callmenu(MNU_BAESAVESTATE);
			if (lay_rulefigdet(fig))
				rs_error(-1);
			cnt++;
			}
		// Report process count
		sprintf(msg,REPRULEREM,cnt);
		bae_prtdialog(msg);
		}
	else {
		// Loop for all group elements
		forall (fig where fig.GROUP && fig.RULEOBJID>=0) {
			// Get the rule count
			rulen=rs_getfigrules(fig,rulel);
			// Clear any previous rule definition
			for (i=rulen-1;i>=0;i--)
				if (strmatch(rulel[i],rulename)) {
					// Delete the old rule
					for (j=i;j<rulen-1;j++)
						rulel[j]=rulel[j+1];
					rulen--;
					rulel[rulen]="";
					cnt++;
					}
			// Save current state for undo
			if (cflag==0) {
				bae_callmenu(MNU_BAESAVESTATE);
				cflag=1;
				}
			// Attach the rule list
			if (rulen==0) {
				if (lay_rulefigdet(fig))
					rs_error(-1);
				}
			else {
				if (lay_rulefigatt(fig,rulel))
					rs_error(-1);
				}
			}
		// Report process count
		sprintf(msg,REPRULEDEL,rulename,cnt);
		bae_prtdialog(msg);
		}
}

static void grpselrules()
// Select group element by rule attachment
{
	index L_FIGURE fig		/* Figure list index */;
	string rulename			/* Rule name string */;
	int cnt = 0			/* Selection count */;
	int i				/* Loop control variable */;
	// Get the rule name or pattern
	if ((rulename=askstr(UPRRULEPAT,MAXKEYLEN))=="" ||
	 rulename==UINPOPABORT)
		error_abort();
	// Query the rule name
	if (rulename=="?" &&
	 bae_askddbename(rulename,rsdatabase,DDBCLRULE,UPRRULE))
		error_abort();
	// Loop for all group elements
	forall (fig where fig.RULEOBJID>=0) {
		// Get the rule count
		rulen=rs_getfigrules(fig,rulel);
		// Search for given rule
		for (i=0;i<rulen;i++)
			if (strmatch(rulel[i],rulename)) {
				ged_elemgrpchg(fig,1);
				cnt++;
				break;
				}
		}
	// Report changes
	prtgrpcount(cnt,1);
}

static void editrules(string name1,string name2)
/*
// Add/delete rule to/from the current rule list
// Parameters :
//	string name1		: Element major name
//	string name2		: Element secondary name
*/
{
	string msg			/* Message string */;
	string ecomm			/* Element comment */;
	string predname			/* Predicate name */;
	string pattern	= ""		/* Pattern string */;
	char c				/* Pattern character */;
	string nrn			/* New rule name buffer */;
	string rn			/* Rule name buffer */;
	string fn			/* File name buffer */;
	double pcol			/* Parameter column */;
	double dialwidth		/* Dialog box width */;
	double dialheight		/* Dialog box height */;
	double baseheight		/* Dialog box base height */;
	double butx			/* Current button position */;
	double cy			/* Dialog box current y coordinate */;
	string strval			/* String value */;
	double dblval			/* Double value */;
	int intval			/* Integer value */;
	int i				/* Loop control variable */;
	switch (seltyp) {
		case L_FIGTEXT :
		sprintf(ruleprompt,UPRDRTEXT,name1,layername(rulefig.LAYER));
		break;
		case L_FIGPATH :
		sprintf(ruleprompt,UPRDRPATH,layername(rulefig.LAYER));
		break;
		case L_FIGPOLY :
		switch (subtyp) {
			case DLINEBIT :
			sprintf(ruleprompt,UPRDRPTYPDL,
			 layername(rulefig.LAYER));
			break;
			case DAREABIT :
			sprintf(ruleprompt,UPRDRPTYPDA,
			 layername(rulefig.LAYER));
			break;
			case KOUTABIT :
			sprintf(ruleprompt,UPRDRPTYPKO,
			 layername(rulefig.LAYER));
			break;
			case COPABIT :
			sprintf(ruleprompt,UPRDRPTYPPC,
			 layername(rulefig.LAYER));
			break;
			case ACOPABIT :
			sprintf(ruleprompt,UPRDRPTYPAC,
			 layername(rulefig.LAYER));
			break;
			case SPPOWBIT :
			sprintf(ruleprompt,UPRDRPTYPSP,
			 layername(rulefig.LAYER));
			break;
			case OUTLBIT :
			ruleprompt=UPRDRPTYPBO;
			break;
			case COPFABIT :
			default :
			sprintf(ruleprompt,UPRDRPTYPCF,
			 layername(rulefig.LAYER));
			}
		break;
		case L_FIGNREF :
		switch (subtyp) {
			case STKBIT :
			sprintf(ruleprompt,UPRDRPIN,name1,name2);
			break;
			case PRTBIT :
			default :
			sprintf(ruleprompt,UPRDRPART,name1,name2);
			}
		break;
		case L_FIGUREF :
		switch (subtyp) {
			case PADBIT :
			sprintf(ruleprompt,UPRDRPAD,name1,
			 layername(rulefig.LAYER));
			break;
			case STKBIT :
			default :
			sprintf(ruleprompt,UPRDRVIA,name1);
			}
		break;
		case L_FIGDRILL :
		sprintf(ruleprompt,UPRDRDRILL,rulefig.DRILL.CLASS==0 ? '-' :
		 ('A'+rulefig.DRILL.CLASS-1));
		break;
		case PLANTYP :
		ruleprompt=bae_plainmenutext(UPRSELE6);
		break;
		default :
		ruleprompt="";
		}
	// Do the rule input loop
	bae_prtdialog("");
	while (1) {
	    // Check if dialog box support
	    if (bae_dialclr()) {
		// Build the query message string
		msg=UPRSELRULE0;
		for (i=0;i<rulen;i++) {
			// Add the rule name seperator
			if (i!=0)
				msg+=",";
			// Add the rule name
			msg+=rulel[i];
			}
		// Terminate the query message string
		msg+=UPRSELRULE1;
		// Get the rule name
		nrn="";
		fn=rsdatabase;
		if (bae_askddbename(nrn,fn,DDBCLRULE,msg))
			break;
		}
	    else {
		baseheight=DIAL_TOPMARG+DIAL_BUTVSTEP+2.0*DIAL_SEPVSTEP+
		 3.0*DIAL_CTRVSTEP;
		dial_getboxsizemin(3015,dialwidth,dialheight,
		 DIAL_LEFTMARG+97.0+DIAL_RIGHTSMARG,baseheight+10.0,
		 DIAL_LEFTMARG+65.0+DIAL_RIGHTSMARG,baseheight+2.0);
		pcol=dialwidth/4.0;
		cy=DIAL_TOPMARG;
		butx=DIAL_LEFTMARG;
		dial_label(0.0,cy,UPRRULENAME);
		// Store edit control
		edidx=bae_dialaddcontrol(PA_STR,0,0,0,0.0,0.0,0.0,
		 pattern,200,DIAL_LEFTMARG+pcol,cy,pcol-3.0,"");
		bae_dialaddcontrol(PA_ACT,0,1,0,0.0,0.0,0.0,"",0,
		 DIAL_LEFTMARG+2.0*pcol,cy,0.0,UPRPATTERN);
		cy+=DIAL_CTRVSTEP;
		labidx=bae_dialaddcontrol(PA_LAB|PA_HBRDREL,0,0,0,0.0,
		 0.0,0.0,"",0,DIAL_LEFTMARG,cy,DIAL_RIGHTSMARG,"");
		cy+=DIAL_CTRVSTEP;
		dial_label(0.0,cy,UPRRULESET);
		bae_dialadvcontrol(PA_VSEP|PA_VBRDREL,0,0,0,0.0,
		 0.0,0.0,"",0,DIAL_LEFTMARG+pcol-1.5,cy,0.0,DIAL_BOTSMARG,"");
		dial_label(pcol,cy,UPRRULEPROJ);
		bae_dialadvcontrol(PA_VSEP|PA_VBRDREL,0,0,0,0.0,0.0,0.0,"",0,
		 DIAL_LEFTMARG+2.0*pcol-1.5,cy,0.0,DIAL_BOTSMARG,"");
		dial_label(2.0*pcol,cy,UPRRULEDB);
		cy+=DIAL_CTRVSTEP;
		// Store rule set list box
		bae_dialadvcontrol(PA_LB|PA_OKSEL|PA_HSCROLL|PA_MCALLBACK,edidx,
		 0,(-1),0.0,0.0,0.0,"",0,DIAL_LEFTMARG,cy,pcol-3.0,
		 dialheight-baseheight,"");
		// Store list box entries
		for (i=0;i<rulen;i++)
			// Add the rule name
			bae_dialaddcontrol(PA_LBE,0,0,0,0.0,0.0,0.0,"",0,
			 0.0,0.0,0.0,rulel[i]);
		// Store project rule database list box
		bae_dialadvcontrol(PA_LB|PA_OKSEL|PA_HSCROLL|PA_MCALLBACK,edidx,
		 0,(-1),0.0,0.0,0.0,"",0,DIAL_LEFTMARG+pcol,cy,pcol-3.0,
		 dialheight-baseheight,"");
		// Store list box entries
		rn="";
		fn=bae_planfname();
		while (scanddbenames(fn,DDBCLRULE,rn)==1)
			if (!strmatch(rn,"scm_*") &&
			 !strmatch(rn,"lay_variant*") &&
			 (pattern[0]=='\0' || strmatch(rn,pattern) ||
			 (ddbgetelemcomment(fn,DDBCLRULE,rn,ecomm)==0 &&
			  strmatch(ecomm,pattern))))
				// Add the rule name
				bae_dialaddcontrol(PA_LBE,0,0,0,0.0,0.0,0.0,
				 "",0,0.0,0.0,0.0,rn);
		// Store rule database list box
		bae_dialadvcontrol(
		 PA_LB|PA_OKSEL|PA_HSCROLL|PA_HBRDREL|PA_MCALLBACK,
		 edidx,0,(-1),0.0,0.0,0.0,"",0,DIAL_LEFTMARG+2.0*pcol,cy,
		 DIAL_RIGHTSMARG,dialheight-baseheight,"");
		cy+=dialheight-baseheight+DIAL_SEPVSTEP;
		// Store list box entries
		rn="";
		fn=rsdatabase;
		while (scanddbenames(fn,DDBCLRULE,rn)==1)
			if (!strmatch(rn,"scm_*") &&
			 !strmatch(rn,"lay_variant*") &&
			 (pattern[0]=='\0' || strmatch(rn,pattern) ||
			 (ddbgetelemcomment(fn,DDBCLRULE,rn,ecomm)==0 &&
			  strmatch(ecomm,pattern))))
				dial_lbddbentry(0,0,fn,rn,DDBCLRULE,1);
		// Store OK button
		bae_dialaddcontrol(PA_ACT,
		 0,0,0,0.0,0.0,0.0,"",0,butx,cy,0.0,UPRTOGGLE);
		butx+=bae_dialgettextlen(0,UPRTOGGLE)+BUTXSTEP;
		// Store done button
		bae_dialaddcontrol(PA_ACT,
		 0,5,0,0.0,0.0,0.0,"",0,butx,cy,0.0,UPRDONE);
		butx+=bae_dialgettextlen(0,UPRDONE)+BUTXSTEP;
		// Store abort button
		bae_dialaddcontrol(PA_ABORT,
		 0,(-1),0,0.0,0.0,0.0,"",0,butx,cy,0.0,"");
		// Store predicate controls button
		butx+=12.0;
		bae_dialaddcontrol(PA_LAB,
		 0,0,0,0.0,0.0,0.0,"",0,butx,cy,0.0,UPRPREDICATE);
		butx+=bae_dialgettextlen(0,UPRPREDICATE)+BUTXSTEP;
		bae_dialaddcontrol(PA_ACT,
		 0,2,0,0.0,0.0,0.0,"",0,butx,cy,0.0,UPRPREDSTR);
		butx+=bae_dialgettextlen(0,UPRPREDSTR)+BUTXSTEP;
		bae_dialaddcontrol(PA_ACT,
		 0,3,0,0.0,0.0,0.0,"",0,butx,cy,0.0,UPRPREDDBL);
		butx+=bae_dialgettextlen(0,UPRPREDDBL)+BUTXSTEP;
		bae_dialaddcontrol(PA_ACT,
		 0,4,0,0.0,0.0,0.0,"",0,butx,cy,0.0,UPRPREDINT);
		cy+=DIAL_BUTVSTEP+DIAL_SEPVSTEP;
		// Display dialog box
		sprintf(msg,UPRDRULEH,ruleprompt);
		bae_setintpar(16,3015);
		switch (bae_dialaskcall("!"+msg,0,dialwidth,cy,ruleactcb)) {
			// Done
			case 0 :
			bae_dialgetdata(edidx,0,0.0,nrn);
			for (i=0;(c=nrn[i])!='\0';i++)
				if (c=='\'' || c=='"' || c=='*' || c=='?')
					break;
			if (c=='*' || c=='?') {
				pattern=nrn;
				continue;
				}
			for (i=0;(c=nrn[i])!='\0';i++)
				if (c=='\'' || c==' ')
					break;
			if (c==' ')
				nrn=strextract(nrn,0,i-1);
			if (nrn=="")
				return;
			break;
			// Pattern
			case 1 :
			bae_dialgetdata(edidx,0,0.0,pattern);
			continue;
			// String predicate
			case 2 :
			valtyp=TYPSTR;
			if ((predname=getpredname())=="")
				continue;
			strval=getpredsval(predname);
			if (editpredsval(predname,strval))
				continue;
			// Delete old value rule
			delpred(predname,
			 predidx>=0 ? predl[predidx].delpat : "");
			// Check if default value
			if (predidx>=0 && predl[predidx].defsval==strval)
				continue;
			// Insert new predicate rule
			sprintf(nrn,":%s:%s='%s';",RS_PCBSUBJ,predname,strval);
			insrule(nrn);
			continue;
			// Double predicate
			case 3 :
			valtyp=TYPDBL;
			if ((predname=getpredname())=="")
				continue;
			dblval=getpreddval(predname);
			if (editpreddval(predname,dblval))
				continue;
			// Delete old value rule
			delpred(predname,
			 predidx>=0 ? predl[predidx].delpat : "");
			// Check if default value
			if (predidx>=0 && predl[predidx].defdval==dblval)
				continue;
			// Insert new predicate rule
			if (floor(dblval)==ceil(dblval))
				sprintf(nrn,":%s:%s=%.1f;",RS_PCBSUBJ,
				 predname,dblval);
			else
				sprintf(nrn,":%s:%s=%.9g;",RS_PCBSUBJ,
				 predname,dblval);
			insrule(nrn);
			continue;
			// Integer predicate
			case 4 :
			valtyp=TYPINT;
			if ((predname=getpredname())=="")
				continue;
			intval=getpredival(predname);
			if (editpredival(predname,intval))
				continue;
			// Delete old value rule
			delpred(predname,
			 predidx>=0 ? predl[predidx].delpat : "");
			// Check if default value
			if (predidx>=0 && predl[predidx].defival==intval)
				continue;
			// Insert new predicate rule
			sprintf(nrn,":%s:%s=%d;",RS_PCBSUBJ,predname,intval);
			insrule(nrn);
			continue;
			// Resize
			case (-2) :
			continue;
			// Abort
			case (-1) :
			error_abort();
			// Done
			case 5 :
			default :
			return;
			}
		}
	    // Scan the rule list
	    for (i=0;i<rulen;i++)
		if (rulel[i]==nrn)
			break;
	    // Test if rule found
	    if (i>=rulen) {
		// Check if rule exists
		if (!rs_isrule(nrn)) {
			// Issue rule not defined message
			sprintf(msg,ERRNORULE,nrn);
			bae_msgbox(2,msg,"");
			continue;
			}
		insrule(nrn);
		}
	    else {
		// Delete the old rule
		for (;i<rulen-1;i++)
			rulel[i]=rulel[i+1];
		rulen--;
		rulel[rulen]="";
		}
	    }
}

static int ruleactcb(
 int reason,int boxidx,int itemidx,int itemid,string itemstr)
/*
// Predicate list activation callback
// Return value :
//	zero if done or (-1) on data error
// Parameters :
//	int reason		: Callback reason
//	int boxidx		: Dialog box index
//	int itemidx		: Dialog box item index
//	int itemid		: Dialog list box item id
//	string itemstr		: Dialog list box item string
*/
{
	string rulename	= ""		/* Rule name */;
	string predname	= ""		/* Predicate name */;
	string predval			/* Predicate value */;
	char c				/* Pattern character */;
	int typmask = (1<<seltyp)	/* Element type mask */;
	int i				/* Loop control variable */;
	if (itemid<0)
		return(0);
	// Get the rule name
	bae_dialgetdata(edidx,0,0.0,rulename);
	// Check if normal rule name
	if (rulename[i]!=':') {
		for (i=0;(c=rulename[i])!='\0';i++)
			if (c=='\'' || c==' ')
				break;
		if (c==' ')
			rulename=strextract(rulename,0,i-1);
		bae_dialsetdata(labidx,PA_LAB|PA_HBRDREL,0,0.0,
		 ddbcelemname(rsdatabase,rulename,DDBCLRULE,1));
		// Return without errors
		return(0);
		}
	// Extract predicate name
	for (i=2+strlen(RS_PCBSUBJ);(c=rulename[i])!='\0';i++)
		if (c=='=') {
			predname=strextract(rulename,2+strlen(RS_PCBSUBJ),i-1);
			break;
			}
	// Assume unknown predicate
	predidx=(-1);
	// Check if known predicate
	for (i=0;i<predn;i++)
		// Apply class/type filter
		if (predl[i].name==predname &&
		 (predl[i].classmask==0 || (predl[i].classmask&classmask)!=0) &&
		 (predl[i].elaymask==0 || (predl[i].elaymask&laytyp)!=0) &&
		 (predl[i].etypmask==0 || (predl[i].etypmask&typmask)!=0) &&
		 (predl[i].estypmask==0 || (predl[i].estypmask&subtyp)!=0)) {
			predidx=i;
			valtyp=predl[i].valtyp;
			break;
			}
	// Check if known type
	if (predidx<0) {
		// Assume integer type
		valtyp=TYPINT;
		for (i++;(c=rulename[i])!='\0';i++)
			if (c=='\'' || c=='"') {
				valtyp=TYPSTR;
				break;
				}
			else if (c=='.') {
				valtyp=TYPDBL;
				break;
				}
		}
	// Query predicate value for current element
	predval=getpredval(predname);
	if (predidx>=0)
		predval=predl[predidx].comm+" : "+predval;
	bae_dialsetdata(labidx,PA_LAB|PA_HBRDREL,0,0.0,predval);
	// Return without errors
	return(0);
}

void insrule(string rulename)
/*
// Insert rule name sorted into rule name list
// Parameter :
//	string name		: New rule name
*/
{
	int i				/* Loop control variable */;
	// Insert new rule sorted into list
	for (i=rulen;i>0;i--)
		if (rulel[i-1]>rulename)
			rulel[i]=rulel[i-1];
		else
			break;
	rulel[i]=rulename;
	rulen++;
}

void delpred(string name,string delpat)
/*
// Delete predicate definition from rule name list
// Parameter :
//	string name		: Predicate name
//	string delpat		: Old rule deletion name pattern
*/
{
	string pdefprefix		/* Predicate def. prefix */;
	int pdefend			/* Predicate def. end */;
	int i				/* Loop control variable */;
	// Get predicate rule definition prefix
	sprintf(pdefprefix,":%s:%s=",RS_PCBSUBJ,name);
	pdefend=strlen(pdefprefix)-1;
	for (i=0;i<rulen;i++)
		if (strextract(rulel[i],0,pdefend)==pdefprefix ||
		 strmatch(rulel[i],delpat)) {
			rulen--;
			for (;i<rulen;i++)
				rulel[i]=rulel[i+1];
			rulel[rulen]="";
			break;
			}
}

static string getpredname()
/*
// Get predicate name
*/
{
	string title			/* Title message string */;
	string msg			/* Message buffer */;
	string predname	= ""		/* Predicate name */;
	double pcol = 23.0		/* Parameter column */;
	double cy			/* Dialog box current y coordinate */;
	double dialwidth		/* Dialog box width */;
	double dialheight		/* Dialog box height */;
	double baseheight		/* Dialog box base height */;
	int repflag	= 1		/* Repeat flag */;
	char c				/* Pattern character */;
	int typmask = (1<<seltyp)	/* Element type mask */;
	int i				/* Loop control variable */;
	baseheight=
	 DIAL_TOPMARG+DIAL_BUTVSTEP+2.0*DIAL_CTRVSTEP+DIAL_SEPVSTEP+0.2;
	do {
		bae_dialclr();
		dial_getboxsizemin(3096,dialwidth,dialheight,
		 DIAL_LEFTMARG+41.0+DIAL_RIGHTSMARG,baseheight+10.0,
		 DIAL_LEFTMARG+25.0+DIAL_RIGHTSMARG,baseheight+1.0);
		// Build the dialog box
		cy=DIAL_TOPMARG;
		// Store predicate edit controls
		edidx=dial_namestring(predname,MAXKEYLEN,0.0,cy);
		labidx=bae_dialaddcontrol(PA_LAB|PA_HBRDREL,0,0,0,0.0,
		 0.0,0.0,"",0,DIAL_LEFTMARG,cy,DIAL_RIGHTSMARG,"");
		cy+=DIAL_CTRVSTEP;
		// Store predicate list box
		bae_dialadvcontrol(
		 PA_LB|PA_OKSEL|PA_HSCROLL|PA_HBRDREL|PA_MCALLBACK,edidx,
		 0,(-1),0.0,0.0,0.0,"",0,DIAL_LEFTMARG,cy,DIAL_RIGHTSMARG,
		 dialheight-baseheight,"");
		// Store list box entries
		for (i=0;i<predn;i++) {
			// Apply class/type filter
			if (predl[i].valtyp!=valtyp ||
			 (predl[i].classmask!=0 &&
			  (predl[i].classmask&classmask)==0) ||
			 (predl[i].elaymask!=0 &&
			  (predl[i].elaymask&laytyp)==0) ||
			 (predl[i].etypmask!=0 &&
			  (predl[i].etypmask&typmask)==0) ||
			 (predl[i].estypmask!=0 &&
			  (predl[i].estypmask&subtyp)==0))
				continue;
			if (predl[i].comm!="") {
				sprintf(msg,"%s : %s",
				 predl[i].name,predl[i].comm);
				bae_dialaddcontrol(PA_LBE,0,0,0,0.0,
				 0.0,0.0,"",0,0.0,0.0,0.0,msg);
				}
			else {
				bae_dialaddcontrol(PA_LBE,0,0,i,0.0,0.0,0.0,
				 "",0,0.0,0.0,0.0,predl[i].name);
				}
			}
		cy+=dialheight-baseheight+0.2;
		// Store OK button
		dial_okabort(cy);
		// Display dialog box
		bae_setintpar(16,3096);
		switch (valtyp) {
			case TYPSTR :
			sprintf(title,UPRDPREDSTR,ruleprompt);
			break;
			case TYPDBL :
			sprintf(title,UPRDPREDDBL,ruleprompt);
			break;
			case TYPINT :
			default :
			sprintf(title,UPRDPREDINT,ruleprompt);
			}
		switch (bae_dialaskcall("!"+title,0,dialwidth,cy,predactcb)) {
			// Done
			case 0 :
			bae_dialgetdata(edidx,0,0.0,predname);
			for (i=0;(c=predname[i])!='\0';i++)
				if (c=='\'' || c==' ')
					break;
			if (c==' ')
				predname=strextract(predname,0,i-1);
			repflag=0;
			break;
			// Resize
			case (-2) :
			bae_dialgetdata(edidx,0,0.0,predname);
			break;
			default :
			return("");
			}
		// Stop if no further repeat requests
		} while (repflag);
	// Assume unknown predicate
	predidx=(-1);
	// Check if known predicate
	for (i=0;i<predn;i++)
		// Apply class/type filter
		if (predl[i].name==predname &&
		 predl[i].valtyp==valtyp &&
		 (predl[i].classmask==0 || (predl[i].classmask&classmask)!=0) &&
		 (predl[i].elaymask==0 || (predl[i].elaymask&laytyp)!=0) &&
		 (predl[i].etypmask==0 || (predl[i].etypmask&typmask)!=0) &&
		 (predl[i].estypmask==0 || (predl[i].estypmask&subtyp)!=0)) {
			predidx=i;
			break;
			}
	// Return predicate name
	return(predname);
}

static int predactcb(
 int reason,int boxidx,int itemidx,int itemid,string itemstr)
/*
// Predicate list activation callback
// Return value :
//	zero if done or (-1) on data error
// Parameters :
//	int reason		: Callback reason
//	int boxidx		: Dialog box index
//	int itemidx		: Dialog box item index
//	int itemid		: Dialog list box item id
//	string itemstr		: Dialog list box item string
*/
{
	string predname	= ""		/* Predicate name */;
	string predval			/* Predicate value */;
	char c				/* Pattern character */;
	int typmask = (1<<seltyp)	/* Element type mask */;
	int i				/* Loop control variable */;
	if (itemid<0)
		return(0);
	// Get the predicate name
	bae_dialgetdata(edidx,0,0.0,predname);
	for (i=0;(c=predname[i])!='\0';i++)
		if (c=='\'' || c==' ')
			break;
	if (c==' ')
		predname=strextract(predname,0,i-1);
	// Assume unknown predicate
	predidx=(-1);
	// Check if known predicate
	for (i=0;i<predn;i++)
		// Apply class/type filter
		if (predl[i].name==predname &&
		 predl[i].valtyp==valtyp &&
		 (predl[i].classmask==0 || (predl[i].classmask&classmask)!=0) &&
		 (predl[i].elaymask==0 || (predl[i].elaymask&laytyp)!=0) &&
		 (predl[i].etypmask==0 || (predl[i].etypmask&typmask)!=0) &&
		 (predl[i].estypmask==0 || (predl[i].estypmask&subtyp)!=0)) {
			predidx=i;
			break;
			}
	// Query predicate value for current element
	predval=getpredval(predname);
	if (predidx>=0)
		predval+=" : "+predl[predidx].comm;
	bae_dialsetdata(labidx,PA_LAB|PA_HBRDREL,0,0.0,predval);
	// Return without errors
	return(0);
}

static string getpredval(string name)
/*
// Get predicate value string for current element
// Parameter :
//	string name		: Predicate name
*/
{
	string strbuf = ""		/* String result buffer */;
	double dblval			/* Double value */;
	int intval			/* Integer value */;
	int bitcnt			/* Bit count */;
	int bitmask			/* Current bit mask */;
	int i				/* Loop control variable */;
	switch (valtyp) {
		case TYPSTR :
		return(getpredsval(name));
		case TYPDBL :
		dblval=getpreddval(name);
		if (predidx>=0 && predl[predidx].valstyp==TYPDBLDIM)
			dblval=cvtlength(dblval,0,2);
		if (floor(dblval)==ceil(dblval))
			sprintf(strbuf,"%.1f",dblval);
		else
			sprintf(strbuf,"%.9g",dblval);
		if (predidx>=0 && predl[predidx].valstyp==TYPDBLDIM)
			strbuf+="mm";
		break;
		case TYPINT :
		default :
		intval=getpredival(name);
		if (predidx>=0) {
			if (predl[predidx].valstyp==TYPINTBITS) {
				if (arylength(predl[predidx].namel)==1)
					return(
					 intval ? UPRPREDFSET : UPRPREDFUSET);
				strbuf=UPRPREDBITS+itoa(intval)+" (";
				bitmask=1;
				bitcnt=arylength(predl[predidx].namel);
				for (i=bitcnt-1;i>=0;i--) {
					strbuf+=
					 ((intval&bitmask)!=0) ? "1" : "0";
					bitmask<<=1;
					}
				strbuf+=")";
				return(strbuf);
				}
			if (predl[predidx].valstyp==TYPINTSEL) {
				if (predl[predidx].defival<0 &&
				 intval>=predl[predidx].defival &
				 intval<(predl[predidx].defival+
				  arylength(predl[predidx].namel)))
					return(bae_plainmenutext(
					 predl[predidx].namel[intval-
					  predl[predidx].defival]));
				else if (intval>=0 &&
				 intval<arylength(predl[predidx].namel))
					return(bae_plainmenutext(
					 predl[predidx].namel[intval]));
				}
			}
		return(itoa(intval));
		}
	return(strbuf);
}

static int editpredival(string name,int val)
/*
// Get integer predicate value for current element
// Parameter :
//	string name		: Predicate name
//	int val			: Predicate value
*/
{
	string prompt			/* Prompt message */;
	STRINGS eleml			/* Selection element list */;
	double cy = DIAL_TOPMARG	/* Current y value */;
	int res				/* Dialog box result buffer */;
	int repflag	= 1		/* Repeat flag */;
	int bitcnt			/* Bit count */;
	int selidx			/* Selection dialog item index */;
	int bitidx[]			/* Bit dialog item index list */;
	int bitval			/* Current bit value */;
	int bitmask			/* Current bit mask */;
	int bits	= 0		/* Bit display start index */;
	int curmask			/* Current bit mask */;
	int newval			/* New bitmask value */;
	int i				/* Loop control variable */;
	sprintf(prompt,UPRNPRED,name,ruleprompt);
	// Check if bitmask input
	if (predidx>=0 && predl[predidx].valstyp==TYPINTBITS &&
	 !bae_dialclr()) {
		// Perform the input loop
		do {
			bae_dialclr();
			cy=DIAL_TOPMARG;
			bitmask=1<<bits;
			bitcnt=arylength(predl[predidx].namel);
			// Store the menu labels
			for (i=0;i<MAXMENULIST && (i+bits)<bitcnt;i++) {
				bitidx[i]=dial_toggle(
				 (val&bitmask)!=0 ? 1 : 0,0.0,cy,
				 name+(predl[predidx].namel[i]!="" ? (" : "+
				 predl[predidx].namel[i+bits]) :
				 predl[predidx].comm!="" ?
				 (" : "+predl[predidx].comm) : ""));
				bitmask<<=1;
				}
			// Store the OK and abort button with seperator
			dial_hsep(cy);
			if (bitcnt>MAXMENULIST) {
				// Previous menu item set
				bae_dialaddcontrol(PA_ACT|
				 (bits==0 ? PA_GRAYED : 0),0,1,0,0.0,0.0,0.0,
				 "",0,DIAL_LEFTMARG+12.0,cy,0.0,UPRPREVDIAL);
				// Next menu item set
				bae_dialaddcontrol(PA_ACT|
				 (i>=bitcnt ? PA_GRAYED : 0),0,2,0,0.0,0.0,0.0,
				 "",0,DIAL_LEFTMARG+12.0+bae_dialgettextlen(
				  0,UPRPREVDIAL),cy,0.0,UPRNEXTDIAL);
				}
			dial_okabort(cy);
			// Call the dialog function
			bae_setintpar(16,3097);
			switch (res=bae_dialaskparams(prompt,0,
			 DIAL_LEFTMARG+45.0,cy)) {
				case 0 :
				case 1 :
				case 2 :
				bitmask=1<<bits;
				newval=curmask=0;
				for (i=0;i<MAXMENULIST && (i+bits)<bitcnt;i++) {
					bae_dialgetdata(
					 bitidx[i],bitval,0.0,"");
					if (bitval)
						newval|=bitmask;
					curmask|=bitmask;
					bitmask<<=1;
					}
				val=newval|(val&~curmask);
				switch (res) {
					// Previous bit set
					case 1 :
					bits-=MAXMENULIST-1;
					if (bits<0)
						bits=0;
					break;
					// Next bit set
					case 2 :
					bits+=MAXMENULIST-1;
					if (bits>=bitcnt)
						bits=bitcnt-MAXMENULIST;
					break;
					case 0 :
					default :
					return(0);
					}
				break;
				default :
				repflag=0;
				}
			// Stop if no further repeat requests
			} while (repflag);
		return(-1);
		}
	// Check if selection input
	else if (predidx>=0 && predl[predidx].valstyp==TYPINTSEL &&
	 !bae_dialclr()) {
		if (predl[predidx].defival<0)
			val-=predl[predidx].defival;
		bitcnt=arylength(predl[predidx].namel);
		if (bitcnt<17) {
			for (i=0;i<bitcnt;i++)
				eleml[i]=predl[predidx].namel[i];
			eleml[bitcnt]=UPRABORT;
			if (val>=0)
				bae_defmenusel(val);
			// Get element selection
			bae_promptdialog(prompt);
			if ((val=bae_askmenu(bitcnt+1,eleml[0],eleml[1],
			 eleml[2],eleml[3],eleml[4],eleml[5],eleml[6],
			 eleml[7], eleml[8],eleml[9],eleml[10],eleml[11],
			 eleml[12],eleml[13],eleml[14],eleml[15],eleml[16],
			 UPRABORT))<0 || val>=bitcnt)
				return(-1);
			}
		else {
			dial_selbox(val,0.0,cy);
			for (i=0;i<bitcnt;i++)
				dial_sbentry(0,i,predl[predidx].namel[i]);
			// Store the OK and abort button with seperator
			dial_hsep(cy);
			dial_okabort(cy);
			// Call the dialog function
			bae_setintpar(16,3098);
			if (bae_dialaskparams(
			 prompt,0,DIAL_LEFTMARG+45.0,cy)!=0)
				return(-1);
			bae_dialgetdata(selidx,val,0.0,"");
			}
		if (predl[predidx].defival<0)
			val+=predl[predidx].defival;
		return(0);
		}
	// Use standard integer input function
	return(askint(val,prompt,10));
}

static int getpredival(string name)
/*
// Get integer predicate value for current element
// Parameter :
//	string name		: Predicate name
*/
{
	int intval			/* Integer value */;
	string pdefprefix		/* Pred. definition prefix */;
	int pdeflen			/* Pred. def. length */;
	int i				/* Loop control variable */;
	// Get predicate rule definition prefix
	sprintf(pdefprefix,":%s:%s=",RS_PCBSUBJ,name);
	pdeflen=strlen(pdefprefix);
	// Scan the rule name list
	for (i=0;i<rulen;i++)
		if (strextract(rulel[i],0,pdeflen-1)==pdefprefix)
			return(atoi(
			 strextract(rulel[i],pdeflen,strlen(rulel[i])-2)));
	if (seltyp==PLANTYP) {
		// Query predicate
		if (lay_rulequery(RS_OCPLAN,0,RS_PCBSUBJ,name,"?d",intval)<1)
			// Set default value
			intval=predidx<0 ? 0 : predl[predidx].defival;
		}
	else {
		// Query predicate
		if (lay_rulequery(RS_OCFIG,rulefig,RS_PCBSUBJ,
		 name,"?d",intval)<1)
			// Set default value
			intval=predidx<0 ? 0 : predl[predidx].defival;
		}
	return(intval);
}

static int editpreddval(string name,double val)
/*
// Get integer predicate value for current element
// Parameter :
//	string name		: Predicate name
//	double val		: Predicate value
*/
{
	string prompt			/* Prompt message */;
	sprintf(prompt,UPRNPRED,name,ruleprompt);
	if (predidx>=0 && predl[predidx].valstyp==TYPDBLDIM)
		return(askdist(val,prompt,1));
	return(askdbl(val,prompt,20));
}

static double getpreddval(string name)
/*
// Get double predicate value for current element
// Parameter :
//	string name		: Predicate name
*/
{
	double dblval			/* Double value */;
	string pdefprefix		/* Pred. definition prefix */;
	int pdeflen			/* Pred. def. length */;
	int i				/* Loop control variable */;
	// Get predicate rule definition prefix
	sprintf(pdefprefix,":%s:%s=",RS_PCBSUBJ,name);
	pdeflen=strlen(pdefprefix);
	// Scan the rule name list
	for (i=0;i<rulen;i++)
		if (strextract(rulel[i],0,pdeflen-1)==pdefprefix)
			return(atof(
			 strextract(rulel[i],pdeflen,strlen(rulel[i])-2)));
	if (seltyp==PLANTYP) {
		// Query predicate
		if (lay_rulequery(RS_OCPLAN,0,RS_PCBSUBJ,name,"?f",dblval)<1)
			// Set default value
			dblval=predidx<0 ? 0.0 : predl[predidx].defdval;
		}
	else {
		// Query predicate
		if (lay_rulequery(RS_OCFIG,rulefig,RS_PCBSUBJ,
		 name,"?f",dblval)<1)
			// Set default value
			dblval=predidx<0 ? 0.0 : predl[predidx].defdval;
		}
	return(dblval);
}

static int editpredsval(string name,string val)
/*
// Get integer predicate value for current element
// Parameter :
//	string name		: Predicate name
//	string val		: Predicate value
*/
{
	string prompt			/* Prompt message */;
	double cy			/* Dialog box current y coordinate */;
	int outfidx			/* Output file index */;
	sprintf(prompt,UPRNPRED,name,ruleprompt);
	if (predidx>=0 && predl[predidx].valstyp==TYPSTRFILE)
		return((bae_askfilename(val,"",prompt) || name=="") ? 1 : 0);
	if (predidx>=0 && predl[predidx].valstyp==TYPSTRLINK &&
	 bae_dialclr()==0) {
		// Init. the y coordinate
		cy=DIAL_TOPMARG;
		// Store file controls
		dial_label(0.0,cy,UPRLINKFILE);
		cy+=DIAL_CTRVSTEP;
		outfidx=dial_string(val,MAXPATHLEN,0.0,cy);
		bae_dialaddcontrol(PA_ACT,0,1,0,0.0,0.0,0.0,"",0,
		DIAL_LEFTMARG,cy,0.0,UPRBRWFILENAME);
		cy+=DIAL_CTRVSTEP;
		// Store the OK and abort button with seperator
		dial_hsep(cy);
		dial_okabort(cy);
		// Call the dialog function
		bae_setintpar(16,3139);
		switch (bae_dialaskparams(prompt,0,
		 DIAL_LEFTMARG+60.0+DIAL_RIGHTSMARG,cy)) {
		 	// Done
			case 0 :
			bae_dialgetdata(outfidx,0,0.0,val);
			return(val);
			// Browse file name
			case 1 :
			return(
			 (bae_askfilename(val,"",prompt) || name=="") ? 1 : 0);
			}
		error_abort();
		}
	return((val=bae_readedittext(prompt,val,predidx>=0 &&
	 predl[predidx].valstyp==TYPSTRNAME ? MAXKEYLEN : MAXTEXTLEN))==
	 UINPOPABORT ? (-1) : 0);
}

static string getpredsval(string name)
/*
// Get string predicate value for current element
// Parameter :
//	string name		: Predicate name
*/
{
	string strval			/* String value */;
	string pdefprefix		/* Pred. definition prefix */;
	int pdeflen			/* Pred. def. length */;
	int i				/* Loop control variable */;
	// Get predicate rule definition prefix
	sprintf(pdefprefix,":%s:%s=",RS_PCBSUBJ,name);
	pdeflen=strlen(pdefprefix);
	// Scan the rule name list
	for (i=0;i<rulen;i++)
		if (strextract(rulel[i],0,pdeflen-1)==pdefprefix)
			return(
			 strextract(rulel[i],pdeflen+1,strlen(rulel[i])-3));
	if (seltyp==PLANTYP) {
		// Query predicate
		if (lay_rulequery(RS_OCPLAN,0,RS_PCBSUBJ,name,"?s",strval)<1)
			// Set default value
			strval=predidx<0 ? "" : predl[predidx].defsval;
		}
	else {
		// Query predicate
		if (lay_rulequery(RS_OCFIG,rulefig,RS_PCBSUBJ,
		 name,"?s",strval)<1)
			// Set default value
			strval=predidx<0 ? "" : predl[predidx].defsval;
		}
	return(strval);
}

void layerstackup()
/*
// Layer stackup data
*/
{
	string msg			/* Message buffer */;
	index L_POWLAYER pl		/* Power layer index */;
	STRINGS rl			/* Rule name list */;
	STRINGS hl			/* Popup menu header list */;
	int hn		= 0		/* Popup menu header count */;
	STRINGS namel			/* Layer name list */;
	int namen	= 0		/* Layer name count */;
	struct laysdes swapls		/* Layer stackup swap buffer */;
	int oldlayscnt			/* Old layer stackup count */;
	string layname			/* Layer name */;
	int laysidx			/* Layer stackup index */;
	int firstflag			/* First radio button flag */;
	int layer			/* Layer code */;
	int ilaycnt			/* Inner layer count */;
	int matidx			/* Material index */;
	int tolidx			/* Tolerance index */;
	double oldthickness = 0.0	/* Old PCB total thickness */;
	double newthickness = 0.0	/* New PCB total thickness */;
	double butx			/* Dialog box button x coordinate */;
	double mlen			/* Max. material name display len. */;
	double cy			/* Current y value */;
	int res				/* Selection result */;
	int repflag	= 1		/* Repeat flag */;
	int lsidx[]			/* Layer surface ctrl. index list */;
	int ctidx[]			/* Copper thickn. ctrl. index list */;
	int liidx[]			/* Layer isolation ctrl. index list */;
	int imidx[]			/* Isol. material ctrl. index list */;
	int eridx[]			/* Epsilon r control index list */;
	int tdidx[]			/* Tan delta control index list */;
	int toidx[]			/* Isol. tolerance ctrl. index list */;
	int coidx[]			/* Isol. core ctrl. index list */;
	int lfidx[]			/* Layer fill ctrl. index list */;
	int lcidx[]			/* Layer comment ctrl. index list */;
	int tsidx			/* Thickness sum control index */;
	int fbidx			/* From button control index */;
	int tbidx			/* To button control index */;
	int from			/* From index */;
	int to				/* To index */;
	int opmode	= 0		/* Operation mode */;
	int i				/* Loop control variable */;
	// Check for dialog support
	if (bae_dialclr())
		error(ERRNOWIN);
	// Get the isolation material list
	for (matpn=0;matpn<100;matpn++) {
		if ((matpl[matpn].name=bae_inistrval(
		 bae_inifieldvarname(PAR_LAYIML,matpn,0),""))=="") {
			// Check if list defined at all
			if (matpn==0) {
				// Use default material list
				matpl=defmatpl;
				matpn=arylength(matpl);
				}
			break;
			}
		matpl[matpn].epsr=bae_inidblval(
		 bae_inifieldvarname(PAR_LAYIML,matpn,1),DEF_EPSR);
		matpl[matpn].tand=bae_inidblval(
		 bae_inifieldvarname(PAR_LAYIML,matpn,2),DEF_TAND);
		}
	// Get the max. material name width
	mlen=MATWIDTH-1.0;
	for (i=0;i<matpn;i++) {
		butx=bae_dialgettextlen(0,matpl[i].name);
		if (mlen<butx)
			mlen=butx;
		}
	mlen+=2.5;
	// Get the isolation tolerance list
	for (tolpn=0;tolpn<100;tolpn++)
		if ((tolpl[tolpn]=bae_inidblval(
		 bae_iniarrayvarname(PAR_LAYITL,tolpn),-1.0))==(-1.0))
			break;
	// Query the current layer stackup
	for (layscnt=0;layscnt<(SIGLAYMAX+POWLAYMAX);layscnt++) {
		// Query the layer code
		if (lay_rulequery(RS_OCLAYS,layscnt,RS_PCBSUBJ,
		 RS_LAYSCODE,"?d",layspl[layscnt].layer)<1)
			break;
		// Query the layer surface type
		if (lay_rulequery(RS_OCLAYS,layscnt,RS_PCBSUBJ,
		 RS_LAYSURFACE,"?s",layspl[layscnt].surf)<1)
			layspl[layscnt].surf=DEF_LAYS;
		// Query the layer thickness
		if (lay_rulequery(RS_OCLAYS,layscnt,RS_PCBSUBJ,
		 RS_LAYTHICK,"?f",layspl[layscnt].cu)<1)
			layspl[layscnt].cu=DEF_LAYT;
		// Query the layer isolation
		if (lay_rulequery(RS_OCLAYS,layscnt,RS_PCBSUBJ,
		 RS_LAYISO,"?f",layspl[layscnt].iso)<1)
			layspl[layscnt].iso=DEF_LAYI;
		// Query the layer isolation material
		if (lay_rulequery(RS_OCLAYS,layscnt,RS_PCBSUBJ,
		 RS_LAYMAT,"?s",layspl[layscnt].mat)<1)
			layspl[layscnt].mat=DEF_ISOM;
		// Query the epsilon r
		if (lay_rulequery(RS_OCLAYS,layscnt,RS_PCBSUBJ,
		 RS_LAYEPSR,"?f",layspl[layscnt].epsr)<1)
			layspl[layscnt].epsr=DEF_EPSR;
		// Query the tangens delta
		if (lay_rulequery(RS_OCLAYS,layscnt,RS_PCBSUBJ,
		 RS_TANDELTA,"?f",layspl[layscnt].tand)<1)
			layspl[layscnt].tand=DEF_TAND;
		// Query the isolation tolerance
		if (lay_rulequery(RS_OCLAYS,layscnt,RS_PCBSUBJ,
		 RS_LAYTOL,"?f",layspl[layscnt].tol)<1)
			layspl[layscnt].tol=DEF_ISOT;
		// Query the layer core flag
		if (lay_rulequery(RS_OCLAYS,layscnt,RS_PCBSUBJ,
		 RS_LAYCORE,"?d",layspl[layscnt].core)<1)
			layspl[layscnt].core=DEF_ISOC;
		// Query the layer fill flag
		if (lay_rulequery(RS_OCLAYS,layscnt,RS_PCBSUBJ,
		 RS_LAYFILL,"?d",layspl[layscnt].fill)<1)
			layspl[layscnt].fill=DEF_LAYF;
		// Query the layer comment
		if (lay_rulequery(RS_OCLAYS,layscnt,RS_PCBSUBJ,
		 RS_LAYCOMMENT,"?s",layspl[layscnt].comm)<1)
			layspl[layscnt].comm= layspl[layscnt].layer<POWLAYBASE
			 ? "" : powlayertext(layspl[layscnt].layer);
		}
	oldlayscnt=layscnt;
	// Check if layer stackup data found
	if (layscnt==0) {
		// Create default layer list
		for (i=0;i<lay_plantoplay();i++) {
			layspl[layscnt].layer=i;
			layspl[layscnt].epsr=DEF_EPSR;
			layspl[layscnt].tand=DEF_TAND;
			layspl[layscnt].cu=DEF_LAYT;
			layspl[layscnt].iso=DEF_LAYI;
			layspl[layscnt].surf=DEF_LAYS;
			layspl[layscnt].fill=DEF_LAYF;
			layspl[layscnt].comm="";
			layscnt++;
			}
		if (lay_plantoplay()==1) {
			ilaycnt=lay_planmidlaycnt();
			for (i=0;i<ilaycnt;i++) {
				layspl[layscnt].layer=2+i;
				layspl[layscnt].epsr=DEF_EPSR;
				layspl[layscnt].tand=DEF_TAND;
				layspl[layscnt].cu=DEF_LAYT;
				layspl[layscnt].iso=DEF_LAYI;
				layspl[layscnt].surf=DEF_LAYS;
				layspl[layscnt].fill=DEF_LAYF;
				layspl[layscnt].comm="";
				layscnt++;
				}
			}
		// Store power layers
		i=0;
		forall (pl) {
			if (pl.CNET.NAME!="") {
				layspl[layscnt].layer=POWLAYBASE+i;
				layspl[layscnt].epsr=DEF_EPSR;
				layspl[layscnt].tand=DEF_TAND;
				layspl[layscnt].cu=DEF_LAYT;
				layspl[layscnt].iso=DEF_LAYI;
				layspl[layscnt].surf=DEF_LAYS;
				layspl[layscnt].fill=DEF_LAYF;
				layspl[layscnt].comm=
				 powlayertext(layspl[layscnt].layer);
				layscnt++;
				}
			i++;
			}
		// Store top layer
		layspl[layscnt].layer=lay_plantoplay();
		layspl[layscnt].epsr=DEF_EPSR;
		layspl[layscnt].tand=DEF_TAND;
		layspl[layscnt].cu=DEF_LAYT;
		layspl[layscnt].iso=DEF_LAYI;
		layspl[layscnt].surf=DEF_LAYS;
		layspl[layscnt].fill=DEF_LAYF;
		layspl[layscnt].comm="";
		layscnt++;
		}
	for (i=0;i<layscnt;i++) {
		oldthickness+=layspl[i].cu;
		if (i!=(layscnt-1))
			oldthickness+=layspl[i].iso;
		}
	// Query the total thickness
	if (lay_rulequery(RS_OCPLAN,0,RS_PCBSUBJ,
	 RS_PCBTHICK,"?f",thickness)<1)
		thickness=oldthickness;
	// Perform the input loop
	do {
		bae_dialclr();
		cy=DIAL_TOPMARG;
		// Store the hint labels
		if (opmode) {
			dial_label(LAYSPACE,cy,UPRLAYFROM);
			dial_label(LAYSPACE+4.0,cy,UPRLAYTO);
			}
		else {
			dial_label(SURFOFF-1.0,cy,UPRLAYSURF);
			dial_label(METOFF+1.0,cy,UPRLAYTHICK);
			dial_label(ISOOFF,cy,UPRLAYISO);
			dial_label(MATOFF+1.5,cy,UPRLAYMAT);
			dial_label(EPSROFF+mlen,cy,UPRLAYEPSR);
			dial_label(TANDOFF+mlen,cy,UPRLAYTAND);
			dial_label(TOLOFF+mlen,cy,UPRLAYTOL);
			dial_label(COREOFF+mlen,cy,UPRLAYCORE);
			dial_label(FILLOFF+mlen,cy,UPRLAYFILL);
			dial_label(COMMOFF+mlen,cy,UPRLAYCOMM);
			}
		// Store the layer controls
		for (laysidx=layscnt-1;laysidx>=0;laysidx--) {
		    cy+=DIAL_CTRVSTEP;
		    dial_label(0.0,cy,layername(layspl[laysidx].layer));
		    if (opmode)
			continue;
		    lsidx[laysidx]=bae_dialaddcontrol(PA_STR,0,0,0,0.0,0.0,0.0,
		     layspl[laysidx].surf,MAXTEXTLEN,DIAL_LEFTMARG+
		     SURFOFF,cy,SURFWIDTH,"");
		    ctidx[laysidx]=bae_dialaddcontrol(PA_DBL|PA_DIST|PA_CHKLL,0,
		     2,0,0.0,0.0,layspl[laysidx].cu,"",0,
		     DIAL_LEFTMARG+METOFF,cy,METWIDTH,"");
		    if (laysidx<layscnt-1) {
			cy-=0.5*DIAL_CTRVSTEP;
			liidx[laysidx]=bae_dialaddcontrol(
			 PA_DBL|PA_DIST|PA_CHKLL,0,2,0,0.0,0.0,
			 layspl[laysidx].iso,"",0,
			 DIAL_LEFTMARG+ISOOFF,cy,ISOWIDTH,"");
			for (matidx=0;matidx<matpn;matidx++)
				if (matpl[matidx].name==layspl[laysidx].mat)
					break;
			if (matidx>=matpn)
				matidx=(-1);
			imidx[laysidx]=bae_dialaddcontrol(PA_SB,0,0,matidx,0.0,
			 0.0,0.0,"",0,DIAL_LEFTMARG+MATOFF,cy,mlen,"");
			dial_sbentry(4,(-1),UPRLAYNOMAT);
			for (i=0;i<matpn;i++)
				dial_sbentry(4,i,matpl[i].name);
			eridx[laysidx]=bae_dialaddcontrol(PA_DBL|PA_CHKLL|
			 (matidx==(-1) ? 0 : PA_GRAYED),0,
			 5,0,0.0,0.0,layspl[laysidx].epsr,"",0,
			 DIAL_LEFTMARG+EPSROFF+mlen,cy,EPSRWIDTH,"");
			tdidx[laysidx]=bae_dialaddcontrol(PA_DBL|PA_CHKLL|
			 (matidx==(-1) ? 0 : PA_GRAYED),0,
			 5,0,0.0,0.0,layspl[laysidx].tand,"",0,
			 DIAL_LEFTMARG+TANDOFF+mlen,cy,TANDWIDTH,"");
			if (tolpn) {
				for (tolidx=0;tolidx<tolpn;tolidx++)
					if (fabs(tolpl[tolidx]-
					 layspl[laysidx].tol)<0.0001)
						break;
				if (tolidx>=tolpn)
					tolidx=0;
				toidx[laysidx]=bae_dialaddcontrol(PA_SB,0,0,
				 tolidx,0.0,0.0,0.0,"",0,
				 DIAL_LEFTMARG+TOLOFF+mlen,cy,TOLWIDTH,"");
				for (i=0;i<tolpn;i++)
					dial_sbentry(0,i,
					 bae_numstring(tolpl[i],3));
				}
			else {
				toidx[laysidx]=bae_dialaddcontrol(
				 PA_DBL|PA_CHKLL,0,5,0,0.0,0.0,
				 layspl[laysidx].tol,"",0,
				 DIAL_LEFTMARG+TOLOFF+mlen,cy,TOLWIDTH,"");
				}
			coidx[laysidx]=bae_dialaddcontrol(PA_TOGGLE,0,
			 0,layspl[laysidx].core,0.0,0.0,0.0,"",0,DIAL_LEFTMARG+
			 COREOFF+mlen+0.5,cy,0.0,"");
			cy+=0.5*DIAL_CTRVSTEP;
			}
		    if (layspl[laysidx].layer<POWLAYBASE)
			lfidx[laysidx]=bae_dialaddcontrol(PA_TOGGLE,0,
			 0,layspl[laysidx].fill,0.0,0.0,0.0,"",0,DIAL_LEFTMARG+
			 FILLOFF+mlen+0.5,cy,0.0,"");
		    lcidx[laysidx]=bae_dialaddcontrol(PA_STR,0,0,0,0.0,0.0,0.0,
		     layspl[laysidx].comm,MAXTEXTLEN,
		     DIAL_LEFTMARG+COMMOFF+mlen,cy,COMMWIDTH,"");
		    }
		// Store from/to selection buttons
		if (opmode) {
			cy=DIAL_TOPMARG;
			firstflag=1;
			for (laysidx=layscnt-1;laysidx>=0;laysidx--) {
				cy+=DIAL_CTRVSTEP;
				if (laysidx==0 || (laysidx==(layscnt-1) &&
				 layspl[laysidx].layer==lay_plantoplay()))
					continue;
				if (firstflag) {
					fbidx=bae_dialaddcontrol(PA_RBF,
					 laysidx,0,layscnt-2,0.0,0.0,0.0,"",0,
					 DIAL_LEFTMARG+LAYSPACE,cy,0.0,"");
					firstflag=0;
					}
				else {
					bae_dialaddcontrol(PA_RBN,laysidx,0,
					 0,0.0,0.0,0.0,"",0,
					 DIAL_LEFTMARG+LAYSPACE,cy,0.0,"");
					}
				}
			cy=DIAL_TOPMARG;
			firstflag=1;
			for (laysidx=layscnt-1;laysidx>=0;laysidx--) {
				cy+=DIAL_CTRVSTEP;
				if (laysidx==0 || (laysidx==(layscnt-1) &&
				 layspl[laysidx].layer==lay_plantoplay()))
					continue;
				if (firstflag) {
					tbidx=bae_dialaddcontrol(PA_RBF,
					 laysidx,0,layscnt-3,0.0,0.0,0.0,"",0,
					 DIAL_LEFTMARG+LAYSPACE+4.0,cy,0.0,"");
					firstflag=0;
					}
				else {
					bae_dialaddcontrol(PA_RBN,laysidx,0,
					 0,0.0,0.0,0.0,"",0,DIAL_LEFTMARG+
					 LAYSPACE+4.0,cy,0.0,"");
					}
				}
			}
		else {
			cy+=DIAL_CTRVSTEP;
			dial_label(0.0,cy,UPRLAYSUM);
			// Summarize thickness
			bae_dialaddcontrol(PA_ACT,0,8,0,0.0,0.0,0.0,"",0,
			 DIAL_LEFTMARG+METOFF-1.0,cy,0.0,UPRLAYSUMB);
			tsidx=bae_dialaddcontrol(PA_DBL|PA_DIST|PA_CHKLL,0,
			 2,0,0.0,0.0,thickness,"",0,DIAL_LEFTMARG+ISOOFF,
			 cy,ISOWIDTH,"");
			}
		cy+=DIAL_BUTVSTEP;
		// Store the separator
		dial_hsep(cy);
		// Store the OK and abort button
		dial_okabort(cy);
		// Store function buttons
		if (!opmode) {
			cy-=DIAL_SEPVSTEP+DIAL_BUTVSTEP;
			// Store symbol pool button
			butx=DIAL_LEFTMARG+LAYSPACE;
			// Add layer
			bae_dialaddcontrol(PA_ACT,0,1,0,0.0,0.0,0.0,"",0,
			 butx,cy,0.0,UPRLAYADD);
			butx+=bae_dialgettextlen(0,UPRLAYADD);
			butx+=ABUTXSTEP;
			// Delete layer
			bae_dialaddcontrol(PA_ACT|(layscnt>2 ? 0 : PA_GRAYED),
			 0,2,0,0.0,0.0,0.0,"",0,butx,cy,0.0,UPRLAYDEL);
			butx+=bae_dialgettextlen(0,UPRLAYDEL);
			butx+=ABUTXSTEP;
			// Move layer
			bae_dialaddcontrol(PA_ACT|((layscnt>3 || layspl[
			 layscnt-1].layer!=lay_plantoplay()) ? 0 : PA_GRAYED),
			 0,3,0,0.0,0.0,0.0,"",0,butx,cy,0.0,UPRLAYMOVE);
			butx+=bae_dialgettextlen(0,UPRLAYMOVE);
			butx+=ABUTXSTEP+5.0;
			// Dump layer setup selection
			bae_dialaddcontrol(PA_ACT,0,5,0,0.0,0.0,0.0,"",0,
			 butx,cy,0.0,UPRLAYDUMP);
			butx+=bae_dialgettextlen(0,UPRLAYDUMP);
			butx+=ABUTXSTEP;
			// Import layer setup selection
			bae_dialaddcontrol(PA_ACT,0,6,0,0.0,0.0,0.0,"",0,
			 butx,cy,0.0,UPRLAYIMP);
			butx+=bae_dialgettextlen(0,UPRLAYIMP);
			butx+=ABUTXSTEP;
			// Export layer setup selection
			bae_dialaddcontrol(PA_ACT,0,7,0,0.0,0.0,0.0,"",0,
			 butx,cy,0.0,UPRLAYEXP);
			cy+=DIAL_SEPVSTEP+DIAL_BUTVSTEP;
			}
		// Call the dialog function
		bae_setintpar(16,3016);
		res=bae_dialaskparams(UPRLAYSET,3,DIAL_LEFTMARG+(opmode ?
		 LAYSPACE+8.3 : COMMOFF+COMMWIDTH+mlen)+DIAL_RIGHTSMARG,cy);
		// Get all layer data
		if (!opmode) {
		    for (i=0;i<layscnt;i++) {
			if (i<layscnt-1) {
				bae_dialgetdata(imidx[i],matidx,0.0,"");
				bae_dialgetdata(eridx[i],0,layspl[i].epsr,"");
				bae_dialgetdata(tdidx[i],0,layspl[i].tand,"");
				bae_dialgetdata(liidx[i],0,layspl[i].iso,"");
				if (tolpn)
					bae_dialgetdata(toidx[i],tolidx,0.0,"");
				else
					bae_dialgetdata(
					 toidx[i],0,layspl[i].tol,"");
				bae_dialgetdata(coidx[i],
				 layspl[i].core,0.0,"");
				}
			else if (i!=0) {
				bae_dialgetdata(imidx[i-1],matidx,0.0,"");
				bae_dialgetdata(eridx[i-1],0,layspl[i].epsr,"");
				bae_dialgetdata(tdidx[i-1],0,layspl[i].tand,"");
				bae_dialgetdata(liidx[i-1],0,layspl[i].iso,"");
				if (tolpn)
					bae_dialgetdata(
					 toidx[i-1],tolidx,0.0,"");
				else
					bae_dialgetdata(
					 toidx[i-1],0,layspl[i].tol,"");
				bae_dialgetdata(coidx[i-1],
				 layspl[i].core,0.0,"");
				}
			if (matidx>=0) {
				layspl[i].mat=matpl[matidx].name;
				layspl[i].epsr=matpl[matidx].epsr;
				layspl[i].tand=matpl[matidx].tand;
				}
			else {
				layspl[i].mat="";
				}
			if (tolpn)
				layspl[i].tol=tolpl[tolidx];
			bae_dialgetdata(ctidx[i],0,layspl[i].cu,"");
			if (layspl[i].layer<POWLAYBASE)
				bae_dialgetdata(
				 lfidx[i],layspl[i].fill,0.0,"");
			bae_dialgetdata(lsidx[i],0,0.0,layspl[i].surf);
			bae_dialgetdata(lcidx[i],0,0.0,layspl[i].comm);
			}
		    bae_dialgetdata(tsidx,0,thickness,"");
		    }
		// Evaluate selected function
		switch (res) {
			case 0 :
			// Check operation mode
			if (opmode==0) {
				repflag=0;
				}
			else {
				// Switch to normal mode
				opmode=0;
				// Perform the layer swap
				bae_dialgetdata(fbidx,from,0.0,"");
				bae_dialgetdata(tbidx,to,0.0,"");
				if (to<0)
					break;
				swapls=layspl[from];
				if (from>to)
					for (i=from;i>to;i--)
						layspl[i]=layspl[i-1];
				else
					for (i=from;i<to;i++)
						layspl[i]=layspl[i+1];
				layspl[to]=swapls;
				}
			break;
			// Add layer
			case 1 :
			bae_prtdialog(UPRSELLAY);
			if (ged_asklayer(layer,4))
				break;
			if ((layer>=0 && layer<SIGLAYMAX) ||
			 (layer>=POWLAYBASE && layer<(POWLAYBASE+POWLAYMAX))) {
				for (i=0;i<layscnt;i++)
					if (layspl[i].layer==layer)
						break;
				if (i<layscnt) {
					sprintf(msg,REPDBLLAY,
					 layername(layer));
					bae_msgbox(2,msg,"");
					break;
					}
				// Insert new layer
				layspl[layscnt]=layspl[layscnt-1];
				layspl[layscnt-1]=layspl[0];
				layspl[layscnt-1].layer=layer;
				layspl[layscnt-1].comm= layer<POWLAYBASE ?
				 "" : powlayertext(layer) ;
				layscnt++;
				}
			break;
			// Delete layer
			case 2 :
			// Build the layer name list
			namen=0;
			if (layspl[layscnt-1].layer!=lay_plantoplay()) {
				namel[namen]=
				 layername(layspl[layscnt-1].layer);
				namen++;
				}
			for (i=layscnt-2;i>0;i--) {
				namel[namen]=layername(layspl[i].layer);
				namen++;
				}
			// Build the layer selection popup menu
			hl[0]=REPLAYL;
			hl[1]="";
			hn=2;
			// Select layer to be deleted
			bae_setintpar(16,3066);
			if ((layname=popupmenu(4,UPRDELLAY,hl,hn,namel,namen,
			  UINPOPABORT,0,-1,-1,0,0,0,UINPOPABORT))=="" ||
			 layname==UINPOPABORT)
				break;
			// Search selected layer
			for (i=0;i<namen;i++)
				if (layname==namel[i])
					break;
			if (i>=namen)
				break;
			i=layscnt-i-2;
			if (layspl[layscnt-1].layer!=lay_plantoplay())
				i++;
			// Remove the layer entry from list
			layscnt--;
			for (;i<layscnt;i++)
				layspl[i]=layspl[i+1];
			break;
			// Move layer
			case 3 :
			opmode=1;
			break;
			// Update material depandant settings
			case 4 :
			break;
			// Dump layer setup
			case 5 :
			dumplaysetup();
			break;
			// Import layer setup
			case 6 :
			importlaysetup();
			break;
			// Export layer setup
			case 7 :
			exportlaysetup();
			break;
			// Summarize PCB thickness
			case 8 :
			thickness=0.0;
			for (i=0;i<layscnt;i++) {
				thickness+=layspl[i].cu;
				if (i!=(layscnt-1))
					thickness+=layspl[i].iso;
				}
			break;
			default :
			if (opmode==1)
				opmode=0;
			else
				error_abort();
			}
		// Stop if no further repeat requests
		} while (repflag);
	for (i=0;i<layscnt;i++) {
		newthickness+=layspl[i].cu;
		if (i!=(layscnt-1))
			newthickness+=layspl[i].iso;
		}
	if (newthickness!=thickness && newthickness!=oldthickness) {
		sprintf(msg,UPRNEWTHICK,
		 bae_numstring(cvtlength(newthickness,0,4),2));
		if (bae_msgboxverify(msg,"")==1)
			thickness=newthickness;
		}
	// Save current state for undo
	bae_callmenu(MNU_BAESAVESTATE);
	// Store all layer rules
	for (i=0;i<layscnt;i++) {
		// Build layer rule list
		sprintf(rl[0],":%s:%s=%d;",
		 RS_PCBSUBJ,RS_LAYSCODE,layspl[i].layer);
		sprintf(rl[1],":%s:%s='%s';",
		 RS_PCBSUBJ,RS_LAYMAT,layspl[i].mat);
		sprintf(rl[2],":%s:%s=%.9g;",
		 RS_PCBSUBJ,RS_LAYEPSR,layspl[i].epsr);
		sprintf(rl[3],":%s:%s=%.9g;",
		 RS_PCBSUBJ,RS_TANDELTA,layspl[i].tand);
		sprintf(rl[4],":%s:%s=%.9g;",
		 RS_PCBSUBJ,RS_LAYTHICK,layspl[i].cu);
		sprintf(rl[5],":%s:%s=%.9g;",
		 RS_PCBSUBJ,RS_LAYISO,layspl[i].iso);
		sprintf(rl[6],":%s:%s='%s';",
		 RS_PCBSUBJ,RS_LAYSURFACE,layspl[i].surf);
		sprintf(rl[7],":%s:%s=%.9g;",
		 RS_PCBSUBJ,RS_LAYTOL,layspl[i].tol);
		if (floor(layspl[i].tol)==ceil(layspl[i].tol))
			sprintf(rl[7],":%s:%s=%.1f;",
			 RS_PCBSUBJ,RS_LAYTOL,layspl[i].tol);
		else
			sprintf(rl[7],":%s:%s=%.9g;",
			 RS_PCBSUBJ,RS_LAYTOL,layspl[i].tol);
		sprintf(rl[8],":%s:%s=%d;",
		 RS_PCBSUBJ,RS_LAYCORE,layspl[i].core);
		sprintf(rl[9],":%s:%s=%d;",
		 RS_PCBSUBJ,RS_LAYFILL,layspl[i].fill);
		sprintf(rl[10],":%s:%s='%s';",
		 RS_PCBSUBJ,RS_LAYCOMMENT,layspl[i].comm);
		if (lay_rulelaysatt(i,rl))
			rs_error(-1);
		}
	// Detach deleted layers
	for (i=layscnt;i<oldlayscnt;i++)
		lay_rulelaysdet(i);
	// Store summarized PCB thickness
	rs_assplandblpred(RS_PCBTHICK,thickness,0.0,"");
	// Check if extra user specific ULC program call requested
	if (laysprog!="")
		ulsystem(laysprog,0);
}

void dumplaysetup()
/*
// Dump layer setup definitions
*/
{
	string dfname			/* Output file name */;
	string msg			/* Message buffer */;
	int dfh				/* Output file handle */;
	int i				/* Loop control variable */;
	// Check if output file name extension defined
	if (LAYSTKEXT!="")
		dfname=convstring(bae_planfname(),0)+LAYSTKEXT;
	// Get the output file name
	else if (bae_askfilename(dfname,bae_swversion(3),UPRDFILE) ||
	 dfname=="")
		error_abort();
	// Test the output file
	fseterrmode(0);
	if ((dfh=fopen(dfname,0))!=(-1)) {
		fclose(dfh);
		fseterrmode(1);
		sprintf(msg,UPRFEXISTS,dfname);
		if (bae_msgboxverify(msg,"")!=1)
			error_abort();
		}
	fseterrmode(1);
	// Open the output file
	dfh=fopen(dfname,1);
	// Write the stackup header
	// Print the file header
	fprintf(dfh,FMTHEADER);
	fprintf(dfh,FMTFILE,bae_planfname());
	fprintf(dfh,FMTBOARD,bae_planename());
	if (LAYSTKORD) {
	    for (i=layscnt-1;i>=0;i--) {
		fprintf(dfh,FMTMETALL,layername(layspl[i].layer)+
		 (layspl[i].layer<POWLAYBASE ? "" :
		  powlayertext(layspl[i].layer)),
		 layspl[i].surf,cvtlength(layspl[i].cu,0,4));
		if (layspl[i].layer<POWLAYBASE && layspl[i].fill)
			fprintf(dfh,FMTSHIELD);
		if (layspl[i].comm!="")
			fprintf(dfh," /* %s */\n",layspl[i].comm);
		else
			fprintf(dfh,"\n");
		if (i>0) {
			fprintf(dfh,FMTISOL,cvtlength(layspl[i].iso,0,4),
			 layspl[i].epsr,layspl[i].tand);
			}
		}
	    }
	else {
	    for (i=0;i<layscnt;i++) {
		fprintf(dfh,FMTMETALL,layername(layspl[i].layer)+
		 (layspl[i].layer<POWLAYBASE ? "" :
		  powlayertext(layspl[i].layer)),
		 layspl[i].surf,cvtlength(layspl[i].cu,0,4));
		if (layspl[i].layer<POWLAYBASE && layspl[i].fill)
			fprintf(dfh,FMTSHIELD);
		if (layspl[i].comm!="")
			fprintf(dfh," /* %s */\n",layspl[i].comm);
		else
			fprintf(dfh,"\n");
		if (i<(layscnt-1)) {
			fprintf(dfh,FMTISOL,cvtlength(layspl[i].iso,0,4),
			 layspl[i].epsr,layspl[i].tand);
			}
		}
	    }
	fclose(dfh);
	sprintf(msg,REPEXPDONE,dfname);
	bae_prtdialog(msg);
}

void exportlaysetup()
/*
// Export layer setup definitions
*/
{
	string dfname			/* Output file name */;
	string msg			/* Message buffer */;
	int dfh				/* Output file handle */;
	int i				/* Loop control variable */;
	// Check if output file name extension defined
	if (CSVEXT!="")
		dfname=convstring(bae_planfname(),0)+CSVEXT;
	// Get the output file name
	if (bae_askfilename(dfname,bae_swversion(3),UPRDFILE) ||
	 dfname=="")
		error_abort();
	// Test the output file
	fseterrmode(0);
	if ((dfh=fopen(dfname,0))!=(-1)) {
		fclose(dfh);
		fseterrmode(1);
		sprintf(msg,UPRFEXISTS,dfname);
		if (bae_msgboxverify(msg,"")!=1)
			error_abort();
		}
	fseterrmode(1);
	// Open the output file
	dfh=fopen(dfname,1);
	// Print the file header
	fprintf(dfh,FMTLAYDENTRY,
	 "Layer",CSVFSEP,"Metallization Material",CSVFSEP,
	 "Metallization Thickness [um]",CSVFSEP,"Filled Layer Flag",CSVFSEP,
	 "Comment",CSVFSEP,"Isolation Thickness [um]",CSVFSEP,
	 "Isolation Material",CSVFSEP,"Epsr",CSVFSEP,
	 "tan delta",CSVFSEP,"Tolerance",CSVFSEP,"Core Flag");
	if (LAYSTKORD) {
	    for (i=layscnt-1;i>=0;i--)
		fprintf(dfh,FMTLAYENTRY,
		 layspl[i].layer<POWLAYBASE ? itoa(layspl[i].layer+1) :
		 ("power "+itoa(layspl[i].layer-POWLAYBASE+1)),
		 CSVFSEP,layspl[i].surf,CSVFSEP,
		 cvtlength(layspl[i].cu,0,4),CSVFSEP,
		  layspl[i].layer<POWLAYBASE ? layspl[i].fill : 1,CSVFSEP,
		 layspl[i].comm,CSVFSEP,
		 cvtlength(i>0 ? layspl[i].iso : thickness ,0,4),CSVFSEP,
		 i>0 ? layspl[i].mat : "",CSVFSEP,
		 i>0 ? layspl[i].epsr : 0.0,CSVFSEP,
		 i>0 ? layspl[i].tand : 0.0,CSVFSEP,
		 i>0 ? layspl[i].tol : 0.0,CSVFSEP,
		 i>0 ? layspl[i].core : 0);
	    }
	else {
	    for (i=0;i<layscnt;i++)
		fprintf(dfh,FMTLAYENTRY,
		 layspl[i].layer<POWLAYBASE ? itoa(layspl[i].layer+1) :
		 ("power "+itoa(layspl[i].layer-POWLAYBASE+1)),
		 CSVFSEP,layspl[i].surf,CSVFSEP,
		 cvtlength(layspl[i].cu,0,4),CSVFSEP,layspl[i].fill,CSVFSEP,
		 layspl[i].comm,CSVFSEP,
		 cvtlength(i<(layscnt-1) ? layspl[i].iso : thickness ,0,4),
		 CSVFSEP,i<(layscnt-1) ? layspl[i].mat : "",CSVFSEP,
		 i<(layscnt-1) ? layspl[i].epsr : 0.0,CSVFSEP,
		 i<(layscnt-1) ? layspl[i].tand : 0.0,CSVFSEP,
		 i<(layscnt-1) ? layspl[i].tol : 0.0,CSVFSEP,
		 i<(layscnt-1) ? layspl[i].core : 0);
	    }
	fclose(dfh);
	sprintf(msg,REPEXPDONE,dfname);
	bae_prtdialog(msg);
}

void importlaysetup()
/*
// Import layer setup definitions
*/
{
	string fname			/* Input file name */;
	string msg			/* Message buffer */;
	string readbuf			/* Input buffer */;
	STRINGS setl[]			/* Data set array */;
	int setn	= 0		/* Data set count */;
	STRINGS strl			/* String list */;
	int strn	= 0		/* String count */;
	int len				/* String length */;
	int fh				/* Input file handle */;
	char c				/* Scan character buffer */;
	int step			/* Step direction */;
	int start, end			/* Step range */;
	int i				/* Loop control variable */;
	// Check if output file name extension defined
	if (CSVEXT!="")
		fname=convstring(bae_planfname(),0)+CSVEXT;
	// Get the output file name
	if (bae_askfilename(fname,bae_swversion(3),UPRDFILE) ||
	 fname=="")
		error_abort();
	fseterrmode(1);
	fh=fopen(fname,0);
	fseterrmode(0);
	// Skip header line
	fgets(readbuf,1024,fh);
	// Loop for data sets
	while (fgets(readbuf,1024,fh)==0) {
		len=strlen(readbuf);
		while (len>0 && ((c=readbuf[len-1])==0x0a || c==0x0d))
			len--;
		readbuf[len]='\0';
		// Split line into semicolon-separated strings
		if ((strn=splitstring(readbuf,strl))<11 ||
		 strl[0]=="")
			continue;
		for (i=0;i<11;i++)
			setl[setn][i]=strtrim(strl[i]);
		setn++;
		}
	fclose(fh);
	fseterrmode(1);
	// Check if valid base layer
	if (setl[0][0]=="1") {
		start=0;
		end=setn;
		step=1;
		}
	else if (setl[setn-1][0]=="1") {
		start=setn-1;
		end=(-1);
		step=(-1);
		}
	else {
		error(ERRBASELAY);
		}
	layscnt=0;
	for (i=start;i!=end;i+=step) {
		if (isdigit(setl[i][0][0]))
			layspl[layscnt].layer=atoi(setl[i][0])-1;
		else
			layspl[layscnt].layer=POWLAYBASE+
			 atoi(strextract(setl[i][0],6,strlen(setl[i][0])))-1;
		layspl[layscnt].surf=setl[i][1];
		layspl[layscnt].cu=cvtlength(atof(setl[i][2]),4,0);
		layspl[layscnt].fill=atoi(setl[i][3]);
		layspl[layscnt].comm=setl[i][4];
		if (layscnt<(setn-1)) {
			layspl[layscnt].iso=cvtlength(atof(setl[i][5]),4,0);
			layspl[layscnt].mat=setl[i][6];
			layspl[layscnt].epsr=atof(setl[i][7]);
			layspl[layscnt].tand=atof(setl[i][8]);
			layspl[layscnt].tol=atof(setl[i][9]);
			layspl[layscnt].core=atoi(setl[i][10]);
			}
		else {
			thickness=cvtlength(atof(setl[i][5]),4,0);
			layspl[layscnt].mat="";
			layspl[layscnt].epsr=0.0;
			layspl[layscnt].tand=0.0;
			layspl[layscnt].tol=0.0;
			layspl[layscnt].core=0;
			}
		layscnt++;
		}
	sprintf(msg,REPIMPDONE,fname);
	bae_prtdialog(msg);
}

int splitstring(string s,STRINGS ssl)
/*
// Split string
// Return value :
//	number of substrings
// Parameters :
//	string s		: Input string
//	STRINGS ssl		: Substring list
*/
{
	int ssp		= 0		/* Substring position */;
	int ssn		= 0		/* Substring count */;
	int sl		= strlen(s)	/* String length */;
	int pos		= 1		/* String scan position */;
	int fs				/* Field seperator character */;
	int c				/* Scan character */;
	// Get the field seperator charachter */
	fs=CSVFSEP[0];
	// Scan input string
	for (pos=0;pos<sl;pos++) {
		if ((c=s[pos])==fs) {
			// Terminate previous field string
			ssl[ssn][ssp]='\0';
			ssn++;
			ssp=0;
			}
		else {
			// Store string character
			ssl[ssn][ssp]=c;
			ssp++;
			}
		}
	// Terminate last field string
	if (sl>0) {
		ssl[ssn][ssp]='\0';
		ssn++;
		}
	// Remove field quotation marks
	for (pos=0;pos<ssn;pos++) {
		sl=strlen(ssl[pos]);
		if ((ssl[pos][0]=='"' && ssl[pos][sl-1]=='"') ||
		 (ssl[pos][0]=='\'' && ssl[pos][sl-1]=='\''))
			ssl[pos]=sl==2 ? "" : strextract(ssl[pos],1,sl-2);
		}
	// Return the substring count
	return(ssn);
}

string strltrim(string s)
/*
// Left trim string (skip leading white spaces)
// Return value :
//	string without leading white spaces
// Parameters :
//	string s		: Input string
*/
{
	// Extract and return substring
	return(strextract(s,strscannext(s," \t\n",1,0)-1,strlen(s)));
}

string strrtrim(string s)
/*
// Right trim string (skip trailing white spaces)
// Return value :
//	string without trailing white spaces
// Parameters :
//	string s		: Input string
*/
{
	int i		= strlen(s)	/* Loop control variable */;
	// Scan string backward for non-space
	while ((--i)>=0 && isspace(s[i]))
		;
	// Extract and return substring
	return(i<0 ? "" : strextract(s,0,i));
}

string strtrim(string s)
/*
// Trim string (skip leading and trailing white spaces)
// Return value :
//	string without leading and trailing white spaces
// Parameters :
//	string s		: Input string
*/
{
	// Extract and return substring
	return(strrtrim(strltrim(s)));
}

string powlayertext(int layer)
/*
// Get power layer net description text
// Return value :
//	power layer net description string
// Parameters :
//	int layer		: Layer number
*/
{
	index L_POWLAYER pl		/* Power layer index */;
	index L_POLY poly		/* Polygon index */;
	index L_CNET cnet		/* Connection net index */;
	string laytext	= ""		/* Layer description text */;
	STRINGS netnames		/* Net names */;
	int netcnt = 0			/* Net count */;
	int layidx			/* Layer index */;
	// Scan the power layer list
	forall (pl) {
		if ((layidx+POWLAYBASE)==layer) {
			laytext= pl.CNET.NAME=="" ? "-" : pl.CNET.NAME;
			break;
			}
		layidx++;
		}
	// Scan all used net names
	forall (poly where poly.LAYER==layer && poly.TYP==L_POLYSPPAREA &&
	 poly.TREE>=0) {
		// Find the net with given tree number
		if (lay_gettreeidx(poly.TREE,cnet)!=0)
			continue;
		for (layidx=0;layidx<netcnt;layidx++)
			if (netnames[layidx]==cnet.NAME)
				break;
		if (layidx>=netcnt) {
			netnames[netcnt]=cnet.NAME;
			netcnt++;
			}
		}
	// Add split power plane net names
	if (netcnt>0) {
		laytext+=" (";
		for (layidx=0;layidx<netcnt;layidx++) {
			if (layidx>0)
				laytext+=",";
			laytext+=netnames[layidx];
			}
		laytext+=")";
		strupper(laytext);
		}
	// Return the layer net description text
	return(laytext);
}

static void updrules()
/*
// Update project rules from rule database
*/
{
	string msg			/* Message string */;
	string fn			/* Project file name */;
	string rn = ""			/* Rule name */;
	int cnt = 0			/* Rule count */;
	// Select project file name
	if (bae_askddbfname(fn,1,UPRPFILE))
		// Abort
		error_abort();
	// Scan project rules
	while (scanddbenames(fn,DDBCLRULE,rn)==1)
		if (ddbcopyelem(rsdatabase,fn,DDBCLRULE,rn,1)==0)
			cnt++;
	sprintf(msg,REPRULECOPY,cnt);
	bae_prtdialog(msg);
}

void setglue(int glue,int grpflag)
/*
// Set glue mode
// Parameters :
//	int glue		: Glue mode
//	int grpflag		: Group process flag
*/
{
	index L_FIGURE fig		/* Pick element */;
	string msg			/* Message buffer */;
	int changes	= 0		/* Change count */;
	if (grpflag) {
		if (glue)
			forall (fig where fig.GROUP && !(fig.FIXED&2)) {
				// Save current state for undo
				if (changes==0)
					bae_callmenu(MNU_BAESAVESTATE);
				rs_assfigintpred(fig,RS_GLUED,glue,0,"");
				changes++;
				}
		else
			forall (fig where fig.GROUP && (fig.FIXED&2)) {
				// Save current state for undo
				if (changes==0)
					bae_callmenu(MNU_BAESAVESTATE);
				rs_assfigintpred(fig,RS_GLUED,glue,0,"");
				changes++;
				}
		sprintf(msg,glue ? REPGLUED : REPUNGLUED,changes);
		bae_prtdialog(msg);
		}
	else {
		// Loop while element picked
		bae_prtdialog(UPRSELNREF);
		while (ged_pickelem(fig,L_FIGNREF)==0) {
			// Save current state for undo
			if (changes==0)
				bae_callmenu(MNU_BAESAVESTATE);
			sprintf(msg,glue ? REPPGLUED : REPPUNGLUED,fig.NAME);
			rs_assfigintpred(fig,RS_GLUED,glue,0,"");
			bae_prtdialog(msg);
			changes++;
			}
		bae_prtdialog("");
		}
}

static void partpredicates()
/*
// Part predicate edit functions
*/
{
	index L_FIGURE fig		/* Figure list element */;
	string msg			/* Message buffer */;
	double cy			/* Current y value */;
	double defoff = 0.0		/* Default button offset */;
	int avidxl[]			/* Attribute value index list */;
	int lockidx	= (-1)		/* Lock toggle index */;
	int menuact			/* Menu action */;
	int mlsidx	= 0		/* Menu attr. list start idx. */;
	int menuoff			/* Menu item offset */;
	int menuidx			/* Menu item index */;
	int defidx			/* Default value index */;
	int repflag	= 1		/* Repeat flag */;
	int lock	= 0		/* Lock attributes flag */;
	int lockflag	= 0		/* Locked attributes exists flag */;
	string partname			/* Part name */;
	string attrvalue		/* Attribute value */;
	int attidx			/* Attribute list index */;
	int gridlock			/* Grid lock flag */;
	int anglock			/* Angle lock flag */;
	int i				/* Loop control variable */;
	// Pick part
	if (bae_peekiact() || varget(GV_PROPCALL,i)==0) {
		if (varget(GV_PROPX,ax)==0 && varget(GV_PROPY,ay)==0) {
			vardelete(GV_PROPX);
			vardelete(GV_PROPY);
			bae_storemouseiact(3,ax,ay,2,LMB);
			}
		else {
			// Get the old grid and angle lock
			gridlock=bae_getgridlock();
			anglock=bae_getanglelock();
			// Release grid and angle lock
			bae_setgridlock(0);
			bae_setanglelock(0);
			if (bae_inpoint(bae_planwsnx(),bae_planwsny(),ax,ay,0))
				bae_promptdialog(UPRSELPART);
			else
				bae_storemouseiact(3,ax,ay,2,LMB);
			// Restore the old grid and angle lock
			bae_setgridlock(gridlock);
			bae_setanglelock(anglock);
			}
		if (ged_pickelem(fig,L_FIGNREF)!=0)
			error(ERRNOPICK);
		}
	else {
		bae_prtdialog(UPRSELPART);
		if (ged_pickelem(fig,L_FIGNREF)!=0)
			error(ERRNOPICK);
		bae_wsmouse(ax,ay,0);
		}
	partname=fig.NAME;
	if (fig.FIXED&2)
		errormsg(ERRPARTGLUED,partname);
	// Check for dialog support
	if (bae_dialclr())
		error(ERRNOWIN);
	// Init. attribute name list
	attn=0;
	// Scan the attributes
	if (lay_scanpool(fig.POOL,
	 0.0,0.0,0.0,0,0,amacfunc,NULL,NULL,atextfunc,NULL,NULL,NULL))
		error_scan();
	// Check if attributes found
	if (attn==0) {
		sprintf(msg,ERRNOPRED,partname,fig.NREF.MACRO.NAME);
		error(msg);
		}
	// Check if multipage attribute list
	if (attn>MAXMENULIST) {
		// Scan the picked attribute
		if (lay_scanfelem(fig,
		 0.0,0.0,0.0,0,0,amacfunc,NULL,NULL,aptextfunc,NULL,NULL,NULL))
			error_scan();
		if (aminname!="")
			for (attidx=0;attidx<attn;attidx++)
				if (attl[attidx].name==aminname) {
					mlsidx=attidx;
					break;
					}
		}
	// Get attribute values
	for (attidx=0;attidx<attn;attidx++) {
		// Query the predicate value
		if (lay_rulequery(RS_OCFIG,fig,RS_PCBSUBJ,
		 attl[attidx].name,"?s",attl[attidx].val)<1)
			attl[attidx].val=PA_NILVAL;
		attl[attidx].valbak=attl[attidx].val;
		// Check if default value defined
		if (attl[attidx].defvaln!=0)
			defoff=9.0;
		// Check if locked attribute
		if (attl[attidx].lock) {
			lock=lockflag=1;
			}
		}
	defoff+=DIAL_LEFTMARG;
	do {
		bae_dialclr();
		cy=DIAL_TOPMARG;
		// Create the dialog box controls
		// Build the attribute table menu
		for (menuidx=0;menuidx<MAXMENULIST &&
		 (menuidx+mlsidx)<attn;menuidx++) {
			attidx=menuidx+mlsidx;
			attrvalue=attl[attidx].val;
			if (attl[attidx].lock==1 && attl[attidx].defvaln>1) {
				// Search current entry index
				defidx=0;
				for (i=0;i<attl[attidx].defvaln;i++)
					if (attl[attidx].defvall[i]==
					 attrvalue) {
						defidx=i;
						break;
						}
				// Store selection box
				avidxl[menuidx]=bae_dialaddcontrol(PA_SB,0,0,
				defidx,0.0,0.0,0.0,"",0,
				DIAL_LEFTMARG+12.0+defoff,cy,20.0,"");
				for (i=0;i<attl[attidx].defvaln;i++)
					dial_sbentry(
					0,i,attl[attidx].defvall[i]);
				}
			else if (lock && (attl[attidx].lock&1)) {
				// Store value label
				dial_label(12.0+defoff,cy,
				 attrvalue==PA_NILVAL ? REPNILATT : attrvalue);
				avidxl[menuidx]=(-1);
				}
			else {
				// Store edit field
				avidxl[menuidx]=bae_dialaddcontrol(
				 PA_STR|PA_NILSTR,0,0,0,0.0,0.0,0.0,
				 attrvalue,MAXTEXTLEN,DIAL_LEFTMARG+12.0+defoff,
				 cy,20.0,"");
				}
			cy+=DIAL_BUTVSTEP;
			}
		// Store the OK and abort button
		cy+=DIAL_SEPVSTEP;
		dial_okabort(cy);
		cy=DIAL_TOPMARG;
		for (menuidx=0;menuidx<MAXMENULIST &&
		 (menuidx+mlsidx)<attn;menuidx++) {
			attidx=menuidx+mlsidx;
			// Store attribute clear button
			if (!(attl[attidx].lock==1 &&
			 attl[attidx].defvaln>1) &&
			 !(lock && attl[attidx].lock)) {
				bae_dialaddcontrol(PA_ACT,0,menuidx+6,0,0.0,
				 0.0,0.0,"",0,DIAL_LEFTMARG,cy,10.0,UPRNOVAL);
				if (attl[attidx].defvaln!=0)
					// Store attribute default value button
					bae_dialaddcontrol(PA_ACT,0,
					 menuidx+MAXMENULIST+6,0,0.0,0.0,0.0,
					 "",0,DIAL_LEFTMARG+11.0,cy,8.0,
					 UPRDEFAULT);
				// Store attribute browse button
				if (attl[attidx].defvaln>1)
					bae_dialaddcontrol(PA_ACT,0,
					 menuidx+2*MAXMENULIST+6,0,0.0,0.0,0.0,
					 "",0,DIAL_LEFTMARG+61.0+defoff,
					 cy,0.0,UPRBROWSE);
				}
			else {
				// Store attribute default button
				if (attl[attidx].defvaln>1)
					bae_dialaddcontrol(PA_ACT,0,menuidx+
					 MAXMENULIST+6,0,0.0,0.0,0.0,"",0,
					 DIAL_LEFTMARG+11.0,cy,8.0,UPRDEFAULT);
				}
			// Store the attribute name control
			sprintf(msg,": %s",attl[menuidx+mlsidx].disp);
			dial_label(32.0+defoff,cy,msg);
			cy+=DIAL_BUTVSTEP;
			}
		cy+=DIAL_SEPVSTEP;
		if (mlsidx>0)
			bae_dialaddcontrol(PA_ACT,0,1,0,0.0,0.0,0.0,
			 "",0,DIAL_LEFTMARG+20.0,cy,0.0,UPRPREVDIAL);
		if ((mlsidx+MAXMENULIST)<attn)
			bae_dialaddcontrol(PA_ACT,0,2,0,0.0,0.0,0.0,
			 "",0,DIAL_LEFTMARG+30.0,cy,0.0,UPRNEXTDIAL);
		bae_dialaddcontrol(PA_ACT,0,3,0,
		 0.0,0.0,0.0,"",0,DIAL_LEFTMARG+40.0,cy,0.0,UPRALLRES);
		if (defoff!=DIAL_LEFTMARG) {
			bae_dialaddcontrol(PA_ACT,0,4,0,
			 0.0,0.0,0.0,"",0,DIAL_LEFTMARG+55.0,cy,0.0,UPRALLDEF);
			if (lockflag)
				lockidx=bae_dialaddcontrol(PA_TOGGLE,0,5,lock,
				 0.0,0.0,0.0,"",0,DIAL_LEFTMARG+70.0,cy,0.0,
				 UPRLOCK);
			}
		else if (lockflag) {
			lockidx=bae_dialaddcontrol(PA_TOGGLE,0,5,lock,
			 0.0,0.0,0.0,"",0,DIAL_LEFTMARG+55.0,cy,0.0,UPRLOCK);
			}
		bae_dialaddcontrol(PA_HSEP|PA_HBRDREL,0,0,0,0.0,0.0,0.0,"",0,
		 DIAL_LEFTMARG,cy-DIAL_SEPVSTEP,DIAL_RIGHTSMARG,"");
		sprintf(msg,UPRPRED,partname);
		// Call the dialog function
		bae_setintpar(16,3017);
		switch ((menuact=bae_dialaskparams(msg,0,
		 DIAL_LEFTMARG+68.3+defoff+DIAL_RIGHTSMARG,cy+1.6))) {
			// Done
			case 0 :
			repflag=0;
			break;
			// Previous attribute list
			case 1 :
			// Fetch current attribute value fields
			for (menuidx=0;menuidx<MAXMENULIST &&
			 (menuidx+mlsidx)<attn;menuidx++)
				if (avidxl[menuidx]!=(-1))
					bae_dialgetdata(avidxl[menuidx],
					 0,0.0,attl[menuidx+mlsidx].val);
			mlsidx-=MAXMENULIST;
			if (mlsidx<0)
				mlsidx=0;
			break;
			// Next attribute list
			case 2 :
			// Fetch current attribute value fields
			for (menuidx=0;menuidx<MAXMENULIST &&
			 (menuidx+mlsidx)<attn;menuidx++)
				if (avidxl[menuidx]!=(-1))
					bae_dialgetdata(avidxl[menuidx],
					 0,0.0,attl[menuidx+mlsidx].val);
			mlsidx+=MAXMENULIST;
			break;
			// Reset all attributes
			case 3 :
			for (attidx=0;attidx<attn;attidx++)
				if (!(lock && attl[attidx].lock))
					attl[attidx].val=PA_NILVAL;
			break;
			// Default all attributes
			case 4 :
			for (attidx=0;attidx<attn;attidx++)
				attl[attidx].val=attl[attidx].defvall[0];
			break;
			// Lock toggle
			case 5 :
			bae_dialgetdata(lockidx,lock,0.0,"");
			break;
			// Fail/abort
			case (-1) :
			error_abort();
			default :
			// Fetch current attribute value fields
			for (menuidx=0;menuidx<MAXMENULIST &&
			 (menuidx+mlsidx)<attn;menuidx++)
				if (avidxl[menuidx]!=(-1))
					bae_dialgetdata(avidxl[menuidx],
					 0,0.0,attl[menuidx+mlsidx].val);
			// Check if browse button
			menuoff=menuact-6;
			if (menuoff>=2*MAXMENULIST) {
				attidx=menuoff-2*MAXMENULIST+mlsidx;
				if ((attrvalue=attl[attidx].val)==PA_NILVAL)
					attrvalue="";
				// Build the list header
				sprintf(headl[0],REPDEFVAL,attl[attidx].disp);
				headl[1]="";
				// Perform the selection popup
				sprintf(msg,UPRDEFVAL,attl[attidx].disp);
				bae_setintpar(16,3068);
				if ((attrvalue=popupmenu(
				 1,UPRDEFVAL,headl,headn,
				 attl[attidx].defvall,attl[attidx].defvaln,
				 attrvalue,0,0,1,0,0,0,
				 UINPOPABORT))==UINPOPABORT)
					break;
				attl[attidx].val=attrvalue;
				}
			else if (menuoff>=MAXMENULIST) {
				attidx=menuoff-MAXMENULIST+mlsidx;
				// Set default attribute value
				attl[attidx].val=attl[attidx].defvall[0];
				}
			else if (menuoff>=0 && menuoff<MAXMENULIST)
				// Reset attribute value
				attl[menuoff+mlsidx].val=PA_NILVAL;
			}
	    }
	 // Stop if no further repeat requests
	 while (repflag);
	// Fetch current attribute value fields
	for (menuidx=0;menuidx<MAXMENULIST && (menuidx+mlsidx)<attn;menuidx++)
		if (avidxl[menuidx]!=(-1))
			bae_dialgetdata(
			 avidxl[menuidx],0,0.0,attl[menuidx+mlsidx].val);
	// Save current state for undo
	bae_callmenu(MNU_BAESAVESTATE);
	// Set changed attributes
	ged_drawelem(fig,DM_CLEAR);
	for (attidx=0;attidx<attn;attidx++)
		if (attl[attidx].val!=attl[attidx].valbak)
			// Assign the predicate rule
			rs_assfigstrpred(
			 fig,attl[attidx].name,attl[attidx].val,PA_NILVAL,"");
	ged_drawelem(fig,DM_SET);
}

void preddefvalset()
/*
// Set default part predicate values
*/
{
	index L_FIGURE fig		/* Figure list element */;
	string msg			/* Message buffer */;
	string name			/* Name buffer */;
	string valstr			/* Value string */;
	STRINGS vall			/* Value list */;
	int valn			/* Value count */;
	int maxvaln			/* Max. set value count */;
	string attrname			/* Attribute name */;
	int lock			/* Lock flag */;
	int attrord			/* Attribute order value */;
	double cy			/* Current y value */;
	int avidxl[]			/* Attribute value index list */;
	int atidxl[]			/* Attribute lock toggle index list */;
	int menuact			/* Menu action */;
	struct attrdata {		// Attribute data descriptor
		string name		/* Attribute name */;
		string dispname		/* Attribute display name */;
		STRINGS vall		/* Attribute value list */;
		int valn		/* Attribute value count */;
		int maxvaln		/* Attribute max. set value count */;
		int lock		/* Attribute lock flag */;
		int order		/* Attribute order */;
		} al[]			/* Attribute list */;
	int an		= 0		/* Attribute count */;
	int mlsidx	= 0		/* Menu attr. list start idx. */;
	int menuidx			/* Menu item index */;
	int attidx			/* Attribute index */;
	int repflag	= 1		/* Repeat flag */;
	int cnt	= 0			/* Element count */;
	int i,j				/* Loop control variables */;
	// Check for dialog support
	if (bae_dialclr()) {
	    // Loop while pick element found
	    while (bae_promptdialog(UPRSELATEXT),
	     ged_pickelem(fig,L_FIGTEXT)==0) {
		// Check if valid part predicate reference text
		name=fig.NAME;
		if (name[0]!='$' || name[1]!='?' ||
		 name[2]!='s' || name[3]!=':')
			// No valid part predicate reference name
			continue;
		name=strextract(name,4,strlen(name));
		// Query the current active default value
		if (lay_rulequery(RS_OCFIG,fig,RS_PCBSUBJ,RS_INIVAL,
		 "?s",valstr)<1)
			// Clear default attribute value
			valstr="";
		// Get default value
		sprintf(msg,UPRDEFVAL,name);
		if ((valstr=
		 bae_readedittext(msg,valstr,MAXTEXTLEN))==UINPOPABORT)
			error_abort();
		// Check if attribute default value requested
		if (valstr!="") {
			// Convert string delimiter character
			for (i=strlen(valstr)-1;i>=0;i--)
				if (valstr[i]=='\'')
					valstr[i]='`';
			}
		// Save current state for undo
		if (cnt==0)
			bae_callmenu(MNU_BAESAVESTATE);
		// Assign the default value predicate rule
		rs_assfigstrpred(fig,RS_INIVAL,valstr,PA_NILVAL,"");
		// Perform screen redraw
		screenredraw();
		cnt++;
		}
	    // No pick
	    if (cnt)
		bae_prtdialog(ERRNOPICK);
	    else
		perror(ERRNOPICK);
	    return;
	    }
	// Loop for all attribute texts
	forall (fig where fig.TYP==L_FIGTEXT) {
		// Check if valid part predicate reference text
		name=fig.NAME;
		if (name[0]!='$' || name[1]!='?' ||
		 name[2]!='s' || name[3]!=':')
			// No valid part predicate reference name
			continue;
		name=strextract(name,4,strlen(name));
		// Query the current active default value
		if (lay_rulequery(RS_OCFIG,fig,RS_PCBSUBJ,RS_INIVAL,
		 "?s",vall[0])<1) {
			// Clear default attribute value
			vall[0]=PA_NILVAL;
			valn=0;
			}
		else {
			valn=1;
			for (i=1;i<100;i++) {
				if (lay_rulequery(RS_OCFIG,fig,RS_PCBSUBJ,
				 RS_INIVAL+itoa(i),"?s",vall[valn])<1)
					break;
				valn++;
				}
			}
		// Query the current active lock flag
		if (lay_rulequery(RS_OCFIG,fig,RS_PCBSUBJ,RS_ATTADIS,
		 "?d",lock)<1)
			// Clear lock flag
			lock=0;
		// Store the attribute name and value to lists
		for (attidx=0;attidx<an;attidx++)
			if (al[attidx].name==name)
				break;
		// Check if new attribute
		if (attidx>=an) {
			// Get upper case attribute
			attrname=name;
			strupper(attrname);
			// Build order variable name
			sprintf(attrname,PAR_ATTRORDP,
			 strextract(attrname,1,strlen(attrname)));
			// Query order variable
			if (varget(attrname,attrord)!=0)
				// No order id available
				attrord=9999;
			attrname=name;
			for (j=an;j>0;j--)
				if (al[j-1].order>attrord ||
				 (al[j-1].order==attrord &&
				  al[j-1].name>attrname))
					al[j]=al[j-1];
				else
					break;
			// Store new attribute
			al[j].name=attrname;
			al[j].order=attrord;
			al[j].vall=vall;
			al[j].valn=valn;
			al[j].maxvaln=valn;
			al[j].lock=lock;
			strupper(attrname);
			// Build comment variable name
			sprintf(attrname,PAR_ATTRCOMMP,
			 strextract(attrname,1,strlen(attrname)));
			// Query comment variable
			if (varget(attrname,valstr)!=0 || valstr=="")
				// No comment available
				al[j].dispname=name;
			else
				// Attach comment to variable name
				sprintf(al[j].dispname,
				 "%s %s",fig.NAME,valstr);
			an++;
			}
		// Check if attribute set
		else if (vall[0]!=PA_NILVAL) {
			al[attidx].vall=vall;
			al[attidx].valn=valn;
			if (valn>al[attidx].maxvaln)
				al[attidx].maxvaln=valn;
			}
		}
	// Check if attributes defined
	if (an==0)
		errormsg(ERRNOATT,bae_planename());
	do {
		bae_dialclr();
		cy=DIAL_TOPMARG;
		// Create the dialog box controls
		// Build the attribute table menu
		for (menuidx=0;menuidx<MAXMENULIST &&
		 (menuidx+mlsidx)<an;menuidx++) {
			// Store edit field
			avidxl[menuidx]=bae_dialaddcontrol(PA_STR|PA_NILSTR,
			 0,0,0,0.0,0.0,0.0,al[menuidx+mlsidx].vall[0],
			 MAXTEXTLEN,DIAL_LEFTMARG+12.0,cy,20.0,"");
			cy+=DIAL_BUTVSTEP;
			}
		// Store the OK and abort button with seperator
		cy+=0.4;
		dial_okabort(cy);
		cy=DIAL_TOPMARG;
		// Create the dialog box controls
		for (menuidx=0;menuidx<MAXMENULIST &&
		 (menuidx+mlsidx)<an;menuidx++) {
			attidx=menuidx+mlsidx;
			// Store attribute clear button
			bae_dialaddcontrol(PA_ACT,0,menuidx+3,0,
			 0.0,0.0,0.0,"",0,DIAL_LEFTMARG,cy,10.0,UPRNOVAL);
			// Store list button
			bae_dialaddcontrol(PA_ACT,0,menuidx+3+an,0,
			 0.0,0.0,0.0,"",0,DIAL_LEFTMARG+33.0,cy,10.0,
			 al[attidx].valn>1 ? UPRLISTEDIT : UPRLISTADD);
			// Store attribute lock toggle
			atidxl[menuidx]=bae_dialaddcontrol(PA_TOGGLE,0,0,
			 al[attidx].lock,0.0,0.0,0.0,"",
			 0,DIAL_LEFTMARG+44.0,cy,0.0,UPRLOCK);
			// Store the attribute name control
			sprintf(msg,": %s",al[attidx].dispname);
			dial_label(52.5,cy,msg);
			cy+=DIAL_BUTVSTEP;
			}
		cy+=0.4;
		// Check for previous and next page menu items
		if (mlsidx>0)
			bae_dialaddcontrol(PA_ACT,0,1,0,0.0,0.0,0.0,"",
			 0,20.0,cy,0.0,UPRPREVDIAL);
		if ((mlsidx+MAXMENULIST)<an)
			bae_dialaddcontrol(PA_ACT,0,2,0,0.0,0.0,0.0,"",
			 0,30.0,cy,0.0,UPRNEXTDIAL);
		bae_dialaddcontrol(PA_HSEP|PA_HBRDREL,0,0,0,0.0,0.0,0.0,"",0,
		 DIAL_LEFTMARG,cy-0.4,DIAL_RIGHTSMARG,"");
		sprintf(msg,UPRATTRVDIAL,bae_planename());
		// Call the dialog function
		bae_setintpar(16,3018);
		switch ((menuact=bae_dialaskparams(
		 msg,0,DIAL_LEFTMARG+80.8+DIAL_RIGHTSMARG,cy+1.6))) {
			// Done
			case 0 :
			repflag=0;
			break;
			// Previous attribute list
			case 1 :
			// Fetch current attribute value fields
			for (menuidx=0;menuidx<MAXMENULIST &&
			 (menuidx+mlsidx)<an;menuidx++) {
				attidx=menuidx+mlsidx;
				bae_dialgetdata(avidxl[menuidx],0,0.0,
				 al[attidx].vall[0]);
				if (al[attidx].vall[0]!=PA_NILVAL &&
				 al[attidx].valn==0)
					al[attidx].valn=1;
				bae_dialgetdata(atidxl[menuidx],
				 al[attidx].lock,0.0,"");
				}
			mlsidx-=MAXMENULIST;
			break;
			// Next attribute list
			case 2 :
			// Fetch current attribute value fields
			for (menuidx=0;menuidx<MAXMENULIST &&
			 (menuidx+mlsidx)<an;menuidx++) {
				attidx=menuidx+mlsidx;
				bae_dialgetdata(avidxl[menuidx],0,0.0,
				 al[attidx].vall[0]);
				if (al[attidx].vall[0]!=PA_NILVAL &&
				 al[attidx].valn==0)
					al[attidx].valn=1;
				bae_dialgetdata(atidxl[menuidx],
				 al[attidx].lock,0.0,"");
				}
			mlsidx+=MAXMENULIST;
			break;
			// Fail/abort
			case (-1) :
			error_abort();
			default :
			// Fetch current attribute value fields
			for (menuidx=0;menuidx<MAXMENULIST &&
			 (menuidx+mlsidx)<an;menuidx++) {
				attidx=menuidx+mlsidx;
				bae_dialgetdata(avidxl[menuidx],0,0.0,
				 al[attidx].vall[0]);
				if (al[attidx].vall[0]!=PA_NILVAL &&
				 al[attidx].valn==0)
					al[attidx].valn=1;
				bae_dialgetdata(atidxl[menuidx],
				 al[attidx].lock,0.0,"");
				}
			// Store NIL value attribute
			if ((attidx=(menuact-3+mlsidx))<an) {
				for (i=0;i<al[attidx].valn;i++)
					al[attidx].vall[i]=PA_NILVAL;
				al[attidx].valn=0;
				break;
				}
			// Edit value list
			if ((attidx=(menuact-3+mlsidx-an))<an)
				editvallist(
				 al[attidx].name,al[attidx].dispname,
				 al[attidx].vall,al[attidx].valn);
			}
		}
	 // Stop if no further repeat requests
	 while (repflag);
	// Fetch current attribute value fields
	for (menuidx=0;menuidx<MAXMENULIST &&
	 (menuidx+mlsidx)<an;menuidx++) {
		attidx=menuidx+mlsidx;
		bae_dialgetdata(avidxl[menuidx],0,0.0,al[attidx].vall[0]);
		bae_dialgetdata(atidxl[menuidx],al[attidx].lock,0.0,"");
		}
	// Save current state for undo
	bae_callmenu(MNU_BAESAVESTATE);
	/* Set attribute default values */
	forall (fig where fig.TYP==L_FIGTEXT) {
		// Check if valid part predicate reference text
		name=fig.NAME;
		if (name[0]!='$' || name[1]!='?' ||
		 name[2]!='s' || name[3]!=':')
			// No valid part predicate reference name
			continue;
		name=strextract(name,4,strlen(name));
		// Get default value
		vall[0]=PA_NILVAL;
		valn=maxvaln=0;
		lock=0;
		for (i=0;i<an;i++)
			if (al[i].name==name) {
				vall=al[i].vall;
				valn=al[i].valn;
				maxvaln=al[i].maxvaln;
				lock=al[i].lock;
				break;
				}
		// Check if attribute default value requested
		if (vall[0]!=PA_NILVAL) {
			// Convert string delimiter character
			for (i=strlen(vall[0])-1;i>=0;i--)
				if (vall[0][i]=='\'')
					vall[0][i]='`';
			}
		// Assign the attribute default value predicate rule
		rs_assfigstrpred(fig,RS_INIVAL,vall[0],PA_NILVAL,"");
		for (i=1;i<valn;i++)
			rs_assfigstrpred(
			 fig,RS_INIVAL+itoa(i),vall[i],PA_NILVAL,"");
		for (;i<maxvaln;i++)
			rs_assfigstrpred(
			 fig,RS_INIVAL+itoa(i),PA_NILVAL,PA_NILVAL,"");
		// Assign the attribute lock predicate rule
		rs_assfigintpred(fig,RS_ATTADIS,lock,0,"");
		}
	// Perform screen redraw
	screenredraw();
}

void editvallist(string attrname,string dispname,STRINGS vall,int valn)
/*
// Edit attribute value list
// Parameters :
//	string attrname		: Attribute name
//	string dispname		: Attribute display name
//	STRINGS vall		: Attribute list
//	int valn		: Attribute count
*/
{
	string msg			/* Message buffer */;
	string swapattr			/* Attribute swap buffer */;
	double cy			/* Current y value */;
	double butx			/* Current button position */;
	double dialwidth		/* Dialog box width */;
	double dialheight		/* Dialog box height */;
	double baseheight		/* Dialog box base height */;
	int res				/* Selection result */;
	int repflag	= 1		/* Repeat flag */;
	int lbidx			/* List box item index */;
	int from			/* From index */;
	int to				/* To index */;
	int i				/* Loop control variable */;
	if (valn==0)
		addvallist(attrname,vall,valn);
	// Perform the input loop
	do {
		baseheight=DIAL_TOPMARG+DIAL_SEPVSTEP+DIAL_BUTVSTEP;
		bae_dialclr();
		dial_getboxsizemin(3019,dialwidth,dialheight,
		 DIAL_LEFTMARG+SELBOXWIDTHLS+DIAL_RIGHTSMARG,baseheight+16.0,
		 DIAL_LEFTMARG+50.0,baseheight+1.0);
		cy=DIAL_TOPMARG;
		butx=DIAL_LEFTMARG;
		// Store function buttons
		// Edit value
		if (valn) {
			bae_dialaddcontrol(PA_ACT,0,0,0,0.0,0.0,0.0,
			 "",0,butx,cy,MBUTWIDTH,UPRDEDIT);
			butx+=MBUTXSTEP;
			}
		// Add value
		bae_dialaddcontrol(PA_ACT,0,1,0,0.0,0.0,0.0,"",0,
		 butx,cy,MBUTWIDTH,UPRDADD);
		butx+=MBUTXSTEP;
		// Delete value
		if (valn) {
			bae_dialaddcontrol(PA_ACT,0,2,0,0.0,0.0,0.0,
			 "",0,butx,cy,MBUTWIDTH,UPRDDEL);
			butx+=MBUTXSTEP;
			}
		// Move value
		if (valn>1) {
			bae_dialaddcontrol(PA_ACT,0,3,0,0.0,0.0,0.0,
			 "",0,butx,cy,MBUTWIDTH,UPRDMOVE);
			butx+=MBUTXSTEP;
			}
		// Store done button
		bae_dialaddcontrol(PA_ACT,0,(-1),0,0.0,0.0,0.0,"",0,
		 butx,cy,MBUTWIDTH,UPRDDONE);
		cy+=DIAL_BUTVSTEP;
		// Store list box
		lbidx=bae_dialadvcontrol(PA_LB|PA_OKSEL|PA_HBRDREL|PA_VBRDREL,
		 (-1),0,(-1),0.0,0.0,0.0,"",0,
		 DIAL_LEFTMARG,cy,DIAL_RIGHTSMARG,DIAL_SEPVSTEP,"");
		// Store list box entries
		for (i=0;i<valn;i++)
			bae_dialaddcontrol(PA_LBE,0,0,i,0.0,0.0,0.0,
			 "",0,0.0,0.0,0.0,vall[i]);
		cy+=dialheight-baseheight;
		// Call the dialog function
		sprintf(msg,UPRDIALVALL,dispname);
		bae_setintpar(16,3019);
		res=bae_dialaskparams("!"+msg,3,dialwidth,cy+DIAL_SEPVSTEP);
		// Evaluate selected function
		switch (res) {
			case 0 :
			// Edit value
			bae_dialgetdata(lbidx,i,0.0,"");
			if (i>=0 && i<valn) {
				if ((msg=bae_readedittext(
				  UPRATTRVAL,vall[i],MAXTEXTLEN))=="" ||
				 msg==UINPOPABORT)
					break;
				vall[i]=msg;
				}
			break;
			// Add value
			case 1 :
			addvallist(attrname,vall,valn);
			break;
			// Delete value
			case 2 :
			bae_dialgetdata(lbidx,i,0.0,"");
			if (i>=0 && i<valn) {
				// Remove the value entry from list
				valn--;
				for (;i<valn;i++)
					vall[i]=vall[i+1];
				}
			break;
			// Move value
			case 3 :
			bae_dialgetdata(lbidx,from,0.0,"");
			if (from<0 || from>=valn) {
				bae_msgbox(2,ERRNOMOVVAL,"");
				break;
				}
			baseheight=DIAL_TOPMARG+DIAL_SEPVSTEP+DIAL_BUTVSTEP;
			do {
				bae_dialclr();
				cy=DIAL_TOPMARG;
				dial_getboxsizemin(3019,dialwidth,dialheight,
				 DIAL_LEFTMARG+SELBOXWIDTHLS+DIAL_RIGHTSMARG,
				 baseheight+16.0,DIAL_LEFTMARG+50.0,
				 baseheight+1.0);
				// Store the OK and abort button with seperator
				dial_okabort(cy);
				cy-=DIAL_SEPVSTEP;
				// Store list box
				lbidx=bae_dialadvcontrol(PA_LB|PA_OKSEL|
				 PA_HBRDREL|PA_HSCROLL|PA_VBRDREL,(-1),0,(-1),
				 0.0,0.0,0.0,"",0,DIAL_LEFTMARG,cy,
				 DIAL_RIGHTSMARG,DIAL_SEPVSTEP,"");
				// Store list box entries
				for (i=0;i<valn;i++)
					bae_dialaddcontrol(PA_LBE,0,0,i,0.0,0.0,
					 0.0,"",0,0.0,0.0,0.0,vall[i]);
				cy+=dialheight-baseheight+DIAL_SEPVSTEP;
				bae_setintpar(16,3019);
				sprintf(msg,UPRVALMOVDST,vall[from]);
				res=bae_dialaskparams("!"+msg,0,dialwidth,cy);
				// Stop if no further repeat requests
				} while (res==(-2));
			if (res<0)
				break;
			// Perform the attribute swap
			bae_dialgetdata(lbidx,to,0.0,"");
			if (to<0)
				break;
			swapattr=vall[from];
			if (from>to)
				for (i=from;i>to;i--)
					vall[i]=vall[i-1];
			else
				for (i=from;i<to;i++)
					vall[i]=vall[i+1];
			vall[to]=swapattr;
			break;
			// Resize :
			case (-2) :
			break;
			default :
			repflag=0;
			}
		// Stop if no further repeat requests
		} while (repflag);
}

void addvallist(string attrname,STRINGS vall,int valn)
/*
// Edit attribute value list
// Parameters :
//	string attrname		: Attribute name
//	STRINGS vall		: Attribute list
//	int valn		: Attribute count
*/
{
	string msg			/* Message buffer */;
	// Perform the input loop
	while (1) {
		// Set default data
		if ((msg=bae_readedittext(UPRATTRVAL,"",
		 MAXTEXTLEN))=="" || msg==UINPOPABORT)
			break;
		vall[valn]=msg;
		valn++;
		}
}

// Predicate attribute scan routines

int amacfunc(index L_MACRO macro,index L_POOL pool,
 int macinws,string refname,index L_LEVEL level)
/*
// Attribute scan macro function
// Return value :
//	0 if out of workspace, 1 if inside, 2 if unknown, or (-1) on error
// Parameters :
//	index L_MACRO macro	: Macro index
//	index L_POOL pool	: Macro pool index
//	int macinws		: Macro in workspace flag
//	string refname		: Macro reference name
//	index L_LEVEL level	: Macro level
*/
{
	return(macro.CLASS==DDBCLLPRT ? 1 : 0);
}

int atextfunc(index L_TEXT textp,double tx,double ty,double tangle,
 int mirrflag,int layer,double tsize,string tstr,int textinws)
/*
// Scan a text data block for predicate attribute definitions
// Return value :
//	zero if done or (-1) on error
// Parameters :
//	index L_TEXT textp	: Text index
//	double tx		: Text X coordinate
//	double ty		: Text Y coordinate
//	double tangle		: Text rotation angle
//	int mirrflag		: Text mirror flag
//	int layer		: Text layer code
//	double tsize		: Text size
//	string tstr		: Text string
//	int textinws		: Text in workspace flag
*/
{
	string attrcommn		/* Attribute comment name */;
	string attrcommv		/* Attribute comment value */;
	int attrord			/* Attribute order value */;
	int lock			/* Attribute lock flag */;
	string lstr			/* Lower case text string */;
	string str			/* Text string */;
	int i, j			/* Loop control variables */;
	// Check if predicate attribute string
	if (strextract(textp.STR,0,3)!="$?s:")
		return(0);
	// Get the predicate name
	str=strextract(textp.STR,4,strlen(textp.STR));
	strlower(lstr=str);
	// Check if internal predicate name
	if (lstr==RS_VARNAME || lstr==RS_PARTDRCEXC || lstr==RS_GROUPNAME)
		return(0);
	// Check if already defined
	for (i=0;i<attn;i++)
		if (attl[i].name==lstr)
			break;
	if (i>=attn) {
		// Get upper case attribute
		attrcommv=str;
		strupper(attrcommv);
		// Query the attribute lock state
		if (lay_rulequery(RS_OCPOOL,textp,RS_PCBSUBJ,RS_ATTADIS,
		 "?d",lock)<1)
			// Clear attribute locked flag
			lock=0;
		// Build order variable name
		sprintf(attrcommn,PAR_ATTRORDP,attrcommv);
		// Query order variable
		if (varget(attrcommn,attrord)!=0)
			// No order id available
			attrord=9999;
		for (i=attn;i>0;i--)
			if (attl[i-1].ord>attrord ||
			 (attl[i-1].ord==attrord && attl[i-1].name>str))
				attl[i]=attl[i-1];
			else
				break;
		// Store the attribute to the list
		attl[i].name=lstr;
		attl[i].ord=attrord;
		attl[i].lock=lock;
		attl[i].defvall[0]=PA_NILVAL;
		attl[i].defvaln=0;
		// Build comment variable name
		sprintf(attrcommn,PAR_ATTRCOMMP,attrcommv);
		// Query comment variable
		if (varget(attrcommn,attrcommv)!=0 || attrcommv=="")
			// No comment available
			attl[i].disp=str;
		else
			// Attach comment to variable name
			sprintf(attl[i].disp,"%s %s",str,attrcommv);
		attn++;
		}
	// Check if default value assigned
	if (attl[i].defvaln==0) {
		// Query the attribute default value
		if (lay_rulequery(RS_OCPOOL,textp,RS_PCBSUBJ,RS_INIVAL,
		 "?s",attl[i].defvall[0])<1) {
			// Clear default attribute value
			attl[i].defvall[0]=PA_NILVAL;
			attl[i].defvaln=0;
			}
		else {
			attl[i].defvaln=1;
			for (j=1;j<100;j++) {
				if (lay_rulequery(RS_OCPOOL,textp,RS_PCBSUBJ,
				 RS_INIVAL+itoa(j),"?s",attl[i].defvall[j])<1)
					break;
				attl[i].defvaln++;
				}
			}
		}
	// Return without errors
	return(0);
}

int aptextfunc(index L_TEXT textp,double tx,double ty,double tangle,
 int mirrflag,int layer,double tsize,string tstr,int textinws)
/*
// Scan a text data block for predicate attribute pick
// Return value :
//	zero if done or (-1) on error
// Parameters :
//	index L_TEXT textp	: Text index
//	double tx		: Text X coordinate
//	double ty		: Text Y coordinate
//	double tangle		: Text rotation angle
//	int mirrflag		: Text mirror flag
//	int layer		: Text layer code
//	double tsize		: Text size
//	string tstr		: Text string
//	int textinws		: Text in workspace flag
*/
{
	double flen			/* Text frame length */;
	double vx,vy			/* Text angle vector */;
	double ftx,fty			/* Text frame top vector */;
	double frx,fry			/* Text frame right vector */;
	double dist			/* Pick point distance */;
	string lstr			/* Lower case text string */;
	string str			/* Text string */;
	// Check if predicate attribute string
	if (strextract(textp.STR,0,3)!="$?s:")
		return(0);
	// Get the predicate name
	str=strextract(textp.STR,4,strlen(textp.STR));
	strlower(lstr=str);
	// Check if internal predicate name
	if (lstr==RS_VARNAME || lstr==RS_PARTDRCEXC || lstr==RS_GROUPNAME)
		return(0);
	// Get the text length
	flen=strlen(tstr);
	// Get the text angle vector
	vx=cos(tangle);
	vy=sin(tangle);
	// Get the frame coordinates
	frx=vx*tsize*FONTASP*flen;
	fry=vy*tsize*FONTASP*flen;
	ftx=(-vy*tsize);
	fty=vx*tsize;
	bae_clearpoints();
	bae_cleardistpoly();
	bae_storepoint(tx,ty,0);
	bae_storepoint(tx+frx,ty+fry,0);
	bae_storepoint(tx+frx+ftx,ty+fry+fty,0);
	bae_storepoint(tx+ftx,ty+fty,0);
	// Get the pick point distance
	if (bae_storedistpoly() || bae_querydist(ax,ay,dist))
		return(0);
	// Check if new min. distance
	if (dist<0.5*tsize && (aminname=="" || dist<amindist)) {
		dist=amindist;
		aminname=lstr;
		}
	// Return without errors
	return(0);
}

static void elementfunctions()
/*
// Edit element functions
*/
{
	index L_FIGURE fig		/* Figure list index */;
	string selmsg			/* Selection message string */;
	int seltyp			/* Selection element type */;
	string predname			/* Predicate name */;
	int lfctn			/* Last function count */;
	int cflag = 0			/* Change flag */;
	int i				/* Loop control variable */;
	if (ddbclass!=DDBCLLAY && ddbclass!=DDBCLLPRT && ddbclass!=DDBCLLSTK)
		error_class();
	// Select the element type
	bae_promptdialog(UPRSELETYP);
	switch (bae_askmenu(7,poly_dis+UPRSELE0,path_dis+UPRSELE1,
	 nref_dis+UPRSELE2,uref_dis+UPRSELE3,text_dis+UPRSELE4,
	 (ddbclass==DDBCLLAY ? "," : "")+UPRSELE6,UPRABORT)) {
		// Areas
		case 0 :
		seltyp=L_FIGPOLY;
		selmsg=UPRSELPOLY;
		break;
		// Traces
		case 1 :
		if (ddbclass==DDBCLLSTK)
			error_abort();
		seltyp=L_FIGPATH;
		selmsg=UPRSELPATH;
		break;
		// Named references
		case 2 :
		if (ddbclass==DDBCLLSTK)
			error_abort();
		seltyp=L_FIGNREF;
		selmsg=UPRSELNREF;
		break;
		case 3 :
		// Unnamed references
		seltyp=L_FIGUREF;
		selmsg=UPRSELUREF;
		break;
		// Texts
		case 4 :
		seltyp=L_FIGTEXT;
		selmsg=UPRSELTEXT;
		break;
		// Plan
		case 5 :
		if (ddbclass==DDBCLLAY)
			error_abort();
		seltyp=(-1);
		break;
		// Abort
		case 6 :
		default :
		error_abort();
		}
	// Check if plan rule
	if (seltyp<0) {
		// Get old functions
		for (cfctn=0;cfctn<MAXMENUITEM;cfctn++) {
			sprintf(predname,RS_FCTSEQ,cfctn);
			if (lay_rulequery(RS_OCPLAN,0,RS_PCBSUBJ,predname,
			 "?s",cfctl[cfctn].seq)<1 || cfctl[cfctn].seq=="")
				break;
			sprintf(predname,RS_FCTNAME,cfctn);
			if (lay_rulequery(RS_OCPLAN,0,RS_PCBSUBJ,predname,
			 "?s",cfctl[cfctn].menu)<1)
				cfctl[cfctn].menu="";
			}
		lfctn=cfctn;
		// Edit the functions
		editfunctions();
		// Save current state for undo
		bae_callmenu(MNU_BAESAVESTATE);
		// Set new functions
		for (i=0;i<cfctn;i++) {
			sprintf(predname,RS_FCTSEQ,i);
			rs_assplanstrpred(predname,cfctl[i].seq,"","");
			sprintf(predname,RS_FCTNAME,i);
			rs_assplanstrpred(predname,cfctl[i].menu,"","");
			}
		// Clear deleted function
		for (;i<lfctn;i++) {
			sprintf(predname,RS_FCTSEQ,i);
			rs_assplanstrpred(predname,"","","");
			sprintf(predname,RS_FCTNAME,i);
			rs_assplanstrpred(predname,"","","");
			}
		}
	else {
		// Loop while element picked
		bae_prtdialog(selmsg);
		while (ged_pickelem(fig,seltyp)==0) {
			for (cfctn=0;cfctn<MAXMENUITEM;cfctn++) {
				sprintf(predname,RS_FCTSEQ,cfctn);
				if (lay_rulequery(RS_OCFIG,fig,RS_PCBSUBJ,
				  predname,"?s",cfctl[cfctn].seq)<1 ||
				 cfctl[cfctn].seq=="")
					break;
				sprintf(predname,RS_FCTNAME,cfctn);
				if (lay_rulequery(RS_OCFIG,fig,RS_PCBSUBJ,
				 predname,"?s",cfctl[cfctn].menu)<1)
					cfctl[cfctn].menu="";
				}
			lfctn=cfctn;
			// Edit the functions
			editfunctions();
			// Save current state for undo
			if (cflag==0) {
				bae_callmenu(MNU_BAESAVESTATE);
				cflag=1;
				}
			// Set new functions
			for (i=0;i<cfctn;i++) {
				sprintf(predname,RS_FCTSEQ,i);
				rs_assfigstrpred(
				 fig,predname,cfctl[i].seq,"","");
				sprintf(predname,RS_FCTNAME,i);
				rs_assfigstrpred(
				 fig,predname,cfctl[i].menu,"","");
				}
			// Clear deleted function
			for (;i<lfctn;i++) {
				sprintf(predname,RS_FCTSEQ,i);
				rs_assfigstrpred(fig,predname,"","","");
				sprintf(predname,RS_FCTNAME,i);
				rs_assfigstrpred(fig,predname,"","","");
				}
			// Prompt for next element
			bae_prtdialog(selmsg);
			}
		}
}

void editfunctions()
/*
// Edit current function set
*/
{
	struct cfctdes swapmenu		/* Menu item swap buffer */;
	string msg			/* Message buffer */;
	double cy			/* Current y value */;
	double butx			/* Current button position */;
	double dialwidth		/* Dialog box width */;
	double dialheight		/* Dialog box height */;
	double baseheight		/* Dialog box base height */;
	int lbidx			/* List box item index */;
	int repflag	= 1		/* Repeat flag */;
	int res				/* Dialog box result buffer */;
	int from			/* From index */;
	int to				/* To index */;
	int i				/* Loop control variable */;
	// Check if dialog box support
	if (bae_dialclr())
		error(ERRNOWIN);
	// Perform the input loop
	do {
		baseheight=DIAL_TOPMARG+DIAL_SEPVSTEP+DIAL_BUTVSTEP;
		bae_dialclr();
		dial_getboxsizemin(3020,dialwidth,dialheight,
		 DIAL_LEFTMARG+SELBOXWIDTHFS+DIAL_RIGHTSMARG,baseheight+16.0,
		 DIAL_LEFTMARG+87.0,baseheight+1.0);
		cy=DIAL_TOPMARG;
		butx=DIAL_LEFTMARG+1.0;
		// Store function buttons
		// Edit menu item
		if (cfctn) {
			bae_dialaddcontrol(PA_ACT,0,0,0,0.0,0.0,0.0,
			 "",0,butx,cy,0.0,UPRDEDIT);
			butx+=BUTXSTEP+bae_dialgettextlen(0,UPRDEDIT);
			}
		// Add menu item
		if (cfctn<MAXMENUITEM) {
			bae_dialaddcontrol(PA_ACT,0,1,0,0.0,0.0,0.0,
			 "",0,butx,cy,0.0,UPRDADDF);
			butx+=BUTXSTEP+bae_dialgettextlen(0,UPRDADDF);
			bae_dialaddcontrol(PA_ACT,0,2,0,0.0,0.0,0.0,
			 "",0,butx,cy,0.0,UPRDADDM);
			butx+=BUTXSTEP+bae_dialgettextlen(0,UPRDADDM);
			bae_dialaddcontrol(PA_ACT,0,6,0,0.0,0.0,0.0,
			 "",0,butx,cy,0.0,UPRDADDU);
			butx+=BUTXSTEP+bae_dialgettextlen(0,UPRDADDU);
			}
		// Delete menu item
		if (cfctn) {
			bae_dialaddcontrol(PA_ACT,0,3,0,0.0,0.0,0.0,
			 "",0,butx,cy,0.0,UPRDDEL);
			butx+=BUTXSTEP+bae_dialgettextlen(0,UPRDDEL);
			bae_dialaddcontrol(PA_ACT,0,5,0,0.0,0.0,0.0,
			 "",0,butx,cy,0.0,UPRDDELA);
			butx+=BUTXSTEP+bae_dialgettextlen(0,UPRDDELA);
			}
		// Move menu item
		if (cfctn>1) {
			bae_dialaddcontrol(PA_ACT,0,4,0,0.0,0.0,0.0,
			 "",0,butx,cy,0.0,UPRDMOVE);
			butx+=BUTXSTEP+bae_dialgettextlen(0,UPRDMOVE);
			}
		// Store done button
		bae_dialaddcontrol(PA_ACT,0,(-1),0,0.0,0.0,0.0,"",0,
		 butx,cy,0.0,UPRDDONE);
		cy+=DIAL_BUTVSTEP;
		// Store list box
		lbidx=bae_dialadvcontrol(PA_LB|PA_OKSEL|PA_HBRDREL|PA_VBRDREL,
		 (-1),0,(-1),0.0,0.0,0.0,"",0,
		 DIAL_LEFTMARG,cy,DIAL_RIGHTSMARG,DIAL_SEPVSTEP,"");
		// Store list box entries
		for (i=0;i<cfctn;i++)
			bae_dialaddcontrol(PA_LBE,0,0,i,0.0,0.0,0.0,
			 "",0,0.0,0.0,0.0,cfctl[i].menu);
		cy+=dialheight-baseheight;
		// Call the dialog function
		bae_setintpar(16,3020);
		switch (bae_dialaskparams("!"+UPRDIALFFUNC,3,
		 dialwidth,cy+DIAL_SEPVSTEP)) {
			case 0 :
			// Edit menu item
			bae_dialgetdata(lbidx,i,0.0,"");
			if (i>=0 && i<cfctn)
				menuitemedit(i);
			break;
			// Add menu item menu function
			case 1 :
			if (bae_swconfig(3)==BAE_WinPulldwn ||
			 bae_swconfig(3)==BAE_MotifPdwn) {
				if (bae_getmenuitem(0,cfctl[cfctn].menu,
				 cfctl[cfctn].seq)!=0)
					error_abort();
				// Dismiss leading menu path
				for (i=strlen(cfctl[cfctn].menu)-4;i>=0;i--)
					if (cfctl[cfctn].menu[i]==' ' &&
					 cfctl[cfctn].menu[i+1]=='-' &&
					 cfctl[cfctn].menu[i+2]=='>' &&
					 cfctl[cfctn].menu[i+3]==' ') {
						cfctl[cfctn].menu=strextract(
						 cfctl[cfctn].menu,i+4,strlen(
						 cfctl[cfctn].menu));
						break;
						}
				for (i=strlen(cfctl[cfctn].seq)-1;i>=0;i--)
					if (cfctl[cfctn].seq[i]=='\'')
						cfctl[cfctn].seq[i]='"';
				}
			else {
				cfctl[cfctn].menu=cfctl[cfctn].seq="";
				}
			// Edit menu item data
			if (menuitemedit(cfctn)==0)
				cfctn++;
			break;
			// Add menu item macro
			case 2 :
			macn=0;
			sprintf(sqlcommand,MN_SELECT,IPTYP);
			if (sqlcmd(BAEMACRODB,sqlcommand,macselfunc)!=0)
				// SQL/DB error
				sql_dberror(0);
			if (macn==0) {
				bae_msgbox(1,ERRNOMACRO,"");
				break;
				}
			bae_setintpar(16,3069);
			if ((cfctl[cfctn].menu=popupmenu(1,UPRMACSEL,macl,0,
			  macl,macn,UINPOPABORT,0,1,1,macn+2,0,0,""))=="" ||
			 cfctl[cfctn].menu==UINPOPABORT)
				error_abort();
			cfctl[cfctn].seq=
			 UL_MACRO+":\""+cfctl[cfctn].menu+"\"";
			// Edit menu item data
			if (menuitemedit(cfctn)==0)
				cfctn++;
			break;
			// Delete menu item
			case 3 :
			bae_dialgetdata(lbidx,i,0.0,"");
			if (i>=0 && i<cfctn) {
				cfctn--;
				for (i++;i<cfctn;i++)
					cfctl[i]=cfctl[i+1];
				}
			break;
			// Move menu item
			case 4 :
			bae_dialgetdata(lbidx,from,0.0,"");
			if (from<0 || from>=cfctn) {
				bae_msgbox(2,ERRNOMOVITEM,"");
				break;
				}
			baseheight=DIAL_TOPMARG+DIAL_SEPVSTEP+DIAL_BUTVSTEP;
			do {
				bae_dialclr();
				dial_getboxsizemin(3020,dialwidth,dialheight,
				 DIAL_LEFTMARG+SELBOXWIDTHFS+DIAL_RIGHTSMARG,
				 baseheight+16.0,DIAL_LEFTMARG+87.0,
				 baseheight+1.0);
				cy=DIAL_TOPMARG;
				// Store the OK and abort button with seperator
				dial_okabort(cy);
				cy-=DIAL_SEPVSTEP;
				// Store list box
				lbidx=bae_dialadvcontrol(PA_LB|PA_OKSEL|
				 PA_HBRDREL|PA_HSCROLL|PA_VBRDREL,(-1),0,(-1),
				 0.0,0.0,0.0,"",0,DIAL_LEFTMARG,cy,
				 DIAL_RIGHTSMARG,DIAL_SEPVSTEP,"");
				// Store list box entries
				for (i=0;i<cfctn;i++)
					bae_dialaddcontrol(PA_LBE,0,0,i,0.0,0.0,
					 0.0,"",0,0.0,0.0,0.0,cfctl[i].menu);
				cy+=dialheight-baseheight+DIAL_SEPVSTEP;
				bae_setintpar(16,3020);
				sprintf(msg,UPRITEMMOVDST,cfctl[from].menu);
				res=bae_dialaskparams("!"+msg,0,dialwidth,cy);
				// Stop if no further repeat requests
				} while (res==(-2));
			if (res<0)
				break;
			// Perform the menu item swap
			bae_dialgetdata(lbidx,to,0.0,"");
			if (to<0)
				break;
			swapmenu=cfctl[from];
			if (from>to)
				for (i=from;i>to;i--)
					cfctl[i]=cfctl[i-1];
			else
				for (i=from;i<to;i++)
					cfctl[i]=cfctl[i+1];
			cfctl[to]=swapmenu;
			break;
			// Delete all menu items
			case 5 :
			cfctn=0;
			break;
			// Add menu item ULC program
			case 6 :
			// Query ULC program name
			if (bae_askddbename(cfctl[cfctn].seq,
			 strgetconffilename(ULDEFPRGVNAME,ULDEFPRGFNAME,1),
			 DDBCLUL,UPRULCPROG))
				// Aborted
				error_abort();
			cfctl[cfctn].menu="ULC "+cfctl[cfctn].seq;
			// Edit menu item data
			if (menuitemedit(cfctn)==0)
				cfctn++;
			break;
			// Resize :
			case (-2) :
			break;
			// Done/Abort
			default :
			repflag=0;
			}
		// Stop if no further repeat requests
		} while (repflag);
}

int menuitemedit(int fctidx)
/*
// Edit menu function data
// Return value :
//	0 if done or (-1) on abort
// Parameters :
//	int fctidx		: Function index
*/
{
	string msg			/* Message string */;
	double cy			/* Dialog box current y coordinate */;
	int fnidx			/* Function name parameter index */;
	int fpidx			/* Function prog. parameter index */;
	bae_dialclr();
	// Init. the y coordinate
	cy=DIAL_TOPMARG;
	dial_label(0.0,cy,UPRDFCTNAME);
	fnidx=dial_string(cfctl[fctidx].menu,200,CCOLOFFF,cy);
	dial_label(0.0,cy,UPRDFCTPROG);
	fpidx=dial_string(cfctl[fctidx].seq,200,CCOLOFFF,cy);
	// Store the OK and abort button with seperator
	dial_hsep(cy);
	dial_okabort(cy);
	// Call the dialog function
	sprintf(msg,UPRDIALFEDIT,fctidx+1);
	bae_setintpar(16,3021);
	switch (bae_dialaskparams(msg,0,DIAL_LEFTMARG+
	 CCOLOFFF+ED_WIDTHF+DIAL_RIGHTSMARG,cy)) {
		case 0 :
		bae_dialgetdata(fnidx,0,0.0,cfctl[fctidx].menu);
		bae_dialgetdata(fpidx,0,0.0,cfctl[fctidx].seq);
		break;
		// Fail/abort
		case (-1) :
		default :
		return(-1);
		}
	// Return without errors
	return(0);
}

static int macselfunc(string dstr,int dint,double ddbl,
 int dval,int dtype,string dtable,string dfield,int didx)
/*
// Macro selection callback function
// Return value :
//	zero if done or (-1) on data error
// Parameters :
//	string dstr		: String/Date data
//	int dint		: Integer/Boolean data
//	double ddbl		: Float data
//	int dval		: Data valid flag
//	int dtype		: Data type
//	string dtable		: Data table name
//	string dfield		: Data field name
//	int didx		: Data output field index
*/
{
	int i				/* Loop control variable */;
	// Store macro name sorted to list
	for (i=macn;i>0;i--)
		if (macl[i-1]>dstr)
			macl[i]=macl[i-1];
		else
			break;
	macl[i]=dstr;
	macn++;
	// Return without errors
	return(0);
}

static int getlaytyp(int layer)
/*
// Get layer type bit mask for given layer
// Return value :
//	Layer type bit mask
*/
{
	// Check for signal layers */
	if ((layer>=0 && layer<SIGLAYMAX) ||
	 layer==LAYERTOP || layer==LAYERALL || layer==LAYERBTW)
		return(SLAYBIT);
	// Check for power layer
	if (layer>=POWLAYBASE && layer<POWLAYBASE+POWLAYMAX)
		return(PLAYBIT);
	// Check for documentary layer
	if (layer>=DOCLAYBASE)
		return(DLAYBIT);
	// Check for board outline layer
	if (layer==LAYERBRD)
		return(OLAYBIT);
	// Unknown layer type
	return(0);
}

static void prtgrpcount(int changes,int selectmode)
/*
// Print group selection/deselection statistics
// Parameters :
//	int changes		: Change count
//	int selectmode		: Select mode
*/
{
	index L_FIGURE fig		/* Figure list index */;
	string msg			/* Message buffer */;
	int grpelemn	= 0		/* Group element count */;
	// Count group elements
	forall (fig where fig.GROUP)
		grpelemn++;
	if (selectmode)
		sprintf(msg,REPELEMSEL,changes,grpelemn);
	else
		sprintf(msg,REPELEMDSEL,changes,grpelemn);
	bae_prtdialog(msg);
}

// User Language program end