/* ATTRSET (SCM) -- SCM Symbol Attribute Assignment */
/* ATTRSET (SCM) -- SCM-Symbol Attributwertzuweisung */
/*
// Copyright (c) 2003-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 (091020) RELEASED FOR BAE V7.4.
//	rl (081014) RELEASED FOR BAE V7.2.
//	rl (080129) ENHANCEMENT:
//		Added alternate variant attribute value control scheme.
//	rl (071029) RELEASED FOR BAE V7.0.
//	rl (070705) BUGFIX:
//		Fixed problem with action buttons in active variant.
//	rl (070620) ENHANCEMENT:
//		Added logical definition eval. option for $rpname transfer.
//	rl (070515) ENHANCEMENT:
//		Added $rpname companion symbols attribute transfer option.
//	rl (061122) ENHANCEMENT:
//		Added project layout macros to $plname browse list.
//	rl (060926) RELEASED FOR BAE V6.8.
//	rl (060823) ENHANCEMENT:
//		Added attribute transfer to external browse program.
//	rl (060822) BUGFIX:
//		Fixed problem with browse buttons.
//	rl (060721) ENHANCEMENT:
//		Added page preselection for picked attribute on multipage
//		attribute lists.
//	rl (060516) ENHANCEMENT:
//		Added optional extern program call on attribute set.
//	rl (060505) ENHANCEMENT:
//		Added variant list attribute setting support.
//	rl (060109) ENHANCEMENT:
//		Added extern attribute browse program support.
//	rl (050916) RELEASED FOR BAE V6.6.
//	rl (040811) RELEASED FOR BAE V6.4.
//	rl (040706) ENHANCEMENT:
//		Added optional part macro display request to $plname browse.
//	rl (031001) ENHANCEMENT:
//		Added attribute lock support.
//	rl (030904) RELEASED FOR BAE V6.2.
//	rl (030210) BUGFIX:
//		Fixed problem with default value buttons.
//	rl (021209) RELEASED FOR BAE V6.0.
//	rl (021117) ENHANCEMENT:
//		Added attribute sorting option.
//	rl (020704) BUGFIX:
//		Fixed problem with non-attribute texts.
//	rl (020618) RELEASED FOR BAE V5.4.
//	rl (020306) ORIGINAL CODING.
//
// DESCRIPTION
//
// The attrset User Language program provides an advanced dialog
// box for assignment of attributes to mouse selectable symbols.
*/

// Includes
#include "pop.ulh"			// User Language popup utilities
#include "scm.ulh"			// User Language SCM utilities

// Disable undo state request
#pragma ULCALLERNOUNDO

// Messages
string UPRVALUES	= M("Attribute von '%s' ('%s') / '%s' :",
			    "Attributes of '%s' ('%s') / '%s' :");
string UPRVVALUES	= M("'%s' ('%s') / '%s' Attribut %s :",
			    "'%s' ('%s') / '%s' Attribute %s:");
string UPRVARIANT	= M("Variante","Variant");
string UPRSYMBOL	= M("Symbol selektieren!","Select Symbol!");
string UPRPLNAME	= M("!Gehaeusename ? ","!Package Name ?");
string UPRVIASTK	= M("!Viapadstack ? ","!Via Padstack Name ?");
string UPRNOVAL		= M("Kein Wert","No Value");
string UPRDEFAULT	= M("Default","Default");
string UPRBROWSE	= M("Browse","Browse");
string UPRPICK		= M("Pick","Pick");
string UPRVAR		= M("V","V");
string UPRLOCK		= M("&Sperren","&Lock");
string UPRBVAL		= M("Basiswert","Base Value");
string UPRALLRES	= M("Alle &ruecksetzen","&Reset All");
string UPRALLDEF	= M("&Alle Default","Default &All");
string UPRNEXTDIAL	= M("&Weitere","&Next");
string UPRPREVDIAL	= M("&Vorherige","&Previous");
string UPRLOGLIB	= M("Selektion $rlext","$rlext Selection");
string UPRDEFVAL	= M("Selektion %s","Selection %s");
string UPRSELRPSYM	= M("Quellsymbol fuer %s selektieren!",
			    "Select source symbol for %s!");
string REPLOGSCAN	= M("Scannen logische Definitionen...",
			    "Scanning logical library...");
string REPLOGLIB	= M("Logische Definitionen zu Symbol '%s':",
			    "Logical Library Entries for Symbol '%s':");
string REPDEFVAL	= M("Werte fuer Attribut %s:",
			    "Values for Attribute %s:");
string REPNILATT	= M("!nicht_gesetzt!","!not_set!");
string REPNILVATT	= M("!Wert_aus_Basisvariante!","!Base_variant_value!");
string REPNILVATTC2	= M(" !Wert_aus_Basisvariante!",
			    " !Base_variant_value!");
string REPPROJDEF	= M("(Projekt)","(Project)");
string REPACTVAR	= M(" (aktiv)"," (active)");
string REPATTRSET	= M("Wert zuweisen '%s'","Assign Values '%s'");
string ERRSETATT	= M("Fehler beim Eintragen des Attributes '%s'!",
			    "Error setting attribute '%s'!");
string ERRNOATT		= M("Bauteil '%s' ('%s') besitzt keine Attribute!",
			    "Part '%s' ('%s') has no selectable attributes!!");
string ERRSYMGLUED	= M("Symbol '%s' ist verankert!",
			    "Symbol '%s' is glued!");
string ERRNOMULP	= M("Symbol '%s' besitzt kein gesetztes %s-Attribut!",
			    "Symbol '%s' doesn't have a %s attribute set!");
string ERRNOPICK	= M_ERRNOPICK();

// INI file parameter name definitions
#define PAR_ATTRDCNT	"ATTRDCNT_SCM"	// Attribute max. dialog items count
#define PAR_ATTRCOMMP	"ATTR_%s_STD"	// Attribute comment pattern
#define PAR_ATTRORDP	"ATTR_ORD_%s_STD"	// Attribute order pattern
#define PAR_ATTRBRWP	"ATTR_BRW_%s_STD"	// Attribute browse program
#define PAR_ATTRSETP	"ATTR_SET_STD"	// Attribute set program
#define PAR_ATTRUPPER	"SATTRUPPER_SCM"// Attribute automatic upper case conv.
#define PAR_DISPPLNAME	"DISPPLNAME_SCM"// $plname part display flag
#define PAR_RPNAMEAUPD	"RPNAMEAUPD_SCM"// $rpname attr. transfer mode
#define PAR_VATTRMODE	"VATTRMODE_SCM"	// Variant attribute set mode
#define PAR_NOPLCPVIS	"NOPLCPVIS_SCM"	// $noplc/plot visibilty relationship

// SQL command definitions
#define V_SELECTA	"select from varinfo;"

// Attribute definitions
struct attrdes {			// Attribute descriptor
	string defvall[]		/* Attribute default value list */;
	int defvaln			/* Attribute default value count */;
	string val			/* Attribute value */;
	string varval			/* Attribute variant specific value */;
	string valbak			/* Attribute value backup */;
	string name			/* Attribute name */;
	string disp			/* Attribute display name */;
	string brwprog			/* Attribute browse program name */;
	int ord				/* Attribute order */;
	int noedit			/* Attribute edit disabled flag */;
	int lock			/* Attribute locked flag */;
	} attl[]			/* Attribute data list */;
int attn		= 0		/* Attribute count */;
STRINGS headl				/* Header string list */;
int headn		= 2		/* Header string count */;
struct vardesc {			// Variant descriptor
	int varnum			/* Variant number */;
	string varname			/* Variant name */;
	} varl[]			/* Variant list */;
int varn		= 0		/* Variant count */;
int act_var		= 0		/* Active variant */;
int act_flag		= 0		/* Active variant defined flag */;
int curvarnum				/* Current variant number */;
string rpold		= ""		/* Old requested part name */;
int rppick		= 0		/* $rpname picked flag */;
STRINGS rpsyml				/* Same $rpname symbol list */;
STRINGS rpmacl				/* Same $rpname symbol macro list */;
int rpsymn		= 0		/* Same $rpname symbol count */;
int rpaidx		= (-1)		/* $rpname attr. list idx. */;
string rpaname				/* $rpname/$rbname */;
string symmacro				/* Symbol macro name */;
int symtyp		= 0		/* Sym. type (0 std, 1 main, 2 sub) */;
int gatecnt		= 0		/* Current gate count */;
int attrsetflag		= 0		/* Attributes set flag */;
double ax, ay				/* Attribute pick search coord. */;
double amindist				/* Attribute pick min. distance */;
string aminname		= ""		/* Attribute pick min. name */;
string fname		= bae_planfname()	/* Project file name */;

// Globals
#define GV_BATTRNAME	"brw_attrname"	// Browse attribute name
#define GV_BATTRVAL	"brw_attrval"	// Browse attribute value
#define GV_BATTRSYM	"brw_attrsym"	// Browse attribute symbol name
#define GV_BATTRN	"brw_attrn"	// Browse attribute count
#define GV_BATTRNL	"brw_attrnl"	// Browse attribute name list
#define GV_BATTRVL	"brw_attrvl"	// Browse attribute value list
#define GV_SATTRNAME	"set_attrname"	// Set attribute name
#define GV_SATTRSYM	"set_attrsym"	// Set symbol name
#define GV_SOATTRN	"set_oattrn"	// Set original attribute count
#define GV_SOATTRNL	"set_oattrnl"	// Set original attribute name list
#define GV_SOATTRVL	"set_oattrvl"	// Set original attribute value list
#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 FONTASP		(2.0/3.0)	// Font aspect ratio
#define MOFF		(7)		// Menu list action code offset
int MAXMENUATTR = bae_iniintval(PAR_ATTRDCNT,12)
					/* Max. attribute menu list length */;
int ATTRUPPER = bae_iniintval(PAR_ATTRUPPER,0)
					/* Automatic attr. upper case conv. */;
int RPNAMEAUPD = bae_iniintval(PAR_RPNAMEAUPD,0)
					/* $rpname attr. transfer mode */;
int VATTRMODE = bae_iniintval(PAR_VATTRMODE,0)
					/* Variant attr. set mode */;
int NOPLCPVIS = bae_iniintval(PAR_NOPLCPVIS,3)
					/* $noplc/plot vis. relationship */;

// Main program
void main()
{
	index C_FIGURE fig		/* Figure list element */;
	index C_NREF nref		/* Named reference */;
	index C_NREF cnref		/* Compare named reference */;
	string msg			/* Message buffer */;
	double x, y			/* Mouse position */;
	double cy			/* Current y value */;
	double defoff = 0.0		/* Default button offset */;
	double voff = 0.0		/* Variant button offset */;
	int avidxl[]			/* Attribute value index list */;
	int abvidxl[]			/* Attribute base value index list */;
	string aevall[]			/* Attribute edit value list */;
	int lockidx	= (-1)		/* Lock toggle index */;
	int menuact			/* Menu action */;
	int plaidx	= (-1)		/* $plname attr. list idx. */;
	int vsaidx	= (-1)		/* $viastk attr. list idx. */;
	int rlaidx	= (-1)		/* $rlname attr. list idx. */;
	int rleidx	= (-1)		/* $rlext attr. list idx. */;
	int mlsidx	= 0		/* Menu attr. list start idx. */;
	int menuoff			/* Menu item offset */;
	int menuidx			/* Menu item index */;
	int attidx			/* Attribute index */;
	int an				/* Attribute value return count */;
	int defidx			/* Default value index */;
	int repflag	= 1		/* Repeat flag */;
	int lock	= 0		/* Lock attributes flag */;
	int lockflag	= 0		/* Locked attributes exists flag */;
	string attrname			/* Attribute name */;
	string attrvalue		/* Attribute value */;
	string varvalstr		/* Variant value string */;
	string actvalstr		/* Active variant value string */;
	string libname			/* Library name */;
	string layname			/* Layout part name */;
	string symname			/* Symbol name */;
	string ename			/* Element name */;
	string pname			/* Picked symbol name */;
	string rpname			/* $rpname value */;
	string oldname			/* Old name */;
	string logldef			/* Definition string */;
	string rlname			/* $rlname value */;
	int lastidx			/* Last changed attribute index */;
	int first	= 1		/* First changed attribute flag */;
	int gridlock			/* Grid lock flag */;
	int anglock			/* Angle lock flag */;
	int alen			/* Attribute value length */;
	int nlen1			/* Nil attribute value 1st length */;
	int nlen2			/* Nil attribute value 2nd length */;
	int setfocus			/* Dialog item focus flag */;
	int focus			/* Dialog item focus mode */;
	int i, j			/* Loop control variables */;
	// Abort if invalid plan class
	if (bae_planddbclass()!=DDBCLSCM)
		error_class();
	// Pick symbol
	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(UPRSYMBOL);
			else
				bae_storemouseiact(3,ax,ay,2,LMB);
			// Restore the old grid and angle lock
			bae_setgridlock(gridlock);
			bae_setanglelock(anglock);
			}
		if (scm_pickelem(fig,C_FIGSREF)!=0)
			error(ERRNOPICK);
		}
	else {
		bae_promptdialog(UPRSYMBOL);
		if (scm_pickelem(fig,C_FIGSREF)!=0)
			error(ERRNOPICK);
		bae_wsmouse(ax,ay,0);
		}
	symname=fig.NAME;
	if (fig.FIXED&2)
		errormsg(ERRSYMGLUED,symname);
	// Check for dialog support
	if (bae_dialclr()) {
		// Get the mouse position
		bae_wsmouse(x,y,0);
		// Assign value with internal function
		bae_clriactqueue();
		bae_storemouseiact(1,x,y,0,LMB);
		call(MNU_SCMASSVALUE);
		return;
		}
	// Query the current active variant
	if (cap_rulequery(RS_OCSCMDB,0,RS_SCMSUBJ,RS_VARIANT,"?d",act_var)<1)
		// Set default variant
		act_var=0;
	act_flag=0;
	// Select all variant table entries
	varn=0;
	sqlcmd(fname,V_SELECTA,datafunc);
	// Check if active variant defined
	if (!act_flag) {
		for (i=varn;i>0;i--)
			if (varl[i-1].varnum<act_var)
				break;
			else
				varl[i]=varl[i-1];
		// Insert variant data
		varl[i].varnum=act_var;
		varl[i].varname="";
		varn++;
		}
	// Check if base variant defined
	if (varl[0].varnum!=0) {
		for (i=varn;i>0;i--)
			varl[i]=varl[i-1];
		// Insert variant data
		varl[0].varnum=0;
		varl[0].varname="";
		varn++;
		}
	if (varn>1)
		voff=3.0;
	// Set nil attribute compare length values
	nlen1=strlen(REPNILVATT);
	nlen2=strlen(REPNILVATTC2);
	// Get symbol reference
	nref=fig.NREF;
	symmacro=rlname=nref.MACRO.NAME;
	// Init. attribute name list
	attn=0;
	// Scan the attributes
	if (cap_scanpool(
	 nref.MACRO,0.0,0.0,0.0,0,amacfunc,NULL,NULL,atextfunc))
		error_scan();
	// Check if attributes found
	if (attn==0) {
		sprintf(msg,ERRNOATT,symname,symmacro);
		error(msg);
		}
	// Scan the picked attribute
	if (cap_scanfelem(fig,0.0,0.0,0.0,1,amacfunc,NULL,NULL,aptextfunc))
		error_scan();
	if (aminname!="") {
		// Check if multipage attribute list
		if (attn>MAXMENUATTR)
			for (attidx=0;attidx<attn;attidx++)
				if (attl[attidx].name==aminname) {
					mlsidx=attidx;
					break;
					}
		setfocus=1;
		}
	else {
		setfocus=0;
		}
	// Get attribute values
	for (attidx=0;attidx<attn;attidx++) {
		attrname=attl[attidx].name;
		if (cap_getpartattrib(symname,attrname,attrvalue)==0)
			attl[attidx].val=attrvalue;
		else
			attl[attidx].val=PA_NILVAL;
		varvalstr=getvarvalue(symname,attrname,act_var);
		if (act_var && VATTRMODE) {
			if (varvalstr==PA_NILVAL) {
				attl[attidx].varval=attl[attidx].val;
				attl[attidx].noedit=1;
				}
			else {
				attl[attidx].varval=varvalstr;
				attl[attidx].noedit=0;
				}
			}
		else {
			attl[attidx].varval=varvalstr;
			attl[attidx].noedit=0;
			}
		attl[attidx].valbak=attl[attidx].varval;
		// Check if default value defined
		if (attl[attidx].defvaln!=0)
			defoff=9.0;
		// Check if locked attribute
		if ((attl[attidx].lock&1) ||
		 ((attl[attidx].lock&2) && act_var!=0)) {
			lock=lockflag=1;
			}
		// Check for special attributes
		if (attl[attidx].defvaln<2)
		    switch (attrname) {
			case "$plname" :
			plaidx=attidx;
			break;
			case "$viastk" :
			vsaidx=attidx;
			break;
			case "$rlname" :
			rlaidx=attidx;
			break;
			case "$rlext" :
			rleidx=attidx;
			break;
			case "$rpname" :
			case "$rbname" :
			rpaidx=attidx;
			rpaname=attrname;
			rpold= attrvalue==PA_NILVAL ? "" : attrvalue;
			oldname=rpold;
			strlower(oldname);
			if ((RPNAMEAUPD&0x03)!=0)
			    forall (cnref where cnref.MACRO.CLASS==DDBCLSSYM &&
			     (pname=cnref.NAME)!=symname)
				if (cap_getpartattrib(pname,rpaname,
				  rpname)==0) {
					strlower(rpname);
					if (rpname==oldname) {
						rpsyml[rpsymn]=pname;
						rpmacl[rpsymn]=cnref.MACRO.NAME;
						rpsymn++;
						}
					}
			break;
			}
		}
	// Get layout part name
	if (cap_getpartattrib(symname,"$",layname)!=0)
		layname=symname;
	// Get layout library name
	libname=strgetvarfilename(scm_defloglname());
	catext(libname,DDBEXT);
	defoff+=DIAL_LEFTMARG;
	do {
		bae_dialclr();
		cy=DIAL_TOPMARG;
		// Create the dialog box controls
		// Build the attribute table menu
		for (menuidx=0;menuidx<MAXMENUATTR &&
		 (menuidx+mlsidx)<attn;menuidx++) {
			// Get current attribute data
			attidx=menuidx+mlsidx;
			attrvalue=attl[attidx].val;
			if (setfocus && attl[attidx].name==aminname) {
				focus=PA_FOCUS;
				setfocus=0;
				}
			else {
				focus=0;
				}
			// Check if locked value list
			if ((attl[attidx].lock==1 ||
			 ((attl[attidx].lock&3)==3 && act_var==0)) &&
			 attl[attidx].defvaln>1) {
				// Search current entry index
				for (i=0;i<attl[attidx].defvaln;i++)
					if (attl[attidx].defvall[i]==
					 attrvalue)
						break;
				if (i>=attl[attidx].defvaln)
					defidx= act_var!=0 ?
					 attl[attidx].defvaln : 0 ;
				else
					defidx=i;
				// Store selection box
				avidxl[menuidx]=bae_dialaddcontrol(PA_SB|focus,
				 0,0,defidx,0.0,0.0,0.0,"",0,
				 DIAL_LEFTMARG+12.0+defoff+voff,cy,20.0,"");
				for (i=0;i<attl[attidx].defvaln;i++)
					dial_sbentry(
					 0,i,attl[attidx].defvall[i]);
				if (act_var!=0)
					dial_sbentry(
					 0,attl[attidx].defvaln,REPNILVATT);
				aevall[menuidx]="";
				}
			// Check if locked value
			else if (lock && ((attl[attidx].lock&1) ||
			 ((attl[attidx].lock&2) && act_var!=0))) {
				// Get variant specific value
				if (act_var) {
					actvalstr=attl[attidx].varval;
					if (actvalstr!=attrvalue)
						varvalstr=
						 (attrvalue==PA_NILVAL ? "" :
						  (attrvalue+" "))+REPNILVATT;
					else
						varvalstr=actvalstr;
					}
				else {
					varvalstr= attrvalue==PA_NILVAL ?
					 REPNILATT : attrvalue;
					}
				// Store value label
				dial_label(12.0+defoff+voff,cy,varvalstr);
				avidxl[menuidx]=(-1);
				}
			else {
				// Get variant specific value
				if (act_var) {
				    actvalstr=attl[attidx].varval;
				    if (VATTRMODE) {
					varvalstr=attl[attidx].noedit ?
					 attl[attidx].val : actvalstr ;
					}
				    else {
					if (actvalstr!=attrvalue)
						varvalstr=
						 (attrvalue==PA_NILVAL ? "" :
						  (attrvalue+" "))+REPNILVATT;
					else
						varvalstr=actvalstr;
					}
				    }
				else {
				    varvalstr=attrvalue;
				    }
				aevall[menuidx]=varvalstr;
				if (attl[attidx].noedit) {
					dial_label(12.0+defoff+voff,cy,
					 varvalstr==PA_NILVAL ? REPNILATT :
					 varvalstr);
					avidxl[menuidx]=(-1);
					}
				else {
					// Store edit field
					avidxl[menuidx]=bae_dialaddcontrol(
					 PA_STR|PA_NILSTR|focus,0,0,0,
					 0.0,0.0,0.0,varvalstr,MAXTEXTLEN+
					 ((act_var==0 || VATTRMODE) ?
					  0 : MAXKEYLEN),
					 DIAL_LEFTMARG+
					 12.0+defoff+voff,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<MAXMENUATTR &&
		 (menuidx+mlsidx)<attn;menuidx++) {
			attidx=menuidx+mlsidx;
			abvidxl[menuidx]=(-1);
			// Store attribute clear button
			if (!((attl[attidx].lock==1 ||
			  ((attl[attidx].lock&3)==3 && act_var==0)) &&
			  attl[attidx].defvaln>1) &&
			 !(lock && ((attl[attidx].lock&1) ||
			 ((attl[attidx].lock&2) && act_var!=0)))) {
				if (act_var==0 || VATTRMODE==0)
					bae_dialaddcontrol(PA_ACT,0,
					 menuidx+MOFF,0,0.0,0.0,0.0,"",0,
					 DIAL_LEFTMARG,cy,10.0,UPRNOVAL);
				else
					abvidxl[menuidx]=bae_dialaddcontrol(
					 PA_TOGGLE,0,menuidx+MOFF,
					 attl[attidx].noedit,0.0,0.0,
					 0.0,"",0,DIAL_LEFTMARG,cy,0.0,
					 UPRBVAL);
				// Store attribute default value button
				if (attl[attidx].defvaln!=0 &&
				 (act_var==0 || (attl[attidx].lock&2)==0))
					bae_dialaddcontrol(PA_ACT,0,
					 menuidx+MAXMENUATTR+MOFF,0,0.0,0.0,
					 0.0,"",0,DIAL_LEFTMARG+11.0,cy,8.0,
					 UPRDEFAULT);
				// Store attr. variant values button
				if (voff!=0.0 && (attl[attidx].lock&2)==0)
					bae_dialaddcontrol(PA_ACT,0,
					 menuidx+3*MAXMENUATTR+MOFF,0,0.0,0.0,
					 0.0,"",0,DIAL_LEFTMARG+11.0+defoff,cy,
					 2.5,UPRVAR);
				// Store attribute browse button
				if (attidx==plaidx || attidx==rlaidx ||
				 attidx==rleidx || attidx==vsaidx ||
				 attl[attidx].brwprog!="" ||
				 attl[attidx].defvaln>1)
					bae_dialaddcontrol(PA_ACT,0,
					 menuidx+2*MAXMENUATTR+MOFF,0,0.0,0.0,
					 0.0,"",0,DIAL_LEFTMARG+61.0+defoff+
					 voff,cy,0.0,UPRBROWSE);
				// Store $rpname/$rbname pick button
				else if (attidx==rpaidx) {
					bae_dialaddcontrol(PA_ACT,0,6,0,0.0,
					 0.0,0.0,"",0,DIAL_LEFTMARG+61.0+
					 defoff+voff,cy,0.0,UPRPICK);
					}
				}
			else {
				// Store attribute default value button
				if (attl[attidx].defvaln>1 &&
				 (act_var==0 || (attl[attidx].lock&2)==0))
					bae_dialaddcontrol(PA_ACT,0,menuidx+
					 MAXMENUATTR+MOFF,0,0.0,0.0,0.0,"",0,
					 DIAL_LEFTMARG+11.0,cy,8.0,UPRDEFAULT);
				// Store attr. variant values button
				if (voff!=0.0 && (attl[attidx].lock&2)==0)
					bae_dialaddcontrol(PA_ACT,0,
					 menuidx+3*MAXMENUATTR+MOFF,0,0.0,0.0,
					 0.0,"",0,DIAL_LEFTMARG+11.0+defoff,
					 cy,2.5,UPRVAR);
				// Store attribute browse button
				if (attl[attidx].brwprog!="")
					bae_dialaddcontrol(PA_ACT,0,
					 menuidx+2*MAXMENUATTR+MOFF,0,0.0,0.0,
					 0.0,"",0,DIAL_LEFTMARG+61.0+
					 defoff+voff,cy,0.0,UPRBROWSE);
				// Store $rpname/$rbname pick button
				else if (attidx==rpaidx && (RPNAMEAUPD&4)==0) {
					bae_dialaddcontrol(PA_ACT,0,6,0,0.0,
					 0.0,0.0,"",0,DIAL_LEFTMARG+61.0+
					 defoff+voff,cy,0.0,UPRPICK);
					}
				}
			// Store the attribute name control
			sprintf(msg,": %s",attl[attidx].disp);
			dial_label(32.0+defoff+voff,cy,msg);
			cy+=DIAL_BUTVSTEP;
			}
		cy+=DIAL_SEPVSTEP;
		// Store page flip buttons
		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+MAXMENUATTR)<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,UPRVALUES,symname,layname,symmacro);
		// Call the dialog function
		bae_setintpar(16,3002);
		switch ((menuact=bae_dialaskparams(msg,0,
		 DIAL_LEFTMARG+68.3+defoff+voff+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<MAXMENUATTR &&
			 (menuidx+mlsidx)<attn;menuidx++) {
			    attidx=menuidx+mlsidx;
			    if (avidxl[menuidx]!=(-1)) {
				bae_dialgetdata(avidxl[menuidx],
				 0,0.0,attrvalue);
				alen=strlen(aevall[menuidx]);
				if (strextract(aevall[menuidx],
				 alen-nlen1,alen)==REPNILVATT) {
					if (aevall[menuidx]==attrvalue) {
						attrvalue=PA_NILVAL;
						}
					else {
						alen=strlen(attrvalue);
						if (strextract(attrvalue,
						 alen-nlen2,alen)==REPNILVATTC2)
							attrvalue=strextract(
							 attrvalue,0,
							 alen-nlen2-1);
						else if (strextract(attrvalue,
						 alen-nlen1,alen)==REPNILVATT)
							attrvalue=strextract(
							 attrvalue,0,
							 alen-nlen1-1);
						}
					}
				attl[attidx].val=attl[attidx].varval=attrvalue;
				}
			    if (abvidxl[menuidx]!=(-1))
				bae_dialgetdata(abvidxl[menuidx],
				 attl[attidx].noedit,0.0,"");
			    }
			mlsidx-=MAXMENUATTR;
			if (mlsidx<0)
				mlsidx=0;
			break;
			// Next attribute list
			case 2 :
			// Fetch current attribute value fields
			for (menuidx=0;menuidx<MAXMENUATTR &&
			 (menuidx+mlsidx)<attn;menuidx++) {
			    attidx=menuidx+mlsidx;
			    if (avidxl[menuidx]!=(-1)) {
				bae_dialgetdata(avidxl[menuidx],
				 0,0.0,attrvalue);
				alen=strlen(aevall[menuidx]);
				if (strextract(aevall[menuidx],
				 alen-nlen1,alen)==REPNILVATT) {
					if (aevall[menuidx]==attrvalue) {
						attrvalue=PA_NILVAL;
						}
					else {
						alen=strlen(attrvalue);
						if (strextract(attrvalue,
						 alen-nlen2,alen)==REPNILVATTC2)
							attrvalue=strextract(
							 attrvalue,0,
							 alen-nlen2-1);
						else if (strextract(attrvalue,
						 alen-nlen1,alen)==REPNILVATT)
							attrvalue=strextract(
							 attrvalue,0,
							 alen-nlen1-1);
						}
					}
				attl[attidx].val=attl[attidx].varval=attrvalue;
				}
			    if (abvidxl[menuidx]!=(-1))
				bae_dialgetdata(abvidxl[menuidx],
				 attl[attidx].noedit,0.0,"");
			    }
			mlsidx+=MAXMENUATTR;
			break;
			// Reset all attributes
			case 3 :
			for (attidx=0;attidx<attn;attidx++)
				if (!(lock &&
				 ((attl[attidx].lock&1) ||
				 ((attl[attidx].lock&2) && act_var!=0)))) {
					if (act_var)
						attl[attidx].val=
						 getvarvalue(symname,
						  attl[attidx].name,0);
					    else
						attl[attidx].val=PA_NILVAL;
					attl[attidx].varval=PA_NILVAL;
					}
			break;
			// Default all attributes
			case 4 :
			for (attidx=0;attidx<attn;attidx++)
				if (act_var==0 ||
				 !(lock && attl[attidx].lock)) {
					attl[attidx].val=
					 attl[attidx].varval=
					 attl[attidx].defvall[0];
					}
			break;
			// Lock toggle
			case 5 :
			bae_dialgetdata(lockidx,lock,0.0,"");
			break;
			// Pick $rpname/$rbname
			case 6 :
			sprintf(msg,UPRSELRPSYM,rpaname);
			bae_prtdialog(msg);
			if (scm_pickelem(fig,C_FIGSREF))
				error(ERRNOPICK);
			pname=fig.NAME;
			rpname="";
			if (cap_getpartattrib(pname,rpaname,rpname)!=0 ||
			 rpname=="") {
				sprintf(msg,ERRNOMULP,pname,rpaname);
				error(msg);
				}
			if (attl[rpaidx].val!=rpname)
				rppick=1;
			// Check if picked symbol attribute transfer
			if ((RPNAMEAUPD&0x03)!=0) {
				// Get attribute values
				for (attidx=0;attidx<attn;attidx++) {
					if (cap_getpartattrib(pname,
					 attl[attidx].name,attrvalue)==0)
						attl[attidx].val=attrvalue;
					else
						attl[attidx].val=PA_NILVAL;
					attl[attidx].varval=attl[attidx].val;
					}
				}
			else {
				attl[rpaidx].val=attl[rpaidx].varval=rpname;
				}
			break;
			// Fail/abort
			case (-1) :
			error_abort();
			default :
			// Fetch current attribute value fields
			for (menuidx=0;menuidx<MAXMENUATTR &&
			 (menuidx+mlsidx)<attn;menuidx++) {
			    attidx=menuidx+mlsidx;
			    if (avidxl[menuidx]!=(-1)) {
				bae_dialgetdata(avidxl[menuidx],
				 0,0.0,attrvalue);
				alen=strlen(aevall[menuidx]);
				if (!VATTRMODE && strextract(aevall[menuidx],
				 alen-nlen1,alen)==REPNILVATT) {
					if (aevall[menuidx]==attrvalue) {
						attrvalue=PA_NILVAL;
						}
					else {
						alen=strlen(attrvalue);
						if (strextract(attrvalue,
						 alen-nlen2,alen)==REPNILVATTC2)
							attrvalue=strextract(
							 attrvalue,0,
							 alen-nlen2-1);
						else if (strextract(attrvalue,
						 alen-nlen1,alen)==REPNILVATT)
							attrvalue=strextract(
							 attrvalue,0,
							 alen-nlen1-1);
						}
					}
				attl[attidx].val=attl[attidx].varval=attrvalue;
				}
			    if (abvidxl[menuidx]!=(-1))
				bae_dialgetdata(abvidxl[menuidx],
				 attl[attidx].noedit,0.0,"");
			    }
			menuoff=menuact-MOFF;
			// Check if variant values button
			if (menuoff>=3*MAXMENUATTR) {
				attidx=menuoff-3*MAXMENUATTR+mlsidx;
				getvarvalues(symname,layname,symmacro,attidx);
				}
			// Check if browse button
			else if (menuoff>=2*MAXMENUATTR) {
			    attidx=menuoff-2*MAXMENUATTR+mlsidx;
			    if (attl[attidx].brwprog!="") {
				varset(GV_BATTRNAME,attl[attidx].name);
				varset(GV_BATTRVAL,attl[attidx].val);
				varset(GV_BATTRSYM,symname);
				varset(GV_BATTRN,attn);
				for (i=0;i<attn;i++) {
					varset(GV_BATTRNL+itoa(i),attl[i].name);
					varset(GV_BATTRVL+itoa(i),attl[i].val);
					}
				runulprog(attl[attidx].brwprog);
				vardelete(GV_BATTRNAME);
				vardelete(GV_BATTRVAL);
				vardelete(GV_BATTRSYM);
				if (varget(GV_BATTRN,an)==0) {
				    for (i=0;i<an;i++) {
					if (
					 varget(
					  GV_BATTRNL+itoa(i),attrname)==0 &&
					 varget(
					  GV_BATTRVL+itoa(i),attrvalue)==0)
					    for (j=0;j<attn;j++) {
						if (attl[j].name==attrname) {
						    if (act_var && VATTRMODE) {
							if (attrvalue==
							 PA_NILVAL) {
							    attl[j].val=
							     getvarvalue(
							      symname,attl[
							       attidx].name,0);
							    attl[j].varval=
							      attrvalue;
							    attl[j].noedit=1;
							    }
							else {
							    attl[j].varval=
							     attl[j].val=
							     attrvalue;
							    attl[j].noedit=0;
							    }
							}
						    else {
							attl[j].varval=
							 attl[j].val=attrvalue;
							}
						    break;
						    }
						}
					vardelete(GV_BATTRNL+itoa(i));
					vardelete(GV_BATTRVL+itoa(i));
					}
				    vardelete(GV_BATTRN);
				    }
				break;
				}
			    if ((attrvalue=attl[attidx].val)==PA_NILVAL)
				attrvalue="";
			    switch (attidx) {
				// $plname browse button
				case plaidx :
				if (ATTRUPPER)
					strlower(attrvalue);
				bae_nameclr();
				ename="";
				while (scanddbenames(
				 libname,DDBCLLPRT,ename)==1)
					ddbnameadd(libname,ename,DDBCLLPRT,2);
				ename="";
				while (scanddbenames(fname,DDBCLLPRT,ename)==1)
					bae_nameadd(ename,"","",REPPROJDEF,2);
				bae_setintpar(16,3129);
				if (bae_askname(attrvalue,UPRPLNAME,MAXKEYLEN))
					break;
				// Check if display request enabled
				if (bae_swconfig(0)==BAE_HighEnd &&
				 bae_iniintval(PAR_DISPPLNAME,0)) {
					// Build the load part macro
					// request message
					sprintf(msg,"%d %s\"%s",MSGID_LLPRTMAC,
					 libname,attrvalue);
					// Send the message
					bae_sendmsg(msg,0);
					}
				if (ATTRUPPER)
					strupper(attrvalue);
				attl[plaidx].val=attl[plaidx].varval=attrvalue;
				break;
				// $viastk browse button
				case vsaidx :
				if (ATTRUPPER)
					strlower(attrvalue);
				bae_nameclr();
				ename="";
				while (scanddbenames(
				 libname,DDBCLLSTK,ename)==1)
					ddbnameadd(libname,ename,DDBCLLSTK,2);
				ename="";
				while (scanddbenames(fname,DDBCLLSTK,ename)==1)
					bae_nameadd(ename,"","",REPPROJDEF,2);
				bae_setintpar(16,3130);
				if (bae_askname(attrvalue,UPRVIASTK,MAXKEYLEN))
					break;
				if (ATTRUPPER)
					strupper(attrvalue);
				attl[vsaidx].val=attl[vsaidx].varval=attrvalue;
				break;
				// $rlname browse button
				case rlaidx :
				if (ATTRUPPER)
					strlower(attrvalue);
				if (bae_askddbename(
				 attrvalue,libname,DDBCLLLIB,"")!=0)
					break;
				if (ATTRUPPER)
					strupper(attrvalue);
				attl[rlaidx].val=attl[rlaidx].varval=attrvalue;
				break;
				// $rlext browse button
				case rleidx :
				if (ATTRUPPER)
					strlower(attrvalue);
				if (askrlext(attrvalue,symmacro,libname)!=0)
					break;
				if (ATTRUPPER)
					strupper(attrvalue);
				attl[rleidx].val=attl[rleidx].varval=attrvalue;
				break;
				// Default value list browse
				default :
				// Build the list header
				sprintf(msg,REPDEFVAL,attl[attidx].disp);
				bae_nameclr();
				for (i=0;i<attl[attidx].defvaln;i++)
					bae_nameadd(
					 attl[attidx].defvall[i],"","","",0);
				bae_setintpar(16,3131);
				if (bae_askname(attrvalue,msg,MAXKEYLEN))
					break;
				attl[attidx].val=attl[attidx].varval=attrvalue;
				}
			    }
			else if (menuoff>=MAXMENUATTR) {
			    attidx=menuoff-MAXMENUATTR+mlsidx;
			    // Set default attribute value
			    attl[attidx].val=attl[attidx].varval=
			     attl[attidx].defvall[0];
			    }
			else {
			    attidx=menuoff+mlsidx;
			    if (act_var!=0 && VATTRMODE) {
				// Edit state toggled
				attl[attidx].val=
				 getvarvalue(symname,attl[attidx].name,0);
				attl[attidx].varval= attl[attidx].noedit ?
				 PA_NILVAL : attl[attidx].val;
				}
			    else {
				 // Reset attribute value
				if (act_var)
					attl[attidx].val=getvarvalue(symname,
					 attl[attidx].name,0);
				else
					attl[attidx].val=PA_NILVAL;
				attl[attidx].varval=PA_NILVAL;
				}
			    }
			}
	    }
	 // Stop if no further repeat requests
	 while (repflag);
	// Fetch current attribute value fields
	for (menuidx=0;menuidx<MAXMENUATTR && (menuidx+mlsidx)<attn;menuidx++) {
		attidx=menuidx+mlsidx;
		if (avidxl[menuidx]!=(-1)) {
			if (act_var!=0 && VATTRMODE)
				bae_dialgetdata(abvidxl[menuidx],
				 attl[menuidx+mlsidx].noedit,0.0,"");
			bae_dialgetdata(
			 avidxl[menuidx],0,0.0,attrvalue);
			alen=strlen(aevall[menuidx]);
			if (act_var && VATTRMODE) {
				if (attl[attidx].noedit)
					attrvalue=PA_NILVAL;
				}
			else if (strextract(
			  aevall[menuidx],alen-nlen1,alen)==REPNILVATT) {
				if (aevall[menuidx]==attrvalue) {
					attrvalue=PA_NILVAL;
					}
				else {
					alen=strlen(attrvalue);
					if (strextract(attrvalue,
					 alen-nlen2,alen)==REPNILVATTC2)
						attrvalue=strextract(
						 attrvalue,0,alen-nlen2-1);
					else if (strextract(attrvalue,
					 alen-nlen1,alen)==REPNILVATT)
						attrvalue=strextract(
						 attrvalue,0,alen-nlen1-1);
					}
				}
			attl[attidx].val=attrvalue;
			}
		else {
			attl[attidx].val=attl[attidx].varval;
			}
		if (abvidxl[menuidx]!=(-1)) {
			bae_dialgetdata(abvidxl[menuidx],
			 attl[attidx].noedit,0.0,"");
			if (attl[attidx].noedit) {
				attl[attidx].val=attl[attidx].varval=PA_NILVAL;
				}
			}
		}
	if (!attrsetflag) {
		// Save current state for undo
		bae_callmenu(MNU_BAESAVESTATE);
		attrsetflag=1;
		}
	// Search last changed attribute
	for (attidx=0;attidx<attn;attidx++)
		if (attl[attidx].val!=attl[attidx].valbak)
			lastidx=attidx;
	// Set changed attributes
	for (attidx=0;attidx<attn;attidx++) {
		attrvalue=attl[attidx].val;
		attrname=attl[attidx].name;
		if (attrvalue!=attl[attidx].valbak) {
			if (scm_setpartattrib(symname,attrname,attrvalue,
			 (first ? 1 : 0)|(lastidx==attidx ? 2 : 0)))
				errormsg(ERRSETATT,attrname);
			if (attrname==rpaname)
				scm_setpartattrib(symname,"$",attrvalue,
				 lastidx==attidx ? 7 : 4);
			if ((NOPLCPVIS&2)==2 && attrname=="$noplc") {
			    if (act_var==0) {
				for (i=0;i<varn;i++)
				    if (varl[i].varnum==act_var) {
					setpvis(symname,attrvalue,act_var);
					}
				    else {
					if (getvarvalue(symname,"$noplc",
					 varl[i].varnum)==PA_NILVAL)
						setpvis(symname,attrvalue,
						 varl[i].varnum);
					}
				}
			    else {
				setpvis(symname,attrvalue,act_var);
				}
			    }
			first=0;
			}
		if (attrname=="$rlname" &&
		 attrvalue!=PA_NILVAL && attrvalue!="")
			rlname=attrvalue;
		}
	// Check if $rpname/$rbname symbol values transfer
	if (rpaidx>=0 && (RPNAMEAUPD&0x03)!=0) {
		// Get symbol type
		if ((RPNAMEAUPD&0x08)!=0)
			if (con_getlogpart(bae_planfname(),
			  rlname,80,logldef)==0 ||
			 con_getlogpart(libname,rlname,80,logldef)==0)
				// Parse definition
				synparsestring(logldef);
		// Get new requested part name
		attrvalue=attl[rpaidx].val;
		// Check if picked name
		if (rppick) {
			// Rescan companion symbols
			rpsymn=0;
			oldname=attrvalue;
			strlower(oldname);
			forall (cnref where cnref.MACRO.CLASS==DDBCLSSYM &&
			 (pname=cnref.NAME)!=symname)
			    if (cap_getpartattrib(pname,rpaname,rpname)==0) {
				strlower(rpname);
				if (rpname==oldname) {
					rpsyml[rpsymn]=pname;
					rpmacl[rpsymn]=cnref.MACRO.NAME;
					rpsymn++;
					}
				}
			}
		// Check if attribute transfer to companion symbols
		if ((RPNAMEAUPD&0x03)==2 || rpold==attl[rpaidx].val || rppick) {
		    // Scan attributes
		    for (attidx=0;attidx<attn;attidx++) {
			attrname=attl[attidx].name;
			attrvalue=attl[attidx].val;
			if (attrname=="$rlname" && (RPNAMEAUPD&0x08)!=0) {
				// Strip macro name for subparts
				if (symtyp==2) {
					for (i=0;attrvalue[i]!='\0';i++)
						if (attrvalue[i]=='_')
							break;
					attrvalue=strextract(attrvalue,0,i-1);
					}
				// Transfer attr. to companion symbols
				for (i=0;i<rpsymn;i++) {
					if (cap_getpartattrib(rpsyml[i],
					 "$rlname",rlname)!=0)
						rlname=rpmacl[i];
					if (con_getlogpart(bae_planfname(),
					  rlname,80,logldef)==0 ||
					 con_getlogpart(libname,
					  rlname,80,logldef)==0)
						// Parse definition
						synparsestring(logldef);
					// Set attribute
					scm_setpartattrib(rpsyml[i],"$rlname",
					 attrvalue+((symtyp==2 &&
					  attrvalue!=PA_NILVAL) ?
					  ("_"+rpmacl[i]) : ""),3);
					}
				continue;
				}
			// Transfer attributes to companion symbols
			for (i=0;i<rpsymn;i++) {
				// Check if gate specific attribute
				if (attrname=="$gp" ||
				 (attrname=="$rlname" && rpmacl[i]!=symmacro))
					continue;
				// Check if base variant attribute
				if (attrname==rpaname && act_var)
					continue;
				// Set attribute
				scm_setpartattrib(
				 rpsyml[i],attrname,attrvalue,3);
				if (attrname==rpaname)
					scm_setpartattrib(rpsyml[i],
					 "$",attrvalue,7);
				if ((NOPLCPVIS&2)==2 && attrname=="$noplc")
				    if (act_var==0) {
					for (j=0;j<varn;j++)
					    if (varl[j].varnum==act_var) {
						setpvis(
						 rpsyml[i],attrvalue,act_var);
						}
					    else {
						if (getvarvalue(
						 rpsyml[i],"$noplc",
						 varl[j].varnum)==PA_NILVAL)
							setpvis(rpsyml[i],
							 attrvalue,
							 varl[j].varnum);
						}
					}
				    else {
					setpvis(rpsyml[i],attrvalue,act_var);
					}
				}
			}
		    }
		}
	// Store undo item text
	sprintf(msg,REPATTRSET,symname);
	bae_setstrpar(7,msg);
	// Check if extra program call needed
	if ((attrname=bae_inistrval(PAR_ATTRSETP,""))!="") {
		varset(GV_SATTRSYM,symname);
		varset(GV_SOATTRN,attn);
		for (i=0;i<attn;i++) {
			varset(GV_SOATTRNL+itoa(i),attl[i].name);
			varset(GV_SOATTRVL+itoa(i),attl[i].valbak);
			}
		runulprog(attrname);
		vardelete(GV_SATTRSYM);
		for (i=0;i<attn;i++) {
			vardelete(GV_SOATTRNL+itoa(i));
			vardelete(GV_SOATTRVL+itoa(i));
			}
		vardelete(GV_SOATTRN);
		}
}

void setpvis(string symname,string attrval,int varnum)
/*
// Set symbol plot visibility
// Parameters :
//	string symname		: Symbol name
//	string attrval		: $noplc attribute value
//	int varnum		: Variant number
*/
{
	index C_FIGURE fig		/* Figure list element */;
	string rulel[]			/* Rule list */;
	int rulen			/* Rule count */;
	string rulename			/* Rule name */;
	int plotdis			/* Plot disable flag */;
	int i, j			/* Loop control variables */;
	if (cap_nrefsearch(symname,fig))
		return;
	// Get the plot visibility state
	plotdis= (attrval==PA_NILVAL || attrval=="") ? 0 : 1 ;
	// Build the plot disable rule name
	sprintf(rulename,":%s:%s%d=1;",RS_SCMSUBJ,RS_VARPLOTDIS,varnum);
	// Get the rule count
	rulen=rsc_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]="";
			}
	// Add the new rule
	if (plotdis)
		rulel[rulen++]=rulename;
	// Attach/detach the rule list
	if (rulen) {
		if (cap_rulefigatt(fig,rulel))
			rsc_error(-1);
		}
	else if (cap_getrulecnt(RS_OCFIG,fig)>0) {
		if (cap_rulefigdet(fig))
			rsc_error(-1);
		}
}

void getvarvalues(string symname,string layname,string symmacro,int attidx)
/*
// Get variant attribute values
// Parameters :
//	string symname		: Symbol name
//	string layname		: Layout part name
//	string symmacro		: Symbol macro name
//	int attidx		: Attribute index
*/
{
	index C_FIGURE fig		/* Figure list element */;
	index C_NREF nref		/* Named reference */;
	index C_ATTRIBUTE attr		/* Attribute index */;
	string vvall[]			/* Variant value list */;
	string ovall[]			/* Old variant value list */;
	string attrname			/* Attribute name */;
	string scanattr			/* Scan attribute name */;
	string attrvalue		/* Attribute value */;
	int varnum			/* Variant number */;
	int len				/* Attribute name length */;
	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 an				/* Attribute value return count */;
	int defidx			/* Default value index */;
	int repflag	= 1		/* Repeat flag */;
	int lock	= 0		/* Lock attributes flag */;
	int lockflag	= 0		/* Locked attributes exists flag */;
	int vidx			/* Variant index */;
	int alen			/* Attribute value length */;
	int nlen1			/* Nil attribute value 1st length */;
	int nlen2			/* Nil attribute value 2nd length */;
	int i, j			/* Loop control variables */;
	if (cap_nrefsearch(symname,fig))
		return;
	nref=fig.NREF;
	// Set nil attribute compare length values
	nlen1=strlen(REPNILVATT);
	nlen2=strlen(REPNILVATTC2);
	// Get attribute name length
	attrname=attl[attidx].name;
	len=strlen(attrname);
	vvall[0]=PA_NILVAL;
	for (i=1;i<varn;i++)
		vvall[i]=REPNILVATT;
	// Check if locked attribute
	if (attl[attidx].lock) {
		lock=lockflag=1;
		}
	// Scan attribute values
	forall (attr of nref) {
		scanattr=attr.NAME;
		// Check if attribute found
		if (attrname==scanattr)
			varnum=0;
		else if (attrname==strextract(scanattr,0,len-1) &&
		 scanattr[len]=='\003')
			varnum=
			 atoi(strextract(scanattr,len+1,strlen(scanattr)-2));
		else
			continue;
		for (i=0;i<varn;i++)
			if (varl[i].varnum==varnum) {
				vvall[i]=attr.VALUE;
				break;
				}
		}
	if (attl[attidx].defvaln!=0)
		defoff=9.0;
	if (act_var) {
		vvall[act_var]=
		 attl[attidx].val==getvarvalue(symname,attrname,0) ?
		  REPNILVATT : attl[attidx].val;
		}
	else {
		vvall[act_var]=attl[attidx].val;
		}
	defoff+=DIAL_LEFTMARG;
	ovall=vvall;
	do {
		bae_dialclr();
		cy=DIAL_TOPMARG;
		// Create the dialog box controls
		// Build the attribute table menu
		for (menuidx=0;menuidx<MAXMENUATTR &&
		 (menuidx+mlsidx)<varn;menuidx++) {
			vidx=menuidx+mlsidx;
			attrvalue=vvall[vidx];
			if ((attl[attidx].lock==1 ||
			 ((attl[attidx].lock&3)==2 && vidx==0)) &&
			 attl[attidx].defvaln>1) {
				// Search current entry index
				for (i=0;i<attl[attidx].defvaln;i++)
					if (attl[attidx].defvall[i]==
					 attrvalue)
						break;
				if (i>=attl[attidx].defvaln)
					defidx= vidx!=0 ?
					 attl[attidx].defvaln : 0 ;
				else
					defidx=i;
				// 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]);
				if (vidx!=0)
					dial_sbentry(
					 0,attl[attidx].defvaln,REPNILVATT);
				}
			else if (lock && ((attl[attidx].lock&1) ||
			 ((attl[attidx].lock&2) && vidx!=0))) {
				// Store value label
				dial_label(12.0+defoff,cy,
				 attrvalue==PA_NILVAL ?
				 (vidx==0 ? REPNILATT : REPNILVATT) :
				 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<MAXMENUATTR &&
		 (menuidx+mlsidx)<varn;menuidx++) {
			vidx=menuidx+mlsidx;
			// Store attribute clear button
			if (!((attl[attidx].lock==1 ||
			  ((attl[attidx].lock&3)==2 && vidx==0)) &&
			  attl[attidx].defvaln>1) &&
			 !(lock && ((attl[attidx].lock&1) ||
			 ((attl[attidx].lock&2) && vidx!=0)))) {
				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+MAXMENUATTR+6,0,0.0,0.0,0.0,
					 "",0,DIAL_LEFTMARG+11.0,cy,8.0,
					 UPRDEFAULT);
				// Store attribute browse button
				if (attl[attidx].brwprog!="" ||
				 attl[attidx].defvaln>1)
					bae_dialaddcontrol(PA_ACT,0,
					 menuidx+2*MAXMENUATTR+6,0,0.0,0.0,0.0,
					 "",0,DIAL_LEFTMARG+61.0+defoff,
					 cy,0.0,UPRBROWSE);
				}
			else {
				if (attl[attidx].defvaln>1)
					// Store attribute default value button
					bae_dialaddcontrol(PA_ACT,0,menuidx+
					 MAXMENUATTR+6,0,0.0,0.0,0.0,"",0,
					 DIAL_LEFTMARG+11.0,cy,8.0,UPRDEFAULT);
				// Store attribute browse button
				if (attl[attidx].brwprog!="")
					bae_dialaddcontrol(PA_ACT,0,
					 menuidx+2*MAXMENUATTR+6,0,0.0,0.0,0.0,
					 "",0,DIAL_LEFTMARG+61.0+defoff,
					 cy,0.0,UPRBROWSE);
				}
			// Store the attribute name control
			if (varl[vidx].varname=="")
				sprintf(msg,": %s %d",UPRVARIANT,
				 varl[vidx].varnum);
			else
				sprintf(msg,": %s",varl[vidx].varname);
			if (act_var==vidx)
				msg+=REPACTVAR;
			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+MAXMENUATTR)<varn)
			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,UPRVVALUES,
		 symname,layname,symmacro,attl[attidx].disp);
		// Call the dialog function
		bae_setintpar(16,3003);
		switch ((menuact=bae_dialaskparams(msg,0,
		 DIAL_LEFTMARG+68.3+defoff+DIAL_RIGHTSMARG,cy+1.6))) {
			// Done
			case 0 :
			repflag=0;
			break;
			// Previous variant list
			case 1 :
			// Fetch current variant value fields
			for (menuidx=0;menuidx<MAXMENUATTR &&
			 (menuidx+mlsidx)<varn;menuidx++)
				if (avidxl[menuidx]!=(-1))
					bae_dialgetdata(avidxl[menuidx],
					 0,0.0,vvall[menuidx+mlsidx]);
			mlsidx-=MAXMENUATTR;
			break;
			// Next variant list
			case 2 :
			// Fetch current variant value fields
			for (menuidx=0;menuidx<MAXMENUATTR &&
			 (menuidx+mlsidx)<varn;menuidx++)
				if (avidxl[menuidx]!=(-1))
					bae_dialgetdata(avidxl[menuidx],
					 0,0.0,vvall[menuidx+mlsidx]);
			mlsidx+=MAXMENUATTR;
			break;
			// Reset all attributes
			case 3 :
			for (vidx=0;vidx<varn;vidx++)
				if (!(lock &&
				 ((attl[attidx].lock&1) ||
				 ((attl[attidx].lock&2) && vidx!=0))))
					vvall[vidx]=
					 vidx==0 ? PA_NILVAL : REPNILVATT;
			break;
			// Default all attributes
			case 4 :
			for (vidx=0;vidx<varn;vidx++)
				if (vidx==0 || !(lock && attl[attidx].lock))
					vvall[vidx]=
					 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<MAXMENUATTR &&
			 (menuidx+mlsidx)<varn;menuidx++)
				if (avidxl[menuidx]!=(-1))
					bae_dialgetdata(avidxl[menuidx],
					 0,0.0,vvall[menuidx+mlsidx]);
			menuoff=menuact-6;
			// Check if browse button
			if (menuoff>=2*MAXMENUATTR) {
			    vidx=menuoff-2*MAXMENUATTR+mlsidx;
			    if (attl[attidx].brwprog!="") {
				varset(GV_BATTRNAME,attl[attidx].name);
				varset(GV_BATTRVAL,vvall[vidx]);
				varset(GV_BATTRSYM,symname);
				runulprog(attl[attidx].brwprog);
				vardelete(GV_BATTRNAME);
				vardelete(GV_BATTRVAL);
				vardelete(GV_BATTRSYM);
				if (varget(GV_BATTRN,an)==0) {
				    for (i=0;i<an;i++) {
					if (
					 varget(
					  GV_BATTRNL+itoa(i),attrname)==0 &&
					 varget(
					  GV_BATTRVL+itoa(i),attrvalue)==0 &&
					  attrname==attl[attidx].name)
						vvall[vidx]=attrvalue;
					vardelete(GV_BATTRNL+itoa(i));
					vardelete(GV_BATTRVL+itoa(i));
					}
				    vardelete(GV_BATTRN);
				    }
				break;
				}
			    if ((attrvalue=vvall[vidx])==PA_NILVAL)
				attrvalue="";
			    // Default value list browse
			    sprintf(msg,REPDEFVAL,attl[attidx].disp);
			    bae_nameclr();
			    for (i=0;i<attl[attidx].defvaln;i++)
				bae_nameadd(attl[attidx].defvall[i],"","","",0);
			    bae_setintpar(16,3131);
			    if (bae_askname(attrvalue,msg,MAXKEYLEN))
				break;
			    vvall[vidx]=attrvalue;
			    }
			else if (menuoff>=MAXMENUATTR) {
			    vidx=menuoff-MAXMENUATTR+mlsidx;
			    // Set default attribute value
			    vvall[vidx]=attl[attidx].defvall[0];
			    }
			else {
			    // Reset attribute value
			    vvall[menuoff+mlsidx]=
			     (menuoff+mlsidx)==0 ? PA_NILVAL : REPNILVATT;
			    }
			}
	    }
	 // Stop if no further repeat requests
	 while (repflag);
	// Fetch current variant value fields
	for (menuidx=0;menuidx<MAXMENUATTR && (menuidx+mlsidx)<varn;menuidx++)
		if (avidxl[menuidx]!=(-1))
			bae_dialgetdata(avidxl[menuidx],
			 0,0.0,vvall[menuidx+mlsidx]);
	if (!attrsetflag) {
		// Save current state for undo
		bae_callmenu(MNU_BAESAVESTATE);
		attrsetflag=1;
		}
	for (i=0;i<varn;i++) {
		if (ovall[i]==vvall[i] &&
		 (i==0 || attl[attidx].name!="$noplc" || ovall[i]!=PA_NILVAL))
			continue;
		attrname=varattrname(attl[attidx].name,varl[i].varnum);
		alen=strlen(vvall[i]);
		if (vvall[i]==REPNILVATT)
			attrvalue=PA_NILVAL;
		else if (strextract(vvall[i],alen-nlen2,alen)==REPNILVATTC2)
			attrvalue=strextract(vvall[i],0,alen-nlen2-1);
		else if (strextract(vvall[i],alen-nlen1,alen)==REPNILVATT)
			attrvalue=strextract(vvall[i],0,alen-nlen1-1);
		else
			attrvalue=vvall[i];
		if (varl[i].varnum==act_var) {
			if (attrvalue==PA_NILVAL && act_var)
				attl[attidx].val=vvall[0];
			else
				attl[attidx].val=attrvalue;
			attl[attidx].varval=attrvalue;
			}
		if (scm_setpartattrib(symname,attrname,
		 attrvalue,4|(varl[i].varnum==act_var ? 3 : 0)))
			errormsg(ERRSETATT,attrname);
		if (i==0 && attrname==rpaname)
			scm_setpartattrib(symname,"$",attrvalue,7);
		if ((NOPLCPVIS&2)==2 && attl[attidx].name=="$noplc")
			setpvis(symname,attrvalue,i);
		}
	if (rpaidx>=0 && (RPNAMEAUPD&0x03)!=0)
	    for (i=0;i<varn;i++) {
		attrname=varattrname(attl[attidx].name,varl[i].varnum);
		if (attrname=="$gp")
			continue;
		if (ovall[i]==vvall[i]) {
			alen=strlen(vvall[i]);
			attrvalue=(i!=0 &&
			  strextract(vvall[i],alen-nlen1,alen)==REPNILVATT) ?
			 PA_NILVAL : vvall[i];
			}
		else {
			alen=strlen(vvall[i]);
			if (strextract(vvall[i],alen-nlen2,alen)==REPNILVATTC2)
				attrvalue=strextract(vvall[i],0,alen-nlen2-1);
			else if (
			 strextract(vvall[i],alen-nlen1,alen)==REPNILVATT)
				attrvalue=strextract(vvall[i],0,alen-nlen1-1);
			else
				attrvalue=vvall[i];
			}
		// Transfer attributes to companion symbols
		for (j=0;j<rpsymn;j++) {
			// Check if gate specific attribute
			if (attrname=="$rlname" && rpmacl[j]!=symmacro)
				continue;
			// Set attribute
			scm_setpartattrib(rpsyml[j],attrname,
			 attrvalue,4|(varl[i].varnum==act_var ? 3 : 0));
			if (i==0 && attrname==rpaname)
				scm_setpartattrib(rpsyml[j],"$",attrvalue,7);
			if ((NOPLCPVIS&2)==2 && attrname=="$noplc")
				setpvis(rpsyml[j],attrvalue,i);
			}
		}
	// Check if extra program call needed
	if ((attrname=bae_inistrval(PAR_ATTRSETP,""))!="") {
		varset(GV_SATTRSYM,symname);
		varset(GV_SATTRNAME,attl[attidx].name);
		runulprog(attrname);
		vardelete(GV_SATTRSYM);
		vardelete(GV_SATTRNAME);
		}
}

string getvarvalue(string symname,string attrname,int varnum)
/*
// Get variant attribute value
// Return value :
//	Attribute value
// Parameters :
//	string symname		: Symbol name
//	string attrname		: Attribute name
//	int varnum		: Variant number
*/
{
	index C_FIGURE fig		/* Figure list element */;
	index C_NREF nref		/* Named reference */;
	index C_ATTRIBUTE attr		/* Attribute index */;
	string vattrname		/* Variant attribute name */;
	if (cap_nrefsearch(symname,fig))
		return(PA_NILVAL);
	vattrname=varattrname(attrname,varnum);
	nref=fig.NREF;
	// Scan attribute values
	forall (attr of nref where attr.NAME==vattrname)
		return(attr.VALUE);
	return(PA_NILVAL);
}

// Attribute scan routines

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

int atextfunc(index C_TEXT textp,double tx,double ty,double tangle,
 int mirrflag,double tsize,string tstr,int textinws,int macclass,int varattr)
/*
// Scan a text data block for attribute definitions
// Return value :
//	zero if done or (-1) on error
//	index C_TEXT textp	: Text index
//	double tx		: Text X coordinate
//	double ty		: Text Y coordinate
//	double tangle		: Text rotation angle
//	int mirrflag		: Text mirror flag
//	double tsize		: Text size
//	string tstr		: Text string
//	int textinws		: Text in workspace flag
//	int macclass		: Text macro class
//	int varattr		: Text variant attribute flag
*/
{
	string attrcommn		/* Attribute comment name */;
	string attrcommv		/* Attribute comment value */;
	int attrord			/* Attribute order value */;
	int lock			/* Attribute lock flag */;
	int lockbase			/* Attrib. locked in base var. flag */;
	string str			/* Text string */;
	int i, j			/* Loop control variables */;
	// Get text string
	str=textp.STR;
	if (scm_chkattrname(str))
		// No valid attribute name
		return(0);
	// Check the rotation visibility
	if (textp.ROTVIS!=100 && !((textp.ROTVIS&1) && (textp.ROTVIS&0x20)))
		// Process only base orientation texts
		return(0);
	// Check if already defined
	for (i=0;i<attn;i++)
		if (attl[i].name==str)
			break;
	if (i>=attn) {
		// Get upper case attribute name
		attrcommv=str;
		strupper(attrcommv);
		// Query the attribute lock state
		if (cap_rulequery(RS_OCPOOL,textp,RS_SCMSUBJ,RS_ATTADIS,
		 "?d",lock)<1)
			// Clear attribute locked flag
			lock=0;
		// Query the attribute base variant lock state
		if (cap_rulequery(RS_OCPOOL,textp,RS_SCMSUBJ,RS_ATTVAR0,
		 "?d",lockbase)<1)
			// Clear attribute locked in base variant flag
			lockbase=0;
		// Build order variable name
		sprintf(attrcommn,PAR_ATTRORDP,
		 strextract(attrcommv,1,strlen(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 &&
			  numstrcmp(attl[i-1].name,str)>0))
				attl[i]=attl[i-1];
			else
				break;
		// Store the attribute to the list
		attl[i].name=str;
		attl[i].ord=attrord;
		attl[i].lock=lock|(lockbase<<1);
		attl[i].defvall[0]=PA_NILVAL;
		attl[i].defvaln=0;
		// Build comment variable name
		sprintf(attrcommn,PAR_ATTRCOMMP,
		 strextract(attrcommv,1,strlen(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);
		// Get upper case attribute name
		attrcommv=str;
		strupper(attrcommv);
		// Build browse program variable name
		sprintf(attrcommn,PAR_ATTRBRWP,
		 strextract(attrcommv,1,strlen(attrcommv)));
		// Query browse program variable
		attl[i].brwprog=
		 varget(attrcommn,attrcommv)==0 ? attrcommv : "";
		attn++;
		}
	// Check if default value assigned
	if (attl[i].defvaln==0) {
		// Query the attribute default value
		if (cap_rulequery(RS_OCPOOL,textp,RS_SCMSUBJ,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 (cap_rulequery(RS_OCPOOL,textp,RS_SCMSUBJ,
				 RS_INIVAL+itoa(j),"?s",attl[i].defvall[j])<1)
					break;
				attl[i].defvaln++;
				}
			}
		}
	// Return without errors
	return(0);
}

int aptextfunc(index C_TEXT textp,double tx,double ty,double tangle,
 int mirrflag,double tsize,string tstr,int textinws,int macclass,int varattr)
/*
// Scan a text data block for attribute pick
// Return value :
//	zero if done or (-1) on error
//	index C_TEXT textp	: Text index
//	double tx		: Text X coordinate
//	double ty		: Text Y coordinate
//	double tangle		: Text rotation angle
//	int mirrflag		: Text mirror flag
//	double tsize		: Text size
//	string tstr		: Text string
//	int textinws		: Text in workspace flag
//	int macclass		: Text macro class
//	int varattr		: Text variant attribute 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 */;
	// Check if valid attribute text string
	if (scm_chkattrname(textp.STR))
		// No valid attribute name
		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=textp.STR;
		}
	// Return without errors
	return(0);
}

int datafunc(string dstr,int dint,double ddbl,
 int dval,int dtype,string dtable,string dfield,int didx)
/*
// Data query 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 */;
	// Check the data field
	switch (didx) {
		case 1 :
		curvarnum=dint;
		break;
		case 2 :
		// Search the insert position
		for (i=varn;i>0;i--)
			if (varl[i-1].varnum<curvarnum)
				break;
			else
				varl[i]=varl[i-1];
		// Insert variant data
		varl[i].varnum=curvarnum;
		varl[i].varname=dstr;
		if (curvarnum==act_var)
			act_flag=1;
		varn++;
		break;
		default :
		;
		}
	// Return without errors
	return(0);
}

// File name routines

int askrlext(string rlext,string symmac,string libfile)
/*
// Menu-driven select a definition name among those with extensions
// Return value :
//	zero if done, 1 if selection aborted
// Parameters :
//	string rlext		: Requested log. lib. name extension
//	string symmac		: Symbol macro name
//	string libfile		: Log. lib. file name
*/
{
	STRINGS entryl			/* Entry string list */;
	int entryn	= 0		/* Entry list */;
	string npat			/* Name pattern string */;
	string ename			/* Entry name */;
	string res			/* Result string */;
	int nmfound			/* Name match found */;
	int i				/* Loop control variable */;
	// Build the list header
	sprintf(headl[0],REPLOGLIB,symmac);
	headl[1]="";
	// Always display symbol macro name
	entryl[0]=symmac;
	entryn=1;
	// Build the name pattern string
	strlower(npat=(symmac+"_?*"));
	// Scan the matching log. library entries
	ename=symmac;
	nmfound=0;
	bae_prtdialog(REPLOGSCAN);
	while (scanddbenames(libfile,DDBCLLLIB,ename)==1)
		if (strmatch(ename,npat)) {
			// Store log. library part name
			entryl[entryn]=ename;
			entryn++;
			nmfound=1;
			}
		else if (nmfound)
			break;
	// Scan the matching log. library entries in project itself
	ename=symmac;
	nmfound=0;
	while (scanddbenames(fname,DDBCLLLIB,ename)==1)
		if (strmatch(ename,npat)) {
			// Store log. library part name
			entryl[entryn]=ename+" "+REPPROJDEF;
			entryn++;
			nmfound=1;
			}
		else if (nmfound)
			break;
	// Perform the $rlext selection popup
	bae_setintpar(16,3060);
	if ((res=popupmenu(1,UPRLOGLIB,headl,headn,
	 entryl,entryn,rlext,0,0,1,0,0,0,UINPOPABORT))==UINPOPABORT)
		return(-1);
	for (i=0;res[i]!='\0';i++)
		if (res[i]==' ') {
			res[i]='\0';
			break;
			}
	// Check if extended symbol name selected
	if (strmatch(res,npat))
		// Remove the symbol name portion
		rlext=strextract(res,strlen(symmac)+1,strlen(res));
	// Check if pure symbol name
	else if (res==symmac)
		rlext="";
	else
		// Use unchanged entered name
		rlext=res;
	// Return without errors
	return(0);
}

// Logical library file syntax

#bnf {	// Loglib file
	libdef	: "part" ident ":" optclassspec partdef
		;
	// Part functions syntax
	optclassspec
		: "class" ident
		|
		;
	partdef	: mainflag defflag plnames partblk
		| "subpart" (p_subpart) ident partblk
		| "virtual" virtblk
		| "logical" virtblk
		;
	mainflag
		: "mainpart" (p_mainpart)
		|
		;
	defflag	: "default"
		|
		;
	plnames : plnames "," ident
		| ident
		;
	partblk	: "{" partcmds "}"
		| ";"
		;
	partcmds
		: partcmds partcmd
		| partcmd
		;
	partcmd	: "bus" pinlist ";"
		| "net" netcmd ":" pinlist ";"
		| "pin" pinlist ";"
		| "swap" swapcmd swapblk ";"
		| "xlat" pinlist "to" xlats ";"
		| "xlat" "(" xlatpinass ")" ";"
		| "netattr" "priority" DQSTR ":" pinlist ";"
		| "netattr" "mindist" DQSTR ":" pinlist ";"
		| "netattr" "powwidth" DQSTR ":" pinlist ";"
		| "netattr" "routwidth" DQSTR ":" pinlist ";"
		| "netattr" idstr DQSTR ":" pinlist ";"
		| "newattr" DQSTR "=" DQSTR
		 topinlist ";"
		| "comment" "=" DQSTR ";"
		;
	virtblk	: "{" virtcmds "}"
		| ";"
		;
	virtcmds
		: virtcmds virtcmd
		| virtcmd
		;
	virtcmd	: "bus" pinlist ";"
		| "net" netcmd ":" pinlist ";"
		| "pin" pinlist ";"
		| "netattr" "priority" DQSTR ":" pinlist ";"
		| "netattr" "mindist" DQSTR ":" pinlist ";"
		| "netattr" "powwidth" DQSTR ":" pinlist ";"
		| "netattr" "routwidth" DQSTR ":" pinlist ";"
		| "netattr" idstr DQSTR ":" pinlist ";"
		| "newattr" DQSTR "=" DQSTR
		 topinlist ";"
		| "call" ident ";"
		| "architecture" "{" synthprog "}"
		| "comment" "=" DQSTR ";"
		;
	topinlist
		: "to" pinlist
		|
		;
	netcmd	: ident
		| "internal"
		;
	swapcmd	: "internal"
		|
		;
	swapblk	: "(" groups ")"
		| "(" gates ")"
		;
	groups	: groups "," "[" gates "]"
		| "[" gates "]"
		;
	gates	: gates "," gate
		| gate
		;
	gate	: "(" gateblk ")"
		| pin
		;
	gateblk	: gateblk "," gatepin
		| gatepin
		;
	gatepin	: pinlist
		| pin
		;
	xlats	: xlats "or" (p_xlator) pinlist
		| pinlist
		;
	xlatpinass : xlatpinass "," xlpindef
		| xlpindef
		;
	xlpindef : "(" pin "," xlpins ")"
		;
	xlpins	: xlpins "," (p_xlator) pin
		| pin
		;
	synthprog
		: synthprog sprogcmd
		| sprogcmd
		;
	sprogcmd
		: "part" ident "(" preqpinlist ")" ";"
		;
	preqpinlist
		: preqpinlist "," preqpinass
		| preqpinass
		;
	preqpinass
		: pin ":" preqdest
		;
	preqdest
		: pin
		| "net" ident
		| "net" "&" ident
		| "&" ident
		;
	pinlist	: "(" pins ")"
		;
	pins	: pins "," pin
		| pin
		;
	pin	: identpt
		| identpt "-" identpt optstep
		;
	optstep	: ":" NUMBER
		|
		;
	// Identifier expression
	ident	: IDENT
		| NUMBER
		| SQSTR
		| DQSTR
		;
	identpt	: identpt idpiece
		| '/' idpiece
		| idpiece
		;
	idpiece	: IDENT
		| NUMBER
		| SQSTR
		| DQSTR
		| '.'
		;
	idstr : IDENT
		| DQSTR
		;
}	// BNF end

int p_mainpart()
/*
// Receive a mainpart flag
// Return value :
//	zero if done, or nonzero on error
*/
{
	symtyp=1;
	// Return without errors
	return(0);
}

int p_subpart()
/*
// Receive a subpart definition
// Return value : zero if done, or nonzero on error
*/
{
	symtyp=2;
	// Return without errors
	return(0);
}

int p_xlator()
/*
// Receive a xlat or command
// Return value :
//	zero if done, or nonzero on error
*/
{
	// Increment the current xlat or command count
	gatecnt++;
	// Return without errors
	return(0);
}

// User Language program end