/* SCMPEDIT (SCM) -- Schematic Editor Position Pick/Element Edit */
/* SCMPEDIT (SCM) -- Schaltplaneditor Positionspick/Elementdatenmanipulation */
/* -- INTENDED FOR KEY-CALL USE (<p|P>:Position Pick/Element Edit) -- */
/*
// Copyright (c) 1999-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 (091027) RELEASED FOR BAE V7.4.
//	rl (081014) RELEASED FOR BAE V7.2.
//	rl (071029) RELEASED FOR BAE V7.0.
//	rl (061109) ENHANCEMENT:
//		Added polygon display bitmap to dialog box.
//	rl (060929) RELEASED FOR BAE V6.8.
//	rl (060809) ENHANCEMENT:
//		Added group name and plot color edit fields.
//	rl (060505) ENHANCEMENT:
//		Added plot disable flag manipulation option.
//	rl (060306) ENHANCEMENT:
//		Added element rule manipulation option.
//	rl (060209) ENHANCEMENT:
//		Added polygon corner browse option.
//	rl (060131) ENHANCEMENT:
//		Fixed problem with rename symbol name used on different plan.
//	rl (060119) ENHANCEMENT:
//		Added snap to origin option for mouse outside workspace.
//	rl (051205) ENHANCEMENT:
//		Added left/right rotate angle buttons.
//	rl (051026) ENHANCEMENT:
//		Added attribute set button to symbol data edit box.
//	rl (050915) RELEASED FOR BAE V6.6.
//	rl (050421) ORIGINAL CODING.
//
// DESCRIPTION
//
// The scmpedit User Language program provides functions to snap to
// the coordinates of elements placed at the current mouse position.
*/

// Includes
#include "baeparam.ulh"			// User Language BAE param. access
#include "pop.ulh"			// User Language popup utilities
#include "popdraw.ulh"			// User Language popup draw. util.
#include "scm.ulh"			// User Language SCM utilities

// Disable undo state request
#pragma ULCALLERNOUNDO

// INI file parameter name definitions
#define PAR_POLYPMODE	"POLYPMODE_SCM"	// Polygon pick mode
#define PAR_NOPLCVAL	"NOPLCVAL_SCM"	// $noplc value for unplaced parts
#define PAR_NOPLCPVIS	"NOPLCPVIS_SCM"	// $noplc/plot visibilty relationship
#define PAR_SINFOWIDTH	"SINFOWIDTH_SCM"// Symbol info box width
#define PAR_ATTRCOMMP	"ATTR_%s_STD"	// Attribute comment pattern
#define PAR_ATTRORDP	"ATTR_ORD_%s_STD"	// Attribute order pattern
#define PAR_MAXEDIT	"MTMAXEDIT_SCM"	// Max. multi line edit length
#define PAR_MTEXTORIG	"MTEXTORIG_STD"	// Multi line text origin mode
#define PAR_TXTLSPC	"TXTLSPACE_SCM"	// Text line relativ spacing

// Messages
string UPRCSYM		= M("Symbol :","Symbol :");
string UPRCLAB		= M("Netzname :","Net Name :");
string UPRCPORT		= M("Portname :","Port Name :");
string UPRCPIN		= M("Pin :","Pin :");
string UPRCMACRO	= M("Makro : ","Macro : ");
string UPRPINMOVE	= M("Freigabe Pinbewegung","Permit Pin Movement");
string UPRPINMODE	= M("Markermodus :","Marker Mode :");
string UPRPINNMIRR	= M("Nicht spiegeln","No Mirroring");
string UPRPINNROT	= M("Nicht drehen","No Rotation");
string UPRPINCON	= M("Autoanschluss","Autoconnection");
string UPRCTEXT		= M("Text :","Text :");
string UPRCMTEXT	= M("Mehrzeilentext :","Multiline Text :");
string UPRCNET		= M("Netzname :","Net Name :");
string UPRCCOORD	= M("Daten setzen","Set Data");
string UPRNIL		= "--------";
string UPRPATTERN	= M("&Muster","&Pattern");
string UPRDONE		= M("&Fertig","D&one");
string UPRTPOSRESET	= M("Namen/Attribute bewegen ruecksetzen",
			    "Reset Name/Attribute moves");
string UPRTOGGLE	= M("&Setzen/Loeschen","Set/Reset");
string UPRRULEBUT	= M("Regeln","Rules");
string UPRDRULEH	= M("Regeln fuer %s setzen/loeschen",
			    "%s rules set/reset");
string UPRDRSTEXT	= M("Standardtext '%s'","Standard text '%s'");
string UPRDRCTEXT	= M("Kommentartext '%s'","Commentary text '%s'");
string UPRDRCON		= M("Verbindung","Connection");
string UPRDRBUS		= M("Busverbindung","Bus connection");
string UPRDRLAB		= M("Label '%s'/'%s'","Label '%s'/'%s'");
string UPRDRSYM		= M("Symbol '%s'/'%s'","Symbol '%s'/'%s'");
string UPRDRPIN		= M("Pin '%s'/'%s'","Pin '%s'/'%s'");
string UPRNETAREA	= M("Bereichsnamen ? ","Area Name ? ");
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 UPRX		= M("X :","X :");
string UPRY		= M("Y :","Y :");
string UPRCCOPY		= M("Koordinaten kopieren","Copy Coordinates");
string UPRRADIUS	= M("Radius :","Radius :");
string UPRPINDEX	= M("%d von %d","%d of %d");
string UPRARCLEFT	= M("Bogen links %s\260","Arc left %s\260");
string UPRARCRIGHT	= M("Bogen rechts %s\260","Arc right %s\260");
string UPRPPREV		= M("&<","&<");
string UPRPNEXT		= M("&>","&>");
string UPRANG		= M("Winkel :","Angle :");
string UPRLEFT		= M("&links (+90)","&left (+90)");
string UPRRIGHT		= M("&rechts (-90)","&right (-90)");
string UPRHEIGHT	= M("Hoehe :","Height :");
string UPRLINESPC	= M("Zeilenabstand (rel.) :","Rel. Line Spacing :");
string UPRPWIDTH	= M("Stiftbreite :","Pen Width :");
string UPRCOMMENT	= M("Kommentartext","Commentary Text");
string UPRCENTER	= M("Zentriert :","Centered :");
string UPRCENTN		= M("nein","no");
string UPRCENTH		= M("Breite","Width");
string UPRCENTV		= M("Hoehe","Height");
string UPRCENTHV	= M("Breite+Hoehe","Width+Height");
string UPRFRAME		= M("Rahmen :","Frame :");
string UPRFRAME1	= M("1","1");
string UPRFRAME2	= M("2","2");
string UPRFRAMEO	= M("links offen","left hand open");
string UPRMIRROR	= M("Spiegelung :","Mirroring :");
string UPRPTYP		= M("Polygontyp :","Polygon Type :");
string UPRPTYPGL	= M("Grafik&linie","Graphic &Line");
string UPRPTYPDL	= M("&Punktlinie","&Dot Line");
string UPRPTYPGA	= M("&Grafikflaeche","&Graphic Area");
string UPRPTYPCA	= M("&Kontaktbereich","&Contact Area");
string UPRPTYPNA	= M("&Netz-/Bauteilbereich","&Net/Part Area");
string UPRPTSTD		= M("&Standard Pin","&Standard Pin");
string UPRPTSYMTAG	= M("S&ymbol Tag","S&ymbol Tag");
string UPRPTPINTAG	= M("&Pin Tag","&Pin Tag");
string UPRPTNETTAG	= M("&Netz Tag","&Net Tag");
string UPRPTNPNTAG	= M("Netzp&in Tag","Net P&in Tag");
string UPRPTNARTAG	= M("Net&zbereich Tag","N&et Area Tag");
string UPRPTPARTAG	= M("&Bauteilbereich Tag","P&art Area Tag");
string UPRPTBUS		= M("Busanschluss","Bus Connection");
string UPRGLUED		= M("Verankerung :","Glue :");
string UPRPLOTVIS	= M("Plotsichtbarkeit","Plot visibility");
string UPRDON		= M("ein","on");
string UPRDOFF		= M("aus","off");
string UPRCGRPNAME	= M("Gruppenname :","Group Name :");
string UPRCELEMCOLOR	= M("PDF-Farbe :","PDF Color :");
string UPRBRWCOLOR	= M("BAE-Auswahl","BAE-Selection");
string UPRDUNITMM	= M("&mm","&mm");
string UPRDUNITINCH	= M("&Inch","&Inch");
string UPRBROWSE	= M("&Browse","&Browse");
string UPRATTRASS	= M("Wert(e) &zuweisen","Assign &Value(s)");
string UPRTEXTCLASS	= M("Textklasse(n)","Text Class(es)");
string UPRDASHPBUT	= M("Strichelung","Dash Settings");
string UPRDASHSET	= M("Strichelungseinstellungen","Dash Settings");
string UPRDWIDTH	= M("Linienbreite b  [mm] :","Line Width w  [mm] :");
string UPRDASHLEN	= M("Basislaenge l  [mm] :","Basislaenge l  [mm] :");
string UPRDASHSPC	= M("Strichfaktor f  ]0.0,0.5[ :",
			    "Dot Factor f  ]0.0,0.5[:");
string UPRGLUECHG	= M("Verankertes Element aendern?",
			    "Change glued element?");
string REPSYMATTR	= M("Attribute:\n\n","Attributes:\n\n");
string REPATTRIB	= "%s %.*s: '%s'";
string REPATTRVAR	= M(" Var. %d"," Var. %d");
string ERRDUPNAME	= M("Name '%s' ist bereits verwendet!",
			    "Name '%s' is already in use!");
string ERRSETATT	= M("Fehler bei Attributzuweisung an Bauteil/Symbol '%s'!",
			    "Error setting attribute on part/symbol '%s'!");
string ERRSETTAG	= M("Fehler bei Tagumleitung auf Bauteil/Symbol '%s'!",
			    "Error redirection tag to part/symbol '%s'!");
string ERROUTBOUND	= M("Position ausserhalb der Elementgrenzen!",
			    "Position outside element boundaries!");
string ERRNORULE	= M("Regel '%s' nicht definiert!",
			    "Rule '%s' not defined!");
string ERRVARFUNC	= M("Diese Funktion ist fuer Varianten nicht erlaubt!",
			    "Not allowed in variant edit mode!");
string ERRNOGRPNAMES	= M("Keine Elemente mit Gruppennamen!",
			    "No elements with group name attached found!");
string WRNVARPDIS	= M("Variante aktiv: nur Plotsichtbarkeit geaendert!",
			    "Variant activ: changed only plot visibility!");
#define ITMPINNAMHD	"PIN"
#define ITMSMRKHD	"MARKER"
#define ITMNETNAMHD	"NET"
#define ITMATRNAMHD	"ATTRIBUTES"
#define ITMBUSPREFIX	"BUS : "
#define ITMULINE	"========================================"
#define ITMUDOT		"......................................."
#define FMTPTABH1	"%-*s %-*s %-*s %s\n"
#define FMTPTABH2	"%.*s %.*s %.*s %.*s\n"
#define FMTPTABF	"%-*s %-*s %-*s %s\n"
int ATTFLEN		= 22		/* Attribute field length */;

// Globals
#define SMALLVAL	0.00000001	// Small compare value
#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 LAYERINV	(-0x4000)	// Invalid layer code
#define PICLABHEIGHT	9.0		// Label button height
#define PICLABWIDTH	100.0		// Label button width
#define PICLABSCOL	15		// Label button length line color
#define PICLABFCOL	8		// Label button factor line color
#define PICLABDCOL	1		// Label button dash line color
#define DEFDASHMODE	0		// Default dash mode
#define DEFDASHLEN	0.002		// Default dash length
#define DEFDASHSPC	0.4		// Default dash relative spacing
#define DEFDASHWIDTH	0.0		// Default dash line width
double DPI           = cvtangle(360.0,1,2)
					/* Double PI value */;
int POLYPMODE = bae_iniintval(PAR_POLYPMODE,0) /* Polygon pick mode */;
string NOPLCVAL = bae_inistrval(PAR_NOPLCVAL,"NP")
					/* $noplc value for unplaced parts */;
int NOPLCPVIS = bae_iniintval(PAR_NOPLCPVIS,3)
					/* $noplc/plot vis. relationship */;
int SINFOW = bae_inidblval(PAR_SINFOWIDTH,40.0) /* Symbol info box width */;
int MAXEDIT = bae_iniintval(PAR_MAXEDIT,60000);
					// Max. multi line edit length
int MTEXTORIG	= bae_iniintval(PAR_MTEXTORIG,0);
					// Multi line text origin mode
double LINESPC = bae_inidblval(PAR_TXTLSPC,1.0);
					// Text rel. line spacing
double px, py				/* Pick coordinates */;
double pinx, piny			/* Pin coordinates */;
int posfound		= 0		/* Position found flag */;
int attrfound		= 0		/* Position found flag */;
int symflag		= 0		/* Symbol info flag */;
string curname				/* Current scan part name */;
double mindist				/* Minimum found distance */;
int figdis				/* Figure list disable bits */;
string rulel[]				/* Rule list */;
int rulen				/* Rule count */;
int varl[]				/* Variant list */;
int varn		= 0		/* Variant count */;
int act_var		= 0		/* Active variant */;
int act_flag				/* Active variant defined flag */;
int MAXPINNAMLEN			/* Maximum pin name length */;
int MAXNETNAMLEN			/* Maximum net name length */;
int MAXATRNAMLEN			/* Maximum attribute name length */;
int MAXSMRKLEN				/* Maximum pin marker name length */;
struct {				// Pin descriptor
	string pinname			/* Pin name */;
	string netname			/* Pin name */;
	double x,y			/* Pin coordinates */;
	double rotang			/* Pin rotation angle */;
	int mirror			/* Pin mirror mode */;
	string attrlist			/* Pin attribute list */;
	string marker			/* Pin marker macro name */;
	} pinl[]			/* Pin list */;
int pinn		= 0		/* Pin count */;

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

// User Language program name definitions
#define UL_ATTRSET	"attrset"
#define UL_SCMTEXT	"scmtext"

// Main program
void main()
{
	index C_FIGURE fig		/* Figure list index */;
	index C_POLY poly		/* Polygon index */;
	index C_BUSTAP tap		/* Bustap index */;
	index C_CONSEG seg		/* Connection segment index */;
	index C_POINT p			/* Polygon point index */;
	double cosa,sina		/* Trigonometric values */;
	double ox,oy			/* Pin offset */;
	double ix1, iy1			/* 1st input coordinate */;
	double iw1			/* 1st input width */;
	int ilay1			/* 1st input layer */;
	int ilay2			/* 2nd input layer */;
	int inpmode			/* Input mode */;
	int menucode			/* Menu code */;
	int pickena			/* Pick type enable bit field */;
	int pickityp			/* Pick index type */;
	int donereq	= 0		/* Connection done request */;
	// Get the figure list element type set
	if (varget(VAR_MSFIGDIS,figdis))
		figdis=0;
	// Get the current mouse position
	bae_wsmouse(px,py,0);
	// Check if standalone call
	if ((ulproginfo("",0,0)<=1 && bae_getactmenu()<0) ||
	 varget(GV_PROPCALL,ilay1)==0) {
		if (varget(GV_PROPX,ix1)==0 && varget(GV_PROPY,iy1)==0) {
			px=ix1; py=iy1;
			vardelete(GV_PROPX);
			vardelete(GV_PROPY);
			}
		// Pick element
		pickena=(~(figdis|(1<<C_FIGPOLYC)));
		if (pickena&(1<<C_FIGPOLY))
			pickena=pickena-(1<<C_FIGPOLY)+(1<<C_FIGPOLYC);
		bae_storemouseiact(3,px,py,0,LMB);
		if (scm_pickanyelem(fig,seg,tap,pickityp,pickena)==0) {
		   switch (pickityp) {
			case 0 :
			if (fig.TYP==C_FIGPOLY) {
				// Search nearest polygon point
				poly=fig.POLY;
				forall (p of poly)
					if (!posfound ||
					 (fabs(p.X-px)+fabs(p.Y-py))<mindist) {
						posfound=1;
						pinx=p.X; piny=p.Y;
						mindist=
						 fabs(px-pinx)+fabs(py-piny);
						}
				editcoord(fig,pinx,piny);
				}
			else {
				editcoord(fig,fig.X,fig.Y);
				}
			break;
			// Connection segment
			case 1 :
			break;
			// Bustap
			case 2 :
			break;
			default :
			;
			}
		    }
		else {
		    bae_callmenu(5001);
		    }
		exit(0);
		}
	// Check if outside workspace
	if (px<bae_planwslx() || px>bae_planwsux() ||
	 py<bae_planwsly() || py>bae_planwsuy()) {
		// Snap to origin
		bae_storemouseiact(3,bae_planwsnx(),bae_planwsny(),2,LMB);
		exit(0);
		}
	// Check the currently active menu
	if ((menucode=bae_getactmenu())>=10000)
		menucode=1003;
	switch (menucode) {
		// Polygon edit functions
		case 500 :
		case 501 :
		case 502 :
		case 503 :
		case 507 :
		case 508 :
		case MNU_SCMGRPPOLY :
		// Check if input data available
		ilay1=LAYERINV;
		if (scm_getinputdata(ix1,iy1,iw1,ilay1,0.0,0.0,0.0,ilay2,
		  inpmode,0.0,0.0,0.0,0.0,0,0.0,0.0,0.0,0.0,0)==0 &&
		 ilay2!=LAYERINV)
			// Swap the edit direction
			scm_getinputdata(0.0,0.0,0.0,ilay2,ix1,iy1,iw1,ilay1,
			 inpmode,0.0,0.0,0.0,0.0,0,0.0,0.0,0.0,0.0,0);
		// Pick polygon at mouse position
		if (!(figdis&(1<<C_FIGPOLY))) {
			bae_storemouseiact(3,px,py,0,LMB);
			if (scm_pickelem(fig,C_FIGPOLYC)==0) {
				// Search nearest polygon point
				poly=fig.POLY;
				forall (p of poly)
					if (!posfound ||
					 (fabs(p.X-px)+fabs(p.Y-py))<mindist) {
						posfound=1;
						pinx=p.X; piny=p.Y;
						mindist=
						 fabs(px-pinx)+fabs(py-piny);
						}
				}
			}
		// Pick symbol pin at mouse position
		if (!posfound && !(figdis&(1<<C_FIGNREF))) {
			bae_storemouseiact(3,px,py,0,LMB);
			if (scm_pickelem(fig,C_FIGNREF)==0) {
				// Store the symbol origin position
				pinx=fig.X; piny=fig.Y;
				posfound=1;
				mindist=fabs(fig.X-px)+fabs(fig.Y-py);
				// Scan the pin position
				if (cap_scanfelem(fig,0.0,0.0,0.0,1,
				 pinposscanfunc,NULL,NULL,NULL))
					break;
				}
			}
		// Pick connection at mouse position
		if (!posfound && !(figdis&(1<<C_FIGCON))) {
			bae_storemouseiact(3,px,py,0,LMB);
			if (scm_pickconseg(seg)==0) {
				// Store the nearer segment corner
				if ((fabs(seg.X1-px)+fabs(seg.Y1-py))<
				 (fabs(seg.X2-px)+fabs(seg.Y2-py))) {
					pinx=seg.X1; piny=seg.Y1;
					}
				else {
					pinx=seg.X2; piny=seg.Y2;
					}
				posfound=1;
				}
			}
		// Pick bustap at mouse position
		if (!posfound && !(figdis&(1<<C_FIGCON))) {
			bae_storemouseiact(3,px,py,0,LMB);
			if (scm_pickbustap(tap)==0) {
				if (cap_scanpool(tap.MACRO,0.0,0.0,0.0,1,
				 pinposscanfunc,NULL,NULL,NULL))
					error_scan();
				sina=sin(tap.ANGLE); cosa=cos(tap.ANGLE);
				// Get the pin placement offset
				ox=pinx; oy=piny;
				if (tap.MIRROR)
					oy=-oy;
				pinx=tap.X+cosa*ox-sina*oy;
				piny=tap.Y+sina*ox+cosa*oy;
				}
			}
		// Pick bustap at mouse position
		if (!posfound && !(figdis&(1<<C_FIGCON))) {
			bae_storemouseiact(3,px,py,0,LMB);
			if (scm_pickbustap(tap)==0) {
				if (cap_scanpool(tap.MACRO,0.0,0.0,0.0,1,
				 pinposscanfunc,NULL,NULL,NULL))
					error_scan();
				sina=sin(tap.ANGLE); cosa=cos(tap.ANGLE);
				// Get the pin placement offset
				ox=pinx; oy=piny;
				if (tap.MIRROR)
					oy=-oy;
				pinx=tap.X+cosa*ox-sina*oy;
				piny=tap.Y+sina*ox+cosa*oy;
				}
			}
		// Check if point found
		if (!posfound)
			break;
		// Contact to corner
		bae_storemouseiact(3,pinx,piny,2,LMB);
		break;
		// Connection place/move functions
		case 412 :
		case MNU_SCMADDCON :
		case MNU_SCMADDBUS :
		if (scm_getinputdata(ix1,iy1,iw1,ilay1,0.0,0.0,0.0,ilay2,
		  inpmode,0.0,0.0,0.0,0.0,0,0.0,0.0,0.0,0.0,0)==0 &&
		 ilay1!=LAYERINV)
			donereq=1;
		case 406 :
		// Text place/move/copy functions
		case MNU_SCMADDTEXT :
		case MNU_SCMMOVETEXT :
		case MNU_SCMCOPYTEXT :
		case MNU_SCMMOVENAME :
		case MNU_SCMMOVEATTR :
		// Symbol place/move functions
		case MNU_SCMADDSYM :
		case MNU_SCMADDLAB :
		case MNU_SCMADDPORT :
		case MNU_SCMMOVESYM :
		case MNU_SCMNEXTSYM :
		// Polygon move/copy functions
		case MNU_SCMMOVEPOLY :
		case MNU_SCMCOPYPOLY :
		case 509 :
		// Group copy/move/save functions
		case MNU_SCMMOVEGRP :
		case MNU_SCMCOPYGRP :
		case MNU_SCMLOADGRP :
		case MNU_BAEGRPPASTE :
		case 707 :
		// Set origin
		case MNU_SCMPARORIG :
		// User script
		case 1003 :
		case (-1) :
		// Pick symbol pin at mouse position
		if (!(figdis&(1<<C_FIGNREF))) {
			bae_storemouseiact(3,px,py,0,LMB);
			if (scm_pickelem(fig,C_FIGNREF)==0) {
				// Store the origin position
				pinx=fig.X; piny=fig.Y;
				posfound=1;
				mindist=fabs(fig.X-px)+fabs(fig.Y-py);
				// Scan the pin position
				if (cap_scanfelem(fig,0.0,0.0,0.0,1,
				 pinposscanfunc,NULL,NULL,NULL))
					break;
				}
			}
		// Pick polygon at mouse position
		if (!posfound && !(figdis&(1<<C_FIGPOLY))) {
			bae_storemouseiact(3,px,py,0,LMB);
			if (scm_pickelem(fig,C_FIGPOLYC)==0)
				// Scan the polygon corners
				if (cap_scanfelem(fig,0.0,0.0,0.0,1,NULL,
				 NULL,polymidscanfunc,NULL))
					break;
			}
		// Pick connection at mouse position
		if (!posfound && !(figdis&(1<<C_FIGCON))) {
			bae_storemouseiact(3,px,py,0,LMB);
			if (scm_pickconseg(seg)==0) {
				// Store the nearer segment corner
				if ((fabs(seg.X1-px)+fabs(seg.Y1-py))<
				 (fabs(seg.X2-px)+fabs(seg.Y2-py))) {
					pinx=seg.X1; piny=seg.Y1;
					}
				else {
					pinx=seg.X2; piny=seg.Y2;
					}
				posfound=1;
				}
			}
		// Pick bustap at mouse position
		if (!posfound && !(figdis&(1<<C_FIGCON))) {
			bae_storemouseiact(3,px,py,0,LMB);
			if (scm_pickbustap(tap)==0) {
				if (cap_scanpool(tap.MACRO,0.0,0.0,0.0,1,
				 pinposscanfunc,NULL,NULL,NULL))
					error_scan();
				sina=sin(tap.ANGLE); cosa=cos(tap.ANGLE);
				// Get the pin placement offset
				ox=pinx; oy=piny;
				if (tap.MIRROR)
					oy=-oy;
				pinx=tap.X+cosa*ox-sina*oy;
				piny=tap.Y+sina*ox+cosa*oy;
				}
			}
		// Check if pin found
		if (!posfound)
			break;
		// Select pin center
		bae_storemouseiact(3,pinx,piny,2,LMB);
		if (donereq) {
			bae_storemouseiact(1,0.0,0.0,1,RMB);
			bae_storemenuiact(1,0,LMB);
			}
		break;
		// Ignore on default
		default :
		}
	// Done
}

int pinposscanfunc(index C_MACRO macro,index C_POOL pool,int macinws,
 string refname,index C_LEVEL level,index C_LEVEL buslevel)
/*
// Pin position scan 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
*/
{
	index C_CNET cnet		/* Net index */;
	string asspname			/* Packager assigned part name */;
	string netname	= ""		/* Pin net name */;
	string attrname	= "!"		/* Pin attribute name */;
	string attrval			/* Pin attribute value */;
	string attrlist	= ""		/* Pin attribute list */;
	int firstnet	= 1		/* First net flag */;
	double xpos,ypos		/* Macro coordinates */;
	double angle			/* Macro angle */;
	int mirrmode			/* Macro mirror mode */;
	// Test the macro class
	if (macro.CLASS==DDBCLSSYM || macro.CLASS==DDBCLSLAB)
		// Return the inside workspace flag
		return(1);
	else if (macro.CLASS!=DDBCLSMRK)
		// Not a pin macro; stop scan
		return(0);
	// Get the macro coordinates
	cap_maccoords(xpos,ypos,angle,mirrmode);
	// Check if new best coordinate match
	if (!posfound || (fabs(xpos-px)+fabs(ypos-py))<mindist) {
		// Store the pin position
		pinx=xpos; piny=ypos;
		posfound=1;
		mindist=fabs(pinx-px)+fabs(piny-py);
		}
	if (!symflag)
		// Pin position found; stop further pin scan
		return(0);
	// Build net name string
	if (level!=(-1)) {
		netname= level.BUSFLAG ? ITMBUSPREFIX : "" ;
		forall (cnet of level) {
			netname=netname+(firstnet ? "" : ",")+cnet.NAME;
			firstnet=0;
			}
		strupper(netname);
		}
	// Get the assigned pin name
	if (
	 con_getddbpattrib(bae_planfname(),curname,refname,"$",asspname)==1 &&
	 asspname!="" && asspname!=refname)
		sprintf(refname,"%s (%s)",refname,asspname);
	// Get the assigned net name
	if (
	 con_getddbpattrib(bae_planfname(),curname,refname,"$net",attrval)==1 &&
	 attrval!="" && namestrcmp(netname,attrval)!=0)
		sprintf(netname,"%s (%s)",netname,attrval);
	// Get the assigned pin attributes
	while (con_getddbpattrib(
	 bae_planfname(),curname,refname,attrname,attrval)==1) {
		if (attrname!="$" && attrname!="$net" && attrname!="$sym" &&
		 attrname!="$blkname" && attrname!="$blkrname") {
			if (attrlist=="")
				sprintf(attrlist,"%s='%s'",attrname,attrval);
			else
				sprintf(attrlist,"%s, %s='%s'",
				 attrlist,attrname,attrval);
			}
		attrname="!"+attrname;
		}
	// Store new pin to pin list
	newpin(refname,xpos,ypos,angle,mirrmode,netname,attrlist,macro.NAME);
	// Pin position found; stop further pin scan
	return(0);
}

void newpin(string pinname,double x,double y,double rotang,int mirror,
 string netname,string attrlist,string marker)
/*
// Store new pin to pin list
// Parameters :
//	string pinname		: Pin name
//	double x		: Pin X coordinate
//	double y		: Pin Y coordinate
//	double rotang		: Pin rotation angle
//	int mirror		: Pin mirror mode
//	string netname		: Pin net name
//	string attrlist		: Pin attribute list
//	string marker		: Pin marker macro name
*/
{
	int slb		= 0		/* Search lower boundary */;
	int sub		= pinn-1	/* Search upper boundary */;
	int sidx			/* Search index */;
	int compres			/* Compare result */;
	// Loop until search area empty
	while (slb<=sub) {
		// Get the search index
		sidx=(slb+sub)>>1;
		// Test if pin found; update the search area
		if ((compres=numstrcmp(pinname,pinl[sidx].pinname))<=0)
			sub=sidx-1;
		else
			slb=sidx+1;
		}
	// Insert new pin to pin list
	for (sidx=pinn;sidx>slb;sidx--)
		pinl[sidx]=pinl[sidx-1];
	pinl[slb].pinname=pinname;
	pinl[slb].x=x;
	pinl[slb].y=y;
	pinl[slb].rotang=rotang;
	pinl[slb].mirror=mirror;
	pinl[slb].netname=netname;
	pinl[slb].attrlist=attrlist;
	pinl[slb].marker=marker;
	pinn++;
	// Update the maximum pin name length
	MAXPINNAMLEN=maxint(MAXPINNAMLEN,strlen(pinname));
	// Update the maximum net name length
	MAXNETNAMLEN=maxint(MAXNETNAMLEN,strlen(netname));
	// Update the maximum marker macro name length
	MAXSMRKLEN=maxint(MAXSMRKLEN,strlen(marker));
	// Update the maximum attribute name length
	MAXATRNAMLEN=maxint(MAXATRNAMLEN,strlen(attrlist));
}

int polymidscanfunc(index C_POLY poly,int polyinws,
 index C_LEVEL level,int macclass,int bustapidx)
/*
// Polygon center scan function
// Return value :
//	zero if done or (-1) on file error
// Parameters :
//	index C_POLY poly	: Polygon
//	int polyinws		: Poly in workspace flag
//	index C_LEVEL level	: Polygon level
//	int macclass		: Polygon macro class
//	int bustapidx		: Polygon bustap index
*/
{
	index C_POINT point		/* Polygon point index */;
	double xsum = 0.0		/* X coordinate sum */;
	double ysum = 0.0		/* Y coordinate sum */;
	// Scan all polygon points
	if (POLYPMODE==0 ||
	 poly.TYP==C_POLYDOCLINE || poly.TYP==C_POLYDOTLINE) {
		// Scan all polygon points
		forall (point of poly)
			// Check if new best coordinate match
			if (!posfound ||
			 (fabs(point.X-px)+fabs(point.Y-py))<mindist) {
				// Store the pin position
				pinx=point.X; piny=point.Y;
				posfound=1;
				mindist=fabs(pinx-px)+fabs(piny-py);
				}
		}
	else {
		// Get polygon center
		forall (point of poly) {
			xsum+=point.X;
			ysum+=point.Y;
			}
		if (poly.PN>0) {
			// Store the pin position
			pinx=xsum/poly.PN;
			piny=ysum/poly.PN;
			posfound=1;
			mindist=fabs(pinx-px)+fabs(piny-py);
			}
		}
	// Return without errors
	return(0);
}

void editcoord(index C_FIGURE fig,double x,double y)
/*
// Edit coordinate pair, prepair pick
// Parameters :
//	index C_FIGURE fig	: Figure list element
//	double x,y		: Coordinate pair
*/
{
	index C_FIGURE nfig		/* New figure list index */;
	index C_FIGURE tfig		/* Tag figure list index */;
	index C_POLY poly		/* Polygon index */;
	index C_POINT p			/* Polygon point index */;
	index C_NREF nref		/* Named reference index */;
	index C_MACRO macro		/* Macro index */;
	index C_ATTRIBUTE att		/* Attribute index */;
	index C_REFTEXT rmod		/* Ref. text modifier index */;
	struct pointdes {		// Polygon point descriptor
		double x		/* Point X coordinate */;
		double y		/* Point Y coordinate */;
		int t			/* Point type */;
		} pl[]			/* Polygon point list */;
	int pn		= 0		/* Point count */;
	double prlx, prly		/* Polygon range lower corner */;
	double prux, pruy		/* Polygon range upper corner */;
	double pradj			/* Polygon range ajust value */;
	string msg			/* Message buffer */;
	string lab1	= ""		/* 1st line 1st label */;
	string lab2	= ""		/* 2nd line 1st label */;
	string lab2a	= ""		/* 2nd line 2nd label */;
	string lab3	= ""		/* 3nd line 1st label */;
	string wprompt			/* Width prompt string */;
	string oldmacro			/* Old part macro name string */;
	string newmacro			/* New part macro name string */;
	string oldtnstr			/* Old text/name string */;
	string newtnstr			/* New text/name string */;
	string oldnetarea = ""		/* Old net area name string */;
	string newnetarea = ""		/* New net area name string */;
	string oldgrpname = ""		/* Old group name string */;
	string newgrpname		/* New group name string */;
	string oldcolor = ""		/* Old color RGB string */;
	string newcolor			/* New color RGB string */;
	STRINGS stext[]			/* Multiline scan text */;
	STRINGS lines			/* Text lines */;
	string mrulel[]			/* Multiline text rule list */;
	string nrulel[]			/* Multiline text new rule list */;
	int mrulen			/* Multiline text rule count */;
	string mtextid = ""		/* Multiline text ID */;
	string textid			/* Current text ID */;
	double linespc			/* Multiline text line spacing */;
	double lsx, lsy			/* Text line spacing vector */;
	double lcx, lcy			/* Text line column vector */;
	int col				/* Multiline text column */;
	int row				/* Multiline text row */;
	int maxline = (-1)		/* Max. text line */;
	int maxcol = (-1)		/* Max. text column */;
	double pcol = 12.0		/* Parameter column */;
	double cy			/* Dialog box current y coordinate */;
	double dialwidth		/* Dialog box width */;
	double dialheight		/* Dialog box height */;
	double minheight		/* Dialog box min. height */;
	double minwidth			/* Dialog box min. width */;
	double defwidth			/* Dialog box min. width */;
	int resize = 0			/* Dialog box resizable flag */;
	double oldang			/* Old angle */;
	double newang			/* New angle */;
	double oldheight		/* Old height */;
	double newheight		/* New height */;
	double oldwidth			/* Old width */;
	double newwidth			/* New width */;
	int oldmirror			/* Old mirror flag */;
	int newmirror			/* New mirror flag */;
	int oldpintag = 0		/* Old pin tag mode */;
	int newpintag			/* New pin tag mode */;
	int oldbuspin = 0		/* Old bus pin mode */;
	int newbuspin			/* New bus pin mode */;
	int oldpinmove			/* Old pin move mode */;
	int newpinmove1			/* New pin move 1st bit */;
	int newpinmove2			/* New pin move 2nd bit */;
	int newpinmove3			/* New pin move 3rd bit */;
	int newpinmove			/* New pin move mode */;
	int oldpincon			/* Old pin connection mode */;
	int newpincon			/* New pin connection mode */;
	int oldpdis			/* Old element plot disable flag */;
	int newpdis			/* New element plot disable flag */;
	int oldglued			/* Old element glued flag */;
	int newglued			/* New element glued flag */;
	int oldcenter			/* Old element center flag */;
	int newcenter			/* New element center flag */;
	int oldframe1			/* Old element 1st frame flag */;
	int newframe1			/* New element 1st frame flag */;
	int oldframe2			/* Old element 2nd frame flag */;
	int newframe2			/* New element 2nd frame flag */;
	int oldframeo			/* Old element frame open flag */;
	int newframeo			/* New element frame open flag */;
	int oldpolytyp			/* Old polygon type */;
	int newpolytyp			/* New polygon type */;
	int oldlabtyp	= 0		/* Old label type */;
	int newlabtyp			/* New label type */;
	int labtypsel	= 0		/* Label type selection flag */;
	int repflag			/* Dialog box repeat flag */;
	int cunits			/* Coordinate display units */;
	int xidx			/* X coordinate parameter index */;
	int yidx			/* Y coordinate parameter index */;
	int aidx			/* Angle parameter index */;
	int angflag = 0			/* Angle parameter flag */;
	int hidx			/* Height parameter index */;
	int hflag = 0			/* Height parameter flag */;
	int widx			/* Width parameter index */;
	int wflag = 0			/* Width parameter flag */;
	int wedit = 0			/* Width edit flag */;
	int ptidx			/* Polygon type param. index */;
	int ptflag = 0			/* Polygon type string flag */;
	int tnidx			/* Text/name string param. index */;
	int tnflag = 0			/* Text/name string flag */;
	int naidx			/* Net area string param. index */;
	int nbidx			/* Net area browse param. index */;
	int rtridx			/* Ref. text reset parameter index */;
	int rtrflag = 0			/* Ref. text reset flag */;
	int nflag = 0			/* Net name string flag */;
	int midx			/* Macro string param. index */;
	int mflag = 0			/* Macro string flag */;
	int miidx			/* Mirror parameter index */;
	int miflag = 0			/* Mirror parameter flag */;
	int ltidx = (-1)		/* Label type parameter index */;
	int tmidx			/* Tag pin mode parameter index */;
	int tmflag = 0			/* Tag pin mode parameter flag */;
	int bpidx			/* Bus pin mode parameter index */;
	int mo1idx			/* Pin move 1st parameter index */;
	int mo2idx			/* Pin move 2nd parameter index */;
	int mo3idx			/* Pin move 3rd parameter index */;
	int pcnidx			/* Pin connection parameter index */;
	int moflag = 0			/* Pin move parameter flag */;
	int bclass			/* Browse class */;
	int lsflag = 0			/* Line spacing flag */;
	int lsidx			/* Line spacing param. index */;
	int fr1idx			/* 1st frame param. index */;
	int fr2idx			/* 2nd frame param. index */;
	int froidx			/* Frame open param. index */;
	int cidx			/* Commentary text param. index */;
	int zidx			/* Center param. index */;
	int zflag = 0			/* Center flag */;
	int ecidx			/* Element color string param. index */;
	int gnidx			/* Group name string param. index */;
	int pdidx			/* Plot disable parameter index */;
	int gidx			/* Glued parameter index */;
	int corner = 0			/* Corner edit mode */;
	int curcorner			/* Current corner index */;
	double bmwidth			/* Picture label width */;
	double bmheight			/* Picture label height */;
	double bmoheight		/* Picture original label height */;
	int polylab = 0			/* Polygon label flag */;
	int cilidx			/* Corner index label index */;
	int ctlidx			/* Corner type label index */;
	int crlidx			/* Corner radius label index */;
	int oldmode			/* Old element mode */;
	int newmode			/* New element mode */;
	int group			/* Element group flag */;
	int nrefflag	= 0		/* Named reference element flag */;
	STRINGS rl			/* Rule list */;
	int rn				/* Rule count */;
	int attrerr	= 0		/* Part attribute error count */;
	int tagerr	= 0		/* Tag redirect error count */;
	struct tagref {			// Tag reference descriptor
		index C_FIGURE fig	/* Tag figure list element */;
		string pinname		/* Tag pin name */;
		string ref1		/* Tag 1st reference name */;
		string ref2		/* Tag 2nd reference name */;
		} tagrl[],tagdl[]	/* Tag reference/destination list */;
	int tagrn	= 0		/* Tag reference count */;
	int tagdn	= 0		/* Tag destination count */;
	string tpinname			/* Tag pin name */;
	string tref1			/* Tag 1st reference name */;
	string tref2			/* Tag 2nd reference name */;
	int tpmode			/* Tag pin mode */;
	int tpidx			/* Tag pin index */;
	double rightw			/* Right box area width */;
	string infostr	= ""		/* Info string */;
	string attrcommn		/* Attribute comment name */;
	string attrcommv		/* Attribute comment value */;
	string attrname			/* Attribute name */;
	string attrvar			/* Attribute variant extension */;
	string attruname		/* Attribute upper case name */;
	string attrdisp			/* Attribute display string */;
	int varnum			/* Attribute variant number */;
	int attrord			/* Attribute sort order */;
	int len				/* Attribute name length */;
	struct attrdata {		// Attribute data descriptor
		string name		/* Attribute name */;
		string disp		/* Attribute display string */;
		int var			/* Attribute variant number */;
		int order		/* Attribute order */;
		} al[]			/* Attribute list */;
	int an		= 0		/* Attribute count */;
	struct reftext {		// Reference text modifier descriptor
		string str		/* Reference text string */;
		double x, y		/* Reference text position */;
		double ang		/* Reference text angle */;
		double size		/* Reference text size */;
		int mirr		/* Reference text mirror flag */;
		} rtl[]			/* Reference text modifier list */;
	int rtn		= 0		/* Reference text modifier count */;
	double tang			/* Text angle */;
	double btx, bty			/* Back transf. text coords. */;
	double ttx, tty			/* Temporary text coords. */;
	double mnx, mny			/* Macro origin coords. */;
	double asin, acos		/* Angle sin, cos values */;
	double ang1, ang2		/* Arc angles */;
	int asidx			/* Arc start index */;
	int aeidx			/* Arc end index */;
	struct attrdes {		// Attribute descriptor
		string name		/* Attribute name */;
		string val		/* Attribute value */;
		} attrl[]		/* Attribute list */;
	int attrn                       /* Attribute count */;
	string planname			/* Query plan name */;
	double dashlen	= DEFDASHLEN	/* Dash base length */;
	double dashspc	= DEFDASHSPC	/* Dash spacing */;
	double dashwidth = DEFDASHWIDTH	/* Dash width */;
	int dashmode	= DEFDASHMODE	/* Dash mode */;
	int res				/* Dialog box query result */;
	int boxid			/* Dialog box ID */;
	int oldcol			/* Old color index */;
	int newcol			/* New color index */;
	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"
		};
	int ddbclass = bae_planddbclass()
					/* Schematic plan DDB class */;
	int i				/* Loop control variables */;
	// Query the current active variant
	if (ddbclass!=DDBCLSCM || cap_rulequery(
	 RS_OCSCMDB,0,RS_SCMSUBJ,RS_VARIANT,"?d",act_var)<1)
		// Set default variant
		act_var=0;
	// Get element data
	oldmirror=fig.MIRROR;
	oldglued=(fig.FIXED&2) ? 1 : 0;
	if (cap_rulequery(RS_OCFIG,fig,RS_SCMSUBJ,
	 RS_VARPLOTDIS+itoa(act_var),"?d",oldpdis)<1)
		oldpdis=0;
	if (fig.RULEOBJID>=0) {
		// Query group name predicate
		if (cap_rulequery(RS_OCFIG,fig,RS_SCMSUBJ,RS_GROUPNAME,
		 "?s",oldgrpname)<1)
			oldgrpname="";
		// Query plot color predicate
		if (cap_rulequery(RS_OCFIG,fig,RS_SCMSUBJ,RS_PLOTRGB,
		 "?s",oldcolor)<1)
			oldcolor="";
		}
	switch (fig.TYP) {
		case C_FIGNREF :
		// Get named reference
		nref=fig.NREF;
		nrefflag=1;
		macro=nref.MACRO;
		oldtnstr=fig.NAME;
		bclass=macro.CLASS;
		oldmacro=macro.NAME;
		if (bclass==DDBCLSLAB) {
			if (existddbelem(bae_planfname(),DDBCLSLAB,oldtnstr)==1)
				lab2a=newmacro=oldmacro;
			else
				mflag=1;
			oldlabtyp=newlabtyp= oldtnstr[0]=='?' ? 1 : 0 ;
			if (oldlabtyp) {
				oldtnstr=
				 strextract(oldtnstr,1,strlen(oldtnstr));
				lab1=UPRCPORT;
				}
			else {
				lab1=UPRCLAB;
				}
			labtypsel= cap_blocktopflag()==1 ? 0 : 1 ;
			nflag=1;
			boxid=3141;
			defwidth=50.8;
			}
		else {
			tnflag=1;
			mflag=1;
			if (ddbclass==DDBCLSSYM) {
				lab1=UPRCPIN;
				oldpintag=newpintag=fig.NREF.TAGPTYP;
				// Query the old bus status
				if (cap_rulequery(RS_OCFIG,fig,RS_SCMSUBJ,
				 RS_AUTOBUS,"?d",oldbuspin)<1)
					oldbuspin=0;
				newbuspin=oldbuspin;
				tmflag=1;
				boxid=3142;
				defwidth=50.8;
				}
			else {
				lab1=UPRCSYM;
				symflag=1;
				// Init the maximum pin name length
				MAXPINNAMLEN=strlen(ITMPINNAMHD);
				// Init the maximum net name length
				MAXNETNAMLEN=strlen(ITMNETNAMHD);
				// Init the maximum marker name length
				MAXSMRKLEN=strlen(ITMSMRKHD);
				// Init the maximum attribute name length
				MAXATRNAMLEN=strlen(ITMATRNAMHD);
				// Scan the current element
				curname=fig.NAME;
				cap_scanfelem(fig,0.0,0.0,0.0,1,
				 pinposscanfunc,NULL,NULL,NULL);
				boxid=3143;
				defwidth=50.8+SINFOW+2.0;
				minwidth=50.8+10.0;
				minheight=9.0*DIAL_CTRVSTEP+3.0*DIAL_SEPVSTEP+
				 2.0*DIAL_BUTVSTEP;
				resize=1;
				}
			}
		if (symflag) {
		    forall (att of nref) {
			// Get attribute base name
			attrname=att.NAME;
			if (strmatch(attrname,"*\003*\003")) {
				len=strlen(attrname);
				sprintf(attrvar,REPATTRVAR,
				 atoi(strextract(attrname,len-3,len-1)));
				attrname[len-4]='\0';
				}
			else {
				attrvar="";
				}
			// Get upper case attribute name
			attruname=attrname;
			strupper(attruname);
			// Build comment variable name
			sprintf(attrcommn,PAR_ATTRCOMMP,
			 strextract(attruname,1,strlen(attruname)));
			// Query comment variable
			if (varget(attrcommn,attrcommv)!=0 || attrcommv=="")
				// No comment available
				attrcommn=attrname;
			else
				// Attach comment to variable name
				sprintf(attrcommn,"%s %s",attrname,attrcommv);
			attrcommn+=attrvar;
			sprintf(attrdisp,REPATTRIB,attrcommn,
			 ATTFLEN>strlen(attrcommn) ?
			  ATTFLEN-strlen(attrcommn) : 0,ITMUDOT,att.VALUE);
			// Build order variable name
			sprintf(attrcommn,PAR_ATTRORDP,
			 strextract(attruname,1,strlen(attruname)));
			// Query order variable
			if (varget(attrcommn,attrord)!=0)
				// No order id available
				attrord=9999;
			for (i=an;i>0;i--)
				if (al[i-1].order>attrord ||
				 (al[i-1].order==attrord &&
				  (numstrcmp(al[i-1].name,attrname)>0 ||
				   (al[i-1].name==attrname &&
				    al[i-1].var>varnum))))
					al[i]=al[i-1];
				else
					break;
			// Store new attribute
			al[i].name=attrname;
			al[i].disp=attrdisp;
			al[i].order=attrord;
			al[i].var=varnum;
			an++;
			}
		    }
		if (an>0) {
			infostr=REPSYMATTR;
			for (i=0;i<an;i++)
				infostr+=al[i].disp+"\n";
			}
		if (pinn>0) {
			// Set the constant header strings
			sprintf(msg,FMTPTABH1,MAXPINNAMLEN,ITMPINNAMHD,
			 MAXSMRKLEN,ITMSMRKHD,MAXNETNAMLEN,ITMNETNAMHD,
			 ITMATRNAMHD);
			if (infostr=="")
				infostr=msg;
			else
				infostr+="\n"+msg;
			sprintf(msg,FMTPTABH2,
			 MAXPINNAMLEN,ITMULINE,MAXSMRKLEN,ITMULINE,
			 MAXNETNAMLEN,ITMULINE,MAXATRNAMLEN,ITMULINE);
			infostr+=msg;
			// Store the pin list
			for (i=0;i<pinn;i++) {
				sprintf(msg,FMTPTABF,MAXPINNAMLEN,
				 pinl[i].pinname,MAXSMRKLEN,pinl[i].marker,
				 MAXNETNAMLEN,pinl[i].netname,pinl[i].attrlist);
				infostr+=msg;
				}
			}
		lab2=UPRCMACRO;
		oldang=fig.ANGLE;
		miflag=1;
		angflag=1;
		if (act_var)
			break;
		// Get the reference text modifiers
		forall (rmod of nref) {
			rtl[rtn].str=rmod.STR;
			rtl[rtn].x=rmod.X;
			rtl[rtn].y=rmod.Y;
			rtl[rtn].ang=rmod.ANGLE;
			rtl[rtn].size=rmod.SIZE;
			rtl[rtn].mirr=rmod.MIRROR;
			rtn++;
			}
		mnx=macro.MNX; mny=macro.MNY;
		if (ddbclass==DDBCLSSYM || ddbclass==DDBCLSLAB) {
			// Query the current pin movement status
			if (cap_rulequery(RS_OCFIG,fig,RS_SCMSUBJ,
			 RS_PINMOVE,"?d",oldpinmove)<1)
				oldpinmove=0;
			// Query the current pin autoconnect status
			if (cap_rulequery(RS_OCFIG,fig,RS_SCMSUBJ,
			 RS_PINCON,"?d",oldpincon)<1)
				oldpincon=0;
			moflag=1;
			}
		break;
		case C_FIGPOLY :
		poly=fig.POLY;
		oldpolytyp=poly.TYP;
		ptflag= poly.PN<3 ? 2 : 1;
		if (oldpolytyp==C_POLYDOCAREA) {
			if (cap_rulequery(RS_OCFIG,fig,RS_SCMSUBJ,
			 RS_TNETAREA,"?s",oldnetarea)<1)
				oldnetarea="";
			else
				oldpolytyp=100;
			}
		newpolytyp=oldpolytyp;
		lab1=UPRPTYP;
		if (oldpolytyp==C_POLYDOCLINE) {
			oldwidth=fig.POLY.WIDTH;
			wedit=1;
			}
		else {
			wedit=0;
			}
		wflag=1;
		wprompt=UPRPWIDTH;
		bae_clearpoints();
		forall (p of poly) {
			pl[pn].x=p.X;
			pl[pn].y=p.Y;
			if (fabs(pl[pn].x-x)<=SMALLVAL &&
			 fabs(pl[pn].y-y)<=SMALLVAL)
				curcorner=pn;
			pl[pn].t=p.TYP;
			bae_storepoint(pl[pn].x,pl[pn].y,pl[pn].t);
			pn++;
			}
		polylab= bae_getpolyrange(prlx,prly,prux,pruy) ? 0 :
		 (oldpolytyp==C_POLYDOCLINE ? 2 : 1);
		corner=1;
		boxid=3144;
		defwidth=80.5;
		minwidth=50.5;
		minheight=8.0*DIAL_CTRVSTEP+3.0*DIAL_SEPVSTEP+
		 2.0*DIAL_BUTVSTEP;
		resize=1;
		break;
		case C_FIGTEXT :
		lab1=UPRCTEXT;
		oldang=fig.ANGLE;
		angflag=1;
		oldheight=fig.SIZE;
		hflag=1;
		oldwidth=fig.TEXT.WIDTH;
		wflag=1;
		wedit=1;
		wprompt=UPRPWIDTH;
		miflag=1;
		oldcenter=newcenter=(fig.TEXT.MODE&(TEXTHCENT|TEXTVCENT));
		oldmode=(fig.TEXT.MODE&1);
		oldframe1=(fig.TEXT.MODE&TEXTFRM1);
		oldframe2=(fig.TEXT.MODE&TEXTFRM2);
		oldframeo=(fig.TEXT.MODE&TEXTOFRM);
		// Query the multiline text status
		if (fig.RULEOBJID<0 || cap_rulequery(
		 RS_OCFIG,fig,RS_SCMSUBJ,RS_MTEXTID,"?s",mtextid)<=0) {
			mtextid="";
			lab1=UPRCTEXT;
			tnflag=1;
			oldtnstr=fig.NAME;
			zflag=1;
			boxid=3145;
			defwidth=50.8;
			}
		else {
			lab1=UPRCMTEXT;
			tnflag=2;
			lsflag=1;
			// Get text line spacing
			if (cap_rulequery(RS_OCFIG,fig,
			 RS_SCMSUBJ,RS_MTEXTLS,"?f",linespc)<1)
				linespc=LINESPC;
			// Scan all related multiline texts for text retrival
			forall (nfig where nfig.RULEOBJID>=0 &&
			 nfig.TYP==C_FIGTEXT && cap_rulequery(RS_OCFIG,
			  nfig,RS_SCMSUBJ,RS_MTEXTID,"?s",textid)>0 &&
			 textid==mtextid) {
				// Get text position
				if (cap_rulequery(RS_OCFIG,nfig,RS_SCMSUBJ,
				 RS_MTEXTCOL,"?d",col)<1)
					continue;
				if (cap_rulequery(RS_OCFIG,nfig,RS_SCMSUBJ,
				 RS_MTEXTROW,"?d",row)<1)
					continue;
				if (MTEXTORIG) {
					if (col==0 && row==0) {
						// Set text base point
						fig=nfig;
						x=fig.X-
						 sin(oldang)*oldheight*linespc;
						y=cos(oldang)*oldheight*linespc;
						y=fig.Y+(oldmirror ? -y : y);
						}
					if (row>maxline)
						maxline=row;
					}
				else {
					// Check if new best base point found
					if (col==0 && row>maxline) {
						// Set text base point
						fig=nfig;
						x=fig.X; y=fig.Y;
						maxline=row;
						}
					}
				if (col>maxcol)
					maxcol=col;
				stext[col][row]=nfig.NAME;
				}
			// Build the text edit string
			oldtnstr="";
			for (row=0;row<=maxline;row++) {
				for (col=0;col<=maxcol;col++)
					oldtnstr+=stext[col][row];
				oldtnstr+="\n";
				}
			boxid=3146;
			defwidth=50.8+SINFOW+2.0;
			minwidth=50.8+10.0;
			minheight=12.0*DIAL_CTRVSTEP+3.0*DIAL_SEPVSTEP+
			 2.0*DIAL_BUTVSTEP;
			resize=1;
			}
		break;
		default :
		exit(0);
		}
	pinx=x; piny=y;
	if (bae_dialclr()) {
		if (askcoord(pinx,piny,1))
			error_abort();
		if (baepar_intval(SCMPAR_RANGEDIS)==0)
			if (pinx<bae_planwslx() || pinx>bae_planwsux() ||
			 piny<bae_planwsly() || piny>bae_planwsuy())
				error(ERROUTBOUND);
		}
	else {
	    newtnstr=oldtnstr;
	    newlabtyp=oldlabtyp;
	    newnetarea=oldnetarea;
	    newpintag=oldpintag;
	    newbuspin=oldbuspin;
	    newang=cvtangle(oldang,0,1);
	    newheight=oldheight;
	    newwidth=oldwidth;
	    newmacro=oldmacro;
	    newmirror=oldmirror;
	    newpinmove=oldpinmove;
	    newpincon=oldpincon;
	    newgrpname=oldgrpname;
	    newcolor=oldcolor;
	    newframe1=oldframe1;
	    newframe2=oldframe2;
	    newframeo=oldframeo;
	    newcenter=oldcenter;
	    newmode=oldmode;
	    newglued=oldglued;
	    newpdis=oldpdis;
	    // Perform the dialog input loop
	    repflag=1;
	    do {
		if (resize) {
			dial_getboxsizemin(boxid,dialwidth,dialheight,
			 DIAL_LEFTMARG+defwidth+DIAL_RIGHTSMARG,minheight,
			 DIAL_LEFTMARG+minwidth+DIAL_RIGHTSMARG,minheight);
			dialwidth-=DIAL_LEFTMARG+DIAL_RIGHTSMARG;
			}
		else {
			dialwidth=defwidth;
			}
		// Init. the y coordinate
		cy=DIAL_TOPMARG;
		rightw=(symflag || tnflag==2) ?
		 (dialwidth-defwidth+SINFOW+1.0) : 0.0 ;
		// Store labels
		if (lab1!="") {
			if (labtypsel) {
				ltidx=bae_dialaddcontrol(PA_SB,0,0,newlabtyp,
				 0.0,0.0,0.0,"",0,DIAL_LEFTMARG,cy,pcol-2.0,"");
				dial_sbentry(0,0,UPRCLAB);
				dial_sbentry(0,1,UPRCPORT);
				}
			else {
				dial_label(0.0,cy,lab1);
				}
			}
		if (nflag) {
			if (act_var) {
				tnidx=dial_label(pcol,cy,newtnstr);
				}
			else {
				tnidx=bae_dialaddcontrol(PA_STR|PA_CHKNAME,
				 0,0,0,0.0,0.0,0.0,newtnstr,MAXKEYLEN,
				 DIAL_LEFTMARG+pcol,cy,30.0,"");
				bae_dialaddcontrol(PA_ACT,0,5,0,0.0,0.0,
				 0.0,"",0,DIAL_LEFTMARG+43.0,cy,0.0,UPRBROWSE);
				}
			cy+=DIAL_CTRVSTEP;
			}
		else if (tnflag==1) {
			if (symflag) {
				if (act_var)
					tnidx=bae_dialaddcontrol(
					 PA_STR|PA_NOEDIT,0,0,0,
					 0.0,0.0,0.0,newtnstr,strlen(newtnstr),
					 DIAL_LEFTMARG+pcol,cy,
					 bae_dialgettextlen(0,newtnstr)+1.0,"");
				else
					tnidx=bae_dialaddcontrol(
					 PA_STR|PA_CHKNAME|PA_HBRDREL,0,0,0,
					 0.0,0.0,0.0,newtnstr,MAXKEYLEN,
					 DIAL_LEFTMARG+pcol,cy,
					 DIAL_RIGHTSMARG+rightw,"");
				cy+=DIAL_CTRVSTEP;
				}
			else {
				tnidx=
				 act_var ? dial_cliplabel(pcol,cy,newtnstr) :
				 (fig.TYP==C_FIGNREF ?
				  dial_namestring(newtnstr,MAXKEYLEN,pcol,cy) :
				 dial_string(newtnstr,MAXTEXTLEN,pcol,cy));
				if (act_var)
					cy+=DIAL_CTRVSTEP;
				}
			}
		else if (tnflag==2)  {
			cy+=DIAL_CTRVSTEP;
			}
		if (rtn)
			rtridx=dial_toggle(rtrflag,pcol,cy,UPRTPOSRESET);
		if (tmflag) {
			tmidx=bae_dialaddcontrol(PA_SB,0,0,newpintag,
			 0.0,0.0,0.0,"",0,DIAL_LEFTMARG+pcol,cy,15.0,"");
			dial_sbentry(0,SYPSTD,UPRPTSTD);
			dial_sbentry(0,SYPSYMTAG,UPRPTSYMTAG);
			dial_sbentry(0,SYPPINTAG,UPRPTPINTAG);
			dial_sbentry(0,SYPNETTAG,UPRPTNETTAG);
			dial_sbentry(0,SYPNPNTAG,UPRPTNPNTAG);
			dial_sbentry(0,SYPNARTAG,UPRPTNARTAG);
			dial_sbentry(0,SYPPARTAG,UPRPTPARTAG);
			bpidx=bae_dialaddcontrol(PA_TOGGLE,0,0,
			 newbuspin,0.0,0.0,0.0,"",0,
			 DIAL_LEFTMARG+pcol+18.0,cy,0.0,UPRPTBUS);
			cy+=DIAL_CTRVSTEP;
			}
		naidx=(-1);
		if (ptflag) {
			ptidx=bae_dialaddcontrol(PA_SB,0,0,newpolytyp,
			 0.0,0.0,0.0,"",0,DIAL_LEFTMARG+pcol,cy,12.0,"");
			dial_sbentry(4,C_POLYDOCLINE,UPRPTYPGL);
			dial_sbentry(4,C_POLYDOTLINE,UPRPTYPDL);
			if (ptflag==1) {
				dial_sbentry(4,C_POLYDOCAREA,UPRPTYPGA);
				if (ddbclass==DDBCLSMRK)
					dial_sbentry(
					 4,C_POLYCONAREA,UPRPTYPCA);
				else if (ddbclass==DDBCLSCM)
					dial_sbentry(4,100,UPRPTYPNA);
				}
			if (newpolytyp==C_POLYDOCLINE)
				bae_dialaddcontrol(PA_ACT,0,7,0,0.0,0.0,0.0,"",
				 0,DIAL_LEFTMARG+pcol+13.0,cy,0.0,UPRDASHPBUT);
			if (newpolytyp==100) {
				naidx=bae_dialaddcontrol(PA_STR,
				 0,0,0,0.0,0.0,0.0,newnetarea,MAXKEYLEN,
				 DIAL_LEFTMARG+pcol+13.0,cy,6.5,"");
				bae_dialaddcontrol(PA_ACT,0,14,0,0.0,0.0,0.0,"",
				 0,DIAL_LEFTMARG+pcol+20.5,cy,0.0,UPRBROWSE);
				}
			cy+=DIAL_CTRVSTEP;
			}
		if (lab2!="")
			dial_label(0.0,cy,lab2);
		if (lab2a!="")
			dial_cliplabel(pcol,cy,lab2a);
		if (mflag) {
			midx=act_var ? dial_cliplabel(pcol,cy,newmacro) :
			 bae_dialaddcontrol(PA_STR|PA_CHKNAME,0,0,0,0.0,0.0,0.0,
			  newmacro,MAXKEYLEN,DIAL_LEFTMARG+pcol,cy,30.0,"");
			if (!act_var)
				bae_dialaddcontrol(PA_ACT,0,3,0,0.0,0.0,
				 0.0,"",0,DIAL_LEFTMARG+43.0,cy,0.0,UPRBROWSE);
			}
		if (lab2!="" || lab2a!="" || mflag)
			cy+=DIAL_CTRVSTEP;
		if (lab3!="") {
			dial_label(0.0,cy,lab3);
			cy+=DIAL_CTRVSTEP;
			}
		// Store coordinate controls
		dial_label(0.0,cy,UPRX);
		xidx=bae_dialaddcontrol(PA_DBL|PA_DIST,0,4,0,0.0,0.0,
		 pinx-bae_planwsnx(),"",0,DIAL_LEFTMARG+pcol,cy,12.0,"");
		if (corner) {
			cilidx=dial_label(pcol+13.0,cy,"");
			bae_dialaddcontrol(PA_ACT,0,10,0,0.0,0.0,0.0,"",0,
			 DIAL_LEFTMARG+pcol+21.0,cy,0.0,UPRPPREV);
			bae_dialaddcontrol(PA_ACT,0,11,0,0.0,0.0,0.0,"",0,
			 DIAL_LEFTMARG+pcol+21.0+
			 bae_dialgettextlen(0,UPRPPREV)+
			 (bae_swconfig(3)==2 ? 2.0 : 0.0),cy,0.0,UPRPNEXT);
			}
		cy+=DIAL_CTRVSTEP;
		dial_label(0.0,cy,UPRY);
		yidx=bae_dialaddcontrol(PA_DBL|PA_DIST,0,4,0,0.0,0.0,
		 piny-bae_planwsny(),"",0,DIAL_LEFTMARG+pcol,cy,12.0,"");
		bae_dialaddcontrol(PA_ACT,0,17,0,0.0,0.0,0.0,"",0,
		 DIAL_LEFTMARG+pcol+13.0,cy,0.0,UPRCCOPY);
		if (corner) {
			cy+=DIAL_CTRVSTEP;
			dial_label(0.0,cy,UPRRADIUS);
			crlidx=dial_label(pcol,cy,"");
			ctlidx=dial_label(pcol+13.0,cy,"");
			}
		if (angflag) {
			cy+=DIAL_CTRVSTEP;
			dial_label(0.0,cy,UPRANG);
			aidx=bae_dialaddcontrol(PA_DBL,0,2,0,0.0,0.0,
			 newang,"",0,DIAL_LEFTMARG+pcol,cy,12.0,"");
			if (!act_var) {
				bae_dialaddcontrol(PA_ACT,0,8,0,0.0,0.0,0.0,"",
				 0,DIAL_LEFTMARG+pcol+13.0,cy,0.0,UPRLEFT);
				bae_dialaddcontrol(PA_ACT,0,9,0,0.0,0.0,0.0,"",
				 0,DIAL_LEFTMARG+pcol+21.0,cy,0.0,UPRRIGHT);
				}
			}
		if (miflag) {
			cy+=DIAL_CTRVSTEP;
			dial_label(0.0,cy,UPRMIRROR);
			miidx=bae_dialaddcontrol(PA_RBF,0,0,newmirror,
			 0.0,0.0,0.0,"",0,DIAL_LEFTMARG+pcol,cy,0.0,UPRDOFF);
			bae_dialaddcontrol(PA_RBN,1,0,0,
			 0.0,0.0,0.0,"",0,DIAL_LEFTMARG+pcol+6.0,cy,0.0,UPRDON);
			}
		if (hflag) {
			cy+=DIAL_CTRVSTEP;
			dial_label(0.0,cy,UPRHEIGHT);
			hidx=bae_dialaddcontrol(PA_DBL|PA_DIST|PA_CHKLL,0,4,0,
			 0.0,0.0,newheight,"",0,DIAL_LEFTMARG+pcol,cy,12.0,"");
			}
		if (lsflag) {
			cy+=DIAL_CTRVSTEP;
			dial_label(0.0,cy,UPRLINESPC);
			 lsidx=bae_dialaddcontrol(PA_DBL|PA_CHKLL,0,5,0,
			 0.0,0.0,linespc,"",0,DIAL_LEFTMARG+pcol,cy,12.0,"");
			}
		widx=(-1);
		if (wflag) {
			cy+=DIAL_CTRVSTEP;
			dial_label(0.0,cy,wprompt);
			if (wedit)
				widx=bae_dialaddcontrol(PA_DBL|PA_DIST,0,4,0,
				 0.0,0.0,newwidth,"",0,DIAL_LEFTMARG+pcol,cy,
				 12.0,"");
			else
				bae_dialaddcontrol(PA_LAB,0,0,0,0.0,0.0,0.0,"",
				 0,DIAL_LEFTMARG+pcol,cy,0.0,UPRNIL);
			}
		if (zflag || tnflag==2) {
			cy+=DIAL_CTRVSTEP;
			cidx=bae_dialaddcontrol(PA_TOGGLE,0,0,
			 newmode,0.0,0.0,0.0,"",0,
			 DIAL_LEFTMARG+pcol,cy,0.0,UPRCOMMENT);
			}
		if (zflag) {
			bae_dialaddcontrol(PA_ACT,0,13,0,0.0,0.0,0.0,"",
			 0,DIAL_LEFTMARG+pcol+13.0,cy,0.0,UPRTEXTCLASS);
			cy+=DIAL_CTRVSTEP;
			dial_label(0.0,cy,UPRCENTER);
			zidx=bae_dialaddcontrol(PA_RBF,0,0,newcenter,
			 0.0,0.0,0.0,"",0,DIAL_LEFTMARG+pcol,cy,0.0,UPRCENTN);
			bae_dialaddcontrol(PA_RBN,TEXTHCENT,0,0,0.0,0.0,0.0,
			 "",0,DIAL_LEFTMARG+pcol+7.0,cy,0.0,UPRCENTH);
			bae_dialaddcontrol(PA_RBN,TEXTVCENT,0,0,0.0,0.0,0.0,
			 "",0,DIAL_LEFTMARG+pcol+14.0,cy,0.0,UPRCENTV);
			bae_dialaddcontrol(PA_RBN,TEXTHCENT|TEXTVCENT,0,0,0.0,
			 0.0,0.0,"",0,DIAL_LEFTMARG+pcol+21.0,cy,0.0,UPRCENTHV);
			cy+=DIAL_CTRVSTEP;
			dial_label(0.0,cy,UPRFRAME);
			fr1idx=bae_dialaddcontrol(PA_TOGGLE,0,0,
			 newframe1 ? 1 : 0,0.0,0.0,0.0,"",0,
			 DIAL_LEFTMARG+pcol,cy,0.0,UPRFRAME1);
			fr2idx=bae_dialaddcontrol(PA_TOGGLE,0,0,
			 newframe2 ? 1 : 0,0.0,0.0,0.0,"",0,
			 DIAL_LEFTMARG+pcol+7.0,cy,0.0,UPRFRAME2);
			froidx=bae_dialaddcontrol(PA_TOGGLE,0,0,
			 newframeo ? 1 : 0,0.0,0.0,0.0,"",0,
			 DIAL_LEFTMARG+pcol+14.0,cy,0.0,UPRFRAMEO);
			}
		cy+=DIAL_CTRVSTEP;
		if (moflag) {
			mo1idx=bae_dialaddcontrol(PA_TOGGLE,0,0,
			 (newpinmove&0x01)!=0 ? 1 : 0,0.0,0.0,0.0,"",0,
			 DIAL_LEFTMARG+pcol,cy,0.0,UPRPINMOVE);
			cy+=DIAL_CTRVSTEP;
			dial_label(0.0,cy,UPRPINMODE);
			mo2idx=bae_dialaddcontrol(PA_TOGGLE,0,0,
			 (newpinmove&0x02)!=0 ? 1 : 0,0.0,0.0,0.0,"",0,
			 DIAL_LEFTMARG+pcol,cy,0.0,UPRPINNMIRR);
			mo3idx=bae_dialaddcontrol(PA_TOGGLE,0,0,
			 (newpinmove&0x04)!=0 ? 1 : 0,0.0,0.0,0.0,"",0,
			 DIAL_LEFTMARG+25.0,cy,0.0,UPRPINNROT);
			cy+=DIAL_CTRVSTEP;
			pcnidx=bae_dialaddcontrol(PA_TOGGLE,0,0,
			 newpincon,0.0,0.0,0.0,"",0,
			 DIAL_LEFTMARG+pcol,cy,0.0,UPRPINCON);
			cy+=DIAL_CTRVSTEP;
			}
		if (resize && polylab)
			cy+=dialheight-minheight;
		if (polylab) {
			bmheight=bmoheight=cy-DIAL_TOPMARG-DIAL_SEPVSTEP;
			bmwidth=dialwidth-41.5;
			bae_clearpoints();
			for (i=0;i<pn;i++)
				bae_storepoint(pl[i].x,pl[i].y,pl[i].t);
			bae_getpolyrange(prlx,prly,prux,pruy);
			if (fabs(prux-prlx)>fabs(pruy-prly))
				pradj=0.1*fabs(prux-prlx);
			else
				pradj=0.1*fabs(pruy-prly);
			prlx-=pradj; prly-=pradj;
			prux+=pradj; pruy+=pradj;
			pradj*=0.5;
			// Create the picture button bitmap
			if (bmp_setsize(
			  prlx,pruy,prux,prly,bmwidth,bmheight,0.0,0.0) ||
			 bae_dialbmpalloc(bmwidth,bmheight,2,0,0)!=2)
				error_abort();
			// Store the bitmap label
			bae_dialadvcontrol(PA_BMLAB,0,0,2,0.0,0.0,0.0,"",0,
			 DIAL_LEFTMARG+40.5,DIAL_TOPMARG+
			  0.5*(bmoheight-bmheight),bmwidth,bmheight,"");
			}
		bae_dialaddcontrol(PA_HSEP|PA_HBRDREL,0,0,0,0.0,0.0,0.0,"",0,
		 DIAL_LEFTMARG,cy,DIAL_RIGHTSMARG+rightw,"");
		cy+=DIAL_SEPVSTEP;
		if (ddbclass==DDBCLSCM) {
			dial_label(0.0,cy,UPRPLOTVIS);
			pdidx=bae_dialaddcontrol(PA_RBF,1,0,newpdis,
			 0.0,0.0,0.0,"",0,DIAL_LEFTMARG+pcol,cy,0.0,UPRDOFF);
			bae_dialaddcontrol(PA_RBN,0,0,0,
			 0.0,0.0,0.0,"",0,DIAL_LEFTMARG+pcol+6.0,cy,0.0,UPRDON);
			cy+=DIAL_CTRVSTEP;
			}
		dial_label(0.0,cy,UPRGLUED);
		gidx=bae_dialaddcontrol(PA_RBF,0,0,newglued,
		 0.0,0.0,0.0,"",0,DIAL_LEFTMARG+pcol,cy,0.0,UPRDOFF);
		bae_dialaddcontrol(PA_RBN,1,0,0,
		 0.0,0.0,0.0,"",0,DIAL_LEFTMARG+pcol+6.0,cy,0.0,UPRDON);
		cy+=DIAL_CTRVSTEP;
		dial_label(0.0,cy,UPRCGRPNAME);
		gnidx=bae_dialaddcontrol(PA_STR,0,0,0,0.0,
		 0.0,0.0,newgrpname,MAXKEYLEN,DIAL_LEFTMARG+pcol,cy,30.0,"");
		bae_dialaddcontrol(PA_ACT,0,15,0,0.0,0.0,
		 0.0,"",0,DIAL_LEFTMARG+43.0,cy,0.0,UPRBROWSE);
		cy+=DIAL_CTRVSTEP;
		dial_label(0.0,cy,UPRCELEMCOLOR);
		ecidx=bae_dialaddcontrol(PA_STR,0,0,0,0.0,
		 0.0,0.0,newcolor,MAXKEYLEN,DIAL_LEFTMARG+pcol,cy,12.0,"");
		bae_dialaddcontrol(PA_ACT,0,16,0,0.0,0.0,
		 0.0,"",0,DIAL_LEFTMARG+25.0,cy,0.0,UPRBRWCOLOR);
		if (resize && !polylab)
			cy+=dialheight-minheight;
		// Store the OK and abort button with seperator
		cy+=DIAL_BUTVSTEP;
		dial_hsep(cy);
		// Store the coordinate unit controls
		cunits= bae_getcoorddisp() ? 1 : 0;
		bae_dialaddcontrol(PA_RBF,0,1,cunits,0.0,0.0,
		 0.0,"",0,DIAL_LEFTMARG+pcol+6.0,cy,0.0,UPRDUNITMM);
		bae_dialaddcontrol(PA_RBN,2,2,0,0.0,0.0,0.0,
		 "",0,DIAL_LEFTMARG+pcol+12.0,cy,0.0,UPRDUNITINCH);
		if (bclass==DDBCLSSYM) {
			// Check if symbol with attributes
			if (cap_scanpool(fig.NREF.MACRO,0.0,0.0,0.0,0,
			 amacfunc,NULL,NULL,atextfunc))
				error_scan();
			if (attrfound)
				bae_dialaddcontrol(PA_ACT,0,6,0,0.0,0.0,0.0,"",
				 0,DIAL_LEFTMARG+52.8,cy,0.0,UPRATTRASS);
			}
		bae_dialaddcontrol(PA_ACT,0,12,0,0.0,0.0,0.0,"",0,
		 DIAL_LEFTMARG+(bclass==DDBCLSSYM ? 43.0 : pcol+20.5),cy,
		 0.0,UPRRULEBUT);
		dial_okabort(cy);
		if (symflag)
			bae_dialadvcontrol(
			 PA_STR|PA_NOEDIT|PA_FNTFIX|PA_HBRDREL|PA_VBRDREL,
			 0,0,0,0.0,0.0,0.0,infostr,2*strlen(infostr),
			 DIAL_LEFTMARG+52.8,0.0,DIAL_RIGHTSMARG,
			 2*DIAL_SEPVSTEP+DIAL_BUTVSTEP+0.2,"");
		if (tnflag==2)
			tnidx=bae_dialadvcontrol(
			 PA_STR|PA_FNTFIX|PA_HBRDREL|PA_VBRDREL,
			 0,0,0,0.0,0.0,0.0,newtnstr,MAXEDIT,
			 DIAL_LEFTMARG+52.8,0.0,DIAL_RIGHTSMARG,
			 2*DIAL_SEPVSTEP+DIAL_BUTVSTEP+0.2,"");
		// Update corner data
		if (corner) {
			sprintf(msg,UPRPINDEX,curcorner+1,pn);
			bae_dialsetdata(cilidx,PA_LAB,0,0.0,msg);
			asidx= (curcorner==0 ? pn : curcorner)-1;
			aeidx= curcorner==(pn-1) ? 0 : (curcorner+1);
			if (pl[curcorner].t) {
				/* Get the arc angles */
				if ((ang1=atan2(
				 pl[asidx].y-pl[curcorner].y,
				 pl[asidx].x-pl[curcorner].x))<0.0)
					ang1+=DPI;
				if ((ang2=atan2(
				 pl[aeidx].y-pl[curcorner].y,
				 pl[aeidx].x-pl[curcorner].x))<0.0)
					ang2+=DPI;
				ang1= pl[curcorner].t==2 ?
				 (ang1-ang2) : (ang2-ang1) ;
				if (ang1<0.0)
					ang1+=DPI;
				}
			sprintf(msg,pl[curcorner].t==2 ? UPRARCRIGHT :
			 pl[curcorner].t==1 ? UPRARCLEFT : "",
			 bae_numstring(cvtangle(ang1,0,1),1));
			bae_dialsetdata(ctlidx,PA_LAB,0,0.0,msg);
			if (pl[curcorner].t==0)
				msg=UPRNIL;
			else
				sprintf(msg,"%smm",bae_numstring(cvtlength(
				 dist(pl[curcorner].x,pl[curcorner].y,
				  pl[aeidx].x,pl[aeidx].y),0,2),3));
			bae_dialsetdata(crlidx,PA_LAB,0,0.0,msg);
			}
		if (polylab) {
			// Draw the picture label bitmap
			bae_popsetarea(2);
			btp_drawrect(COLOR_BLACK,DM_REPLACE,1,
			 prlx,prly,prux-prlx,pruy-prly);
			bae_clearpoints();
			for (i=0;i<pn;i++)
				btp_storepoint(pl[i].x,pl[i].y,pl[i].t);
			bae_popdrawpoly(COLOR_YELLOW,DM_SET,
			 (!ptflag || newpolytyp==C_POLYDOCLINE) ?
			 PPFM_LINE : PPFM_CLINE);
			btp_drawline(COLOR_WHITE,DM_REPLACE,
			 pl[curcorner].x-pradj,pl[curcorner].y-pradj,
			 pl[curcorner].x+pradj,pl[curcorner].y+pradj);
			btp_drawline(COLOR_WHITE,DM_REPLACE,
			 pl[curcorner].x-pradj,pl[curcorner].y+pradj,
			 pl[curcorner].x+pradj,pl[curcorner].y-pradj);
			bae_popsetarea(0);
			}
		// Call the dialog function
		bae_setintpar(16,boxid);
		res=bae_dialaskparams((resize ? "!" : "")+UPRCCOORD,cunits,
		 DIAL_LEFTMARG+dialwidth+DIAL_RIGHTSMARG,cy);
		if (act_var)
			newtnstr=oldtnstr;
		else
			bae_dialgetdata(tnidx,0,0.0,newtnstr);
		if (labtypsel)
			bae_dialgetdata(ltidx,newlabtyp,0.0,"");
		if (rtn)
			bae_dialgetdata(rtridx,rtrflag,0.0,"");
		if (ptflag) {
			bae_dialgetdata(ptidx,newpolytyp,0.0,"");
			if (naidx>=0)
				bae_dialgetdata(naidx,0,0.0,newnetarea);
			}
		if (tmflag) {
			bae_dialgetdata(tmidx,newpintag,0.0,"");
			bae_dialgetdata(bpidx,newbuspin,0.0,"");
			}
		bae_dialgetdata(xidx,0,pinx,"");
		bae_dialgetdata(yidx,0,piny,"");
		pinx+=bae_planwsnx();
		piny+=bae_planwsny();
		if (ptflag) {
			pl[curcorner].x=pinx;
			pl[curcorner].y=piny;
			}
		if (angflag)
			bae_dialgetdata(aidx,0,newang,"");
		if (hflag)
			bae_dialgetdata(hidx,0,newheight,"");
		if (lsflag)
			bae_dialgetdata(lsidx,0,linespc,"");
		if (widx>=0)
			bae_dialgetdata(widx,0,newwidth,"");
		if (mflag)
			bae_dialgetdata(midx,0,0.0,newmacro);
		if (miflag)
			bae_dialgetdata(miidx,newmirror,0.0,"");
		if (moflag) {
			bae_dialgetdata(mo1idx,newpinmove1,0.0,"");
			bae_dialgetdata(mo2idx,newpinmove2,0.0,"");
			bae_dialgetdata(mo3idx,newpinmove3,0.0,"");
			newpinmove=(newpinmove1 ? 1 : 0)|
			 (newpinmove2 ? 2 : 0)|(newpinmove3 ? 4 : 0);
			bae_dialgetdata(pcnidx,newpincon,0.0,"");
			}
		bae_dialgetdata(gnidx,0,0.0,newgrpname);
		bae_dialgetdata(ecidx,0,0.0,newcolor);
		if (zflag) {
			bae_dialgetdata(fr1idx,newframe1,0.0,"");
			if (newframe1)
				newframe1=TEXTFRM1;
			bae_dialgetdata(fr2idx,newframe2,0.0,"");
			if (newframe2)
				newframe2=TEXTFRM2;
			bae_dialgetdata(froidx,newframeo,0.0,"");
			if (newframeo)
				newframeo=TEXTOFRM;
			bae_dialgetdata(zidx,newcenter,0.0,"");
			bae_dialgetdata(cidx,newmode,0.0,"");
			}
		else if (tnflag==2) {
			bae_dialgetdata(cidx,newmode,0.0,"");
			}
		bae_dialgetdata(gidx,newglued,0.0,"");
		if (ddbclass==DDBCLSCM)
		    bae_dialgetdata(pdidx,newpdis,0.0,"");
		else
		    newpdis=0;
		switch (res) {
			// Done
			case 6 :
			if (act_var) {
				scm_setpickelem(fig);
				bae_storemouseiact(3,px,py,0,LMB);
				ulsystem(UL_ATTRSET,0);
				exit(0);
				}
			case 0 :
			case 7 :
			case 8 :
			case 9 :
			case 12 :
			case 13 :
			case 14 :
			if (tnflag || nflag) {
				if (fig.TYP==C_FIGNREF && !nflag &&
				 oldtnstr!=newtnstr &&
				 (cap_nrefsearch(newtnstr,nfig)==0 ||
				  ((planname=cap_partplan(
				    bae_planfname(),newtnstr))!="" &&
				   planname!=bae_planename()))) {
					sprintf(msg,ERRDUPNAME,newtnstr);
					bae_msgbox(2,msg,"");
					break;
					}
				}
			if (angflag) {
				if (res==8)
					newang=fmod(newang+90.0,360.0);
				else if (res==9)
					newang=fmod(newang-90.0,360.0);
				}
			if (ddbclass==DDBCLSCM) {
			    if (act_var && res==0) {
				// Check if multiline text
				if (mtextid!="") {
					forall (nfig where
					 nfig.TYP==C_FIGTEXT &&
					 nfig.RULEOBJID>=0 &&
					 cap_rulequery(RS_OCFIG,nfig,RS_SCMSUBJ,
					  RS_MTEXTID,"?s",textid)>0 &&
					 textid==mtextid)
						rsc_assfigintpred(nfig,
						 RS_VARPLOTDIS+itoa(act_var),
						 newpdis,0,"");
					}
				else {
					rsc_assfigintpred(fig,RS_VARPLOTDIS+
					 itoa(act_var),newpdis,0,"");
					if ((NOPLCPVIS&1)==1 && symflag)
						scm_setpartattrib(
						 oldtnstr,"$noplc",
						 newpdis ? NOPLCVAL : "",0);
					}
				bae_callmenu(MNU_BAEREDISPL);
				bae_prtdialog(WRNVARPDIS);
				exit(0);
				}
			    }
			if (baepar_intval(SCMPAR_RANGEDIS)==0 &&
			 (pinx<bae_planwslx() || pinx>bae_planwsux() ||
			  piny<bae_planwsly() || piny>bae_planwsuy())) {
				bae_msgbox(2,ERROUTBOUND,"");
				break;
				}
			repflag=0;
			break;
			// Switch to mm units
			case 1 :
			cunits=0;
			break;
			// Switch to Inch units
			case 2 :
			cunits=1;
			break;
			// Browse macro name
			case 3 :
			msg=newmacro;
			if (bae_asksymname(msg,bae_planfname(),
			 bclass,strextractfilepath(scm_deflibname()),
			 scm_libfname(),msg)==0)
				newmacro=msg;
			break;
			// Polygon type change
			case 4 :
			wedit= newpolytyp==C_POLYDOCLINE ? 1 : 0 ;
			break;
			// Browse net name
			case 5 :
			msg=newtnstr;
			if (scm_asktreename(msg)==0)
				newtnstr=msg;
			break;
			// Polygon previous point
			case 10 :
			// Polygon next point
			case 11 :
			pl[curcorner].x=pinx;
			pl[curcorner].y=piny;
			// Adjust arc center neighbours
			if (pl[curcorner].t) {
				if (curcorner==0) {
					pl[pn-1].x+=pinx-x;
					pl[pn-1].y+=piny-y;
					}
				else {
					pl[curcorner-1].x+=pinx-x;
					pl[curcorner-1].y+=piny-y;
					}
				if (curcorner==(pn-1)) {
					pl[0].x+=pinx-x;
					pl[0].y+=piny-y;
					}
				else {
					pl[curcorner+1].x+=pinx-x;
					pl[curcorner+1].y+=piny-y;
					}
				}
			if (res==10) {
				curcorner--;
				if (curcorner<0)
					curcorner=pn-1;
				}
			else {
				curcorner++;
				if (curcorner>=pn)
					curcorner=0;
				}
			pinx=x=pl[curcorner].x; piny=y=pl[curcorner].y;
			break;
			// Browse group name name
			case 15 :
			res=0;
			bae_nameclr();
			forall (nfig where nfig.RULEOBJID>=0) {
				// Query group name predicate
				if (cap_rulequery(RS_OCFIG,nfig,RS_SCMSUBJ,
				 RS_GROUPNAME,"?s",msg)<1)
					continue;
				bae_nameadd(msg,"","","",2);
				res=1;
				}
			// Check if group names found
			if (!res) {
				bae_msgbox(2,ERRNOGRPNAMES,"");
				break;
				}
			msg=newgrpname;
			// Select group name
			bae_setintpar(16,3136);
			if (bae_askname(msg,UPRCGRPNAME,MAXKEYLEN))
				// Aborted
				break;
			newgrpname=msg;
			break;
			// Browse color
			case 16 :
			// Process any redraw event
			bae_wsmouse(0.0,0.0,0);
			// Temporarily use tag links for color query
			oldcol=bae_getcolor(13);
			bae_setcolor(13,0);
			bae_clriactqueue();
			bae_storemenuiact(1,11,LMB);
			bae_storemouseiact(0,0.0,0.0,0,LMB);
			bae_storemenuiact(1,14,LMB);
			bae_callmenu(107);
			if ((newcol=bae_getcolor(13))>=0 && newcol<=15)
				newcolor=colstrings[newcol];
			// Restore tag links color
			bae_setcolor(13,oldcol);
			break;
			// Copy coordinates
			case 17 :
			if (corner) {
				msg="";
				for (i=0;i<pn;i++)
					msg+=(i!=0 ? "\n" : "")+
					 coordstr(pl[i].x-bae_planwsnx(),
					  pl[i].y-bae_planwsny(),
					  pl[i].t,cunits);
				}
			else {
				msg=coordstr(pinx-bae_planwsnx(),
				 piny-bae_planwsny(),0,cunits);
				}
			bae_setclipboard(msg);
			break;
			// Resize
			case (-2) :
			break;
			// Fail/abort
			case (-1) :
			default :
			error_abort();
			}
		bae_dialclr();
		} while (repflag);
	    }
	// Check if variant disabled function
	if (act_var) {
		bae_msgbox(2,ERRVARFUNC,"");
		exit(0);
		}
	// Browse net area name
	if (res==14) {
		// Build the net area name list
		bae_nameclr();
		forall (nfig where nfig.TYP==C_FIGPOLY && nfig.RULEOBJID>=0) {
			// Query net area name predicate
			if (cap_rulequery(RS_OCFIG,nfig,
			 RS_SCMSUBJ,RS_TNETAREA,"?s",msg)<1)
				continue;
			bae_nameadd(msg,"","","",2);
			}
		// Select net area name
	 	bae_setintpar(16,3137);
		if (bae_askname(newnetarea,UPRNETAREA,MAXKEYLEN))
			// Aborted
			error_abort();
		}
	// Check if glued element
	if (oldglued) {
		if (!bae_msgboxverify(UPRGLUECHG,""))
			error_abort();
		// Save current state for undo
		bae_callmenu(MNU_BAESAVESTATE);
		rsc_assfigintpred(fig,RS_GLUED,0,0,"");
		bae_postprocess();
		}
	else {
		// Save current state for undo
		bae_callmenu(MNU_BAESAVESTATE);
		}
	// Check the corner process mode
	if (corner) {
		pl[curcorner].x=pinx;
		pl[curcorner].y=piny;
		if (pl[curcorner].t) {
			if (curcorner==0) {
				pl[pn-1].x+=pinx-x;
				pl[pn-1].y+=piny-y;
				}
			else {
				pl[curcorner-1].x+=pinx-x;
				pl[curcorner-1].y+=piny-y;
				}
			if (curcorner==(pn-1)) {
				pl[0].x+=pinx-x;
				pl[0].y+=piny-y;
				}
			else {
				pl[curcorner+1].x+=pinx-x;
				pl[curcorner+1].y+=piny-y;
				}
			}
		}
	// Get the element data
	rn= fig.RULEOBJID>=0 ? rsc_getfigrules(fig,rl) : 0;
	group=fig.GROUP;
	newang=cvtangle(newang,1,0);
	// Store changed element
	switch (fig.TYP) {
		case C_FIGNREF :
		if (bclass!=DDBCLSLAB && oldtnstr!=newtnstr &&
		 cap_nrefsearch(newtnstr,nfig)==0) {
			sprintf(msg,ERRDUPNAME,newtnstr);
			error(msg);
			}
		// Scan tag references to this part
		forall (tfig where tfig.TYP==C_FIGNREF &&
		 tfig.NREF.MACRO.TAGSYM!=0) {
			// Scan tag pins
			tpidx=0;
			while (cap_gettagdata(
			 tfig,tpidx,tpmode,tpinname,tref1,tref2)==0) {
				// Check if reference to renamed symbol
				if (tref1==oldtnstr &&
				 (tpmode==1 || tpmode==2)) {
					// Store tag data
					tagrl[tagrn].fig=tfig;
					tagrl[tagrn].pinname=tpinname;
					tagrl[tagrn].ref2=tref2;
					tagrn++;
					}
				tpidx++;
				}
			}
		// Scan own tag pins
		while (cap_gettagdata(
		 fig,tagdn,tpmode,tpinname,tref1,tref2)==0) {
			// Store tag data
			tagdl[tagdn].fig=tfig;
			tagdl[tagdn].pinname=tpinname;
			tagdl[tagdn].ref1=tref1;
			tagdl[tagdn].ref2=tref2;
			tagdn++;
			}
		// Store new part
		if (bclass==DDBCLSLAB) {
			// Request optional connection re-route
			scm_setintpar(11,1);
			// Delete the picked label
			scm_delelem(fig);
			oldmacro=baepar_strval(
			 newlabtyp ? SCMPAR_PORTMACRO : SCMPAR_LABELMACRO);
			bae_storetextiact(3,newmacro);
			bae_callmenu(newlabtyp ? 811 : 809);
			scm_storelabel(
			 newtnstr,newlabtyp,pinx,piny,newang,newmirror);
			bae_storetextiact(3,oldmacro);
			bae_callmenu(newlabtyp ? 811 : 809);
			}
		else {
			if (oldtnstr!=newtnstr || bclass==DDBCLSMRK) {
				// Get the part attributes
				attrn=0;
				forall (att of nref
				 where scm_chkattrname(att.NAME)==0) {
					attrl[attrn].name=att.NAME;
					attrl[attrn].val=att.VALUE;
					attrn++;
					}
				// Delete the picked symbol
				scm_delelem(fig);
				scm_storepart(newtnstr,newmacro,pinx,piny,
				 newang,newmirror|(newpintag<<1));
				for (i=0;i<attrn;i++)
					if (scm_setpartattrib(newtnstr,
					 attrl[i].name,attrl[i].val,4|
					 (i==0 ? 1 : 0)|(i==(attrn-1) ? 2 : 0)))
						attrerr++;
				}
			else {
				// Force replacement with full attr. transfer
				scm_storepart(" "+newtnstr,newmacro,pinx,piny,
				 newang,newmirror|(newpintag<<1));
				if (rtrflag && cap_nrefsearch("",nfig)==0)
					// Reset text positions
					scm_attachtextpos(nfig,"",
					 0.0,0.0,0.0,0.0,0);
				}
			}
		if ((NOPLCPVIS&1)==1)
			scm_setpartattrib(
			 newtnstr,"$noplc",newpdis ? NOPLCVAL : "",3);
		// Transfer name moves
		if (!rtrflag)
		    for (i=0;i<rtn;i++)
			if (cap_nrefsearch("",nfig)==0) {
				ttx=rtl[i].x-mnx;
				tty=rtl[i].y-mny;
				tang=rtl[i].ang;
				rtl[i].mirr= newmirror!=rtl[i].mirr ? 1 : 0 ;
				if (rtl[i].mirr)
					tang-=newang;
				else
					tang+=newang;
				if (newmirror)
					tty=(-tty);
				asin=sin(newang);
				acos=cos(newang);
				btx=acos*ttx-asin*tty;
				bty=asin*ttx+acos*tty;
				while (tang<0.0)
					tang+=DPI;
				while (tang>=DPI)
					tang-=DPI;
				// Store the text position
				scm_attachtextpos(nfig,rtl[i].str,pinx+btx,
				 piny+bty,tang,rtl[i].size,rtl[i].mirr);
				}
		break;
		case C_FIGPOLY :
		// Test if area to line transformation
		if ((oldpolytyp!=C_POLYDOCLINE && oldpolytyp!=C_POLYDOTLINE) &&
		 (newpolytyp==C_POLYDOCLINE || newpolytyp==C_POLYDOTLINE) &&
		 pn>0) {
			if (pl[0].t) {
				for (i=pn;i>0;i--)
					pl[i]=pl[i-1];
				pl[0]=pl[pn];
				pn++;
				}
			else {
				// Add first area point to line point list
				pl[pn++]=pl[0];
				}
			}
		// Test if closed line to area transformation
		else if (
		 (oldpolytyp==C_POLYDOCLINE || oldpolytyp==C_POLYDOTLINE) &&
		 (newpolytyp!=C_POLYDOCLINE && newpolytyp!=C_POLYDOTLINE) &&
		 pn>2 && pl[0].x==pl[pn-1].x && pl[0].y==pl[pn-1].y &&
		 pl[0].t==pl[pn-1].t)
			// Delete last area point from point list
			pn--;
		scm_delelem(fig);
		bae_clearpoints();
		for (i=0;i<pn;i++)
			bae_storepoint(pl[i].x,pl[i].y,pl[i].t);
		scm_storepoly(newpolytyp==100 ? C_POLYDOCAREA : newpolytyp);
		break;
		case C_FIGTEXT :
		if (tnflag==2) {
			// Scan all related multiline texts for deletion
			forall (nfig where nfig.RULEOBJID>=0 &&
			 nfig.TYP==C_FIGTEXT && cap_rulequery(RS_OCFIG,
			  nfig,RS_SCMSUBJ,RS_MTEXTID,"?s",textid)>0 &&
			 textid==mtextid) {
				fig=nfig;
				scm_delelem(fig);
				}
			// Split text into lines
			maxline=splitstring(newtnstr,lines);
			// Get the base rules
			mrulen=4;
			sprintf(mrulel[0],":%s:%s='%s';",
			 RS_SCMSUBJ,RS_MTEXTID,mtextid);
			for (i=0;i<rn;i++) {
				msg=rl[i];
				if (strmatch(msg,":scm_rules:mtextid=*;") ||
				 strmatch(msg,":scm_rules:mtextrow=*;") ||
				 strmatch(msg,":scm_rules:mtextcol=*;") ||
				 strmatch(msg,":scm_rules:mtextls=*;"))
					continue;
				mrulel[mrulen]=msg;
				mrulen++;
				}
			lsx=-sin(newang)*newheight*linespc;
			lsy=cos(newang)*newheight*linespc;
			lcx=cos(newang)*newheight*MAXKEYLEN*2.0/3.0;
			lcy=sin(newang)*newheight*MAXKEYLEN*2.0/3.0;
			if (newmirror) {
				lcy=(-lcy);
				lsy=(-lsy);
				}
			if (MTEXTORIG) {
				pinx-=lsx*maxline;
				piny-=lsy*maxline;
				}
			// Place the text lines
			for (maxline--;maxline>=0;maxline--) {
				col=0;
				newtnstr=
				strextract(lines[maxline],0,MAXKEYLEN-1);
				while (strlen(newtnstr)>0) {
					// Store text with new string
					scm_storetext(newtnstr,
					 pinx+col*lcx,piny+col*lcy,newang,
					  newheight,newmirror,newmode);
					// Attach rules
					if (cap_lastfigelem(fig)==0) {
						sprintf(mrulel[1],":%s:%s=%d;",
						 RS_SCMSUBJ,RS_MTEXTCOL,col);
						sprintf(mrulel[2],":%s:%s=%d;",
						 RS_SCMSUBJ,RS_MTEXTROW,
						 maxline);
						sprintf(mrulel[3],
						 ":%s:%s=%.2f;",RS_SCMSUBJ,
						 RS_MTEXTLS,linespc);
						if (cap_rulefigatt(fig,mrulel))
							rsc_error(-1);
						}
					// Advance to next column
					col++;
					newtnstr=strextract(lines[maxline],
					 col*MAXKEYLEN,(col+1)*MAXKEYLEN-1);
					}
				// Advance to next line
				pinx+=lsx;
				piny+=lsy;
				}
			}
		 else {
			scm_delelem(fig);
			scm_storetext(
			 newtnstr,pinx,piny,newang,newheight,newmirror,
			 newframe1|newframe2|newframeo|newcenter|newmode);
			}
		break;
		}
	// Check if element should be group selected
	if (group &&
	 (nrefflag ? cap_nrefsearch("",nfig) : cap_lastfigelem(nfig))==0)
		scm_elemgrpchg(nfig,1);
	// Attach rules
	if (tnflag!=2 && rn>0 &&
	 (nrefflag ? cap_nrefsearch("",nfig) : cap_lastfigelem(nfig))==0 &&
	 cap_rulefigatt(nfig,rl))
		rsc_error(-1);
	// Dismiss any polygon dash rule
	if (rn>0 && cap_lastfigelem(nfig)==0 &&
	 ptflag && newpolytyp!=C_POLYDOCLINE) {
		rsc_assfigintpred(nfig,RS_POLYDASH,0,0,"");
		cap_lastfigelem(nfig);
		rsc_assfigdblpred(nfig,RS_POLYDASHLEN,0.0,0.0,"");
		cap_lastfigelem(nfig);
		rsc_assfigdblpred(nfig,RS_POLYDASHSPC,0.0,0.0,"");
		}
	// Set net area text
	if (ptflag && cap_lastfigelem(nfig)==0)
		rsc_assfigstrpred(
		 nfig,RS_TNETAREA,newpolytyp==100 ? newnetarea : "","","");
	// Set bus pin mode
	if (tmflag && cap_lastfigelem(nfig)==0)
		rsc_assfigintpred(nfig,RS_AUTOBUS,newbuspin,0,"");
	// Set plot visibility
	if (ddbclass==DDBCLSCM &&
	 (nrefflag ? cap_nrefsearch("",nfig) : cap_lastfigelem(nfig))==0) {
		if (nrefflag && act_var==0 &&
		 nfig.NREF.MACRO.CLASS==DDBCLSSYM && (NOPLCPVIS&2)==2)
			newtnstr=nfig.NAME;
		else
			nrefflag=0;
		rsc_assfigintpred(nfig,
		 RS_VARPLOTDIS+itoa(act_var),newpdis,0,"");
		if (nrefflag) {
			// Select all variant table entries
			varn=0;
			act_flag=0;
			sqlcmd(bae_planfname(),V_SELECTA,datafunc);
			// Check if active variant defined
			if (!act_flag) {
				for (i=varn;i>0;i--)
					if (varl[i-1]<act_var)
						break;
					else
						varl[i]=varl[i-1];
				// Insert variant data
				varl[i]=act_var;
				varn++;
				}
			// Check if base variant defined
			if (varl[0]!=0) {
				for (i=varn;i>0;i--)
					varl[i]=varl[i-1];
				// Insert variant data
				varl[0]=0;
				varn++;
				}
			for (i=1;i<varn;i++)
				if (getvarvalue(
				 newtnstr,"$noplc",varl[i])==PA_NILVAL)
					setpvis(newtnstr,newpdis,varl[i]);
			}
		}
	// Redirect tag references from this symbol
	for (tpidx=0;tpidx<tagdn;tpidx++)
		if (cap_nrefsearch("",nfig)==0)
			if (scm_settagdata(nfig,tagdl[tpidx].pinname,
			 tagdl[tpidx].ref1,tagdl[tpidx].ref2))
				tagerr++;
	// Redirect tag references to this symbol
	for (tpidx=0;tpidx<tagrn;tpidx++) {
		tfig=tagrl[tpidx].fig;
		if (scm_settagdata(
		 tfig,tagrl[tpidx].pinname,newtnstr,tagrl[tpidx].ref2))
			tagerr++;
		// Adjust tag figure list references
		if (tpidx<(tagrn-1) && cap_nrefsearch("",nfig)==0)
			for (i=tpidx+1;i<tagrn;i++)
				if (tagrl[i].fig==tfig)
					tagrl[i].fig=nfig;
				else
					break;
		}
	// Check if errors occured
	if (attrerr)
		errormsg(ERRSETATT,newtnstr);
	else if (tagerr)
		errormsg(ERRSETTAG,newtnstr);
	// Set element width
	if (wflag && cap_lastfigelem(nfig)==0) {
		// Assign the plot width predicate rule
		rsc_assfigdblpred(nfig,RS_PLOTWIDTH,newwidth,0.0,"");
		bae_callmenu(MNU_BAEREDISPL);
		}
	// Set element color
	if ((nrefflag ? cap_nrefsearch("",nfig) : cap_lastfigelem(nfig))==0)
		// Assign the element color predicate rule
		rsc_assfigstrpred(nfig,RS_PLOTRGB,newcolor,"","");
	// Set group name
	if ((nrefflag ? cap_nrefsearch("",nfig) : cap_lastfigelem(nfig))==0)
		// Assign the group name predicate rule
		rsc_assfigstrpred(nfig,RS_GROUPNAME,newgrpname,"","");
	// Set pin movement status
	if (moflag && cap_lastfigelem(nfig)==0)
		// Assign the pin movement status
		rsc_assfigintpred(nfig,RS_PINMOVE,newpinmove,0,"scm_pin_move");
	// Set pin connection status
	if (moflag && cap_lastfigelem(nfig)==0)
		// Assign the pin connection status
		rsc_assfigintpred(nfig,RS_PINCON,newpincon,0,"scm_pin_autocon");
	// Check if element should be glued
	if (newglued &&
	 (nrefflag ? cap_nrefsearch("",nfig) : cap_lastfigelem(nfig))==0)
		rsc_assfigintpred(nfig,RS_GLUED,newglued,0,"");
	// Check if attribute set request
	if (res==6 &&
	 (nrefflag ? cap_nrefsearch("",nfig) : cap_lastfigelem(nfig))==0) {
		scm_setpickelem(nfig);
		bae_storemouseiact(3,px,py,0,LMB);
		ulsystem(UL_ATTRSET,0);
		}
	// Check if text class set request
	if (res==13 && cap_lastfigelem(nfig)==0) {
		scm_setpickelem(nfig);
		bae_storemouseiact(3,px,py,0,RMB);
		bae_storetextiact(2,"");
		bae_storemouseiact(3,px,py,0,LMB);
		bae_storemenuiact(3,0,LMB);
		bae_storemenuiact(3,10,LMB);
		ulsystem(UL_SCMTEXT,0);
		}
	// Check if dash parameter set request
	if (res==7 && cap_lastfigelem(nfig)==0) {
		// Query the polygon dash data
		if (nfig.RULEOBJID>=0) {
			// Query the current active dash mode
			if (cap_rulequery(RS_OCFIG,nfig,RS_SCMSUBJ,
			 RS_POLYDASH,"?d",dashmode)<1)
				dashwidth=0.0;
			// Query the current active dash base length
			if (cap_rulequery(RS_OCFIG,nfig,RS_SCMSUBJ,
			 RS_POLYDASHLEN,"?f",dashlen)<1)
				dashlen=DEFDASHLEN;
			// Query the current active dash rel. spacing
			if (cap_rulequery(RS_OCFIG,nfig,RS_SCMSUBJ,
			 RS_POLYDASHSPC,"?f",dashspc)<1)
				dashspc=DEFDASHSPC;
			// Query the current active plot width
			if (cap_rulequery(RS_OCFIG,nfig,RS_SCMSUBJ,
			 RS_PLOTWIDTH,"?f",dashwidth)<1)
				dashwidth=0.0;
			}
		// Get the new dash values
		getdashdata(dashmode,dashlen,dashspc,dashwidth);
		// Set the new dash values
		setdashdata(nfig,dashmode,dashlen,dashspc,dashwidth);
		// Redraw the screen
		bae_callmenu(MNU_BAEREDISPL);
		}
	// Check if rule set request
	if (res==12 &&
	 (nrefflag ? cap_nrefsearch("",nfig) : cap_lastfigelem(nfig))==0 &&
	 bae_dialclr()==0) {
		// Get the rule count
		rulen=rsc_getfigrules(nfig,rulel);
		switch (nfig.TYP) {
			case C_FIGTEXT :
			sprintf(msg,(nfig.TEXT.MODE&1) ?
			 UPRDRCTEXT : UPRDRSTEXT,nfig.NAME);
			break;
			case C_FIGPOLY :
			switch (nfig.POLY.TYP) {
				case C_POLYDOCLINE :
				msg=bae_plainmenutext(UPRPTYPGL);
				break;
				case C_POLYDOTLINE :
				msg=bae_plainmenutext(UPRPTYPDL);
				break;
				case C_POLYCONAREA :
				msg=bae_plainmenutext(UPRPTYPCA);
				break;
				case 100 :
				msg=bae_plainmenutext(UPRPTYPNA);
				break;
				case C_POLYDOCAREA :
				default :
				msg=bae_plainmenutext(UPRPTYPGA);
				}
			break;
			case C_FIGNREF :
			switch (nfig.NREF.MACRO.CLASS) {
				case DDBCLSMRK :
				sprintf(msg,UPRDRPIN,nfig.NAME,
				 nfig.NREF.MACRO.NAME);
				break;
				case DDBCLSLAB :
				sprintf(msg,UPRDRLAB,nfig.NAME,
				 nfig.NREF.MACRO.NAME);
				break;
				case DDBCLSSYM :
				default :
				sprintf(msg,UPRDRSYM,nfig.NAME,
				 nfig.NREF.MACRO.NAME);
				}
			break;
			default :
			msg="";
			}
		// Edit the rules
		editrules(msg);
		// Attach/detach the rule list
		if (rulen) {
			if (cap_rulefigatt(nfig,rulel))
				rsc_error(-1);
			}
		else if (cap_getrulecnt(RS_OCFIG,nfig)>0) {
			if (cap_rulefigdet(nfig))
				rsc_error(-1);
			}
		}
	// Check if multiline text rule transfer
	if (mtextid!="" && cap_lastfigelem(nfig)==0) {
		// Get the rule count
		rulen=rsc_getfigrules(nfig,rulel);
		// Get the base rules
		mrulen=4;
		sprintf(nrulel[0],":%s:%s='%s';",RS_SCMSUBJ,RS_MTEXTID,mtextid);
		for (i=0;i<rulen;i++) {
			msg=rulel[i];
			if (strmatch(msg,":scm_rules:mtextid=*;") ||
			 strmatch(msg,":scm_rules:mtextrow=*;") ||
			 strmatch(msg,":scm_rules:mtextcol=*;") ||
			 strmatch(msg,":scm_rules:mtextls=*;"))
				continue;
			nrulel[mrulen]=msg;
			mrulen++;
			}
		forall (nfig where nfig.TYP==C_FIGTEXT && nfig.RULEOBJID>=0 &&
		 cap_rulequery(RS_OCFIG,nfig,RS_SCMSUBJ,
		  RS_MTEXTID,"?s",textid)>0 && textid==mtextid) {
			// Get multiline text data
			if (cap_rulequery(RS_OCFIG,nfig,RS_SCMSUBJ,
			  RS_MTEXTCOL,"?d",col)<1 ||
			 cap_rulequery(RS_OCFIG,nfig,RS_SCMSUBJ,
			  RS_MTEXTROW,"?d",row)<1 ||
			 cap_rulequery(RS_OCFIG,nfig,RS_SCMSUBJ,
			  RS_MTEXTLS,"?f",linespc)<1)
				continue;
			sprintf(nrulel[1],":%s:%s=%d;",
			 RS_SCMSUBJ,RS_MTEXTCOL,col);
			sprintf(nrulel[2],":%s:%s=%d;",
			 RS_SCMSUBJ,RS_MTEXTROW,row);
			sprintf(nrulel[3],":%s:%s=%.2f;",
			 RS_SCMSUBJ,RS_MTEXTLS,linespc);
			if (cap_rulefigatt(nfig,nrulel))
				rsc_error(-1);
			}
		}
	// Evaluate any rules
	bae_postprocess();
	// Redraw the screen
	bae_callmenu(MNU_BAEREDISPL);
	exit(0);
}

void setdashdata(index C_FIGURE fig,
 int dashmode,double dashlen,double dashspc,double dashwidth)
/*
// Get dash data
// Parameters :
//	index C_FIGURE fig	: Polygon figure list index
//	int dashmode		: Polygon dash mode
//	double dashlen		: Polygon dash length
//	double dashspc		: Polygon dash spacing factor
//	double dashwidth	: Polygon dash line width
*/
{
	string dmpprefix		/* Dash mode predicate def. prefix */;
	int dmplen			/* Dash mode predicate def. length */;
	string dlpprefix		/* Dash len. predicate def. prefix */;
	int dlplen			/* Dash len. predicate def. length */;
	string dspprefix		/* Dash spc. predicate def. prefix */;
	int dsplen			/* Dash spc. predicate def. length */;
	string dwpprefix		/* Dash width pred. def. prefix */;
	int dwplen			/* Dash width pred. def. length */;
	STRINGS rl			/* Rule list */;
	int rn				/* Rule count */;
	int nrn				/* New rule count */;
	int i				/* Loop control variable */;
	// Get dash mode predicate rule definition prefix
	sprintf(dmpprefix,":%s:%s=",RS_SCMSUBJ,RS_POLYDASH);
	dmplen=strlen(dmpprefix);
	// Get dash length predicate rule definition prefix
	sprintf(dlpprefix,":%s:%s=",RS_SCMSUBJ,RS_POLYDASHLEN);
	dlplen=strlen(dlpprefix);
	// Get dash spacing predicate rule definition prefix
	sprintf(dspprefix,":%s:%s=",RS_SCMSUBJ,RS_POLYDASHSPC);
	dsplen=strlen(dspprefix);
	// Get dash width predicate rule definition prefix
	sprintf(dwpprefix,":%s:%s=",RS_SCMSUBJ,RS_PLOTWIDTH);
	dwplen=strlen(dwpprefix);
	// Get the element rules
	nrn=rn=rsc_getfigrules(fig,rl);
	// Delete any old dash rules
	for (i=0;i<rn;i++)
		if (strextract(rl[i],0,dmplen-1)!=dmpprefix ||
		 strextract(rl[i],0,dlplen-1)!=dlpprefix ||
		 strextract(rl[i],0,dsplen-1)!=dspprefix ||
		 strextract(rl[i],0,dwplen-1)!=dwpprefix) {
			rl[i]="";
			nrn--;
			}
	// Add the new rules to the list
	if (dashmode!=0) {
		sprintf(rl[rn],"%s%d;",dmpprefix,dashmode);
		sprintf(rl[rn+1],"%s%.9g;",dlpprefix,dashlen);
		sprintf(rl[rn+2],"%s%.9g;",dspprefix,dashspc);
		rn+=3;
		nrn+=3;
		}
	if (dashwidth!=0.0) {
		sprintf(rl[rn],"%s%.9g;",dwpprefix,dashwidth);
		rn++;
		nrn++;
		}
	// Attach/detach the rule list
	if (nrn) {
		if (cap_rulefigatt(fig,rl))
			rsc_error(-1);
		}
	else if (cap_getrulecnt(RS_OCFIG,fig)>0) {
		if (cap_rulefigdet(fig))
			rsc_error(-1);
		}
}

void getdashdata(int dashmode,double dashlen,double dashspc,double dashwidth)
/*
// Get dash data
// Parameters :
//	int dashmode		: Polygon dash mode
//	double dashlen		: Polygon dash length
//	double dashspc		: Polygon dash spacing factor
//	double dashwidth	: Polygon dash line width
*/
{
	double labwidth			/* Picture label width */;
	double labheight		/* Picture label height */;
	double cy			/* Current y value */;
	int dmidx = (-1)		/* Dash mode control index */;
	int dlidx = (-1)		/* Dash length control index */;
	int dsidx = (-1)		/* Dash spacing fac. control index */;
	int dwidx = (-1)		/* Dash width control index */;
	// Check for dialog support
	if (bae_dialclr())
		return;
	// Set the default picture button bitmap size
	labwidth=PICLABWIDTH;
	labheight=PICLABHEIGHT;
	// Create the picture button bitmap
	if (bmp_setsize(0.0,0.0,18.0,9.0,labwidth,labheight,0.0,0.0) ||
	 bae_dialbmpalloc(labwidth,labheight,2,0,0)!=2)
		error_abort();
	// Draw the picture label bitmap
	bae_popsetarea(2);
	// Display spacing seperator lines
	btp_drawline(PICLABSCOL,DM_REPLACE,2.5,0.5,2.5,8.5);
	btp_drawline(PICLABSCOL,DM_REPLACE,6.5,0.5,6.5,8.5);
	btp_drawline(PICLABSCOL,DM_REPLACE,10.5,0.5,10.5,8.5);
	btp_drawline(PICLABSCOL,DM_REPLACE,14.5,0.5,14.5,8.5);
	btp_drawline(PICLABSCOL,DM_REPLACE,6.5,8.0,10.5,8.0);
	btp_drawtext(8.3,8.1,PICLABSCOL,0,"l");
	// Display factor documenation
	btp_drawline(PICLABFCOL,DM_REPLACE,4.1,0.5,4.1,8.5);
	btp_drawline(PICLABFCOL,DM_REPLACE,2.5,8.0,4.1,8.0);
	btp_drawtext(3.0,8.1,PICLABFCOL,0,"f*l");
	// Display width documentation
	btp_drawline(PICLABSCOL,DM_REPLACE,17.0,1.9,17.2,1.9);
	btp_drawtext(17.3,1.80,PICLABSCOL,0,M("b","w"));
	btp_drawline(PICLABSCOL,DM_REPLACE,17.1,1.9,17.1,2.1);
	btp_drawline(PICLABSCOL,DM_REPLACE,17.0,2.1,17.2,2.1);
	// Display mode 0 line
	btp_drawwideline(PICLABDCOL,DM_REPLACE,1,0.5,1.0,16.5,1.0,0.2);
	// Display mode 1+ lines
	btp_drawwideline(PICLABDCOL,DM_REPLACE,1,0.5,2.0,2.5,2.0,0.2);
	btp_drawwideline(PICLABDCOL,DM_REPLACE,1,6.5,2.0,10.5,2.0,0.2);
	btp_drawwideline(PICLABDCOL,DM_REPLACE,1,14.5,2.0,16.5,2.0,0.2);
	// Display mode 2+ lines
	btp_drawwideline(PICLABDCOL,DM_REPLACE,1,4.1,3.0,4.9,3.0,0.2);
	btp_drawwideline(PICLABDCOL,DM_REPLACE,1,12.1,3.0,12.9,3.0,0.2);
	// Display mode 3+ lines
	btp_drawwideline(PICLABDCOL,DM_REPLACE,1,0.5,4.0,2.5,4.0,0.2);
	btp_drawwideline(PICLABDCOL,DM_REPLACE,1,4.1,4.0,4.9,4.0,0.2);
	btp_drawwideline(PICLABDCOL,DM_REPLACE,1,6.5,4.0,10.5,4.0,0.2);
	btp_drawwideline(PICLABDCOL,DM_REPLACE,1,12.1,4.0,12.9,4.0,0.2);
	btp_drawwideline(PICLABDCOL,DM_REPLACE,1,14.5,4.0,16.5,4.0,0.2);
	// Display mode 1- lines
	btp_drawwideline(PICLABDCOL,DM_REPLACE,1,0.5,5.0,4.1,5.0,0.2);
	btp_drawwideline(PICLABDCOL,DM_REPLACE,1,4.9,5.0,12.1,5.0,0.2);
	btp_drawwideline(PICLABDCOL,DM_REPLACE,1,12.9,5.0,16.5,5.0,0.2);
	// Display mode 2- lines
	btp_drawwideline(PICLABDCOL,DM_REPLACE,1,2.5,6.0,4.1,6.0,0.2);
	btp_drawwideline(PICLABDCOL,DM_REPLACE,1,4.9,6.0,6.5,6.0,0.2);
	btp_drawwideline(PICLABDCOL,DM_REPLACE,1,10.5,6.0,12.1,6.0,0.2);
	btp_drawwideline(PICLABDCOL,DM_REPLACE,1,12.9,6.0,14.5,6.0,0.2);
	// Display mode 3- lines
	btp_drawwideline(PICLABDCOL,DM_REPLACE,1,0.5,7.0,1.3,7.0,0.2);
	btp_drawwideline(PICLABDCOL,DM_REPLACE,1,2.5,7.0,4.1,7.0,0.2);
	btp_drawwideline(PICLABDCOL,DM_REPLACE,1,4.9,7.0,6.5,7.0,0.2);
	btp_drawwideline(PICLABDCOL,DM_REPLACE,1,8.1,7.0,9.9,7.0,0.2);
	btp_drawwideline(PICLABDCOL,DM_REPLACE,1,10.5,7.0,12.1,7.0,0.2);
	btp_drawwideline(PICLABDCOL,DM_REPLACE,1,12.9,7.0,14.5,7.0,0.2);
	btp_drawwideline(PICLABDCOL,DM_REPLACE,1,15.7,7.0,16.5,7.0,0.2);
	bae_popsetarea(0);
	// Store the hint label
	cy=DIAL_TOPMARG;
	// Store the bitmap label
	bae_dialadvcontrol(PA_BMLAB,0,0,2,0.0,0.0,0.0,"",0,
	 DIAL_LEFTMARG+4.0,cy,labwidth,labheight,"");
	// Store dash mode controls
	dmidx=bae_dialaddcontrol(PA_RBF,0,0,
	 dashspc<0.0 ? dashmode+3 : dashmode,0.0,0.0,0.0,
	 "",0,DIAL_LEFTMARG+1.0,cy+0.7,0.0,"");
	bae_dialaddcontrol(PA_RBN,1,0,0,0.0,0.0,0.0,
	 "",0,DIAL_LEFTMARG+1.0,cy+1.7,0.0,"");
	bae_dialaddcontrol(PA_RBN,2,0,0,0.0,0.0,0.0,
	 "",0,DIAL_LEFTMARG+1.0,cy+2.7,0.0,"");
	bae_dialaddcontrol(PA_RBN,3,0,0,0.0,0.0,0.0,
	 "",0,DIAL_LEFTMARG+1.0,cy+3.7,0.0,"");
	bae_dialaddcontrol(PA_RBN,4,0,0,0.0,0.0,0.0,
	 "",0,DIAL_LEFTMARG+1.0,cy+4.7,0.0,"");
	bae_dialaddcontrol(PA_RBN,5,0,0,0.0,0.0,0.0,
	 "",0,DIAL_LEFTMARG+1.0,cy+5.7,0.0,"");
	bae_dialaddcontrol(PA_RBN,6,0,0,0.0,0.0,0.0,
	 "",0,DIAL_LEFTMARG+1.0,cy+6.7,0.0,"");
	cy+=PICLABHEIGHT+DIAL_SEPVSTEP;
	// Store the dash length controls
	dial_label(4.0,cy,UPRDASHLEN);
	dlidx=bae_dialaddcontrol(PA_DBL|PA_DIST|PA_CHKLL,0,
	 5,0,0.0,0.0,dashlen,"",0,DIAL_LEFTMARG+20.0,cy,10.0,"");
	cy+=DIAL_CTRVSTEP;
	// Store the dash spacing controls
	dial_label(4.0,cy,UPRDASHSPC);
	dsidx=bae_dialaddcontrol(PA_DBL|PA_CHKLL|PA_CHKUL,0,5,0,0.0,
	 0.499,fabs(dashspc),"",0,DIAL_LEFTMARG+20.0,cy,10.0,"");
	cy+=DIAL_CTRVSTEP;
	// Store the dash length controls
	dial_label(4.0,cy,UPRDWIDTH);
	dwidx=bae_dialaddcontrol(PA_DBL|PA_DIST,0,
	 5,0,0.0,0.0,dashwidth,"",0,DIAL_LEFTMARG+20.0,cy,10.0,"");
	cy+=DIAL_BUTVSTEP;
	// Store the separator
	bae_dialaddcontrol(PA_HSEP|PA_HBRDREL,0,0,0,0.0,0.0,0.0,"",
	 0,DIAL_LEFTMARG,cy,DIAL_RIGHTSMARG,"");
	cy+=DIAL_SEPVSTEP;
	// 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,"");
	// Call the dialog function
	bae_setintpar(16,3027);
	if (bae_dialaskparams(UPRDASHSET,0,
	 DIAL_LEFTMARG+labwidth+4.3+DIAL_RIGHTSMARG,
	 cy+DIAL_SEPVSTEP+DIAL_BUTVSTEP)!=0)
		error_abort();
	bae_dialgetdata(dmidx,dashmode,0.0,"");
	bae_dialgetdata(dlidx,0,dashlen,"");
	bae_dialgetdata(dsidx,0,dashspc,"");
	bae_dialgetdata(dwidx,0,dashwidth,"");
	if (dashmode>3) {
		dashmode-=3;
		dashspc=(-dashspc);
		}
}

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
*/
{
	if (scm_chkattrname(tstr)==0)
		attrfound=1;
	// Return without errors
	return(0);
}

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);
}

void setpvis(string symname,int plotdis,int varnum)
/*
// Set symbol plot visibility
// Parameters :
//	string symname		: Symbol name
//	string attrval		: $noplc attribute value
//	int plotdis		: Plot disable flag
//	int varnum		: Variant number
*/
{
	index C_FIGURE fig		/* Figure list element */;
	string rulel[]			/* Rule list */;
	int rulen			/* Rule count */;
	string rulename			/* Rule name */;
	int i, j			/* Loop control variables */;
	if (cap_nrefsearch(symname,fig))
		return;
	// 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);
		}
}

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 */;
	// Search the insert position
	for (i=varn;i>0;i--)
		if (varl[i-1]<dint)
			break;
		else
			varl[i]=varl[i-1];
	// Insert variant data
	varl[i]=dint;
	varn++;
	if (dint==act_var)
		act_flag=1;
	// Return without errors
	return(0);
}

static void editrules(string prompt)
/*
// Add/delete rule to/from the current rule list
// Parameters :
//	string prompt		: Prompt string
*/
{
	string msg			/* Message string */;
	string ecomm			/* Element comment */;
	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 cy			/* Dialog box current y coordinate */;
	double dialwidth		/* Dialog box width */;
	double dialheight		/* Dialog box height */;
	double baseheight		/* Dialog box base height */;
	int editidx = (-1)		/* Edit field dialog box item idx. */;
	int i				/* Loop control variable */;
	baseheight=DIAL_TOPMARG+DIAL_BUTVSTEP+2.0*DIAL_SEPVSTEP+
	 2.0*DIAL_CTRVSTEP;
	// Do the rule input loop
	bae_prtdialog("");
	while (1) {
		// Check if dialog box support
		bae_dialclr();
		dial_getboxsizemin(3028,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;
		dial_label(0.0,cy,UPRRULENAME);
		// Store edit control
		editidx=bae_dialaddcontrol(PA_STR,0,0,0,0.0,0.0,0.0,
		 "",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;
		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,editidx,
		 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,editidx,
		 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,"lay_*") && !strmatch(rn,"cam*") &&
			 !strmatch(rn,"var_doc*") &&
			 !strmatch(rn,"scm_variant*") &&
			 (pattern[0]=='\0' || strmatch(rn,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,editidx,
		 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=rsc_database();
		while (scanddbenames(fn,DDBCLRULE,rn)==1)
			if (!strmatch(rn,"lay_*") && !strmatch(rn,"cam*") &&
			 !strmatch(rn,"var_doc*") &&
			 !strmatch(rn,"scm_variant*") &&
			 (pattern[0]=='\0' || strmatch(rn,pattern)))
				dial_lbddbentry(0,0,fn,rn,DDBCLRULE,0);
		// Store OK button
		bae_dialaddcontrol(PA_ACT,
		 0,0,0,0.0,0.0,0.0,"",0,DIAL_LEFTMARG,cy,0.0,UPRTOGGLE);
		// Store abort button
		bae_dialaddcontrol(PA_ACT,
		 0,(-1),0,0.0,0.0,0.0,"",0,15.0,cy,0.0,UPRDONE);
		cy+=DIAL_BUTVSTEP+DIAL_SEPVSTEP;
		// Display dialog box
		sprintf(msg,UPRDRULEH,prompt);
		bae_setintpar(16,3028);
		switch (bae_dialaskparams("!"+msg,0,dialwidth,cy)) {
			// Done
			case 0 :
			bae_dialgetdata(editidx,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(editidx,0,0.0,pattern);
			continue;
			// Resize
			case (-2) :
			continue;
			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 (!rsc_isrule(nrn)) {
				// Issue rule not defined message
				sprintf(msg,ERRNORULE,nrn);
				bae_msgbox(2,msg,"");
				continue;
				}
			// Insert new rule sorted into list
			for (i=rulen;i>0;i--)
				if (rulel[i-1]>nrn)
					rulel[i]=rulel[i-1];
				else
					break;
			rulel[i]=nrn;
			rulen++;
			}
		else {
			// Delete the old rule
			for (;i<rulen-1;i++)
				rulel[i]=rulel[i+1];
			rulen--;
			rulel[rulen]="";
			}
	    }
}

int splitstring(string s,STRINGS ssl)
/*
// Split string into lines
// Return value :
//	number of substrings
// Parameters :
//	string s		: Input string
//	STRINGS ssl		: Substring list
*/
{
	int ssn		= 0		/* Substring count */;
	int sl		= strlen(s)	/* String length */;
	int pos1	= 1		/* String position buffer 1 */;
	int pos2			/* String position buffer 2 */;
	int i				/* Loop controo variable */;
	// Repetively scan string
	while ((pos2=strscannext(s,"\n",pos1,1))<sl) {
		// Extract next substring
		ssl[ssn++]= pos2>pos1 ? strextract(s,pos1-1,pos2-2) : "";
		// Update the scan start position
		pos1=pos2+1;
		}
	// Extract last substring if last char not delimiter
	if (pos1<pos2)
		ssl[ssn++]=strextract(s,pos1-1,pos2-1);
	// Remove any trailing CR/LF characters
	for (i=0;i<ssn;i++) {
		if (ssl[i][0]=='\0')
			continue;
		if (ssl[i][(sl=strlen(ssl[i])-1)]=='\012')
			ssl[i][sl]='\0';
		if (ssl[i][(sl=strlen(ssl[i])-1)]=='\015')
			ssl[i][sl]='\0';
		}
	// Return the substring count
	return(ssn);
}

string coordstr(double x, double y,int typ,int cunits)
/*
// Build coordinate string
// Return value :
//	coordinate string
// Parameters :
//	double x, y		: Coordinate values
//	int typ			: Coordinate type
//	int cunits		: Coordinate units
*/
{
	string res		/* Result buffer */;
	string pdes		/* Point descriptor */;
	// Get the coordinate type descriptor
	switch (typ) {
		case 2 :
		pdes=":r ";
		break;
		case 1 :
		pdes=":l ";
		break;
		default :
		pdes="";
		}
	switch (cunits) {
		case 1 :
		sprintf(res,"%s%s\",%s\"",pdes,
		 bae_numstring(cvtlength(x,0,1),5),
		 bae_numstring(cvtlength(y,0,1),5));
		break;
		case 2 :
		sprintf(res,"%s%smil,%smil",pdes,
		 bae_numstring(cvtlength(x,0,3),5),
		 bae_numstring(cvtlength(y,0,3),5));
		break;
		case 3 :
		sprintf(res,"%s%sum,%sum",pdes,
		 bae_numstring(cvtlength(x,0,4),5),
		 bae_numstring(cvtlength(y,0,4),5));
		break;
		default :
		sprintf(res,"%s%smm,%smm",pdes,
		 bae_numstring(cvtlength(x,0,2),3),
		 bae_numstring(cvtlength(y,0,2),3));
		}
	return(res);
}

// User Language program end