/* KEYPROG (STD) -- User Language Program Call and Key Programming Utility */
/* KEYPROG (STD) -- User Language-Programmaufruf und Tastaturprogrammierung */
/* -- INTENDED FOR KEY-CALL USE -- */
/*
// Copyright (c) 1994-2012 Oliver Bartels F+E, Muenchen
// Author: Manfred Baumeister
// Changes History:
//	rl (120427) RELEASED FOR BAE V7.8.
//	rl (101019) RELEASED FOR BAE V7.6.
//	rl (091021) RELEASED FOR BAE V7.4.
//	rl (081014) RELEASED FOR BAE V7.2.
//	rl (080922) ENHANCEMENT:
//		Added favorite grid selection to key/menu programming.
//	rl (071029) RELEASED FOR BAE V7.0.
//	rl (061027) ENHANCEMENT:
//		Enabled help text entry for pure interaction sequences.
//	rl (060829) RELEASED FOR BAE V6.8.
//	rl (060531) ENHANCEMENT:
//		Added shift+control key support.
//	rl (060201) ENHANCEMENT:
//		Added comment store to ULC database on UL call update.
//	rl (050912) RELEASED FOR BAE V6.6.
//	rl (050912) BUGFIX:
//		Fixed problems with key assignment of menu macro items and
//		key reassignment of macros with blank characters in name.
//	rl (040811) RELEASED FOR BAE V6.4.
//	rl (040616) ENHANCEMENT:
//		Added user menu definition support.
//	rl (031010) ENHANCEMENT:
//		Added program import function.
//	rl (030904) RELEASED FOR BAE V6.2.
//	rl (030807) ENHANCEMENT:
//		Added macro support functions.
//	rl (030704) ENHANCEMENT:
//		Added control key support.
//		Fixed display/selection problems with &-character.
//	rl (030115) ENHANCEMENT:
//		Using current hot key program sequence as default edit
//		field value.
//	rl (021209) RELEASED FOR BAE V6.0.
//	rl (020618) RELEASED FOR BAE V5.4.
//	rl (020207) ENHANCEMENT:
//		Introduced environment variable BAE_PARLIB for
//		database file name.
//	rl (020207) BUGFIX:
//		Fixed problem with alternate ULC database file name
//		specified by environment variable BAE_ULCLIB.
//	rl (010710) RELEASED FOR BAE V5.0.
//	rl (010702) ENHANCEMENT:
//		Added menu selection option for hotkeys assignment.
//	rl (010125) BUGFIX:
//		Fixed help text store problem.
//		Added help text edit capability for windows environments.
//	rl (001201) BUGFIX:
//		Fixed Linux directory delimiter problem.
//	rl (000609) RELEASED FOR BAE V4.6.
//	rl (000609) ENHANCEMENT:
//		Hotkeys for menu functions allowed.
//	rl (991013) RELEASED FOR BAE V4.4.
//	rl (991013) ENHANCEMENT:
//		Hotkeys permanently stored to SQL-Database.
//	rl (981002) RELEASED FOR BAE V4.2.
//	mb (980713) CHANGE:
//		SQL tables ulcalltab and ulhelptab renamed to ul_calltab
//		and ul_helptab to avoid compatibility problems.
//	mb (980710) ENHANCEMENT:
//		Dynamic multi-language support introduced.
//	rl (970929) RELEASED FOR BAE V4.0.
//	mb (970616) ENHANCEMENT:
//		Applied CAM View User Language support.
//	mb (970514) CHANGE:
//		Multi-language support for online documentation
//		extraction introduced, i.e. UL sources assumed
//		to contain English/default help string in first
//		non-blank line, and to contain German help string
//		in second non-blank line.
//	mb (970326) BUGFIX:
//		Directory delimiter character appended to directory
//		path name specifications with only one (non-directory-
//		delimiter) character (e.g. working directory ".") in
//		order to ensure correct file name derivates within
//		subsequent functions.
//	mb (960927) RELEASED FOR BAE V3.4.
//	mb (960927) IMPROVEMENT:
//		UL program database update automatically suggested (and
//		performed on request), if UL program database not available.
//		UL call update automatically performed after help text
//		update. Help text update to query for UL source directory.
//	mb (960801) ENHANCEMENT:
//		Changed menu items to support key selection
//		in Windows/Motif user interfaces.
//	mb (95) RELEASED FOR BAE V3.2.
//	mb (941212) ENHANCEMENT:
//		Integrated menu-driven ULP call features.
//		Introduced key programming utilities.
//	mb (941123) IMPROVEMENT:
//		Optionally build program selection menu from SQL table
//		ulcalltab (stored to "baeparam.dat" in BAE programs
//		directory using integrated key programming utilities).
//	mb (94) RELEASED FOR BAE V3.0.
//	mb (94) ORIGINAL CODING:
//		Retrieved from PROGKEYS.
//
// DESCRIPTION
//
// The keyprog User Language program provides features for
// menu-controlled User Language program call, online key
// programming, menu assignment management, and SQL-based
// User Language help text database management.
//
// NOTES
//
// Program maintains SQL database tables "ul_calltab" and
// "ul_helptab" from SQL/DDB file "baeparam.dat" within
// BAE programs directory.
*/

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

// Disable undo state request
#pragma ULCALLERNOUNDO

// Compiler directives
#define LGECOUNT	2		// Language count
int curlanguage		= bae_uilanguage()
					/* Current language code */;

// Messages
string UPRABORT		= M_UPRABORT();
string UPRFEXIT		= M_UPRFEXIT();
string UPRDONE		= M("%Fertig","%Done");
string REPPROGHEAD	= M("User Language Programme :",
			    "User Language Programs :");
string REPKEY		= M("UL Interpreter %s / Tastenbelegung :",
			    "UL Interpreter %s / Key Assignments :");
string REPPROG		= M("Taste : %s / Programm : %s",
			    "Key : %s / Program : %s");
string REPPROGCOM	= M("Programm  : %s  Kommentar :",
			    "Program  : %s  Comment :");
string REPPROGL		= M("Programme :","Programs :");
string REPNOPROG	= M("Keine User Language-Programme in der Datenbank!",
			    "User Language program database empty!");
string REPHLPUPD	= M("Update '%s'-Hilfstext...",
			    "Update '%s' help text...");
string REPCALLUPD	= M("Update '%s'-Programmaufruf...",
			    "Update '%s' program call entry...");
STRINGS UPRULDBUPDL	= {
	M("Dieses Programm verwaltet eine Datenbank fuer",
	  "This programs maintains a User Language program"),
	M("User Language-Programme, um Hilfstexte in den",
	  "database for providing convenient User Language"),
	M("Menues zur Programmauswahl bereitzustellen.",
	  "program selection menus including program help"),
	M("Diese Datenbank ist in Ihrem System zur Zeit",
	  "texts. The UL program database is currently not"),
	M("nicht verfuegbar.",
	  "available on your system.")
	};
string UPRULDBUPD	= M("UL-Programmdatenbank generieren [J|N] ? ",
			    "Generate UL Program Database [Y|N] ? ");
string ERRPRGCALL	= M("Programm '%s' nicht aufrufbar!",
			    "Program '%s' not callable!");
string UPRUPDCALL	= M(ERRPRGCALL+" UL-Aufruf Update ? ",
			    ERRPRGCALL+" UL Call Update ? ");
string UPRSELFCT	= M("Tasten-Programmierfunktion selektieren!",
			    "Select Key Programming Function!");
string UPRHKEYSET	= M("Hot&Keys belegen"    ,"Set Hot&Keys"      );
string UPRHKEYDEL	= M("HotKe&ys loeschen"   ,"Delete HotKe&ys"   );
string UPRHELPUPD	= M("%&Hilfstext Update"  ,"%&Help Text Update");
string UPRHELPINP	= M("Hilfs&text Eintrag"  ,"Help &Text Input"  );
string UPRHELPDEL	= M("Hilfste&xt Loeschen" ,"Help Te&xt Delete" );
string UPRCALLUPD	= M("%&UL-Aufruf Update"  ,"%&UL Call Update"  );
string UPRCALLDEL	= M("UL-Aufruf &Loeschen" ,"UL Call De&lete"   );
string UPRMENURES	= M("%Menu &ruecksetzen"  ,"%&Reset Menu"      );
string UPRMENUDEF	= M("Menu &definieren"    ,"&Define Menu"      );
string UPRMENUREP	= M("Menu Rep&ort"        ,"Menu Rep&ort"      );
string UPRMACRO		= M("%&Makroverwaltung"   ,"%&Macro Management");
string UPRMACSEL	= M("Makroauswahl","Macro Selection");
string UPRGRIDSEL	= M("Rasterauswahl","Grid Selection");
string UPRSELKEYT	= M("Tastentyp(en) selektieren!",
			    "Select Key Type!");
string UPRKEYALL	= M("A&lle Tasten"        ,"A&ll Keys"             );
string UPRKEYFCT	= M("&Funktionstasten"    ,"&Function Keys"        );
string UPRKEYSTD	= M("&Standardtasten"     ,"&Standard Keys"        );
string UPRKEYSEL	= M("%&Tastenselektion"   ,"%Select &Key"          );
string UPRKEY		= M("Taste ? "            ,"Key Designator ? "     );
string UPRPROG		= M("Programmname ? "     ,"Program Name ? "	   );
string UPRPROGMD	= M("Programmname (<?>:Liste) ? ",
			    "Program Name (<?>:List) ? ");
string UPRCOMM		= M("Kommentar ? "        ,"Comment ? "		   );
string UPRULSRCDIR	= M("UL-Quellcode-Verzeichnis ? ",
			    "UL Source Code Directory ? ");
string UPRULSRC		= M("UL-Quelldatei ? ","UL Source File ? ");
string UPRSELSRC	= M("UL-Quellcodedatei ? ","UL Source Code File ? ");
string UPRSELMENU	= M("Menu fuer die Erweiterung selektieren!",
			    "Select Menu to Extend!");
string UPRNMENU		= M("Neues Menu ? ","New Menu ? ");
string UPRDELMENU	= M("Menu '%s' loeschen ? ","Delete Menu '%s' ? ");
string UPRSELDMENU	= M("Zu loeschendes Menu selektieren!",
			    "Select Menu to Delete!");
string UPRSELMENUFCT	= M("Menufunktion selektieren!",
			    "Select Menu Function!");
string UPRDEDIT		= M("&Aendern","&Edit");
string UPRDADDF		= M("Neue Menu&funktion","Add Menu &Item");
string UPRDADDM		= M("Neues &Makro","Add Ma&cro");
string UPRDADDG		= M("Neues &Raster","Add &Grid");
string UPRDADDU		= M("Neue &Anwenderfunktion ","Add &User Script");
string UPRDDEL		= M("&Loeschen","Dele&te");
string UPRDDELA		= M("Alle l&oeschen","Delete All");
string UPRDMOVE		= M("&Verschieben","&Move");
string UPRDDONE		= M("Fer&tig","&Done");
string UPRDIALFFUNC	= M("Menufunktionen zu '%s'","Menu Functions for '%s'");
string UPRMENUMOVDST	= M("Neue Position fuer Menufunktion '%s' selektieren",
			    "Select new position for menu function '%s'");
string UPRDIALFEDIT	= M("Definition Menufunktion %s / %d",
			    "Menu Function Definition %s / %d");
string UPRDFCTNAME	= M("Name :","Name :");
string UPRDFCTPROG	= M("Aufrufsequenz :","Calling sequence :");
string REPCOPYDONE	= M("%d ULC-Programm(e) von '%s' nach '%s' kopiert.",
			    "%d ULC program(s) copied from '%s' to '%s'.");
string ERRCOPY		= M("Fehler beim Kopieren von ULC-Programm '%s'!",
			    "Error copying ULC program '%s'!");
string ERRNOMACRO	= M("Keine Makros definiert!","No Macros defined!");
string ERRNOGRID	= M("Keine Raster definiert!","No Grids defined!");
string ERRNOMOVMENU	= M("Keine Menufunktion fuer die Verschiebung selektiert!",
			    "No move source menu function selected!");
string ERRNOWIN		= M("Nur in Windowsumgebungen verfuegbar!",
			    "Windows Environment needed!");

// Error messages
#define DE_ERRDBINIT	"SQL/DB-Datei '%s' kann nicht initialisiert werden!"
#define EN_ERRDBINIT	"Error initialyzing SQL/DB file '%s'!"
#define DE_ERRDDBERROR	"DDB/Datenbank-Zugriffs-Fehler"
#define EN_ERRDDBERROR	"DDB/Database access error"
#define DE_ERRULPINMEM	"Programm ist bereits geladen"
#define EN_ERRULPINMEM	"Program already loaded"
#define DE_ERRULPNTFND	"Programm nicht gefunden"
#define EN_ERRULPNTFND	"Program not found"
#define DE_ERRULPIVERS	"Programm Version inkompatibel"
#define EN_ERRULPIVERS	"Program version incompatible"
#define DE_ERRULPIFREF	"Programm inkompatibel zur Umgebung"
#define EN_ERRULPIFREF	"Program environment incompatible"
#define DE_ERRULSTKUFL	"Stack Unterlauf (interner Fehler)"
#define EN_ERRULSTKUFL	"Stack underflow (internal error)"
#define DE_ERRULSTKOFL	"Stack Ueberlauf"
#define EN_ERRULSTKOFL	"Stack overflow"
#define DE_ERRULDIVZRO	"Division durch Null"
#define EN_ERRULDIVZRO	"Division by zero"
#define DE_ERRULFCTCAL	"Funktions-Aufruf fehlgeschlagen"
#define EN_ERRULFCTCAL	"Function-Call failed"
#define DE_ERRULFCTNAV	"System-Funktion in dieser Umgebung nicht verfuegbar"
#define EN_ERRULFCTNAV	"System function not in this environment"
#define DE_ERRULFCTNIP	"System-Funktion nicht implementiert"
#define EN_ERRULFCTNIP	"System function not implemented"
#define DE_ERRULFCTNFD	"User-Funktion nicht gefunden"
#define EN_ERRULFCTNFD	"User function not found"
#define DE_ERRULFCTTYP	"Falscher Typ der referenzierten Funktion"
#define EN_ERRULFCTTYP	"Wrong referenced function type"
#define DE_ERRULFCTPAR	"Ungueltige Parameter fuer referenzierte Funktion"
#define EN_ERRULFCTPAR	"Invalid function parameters used"
#define DE_ERRULARYACC	"Fehler beim Array Zugriff"
#define EN_ERRULARYACC	"Array access failed"
#define DE_ERRULARYRNG	"Ungueltiger Array Index Wert"
#define EN_ERRULARYRNG	"Invalid array index value"
#define DE_ERRULFACCES	"Datei-Zugriffs-Fehler"
#define EN_ERRULFACCES	"File access failed"
#define DE_ERRULFIREAD	"Datei-Lese-Fehler"
#define EN_ERRULFIREAD	"File read failed"
#define DE_ERRULFWRITE	"Datei-Schreib-Fehler"
#define EN_ERRULFWRITE	"File write failed"
#define DE_ERRULOTHER	"Unbekannter User Language Fehler"
#define EN_ERRULOTHER	"Unknown User Language error"
#define DE_ERRFORMAT	"UL FEHLER (%s%s) : %s!"
#define EN_ERRFORMAT	"UL ERROR (%s%s) : %s!"
string ERRKEYPROG	= M("Fehler bei Programmierung der Taste <%s>!",
			    "Error programming key <%s>!");

// Global main menu items
string MNU_FILE		= M("&Datei","&File");
string MNU_EDIT		= M("&Bearbeiten","&Edit");
string MNU_VIEW		= M("&Ansicht","&View");
string MNU_UTIL		= M("&Utilities","&Utilities");
string MNU_PARAM	= M("&Einstellungen","&Settings");
string MNU_HELP		= M("&Hilfe","&Help");
string SCM_M_3		= M("&Symbole","S&ymbols");
string SCM_M_4		= M("Ve&rbindungen","&Connections");
string SCM_M_5		= M("Gra&fik","Gr&aphic");
string SCM_M_6		= M("&Texte","&Text");
string SCM_M_9		= M("Pl&otausgabe","Plot &Output");
string GED_M_3		= M("Baute&ile","&Parts");
string GED_M_4		= M("&Leiterbahnen","T&races");
string GED_M_5		= M("&Flaechen","&Areas");
string GED_M_6		= M("&Texte, Bohrungen","&Text, Drill");
string AR_M_2		= M("Prepla&cement","P&replacement");
string AR_M_3		= M("Auto&router","&Autorouter");
string CAM_M_2		= M("&Kontrollplot","&Control Plot");
string CAM_M_3		= M("&Gerber Fotoplot","&Gerber Photoplot");
string CAM_M_4		= M("Bohr+Be&stueckdaten","Drilling+&Insertion");
string CED_M_3		= M("&Macros","Ma&cros");
string CED_M_4		= M("B&ahnen","T&races");
string CED_M_5		= M("&Flaechen","&Areas");
string CED_M_6		= M("&Texte","&Text");
string MNU_MMBMENU	= M("MMB-Menu","MMB Menu");
string MNU_ADDMENU	= M("%Neues Menu","%Add Menu");
string MNU_DELMENU	= M("Menu loeschen","Delete Menu");

// Format strings
string ITMKEYPROG	= M("(Tastaturprogrammierung)"	,"(Key Programming)");
string ITMMENPROG	= M("(Menuerweiterung)"		,"(Menu Extension)");
string ITMIMPPROG	= M("(Import)"			,"(Import)" );
string ITMDEFAULT	= M("(DEFAULT/NONE)"		,"(DEFAULT/NONE)");
string ITMALLPROG	= M("(Alle ULC-Programme)"	,"(All ULC programs)");
string ITMALLTEXT	= M("(Alle Hilfstexte)"		,"(All Help Texts)");
string ITMALL		= M("(Alle Tasten)"		,"(All keys)");
string ITMDALL		= M("Alle Tasten"		,"All keys");
string ITMMENUQRY	= M("(Menuauswahl)"		,"(Menu Selection)");
string ITMMACQRY	= M("(Makroauswahl)"		,"(Makro Selection)");
string ITMGRIDQRY	= M("(Rasterauswahl)"		,"(Grid Selection)");
string FMTSTDKEY	= M("Standardtaste  < %c >      ==> %s",
			    "Standard Key < %c >      ==> %s");
string FMTSSTDKEY	= M("%s <%c>","%s <%c>");
string FMTLMWFKEY	= M("Standardtaste  < [ > (LMB+Mausrad vor) ==> %s",
			    "Standard Key < [ > (LMB+Mouse Wheel Forward) ==> %s");
string FMTSLMWFKEY	= M("%s <[> (LMB+Mausrad vor)",
			    "%s <[> (LMB+Mouse Wheel Forward)");
string FMTLMWBKEY	= M("Standardtaste  < ] > (LMB+Mausrad zurueck) ==> %s",
			    "Standard Key < ] > (LMB+Mouse Wheel Back) ==> %s");
string FMTSLMWBKEY	= M("%s <]> (LMB+Mausrad zurueck)",
			    "%s <]> (LMB+Mouse Wheel Back)");
string FMTRMWFKEY	= M("Standardtaste  < { > (RMB+Mausrad vor) ==> %s",
			    "Standard Key < { > (RMB+Mouse Wheel Forward) ==> %s");
string FMTSRMWFKEY	= M("%s <{> (RMB+Mausrad vor)",
			    "%s <{> (RMB+Mouse Wheel Forward)");
string FMTRMWBKEY	= M("Standardtaste  < } > (RMB+Mausrad zurueck) ==> %s",
			    "Standard Key < } > (RMB+Mouse Wheel Back) ==> %s");
string FMTSRMWBKEY	= M("%s <}> (RMB+Mausrad zurueck)",
			    "%s <}> (RMB+Mouse Wheel Back)");
string FMTCMWFKEY	= M("Standardtaste  < ( > (Strg+Mausrad vor) ==> %s",
			    "Standard Key < ( > (Ctrl+Mouse Wheel Forward) ==> %s");
string FMTSCMWFKEY	= M("%s <(> (Strg+Mausrad vor)",
			    "%s <(> (Ctrl+Mouse Wheel Forward)");
string FMTCMWBKEY	= M("Standardtaste  < ) > (Strg+Mausrad zurueck) ==> %s",
			    "Standard Key < ) > (Ctrl+Mouse Wheel Back) ==> %s");
string FMTSCMWBKEY	= M("%s <)> (Strg+Mausrad zurueck)",
			    "%s <)> (Ctrl+Mouse Wheel Back)");
string FMTCTRKEY	= M("Standardtaste  < Strg+%c > ==> %s",
			    "Standard Key < Ctrl+%c > ==> %s"  );
string FMTSCTRKEY	= M("%s <Strg+%c>","%s <Ctrl+%c>");
string FMTSHCKEY	= M("Standardtaste  < Shift+Strg+%c > ==> %s",
			    "Standard Key < Shift+Ctrl+%c > ==> %s"  );
string FMTSSHCKEY	= M("%s <Shift+Strg+%c>","%s <Shift+Ctrl+%c>");
string FMTTABKEY	= M("Standardtaste  < Tab >   ==> %s",
			    "Standard Key < Tab >    ==> %s"  );
string FMTSTABKEY	= M("%s <Tab>","%s <Tab>");
string FMTCRKEY		= M("Standardtaste  < Enter >   ==> %s",
			    "Standard Key < Enter >    ==> %s"  );
string FMTSCRKEY	= M("%s <Enter>","%s <Enter>");
string FMTESCKEY	= M("Standardtaste  < Esc >   ==> %s",
			    "Standard Key < Esc >    ==> %s"  );
string FMTSESCKEY	= M("%s <Esc>","%s <Esc>");
string FMTSAMPKEY	= M("%s <&&>","%s <&&>");
string FMTDELKEY	= M("Standardtaste  < Entf >   ==> %s",
			    "Standard Key < Del >    ==> %s"  );
string FMTSDELKEY	= M("%s <Entf>","%s <Del>");
string FMTFCTKEY	= M("Funktionstaste < F%-2d >    ==> %s",
			    "Function Key < F%-2d >    ==> %s"  );
string FMTSFCTKEY	= M("%s <F%d>","%s <F%d>");

// Directory designators
#define UPRWD		"Current Directory"
#define UPRPD		"Parent Directory"
#define UPRRD		"Root Directory"
#define UPRSD		"Select Directory"
#define UINWD		CURDIR
#define UINPD		PARDIR
#define UINRD		"/."
#define UINSD		"?"

// INI file parameter name definitions
#define PAR_LISTDCNT	"MACRODCNT_STD"	// Max. dialog list items count

// Setup and SQL/DB file names
static string ULPRGDB	= strgetconffilename(ULDEFPRGVNAME,ULDEFPRGFNAME,1);
static string BAEPARAMDB = strgetconffilename(PARAMVNAME,PARAMFNAME,1);
static string BAEMACRODB = strgetconffilename(MACROVNAME,MACROFNAME,1);
static string BAEULHLPDB = strgetconffilename(ULHLPVNAME,ULHLPFNAME,1);

// Program sources extension
#define ULCEXT		".ulc"
#define VDBEXT		".vdb"

// Key definitions
#define MINFCTKEY	1		// Minimum function key code
#define MAXFCTKEY	12		// Maximum function key code
#define MINCTRKEY	1		// Minimum control key code
#define MAXCTRKEY	26		// Maximum control key code
#define MINSHCKEY	257		// Minimum shift control key code
#define MAXSHCKEY	282		// Maximum shift control key code
#define MINSTDKEY	32		// Minimum standard key code
#define MAXSTDKEY	127		// Maximum standard key code
#define KEYINV		(-1)		// Invalid/unknown key type
#define KEYALL		0		// All keys type
#define KEYSTD		1		// Standard key type
#define KEYFCT		2		// Function key type
#define MAINMCODE	50		// Main menu code
#define DISPMENUNUM	99		// Online display menu number
static STRINGS hotkeys			/* Hot key item list */;
static int hotkeyn	= 0		/* Hot key count */;
int dialkeyidx				/* Dialog box key item index */;

// Dialog box definitions
#define ED_WIDTHF	40.0		// Favorite param. edit field width
#define CCOLOFFFL	87.0		// Fav. list 2nd ctrl. column offset
#define CCOLOFFF	20.0		// Fav. param. 2nd ctrl. column offset
#define MBUTWIDTH	8.0		// Menu action button width
#define MBUTXSTEP	10.0		// Menu action button x step
double BUTXSTEP	= bae_swconfig(3)==2 ? 2.0 : 0.0
					/* Menu action button x spacing */;
#define SELBOXWIDTHFS	97.0		// Favorite selection box width
#define MAXMENUITEM	28		// Max. menu item count

// SQL command definitions
#define C_SELVER	"select pname,phlp_en,phlp_de,ptyp from ul_calltab where pver<=%d AND pver>=%d;"
#define C_CREATE1	"create table ul_calltab (pname string,"
#define C_CREATE2	" phlp_en string, phlp_de string,"
#define C_CREATE3	" pver integer, ptyp integer);"
#define C_CREATE	C_CREATE1+C_CREATE2+C_CREATE3
#define C_INSERT	"insert into ul_calltab values(%s,%s,%s,%d,%d);"
#define C_DROP		"drop table ul_calltab;"
#define H_CREATE1	"create table ul_helptab"
#define H_CREATE2	" (progname string, cmt_en string, cmt_de string);"
#define H_CREATE	H_CREATE1+H_CREATE2
#define H_HELP		"help ul_helptab;"
#define H_INSERT	"insert into ul_helptab values(%s,%s,%s);"
#define H_SELECT_EN	"select cmt_en from ul_helptab where progname=%s;"
#define H_SELECT_DE	"select cmt_de from ul_helptab where progname=%s;"
#define H_ALLSEL	"select progname from ul_helptab;"
#define H_DELETE	"delete from ul_helptab where progname=%s;"
#define H_DROP		"drop table ul_helptab;"
#define K_CREATE1	"create table keytab (progname string, "
#define K_CREATE2	"keytype integer, keycode integer, iptype integer);"
#define K_CREATE	K_CREATE1+K_CREATE2
#define K_HELP		"help keytab;"
#define K_INSERT	"insert into keytab values(%s,%d,%d,%d);"
#define K_DELETE	"delete from keytab where keytype=%d AND keycode=%d AND iptype=%d;"
#define K_TDELETE	"delete from keytab where keytype=%d AND iptype=%d;"
#define K_DELALL	"delete from keytab where iptype=%d;"
#define MN_SELECT	"select macname from macrotab where ptyp=%d AND midx=0;"
#define GN_SELECT	"select name from gridtab where ptyp=%d;"
#define M_SELECT1	"select fidx,name,progseq from menutab"
#define M_SELECT2	" where ptyp=%d AND midx=%d;"
#define M_SELECT	M_SELECT1+M_SELECT2
#define M_CREATE1	"create table menutab (midx integer,fidx integer,"
#define M_CREATE2	"ptyp integer,name string,progseq string);"
#define M_CREATE	M_CREATE1+M_CREATE2
#define M_HELP		"help menutab;"
#define M_INSERT	"insert into menutab values(%d,%d,%d,%s,%s);"
#define M_DELETE	"delete from menutab where ptyp=%d AND midx=%d;"
#define B_SELECT	"select name from menubar where ptyp=%d AND midx=%d;"
#define B_CREATE1	"create table menubar (midx integer,"
#define B_CREATE2	"ptyp integer,name string);"
#define B_CREATE	B_CREATE1+B_CREATE2
#define B_HELP		"help menubar;"
#define B_INSERT	"insert into menubar values(%d,%d,%s);"
#define B_DELETE	"delete from menubar where ptyp=%d AND midx=%d;"

// Globals
#define UL_UIFDUMP	"uifdump"	// ULP: User Interface Dump
#define UL_UIFRESET	"uifreset"	// ULP: User Interface Reset
#define UL_UIFSETUP	"uifsetup"	// ULP: User Interface Setup
#define UL_FAVORITE	"favorite"	// ULP: Favorite Management
#define UL_MACRO	"macro"		// ULP: Macro Management
#define GV_LASTPROG	"lastprog"	// Last called program name
static int MAXCOLS	= 100		/* Maximum popup columns */;
static int IPTYP	= uliptype()	/* UL interpreter type */;
static int IPVER	= ulipversion()	/* UL interpreter version */;
static string sqlcommand		/* SQL command string */;
static string ulipname	= getcurulipname()	/* Current interpreter name */;
static string progname			/* Program name */;
static STRINGS progl			/* Program list */;
static int progn=0			/* Program count */;
static string macl[]			/* Macro name list */;
static int macn				/* Macro name count */;
static string curcomment		/* Current comment */;
static string curpname			/* Current UL program name */;
static string curphlp_en		/* Current ULP English help text */;
static string curphlp_de		/* Current ULP German help text */;
static int pc				/* Program counter */;
struct menuitemdes {			// Menu item descriptor
	string name			/* Menu item display name */;
	string progseq			/* Menu item program sequence */;
	} menul[]			/* Menu list */;
static int menun	= 0		/* Menu count */;
static string curmenuname		/* Current menu name */;
static int curmenu	= 0		/* Current menu index */;
static int updrequest	= 0		/* Menu update request */;

// Main program
void main()
{
	int errcode			/* Database error code */;
	// Calculate the maximum popup columns
	if (bae_swconfig(3)!=BAE_WinPulldwn && bae_swconfig(3)!=BAE_MotifPdwn)
		calcpopwidth(MAXCOLS);
	// Get the menu list
	message(M_REPSCANDDB(),BAEULHLPDB);
	// Create/init database files
	if (sqlinit(BAEPARAMDB,0)==(-1) && sqlinit(BAEPARAMDB,1)==(-1)) {
		// Get error code
		sqlerr(errcode,"");
		// Ignore write access failure
		if (errcode!=8)
			// SQL/DB create/init error
			errormsg(M(DE_ERRDBINIT,EN_ERRDBINIT),BAEPARAMDB);
		}
	// Create/init database files
	if (sqlinit(BAEULHLPDB,0)==(-1) && sqlinit(BAEULHLPDB,1)==(-1)) {
		// Get error code
		sqlerr(errcode,"");
		// Ignore write access failure
		if (errcode!=8)
			// SQL/DB create/init error
			errormsg(M(DE_ERRDBINIT,EN_ERRDBINIT),BAEULHLPDB);
		}
	// Select program
	if (varget(GV_LASTPROG,progname))
		progname=UINPOPABORT;
	if ((progname=selectprogram(REPPROGHEAD,0,progname))=="")
		// Aborted
		error_abort();
	// Test if key programming selected
	if (progname==ITMKEYPROG) {
		// Perform key programming
		keyprogram();
		// Done
		return;
		}
	// Test if menu programming selected
	if (progname==ITMMENPROG) {
		// Perform menu programming
		menuprogram();
		// Done
		return;
		}
	// Test if program import selected
	else if (progname==ITMIMPPROG) {
		// Import program(s)
		importprogram();
		// Done
		return;
		}
	varset(GV_LASTPROG,progname);
	// Run the program
	switch (ulsystem(progname,pc)) {
		// No error
		case 0 :
		break;
		// DDB ACCESS ERROR
		case 1 : prterr(M(DE_ERRDDBERROR,EN_ERRDDBERROR)); break;
		// PROGRAM LOADER ERRORS
		// Program already loaded
		case 2 : prterr(M(DE_ERRULPINMEM,EN_ERRULPINMEM)); break;
		// Program not found
		case 3 : prterr(M(DE_ERRULPNTFND,EN_ERRULPNTFND)); break;
		// Incompatible User Language version
		case 4 : prterr(M(DE_ERRULPIVERS,EN_ERRULPIVERS)); break;
		// Incompatible index/function reference(s)
		case 5 : prterr(M(DE_ERRULPIFREF,EN_ERRULPIFREF)); break;
		// PROGRAM RUNTIME ERRORS
		// Stack underflow
		case 6 : prterr(M(DE_ERRULSTKUFL,EN_ERRULSTKUFL)); break;
		// Stack overflow
		case 7 : prterr(M(DE_ERRULSTKOFL,EN_ERRULSTKOFL)); break;
		// Division by zero
		case 8 : prterr(M(DE_ERRULDIVZRO,EN_ERRULDIVZRO)); break;
		// Error from system function call
		case 9 : prterr(M(DE_ERRULFCTCAL,EN_ERRULFCTCAL)); break;
		// System function not available
		case 10 : prterr(M(DE_ERRULFCTNAV,EN_ERRULFCTNAV)); break;
		// System function not implemented
		case 11 : prterr(M(DE_ERRULFCTNIP,EN_ERRULFCTNIP)); break;
		// User function not found
		case 12 : prterr(M(DE_ERRULFCTNFD,EN_ERRULFCTNFD)); break;
		// Invalid ref. function type
		case 13 : prterr(M(DE_ERRULFCTTYP,EN_ERRULFCTTYP)); break;
		// Invalid ref. function par. list
		case 14 : prterr(M(DE_ERRULFCTPAR,EN_ERRULFCTPAR)); break;
		// Array access error
		case 15 : prterr(M(DE_ERRULARYACC,EN_ERRULARYACC)); break;
		// Array index out of range
		case 16 : prterr(M(DE_ERRULARYRNG,EN_ERRULARYRNG)); break;
		// General file access error
		case 17 : prterr(M(DE_ERRULFACCES,EN_ERRULFACCES)); break;
		// General file read error
		case 18 : prterr(M(DE_ERRULFIREAD,EN_ERRULFIREAD)); break;
		// General file write error
		case 19 : prterr(M(DE_ERRULFWRITE,EN_ERRULFWRITE)); break;
		// Other errors
		default : prterr(M(DE_ERRULOTHER,EN_ERRULOTHER));
		}
}

/*________________________________________________________________*/
// Key programming routines

static void keyprogram()
/*
// Perfrom key programming
*/
{
	int abort	= 0		/* Abort flag */;
	// Perform key programming until abort
	do {
		// Select key programming function
		bae_promptdialog(UPRSELFCT);
		switch (bae_askmenu(12,
		 UPRHKEYSET,UPRHKEYDEL,
		 UPRHELPUPD,UPRHELPINP,UPRHELPDEL,
		 UPRCALLUPD,UPRCALLDEL,
		 UPRMENURES,UPRMENUDEF,UPRMENUREP,UPRMACRO,UPRABORT)) {
			// Set hot keys and abort
			case 0 :
			hotkeyset();
			abort=1;
			break;
			// Reset hot keys
			case 1 :
			hotkeyreset();
			break;
			// Help database update
			case 2 :
			helpupdate();
			progn=0;
			break;
			// Help database input
			case 3 :
			helpinput();
			break;
			// Help database delete
			case 4 :
			helpdelete();
			break;
			// UL program call database update
			case 5 :
			ulpcallupdate();
			break;
			// UL program call database delete
			case 6 :
			ulpcalldrop();
			break;
			// Run the User Interface Reset program and abort
			case 7 :
			runulprog(UL_UIFRESET);
			abort=1;
			break;
			// Run the User Interface Setup program
			case 8 :
			runulprog(UL_UIFSETUP);
			break;
			// Run the User Interface Dump program and abort
			case 9 :
			runulprog(UL_UIFDUMP);
			abort=1;
			break;
			// Run the Macro Management program
			case 10 :
			runulprog(UL_MACRO);
			break;
			// Abort on default
			default :
			abort=1;
			}
		// Test on abort request
		} while (!abort);
	// Done
	bae_prtdialog("");
}

static void menuprogram()
/*
// Perform menu programming
*/
{
	string menunl[]			/* Menu name list */;
	int menuidx			/* Menu index */;
	int menucnt			/* Menu count */;
	int stdmenucnt			/* Standard menu count */;
	int addmcode			/* Add menu code */;
	int mmbmcode			/* MMB menu code */;
	int delmcode	= (-2)		/* Delete menu code */;
	int abortflag	= 0		/* Abort flag */;
	// Create SQL database table
	if (sqlcmd(bae_planfname(),B_HELP,NULL)!=0)
		if (sqlcmd(BAEPARAMDB,B_CREATE,NULL))
			// SQL/DB error (ignore table already defined error)
			sql_dberror(25);
	// Perform menu programming until abort
	do {
		// Build the menu list
		menunl[0]=MNU_FILE;
		// Test the interpreter type
		switch (IPTYP) {
			// SCM
			case ULIPSCM :
			menunl[1]=MNU_EDIT;
			menunl[2]=MNU_VIEW;
			menunl[3]=SCM_M_3;
			menunl[4]=SCM_M_4;
			menunl[5]=SCM_M_5;
			menunl[6]=SCM_M_6;
			menunl[7]=SCM_M_9;
			menucnt=8;
			break;
			// GED
			case ULIPGED :
			menunl[1]=MNU_EDIT;
			menunl[2]=MNU_VIEW;
			menunl[3]=GED_M_3;
			menunl[4]=GED_M_4;
			menunl[5]=GED_M_5;
			menunl[6]=GED_M_6;
			menucnt=7;
			break;
			// AR
			case ULIPAR  :
			menunl[1]=MNU_EDIT;
			menunl[2]=MNU_VIEW;
			menunl[3]=AR_M_2;
			menunl[4]=AR_M_3;
			menucnt=5;
			break;
			// CAM
			case ULIPCAM :
			menunl[1]=MNU_VIEW;
			menunl[2]=CAM_M_2;
			menunl[3]=CAM_M_3;
			menunl[4]=CAM_M_4;
			menucnt=5;
			break;
			// CED
			case ULIPCED :
			menunl[1]=MNU_EDIT;
			menunl[2]=MNU_VIEW;
			menunl[3]=CED_M_3;
			menunl[4]=CED_M_4;
			menunl[5]=CED_M_5;
			menunl[6]=CED_M_6;
			menucnt=7;
			break;
			// CV
			case ULIPCV  :
			menunl[1]=MNU_EDIT;
			menunl[2]=MNU_VIEW;
			menucnt=3;
			break;
			// Abort on default
			default :
			error_abort();
			}
		menunl[menucnt++]=MNU_PARAM;
		menunl[menucnt++]=MNU_UTIL;
		menunl[menucnt++]=MNU_HELP;
		stdmenucnt=menucnt;
		for (menuidx=menucnt;menuidx<99;menuidx++)
			if ((menunl[menucnt]=
			 bae_getmenutext(MAINMCODE,menuidx))=="")
				break;
			else
				menucnt++;
		mmbmcode=menucnt;
		menunl[menucnt++]=MNU_MMBMENU;
		addmcode=menucnt;
		menunl[menucnt++]=MNU_ADDMENU;
		if (menucnt!=stdmenucnt) {
			delmcode=menucnt;
			menunl[menucnt++]=MNU_DELMENU;
			}
		menunl[menucnt++]=UPRDONE;
		updrequest=0;
		// Select the menu
		bae_promptdialog(UPRSELMENU);
		if ((menuidx=bae_askmenu(menucnt,menunl[0],menunl[1],menunl[2],
		 menunl[3],menunl[4],menunl[5],menunl[6],menunl[7],menunl[8],
		 menunl[9],menunl[10],menunl[11],menunl[12],menunl[13],
		 menunl[14],menunl[15],menunl[16],menunl[17],menunl[18],
		 menunl[19],menunl[20],menunl[21],menunl[22],menunl[23],
		 menunl[24],menunl[25],menunl[26],menunl[27],menunl[28],
		 menunl[29]))<0 || menuidx>=(menucnt-1))
			abortflag=1;
		else if (menuidx==addmcode)
			menuadd(addmcode-1);
		else if (menuidx==mmbmcode)
			menuedit(DISPMENUNUM,MNU_MMBMENU);
		else if (menuidx==delmcode)
			menudelete(stdmenucnt);
		else
			menuedit(menuidx,menunl[menuidx]);
		if (updrequest)
			// Redefine menu
			runulprog(UL_UIFSETUP);
		// Test on abort request
		} while (!abortflag);
	bae_prtdialog("");
}

void menuadd(int usermenuend)
/*
// Add menu
// Parameter :
//	int usermenuend		: User menu end index
*/
{
	string menuname			/* Menu name */;
	// Ask for new menu name
	if ((menuname=askstr(UPRNMENU,MAXKEYLEN))=="" || menuname==UINPOPABORT)
		error_abort();
	// Set menu rebuild request flag
	updrequest=1;
	// Store menu name to database
	sprintf(sqlcommand,B_INSERT,usermenuend,IPTYP,sql_quotestr(menuname));
	if (sqlcmd(BAEPARAMDB,sqlcommand,NULL)!=0)
		// SQL/DB error
		sql_dberror(0);
	// Edit new menu
	menuedit(usermenuend,menuname);
}

void menudelete(usermenubase)
/*
// Delete menu
// Parameter :
//	int usermenubase	: User menu index base
*/
{
	string menunl[]			/* Menu name list */;
	string prompt			/* Prompt string */;
	int menuidx			/* Menu index */;
	int menucnt			/* Menu count */;
	int i				/* Loop control variable */;
	// Get user menu names
	for (menuidx=usermenubase;menuidx<99;menuidx++)
		if ((menunl[menucnt]=bae_getmenutext(MAINMCODE,menuidx))=="")
			break;
		else
			menucnt++;
	menunl[menucnt++]=UPRABORT;
	// Select the menu
	bae_promptdialog(UPRSELDMENU);
	if ((menuidx=bae_askmenu(menucnt,menunl[0],menunl[1],menunl[2],
	 menunl[3],menunl[4],menunl[5],menunl[6],menunl[7],menunl[8],
	 menunl[9],menunl[10],menunl[11],menunl[12],menunl[13],
	 menunl[14],menunl[15],menunl[16],menunl[17],menunl[18],
	 menunl[19],menunl[20],menunl[21],menunl[22],menunl[23],
	 menunl[24],menunl[25],menunl[26],menunl[27],menunl[28],
	 menunl[29]))<0 || menuidx>=(menucnt-1))
		return;
	// Verify menu deletion
	sprintf(prompt,UPRDELMENU,menunl[menuidx]);
	if (!verify(prompt,0))
		return;
	// Set menu rebuild request flag
	updrequest=1;
	// Move following menu data sets
	for (i=menuidx;i<(menucnt-2);i++) {
		menun=0;
		sprintf(sqlcommand,M_SELECT,IPTYP,i+1+usermenubase);
		sqlcmd(BAEPARAMDB,sqlcommand,fctselfunc);
		updatemenu(i+usermenubase);
		sprintf(sqlcommand,B_DELETE,IPTYP,i+usermenubase);
		if (sqlcmd(BAEPARAMDB,sqlcommand,NULL)!=0)
			// SQL/DB error
			sql_dberror(29);
		sprintf(sqlcommand,B_SELECT,IPTYP,i+1+usermenubase);
		sqlcmd(BAEPARAMDB,sqlcommand,menuselfunc);
		sprintf(sqlcommand,B_INSERT,
		 i+usermenubase,IPTYP,sql_quotestr(curmenuname));
		if (sqlcmd(BAEPARAMDB,sqlcommand,NULL)!=0)
			// SQL/DB error
			sql_dberror(0);
		}
	// Delete the last menu data
	sprintf(sqlcommand,M_DELETE,IPTYP,menucnt-2+usermenubase);
	if (sqlcmd(BAEPARAMDB,sqlcommand,NULL)!=0)
		// SQL/DB error
		sql_dberror(29);
	sprintf(sqlcommand,B_DELETE,IPTYP,menucnt-2+usermenubase);
	if (sqlcmd(BAEPARAMDB,sqlcommand,NULL)!=0)
		// SQL/DB error
		sql_dberror(29);
}

void menuedit(int menuidx,string menuname)
/*
// Edit menu, store result to database
// Parameters :
//	int menuidx		: Menu index
//	string menuname		: Menu name
*/
{
	string msg			/* Message buffer */;
	struct menuitemdes swapmenu	/* Menu item swap buffer */;
	double cy			/* Current y value */;
	double butx			/* Current button position */;
	double dialwidth		/* Dialog box width */;
	double dialheight		/* Dialog box height */;
	double baseheight		/* Dialog box base height */;
	int lbidx			/* List box item index */;
	int repflag	= 1		/* Repeat flag */;
	int res				/* Dialog box result buffer */;
	int from			/* From index */;
	int to				/* To index */;
	int i				/* Loop control variable */;
	// Check if dialog box support
	if (bae_dialclr())
		error(ERRNOWIN);
	// Create SQL database table
	if (sqlcmd(bae_planfname(),M_HELP,NULL)!=0)
		if (sqlcmd(BAEPARAMDB,M_CREATE,NULL))
			// SQL/DB error (ignore table already defined error)
			sql_dberror(25);
	menun=0;
	sprintf(sqlcommand,M_SELECT,IPTYP,menuidx);
	sqlcmd(BAEPARAMDB,sqlcommand,fctselfunc);
	// Perform the input loop
	do {
		baseheight=DIAL_TOPMARG+DIAL_SEPVSTEP+DIAL_BUTVSTEP;
		bae_dialclr();
		dial_getboxsizemin(5010,dialwidth,dialheight,
		 DIAL_LEFTMARG+SELBOXWIDTHFS+DIAL_RIGHTSMARG,baseheight+16.0,
		 DIAL_LEFTMARG+95.3+DIAL_RIGHTSMARG,baseheight+2.0);
		cy=DIAL_TOPMARG;
		butx=DIAL_LEFTMARG+1.0;
		// Store function buttons
		// Edit menu item
		if (menun) {
			bae_dialaddcontrol(PA_ACT,0,0,0,0.0,0.0,0.0,
			 "",0,butx,cy,0.0,UPRDEDIT);
			butx+=BUTXSTEP+bae_dialgettextlen(0,UPRDEDIT);
			}
		// Add menu item
		if (menun<MAXMENUITEM) {
			bae_dialaddcontrol(PA_ACT,0,1,0,0.0,0.0,0.0,
			 "",0,butx,cy,0.0,UPRDADDF);
			butx+=BUTXSTEP+bae_dialgettextlen(0,UPRDADDF);
			bae_dialaddcontrol(PA_ACT,0,7,0,0.0,0.0,0.0,
			 "",0,butx,cy,0.0,UPRDADDG);
			butx+=BUTXSTEP+bae_dialgettextlen(0,UPRDADDG);
			bae_dialaddcontrol(PA_ACT,0,2,0,0.0,0.0,0.0,
			 "",0,butx,cy,0.0,UPRDADDM);
			butx+=BUTXSTEP+bae_dialgettextlen(0,UPRDADDM);
			bae_dialaddcontrol(PA_ACT,0,6,0,0.0,0.0,0.0,
			 "",0,butx,cy,0.0,UPRDADDU);
			butx+=BUTXSTEP+bae_dialgettextlen(0,UPRDADDU);
			}
		// Delete menu item
		if (menun) {
			bae_dialaddcontrol(PA_ACT,0,3,0,0.0,0.0,0.0,
			 "",0,butx,cy,0.0,UPRDDEL);
			butx+=BUTXSTEP+bae_dialgettextlen(0,UPRDDEL);
			bae_dialaddcontrol(PA_ACT,0,5,0,0.0,0.0,0.0,
			 "",0,butx,cy,0.0,UPRDDELA);
			butx+=BUTXSTEP+bae_dialgettextlen(0,UPRDDELA);
			}
		// Move menu item
		if (menun>1) {
			bae_dialaddcontrol(PA_ACT,0,4,0,0.0,0.0,0.0,
			 "",0,butx,cy,0.0,UPRDMOVE);
			butx+=BUTXSTEP+bae_dialgettextlen(0,UPRDMOVE);
			}
		// Store done button
		bae_dialaddcontrol(PA_ACT,0,(-1),0,0.0,0.0,0.0,"",0,
		 butx,cy,0.0,UPRDDONE);
		cy+=DIAL_BUTVSTEP;
		// Store list box
		lbidx=bae_dialadvcontrol(
		 PA_LB|PA_OKSEL|PA_HBRDREL|PA_HSCROLL|PA_VBRDREL,
		 (-1),0,(-1),0.0,0.0,0.0,"",0,
		 DIAL_LEFTMARG,cy,DIAL_RIGHTSMARG,DIAL_SEPVSTEP,"");
		// Store list box entries
		for (i=0;i<menun;i++)
			bae_dialaddcontrol(PA_LBE,0,0,i,0.0,0.0,0.0,
			 "",0,0.0,0.0,0.0,menul[i].name);
		cy+=dialheight-baseheight;
		// Call the dialog function
		sprintf(msg,UPRDIALFFUNC,menuname);
		bae_setintpar(16,5010);
		switch (bae_dialaskparams("!"+msg,3,
		 dialwidth,cy+DIAL_SEPVSTEP)) {
			case 0 :
			// Edit menu item
			bae_dialgetdata(lbidx,i,0.0,"");
			if (i>=0 && i<menun)
				if (menuitemedit(i,menuname)==0)
					updatemenu(menuidx);
			break;
			// Add menu item menu function
			case 1 :
			if (bae_swconfig(3)==BAE_WinPulldwn ||
			 bae_swconfig(3)==BAE_MotifPdwn) {
				if (bae_getmenuitem(0,menul[menun].name,
				 menul[menun].progseq)!=0)
					error_abort();
				// Dismiss leading menu path
				for (i=strlen(menul[menun].name)-4;i>=0;i--)
					if (menul[menun].name[i]==' ' &&
					 menul[menun].name[i+1]=='-' &&
					 menul[menun].name[i+2]=='>' &&
					 menul[menun].name[i+3]==' ') {
						menul[menun].name=strextract(
						 menul[menun].name,i+4,strlen(
						 menul[menun].name));
						break;
						}
				}
			else {
				menul[menun].name=menul[menun].progseq="";
				}
			// Edit menu item data
			if (menuitemedit(menun,menuname)==0) {
				menun++;
				updatemenu(menuidx);
				}
			break;
			// Add menu item macro
			case 2 :
			macn=0;
			sprintf(sqlcommand,MN_SELECT,IPTYP);
			if (sqlcmd(BAEMACRODB,sqlcommand,macselfunc)!=0)
				// SQL/DB error
				sql_dberror(27);
			if (macn==0) {
				bae_msgbox(1,ERRNOMACRO,"");
				break;
				}
			bae_setintpar(16,5025);
			if ((menul[menun].name=popupmenu(1,UPRMACSEL,macl,0,
			  macl,macn,UINPOPABORT,0,1,1,macn+2,0,0,""))=="" ||
			 menul[menun].name==UINPOPABORT)
				error_abort();
			menul[menun].progseq=
			 UL_MACRO+":\""+menul[menun].name+"\"";
			// Edit menu item data
			if (menuitemedit(menun,menuname)==0) {
				menun++;
				updatemenu(menuidx);
				}
			break;
			// Delete menu item
			case 3 :
			bae_dialgetdata(lbidx,i,0.0,"");
			if (i>=0 && i<menun) {
				menun--;
				for (;i<menun;i++)
					menul[i]=menul[i+1];
				}
			updatemenu(menuidx);
			break;
			// Move menu item
			case 4 :
			bae_dialgetdata(lbidx,from,0.0,"");
			if (from<0 || from>=menun) {
				bae_msgbox(2,ERRNOMOVMENU,"");
				break;
				}
			baseheight=DIAL_TOPMARG+DIAL_SEPVSTEP+DIAL_BUTVSTEP;
			do {
				bae_dialclr();
				dial_getboxsizemin(5010,dialwidth,dialheight,
				 DIAL_LEFTMARG+SELBOXWIDTHFS+DIAL_RIGHTSMARG,
				 baseheight+16.0,
				 DIAL_LEFTMARG+95.3+DIAL_RIGHTSMARG,
				 baseheight+2.0);
				cy=DIAL_TOPMARG;
				// Store the OK and abort button with seperator
				dial_okabort(cy);
				cy-=DIAL_SEPVSTEP;
				// Store list box
				lbidx=bae_dialadvcontrol(PA_LB|PA_OKSEL|
				 PA_HBRDREL|PA_HSCROLL|PA_VBRDREL,(-1),0,(-1),
				 0.0,0.0,0.0,"",0,DIAL_LEFTMARG,cy,
				 DIAL_RIGHTSMARG,DIAL_SEPVSTEP,"");
				// Store list box entries
				for (i=0;i<menun;i++)
					bae_dialaddcontrol(PA_LBE,0,0,i,0.0,0.0,
					 0.0,"",0,0.0,0.0,0.0,menul[i].name);
				cy+=dialheight-baseheight+DIAL_SEPVSTEP;
				bae_setintpar(16,5010);
				sprintf(msg,UPRMENUMOVDST,menul[from].name);
				res=bae_dialaskparams("!"+msg,0,dialwidth,cy);
				// Stop if no further repeat requests
				} while (res==(-2));
			if (res<0)
				break;
			// Perform the menu item swap
			bae_dialgetdata(lbidx,to,0.0,"");
			if (to<0)
				break;
			swapmenu=menul[from];
			if (from>to)
				for (i=from;i>to;i--)
					menul[i]=menul[i-1];
			else
				for (i=from;i<to;i++)
					menul[i]=menul[i+1];
			menul[to]=swapmenu;
			updatemenu(menuidx);
			break;
			// Delete all menu items
			case 5 :
			menun=0;
			updatemenu(menuidx);
			break;
			// Add menu item ULC program
			case 6 :
			// Select program
			if ((menul[menun].progseq=selectprogram(
			 REPPROGHEAD,3,UINPOPABORT))=="")
				// Aborted
				error_abort();
			menul[menun].name="ULC "+menul[menun].progseq;
			// Edit menu item data
			if (menuitemedit(menun,menuname)==0) {
				menun++;
				updatemenu(menuidx);
				}
			break;
			// Add menu item grid
			case 7 :
			macn=0;
			sprintf(sqlcommand,GN_SELECT,IPTYP);
			if (sqlcmd(BAEPARAMDB,sqlcommand,macselfunc)!=0)
				// SQL/DB error
				sql_dberror(27);
			if (macn==0) {
				bae_msgbox(1,ERRNOGRID,"");
				break;
				}
			bae_setintpar(16,5048);
			if ((menul[menun].name=popupmenu(1,UPRGRIDSEL,macl,0,
			  macl,macn,UINPOPABORT,0,1,1,macn+2,0,0,""))=="" ||
			 menul[menun].name==UINPOPABORT)
				error_abort();
			menul[menun].progseq=UL_FAVORITE+
			 ":\"gridset\":\""+menul[menun].name+"\"";
			// Edit menu item data
			if (menuitemedit(menun,menuname)==0) {
				menun++;
				updatemenu(menuidx);
				}
			break;
			// Resize
			case (-2) :
			break;
			// Done/Abort
			default :
			repflag=0;
			}
		// Stop if no further repeat requests
		} while (repflag);
}

static int fctselfunc(string dstr,int dint,double ddbl,
 int dval,int dtype,string dtable,string dfield,int didx)
/*
// Menu function selection callback function
// Return value :
//	zero if done or (-1) on data error
// Parameters :
//	string dstr		: String/Date data
//	int dint		: Integer/Boolean data
//	double ddbl		: Float data
//	int dval		: Data valid flag
//	int dtype		: Data type
//	string dtable		: Data table name
//	string dfield		: Data field name
//	int didx		: Data output field index
*/
{
	// Store the current entry
	switch (didx) {
		// Index
		case 1 :
		curmenu=dint;
		if (curmenu>=menun)
			menun=curmenu+1;
		break;
		// Name
		case 2 :
		menul[curmenu].name=dstr;
		break;
		// Program sequence
		case 3 :
		menul[curmenu].progseq=dstr;
		break;
		}
	// Return without errors
	return(0);
}

static int menuselfunc(string dstr,int dint,double ddbl,
 int dval,int dtype,string dtable,string dfield,int didx)
/*
// Menu name selection callback function
// Return value :
//	zero if done or (-1) on data error
// Parameters :
//	string dstr		: String/Date data
//	int dint		: Integer/Boolean data
//	double ddbl		: Float data
//	int dval		: Data valid flag
//	int dtype		: Data type
//	string dtable		: Data table name
//	string dfield		: Data field name
//	int didx		: Data output field index
*/
{
	curmenuname=dstr;
	// Return without errors
	return(0);
}

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

void updatemenu(int menuidx)
/*
// Update menu database
// Parameter :
//	int menuidx		: Menu index
*/
{
	int i				/* Loop control variable */;
	// Set menu rebuild request flag
	updrequest=1;
	// Delete the old menu data
	sprintf(sqlcommand,M_DELETE,IPTYP,menuidx);
	if (sqlcmd(BAEPARAMDB,sqlcommand,NULL)!=0)
		// SQL/DB error
		sql_dberror(29);
	// Store new menu data
	for (i=0;i<menun;i++) {
		sprintf(sqlcommand,M_INSERT,menuidx,i,IPTYP,
		 sql_quotestr(menul[i].name),sql_quotestr(menul[i].progseq));
		if (sqlcmd(BAEPARAMDB,sqlcommand,NULL)!=0)
			// SQL/DB error
			sql_dberror(0);
		}
}

/*________________________________________________________________*/
// Program import routines

static void importprogram()
/*
// Import program(s)
*/
{
	string srcfname			/* Source file name */;
	string msg			/* Error message */;
	STRINGS entryl			/* Entry string list */;
	int entryn	= 0		/* Entry count */;
	string ename			/* Element name buffer */;
	int i				/* Loop control variable */;
	// Select the program(s) source file
	if (bae_askfilename(srcfname,VDBEXT,UPRULSRC) || srcfname=="")
		error_abort();
	// Scan all elements
	ename="";
	while (scanddbenames(srcfname,DDBCLUL,ename)==1) {
		entryl[entryn]=ename;
		entryn++;
		}
	// Copy elements
	for (i=0;i<entryn;i++)
		if (ddbcopyelem(srcfname,ULPRGDB,DDBCLUL,entryl[i],1))
			 errormsg(ERRCOPY,entryl[i]);
	// Done
	sprintf(msg,REPCOPYDONE,entryn,srcfname,ULPRGDB);
	bae_prtdialog(msg);
}

/*________________________________________________________________*/
// Hot key programming functions

static void hotkeyset()
/*
// Perform hot key setting
*/
{
	int keytype			/* Key type */;
	int keycode			/* Key code */;
	string keyname			/* Key designator */;
	string header			/* Menu header string buffer */;
	int insidx			/* Hot key insert index */;
	// Repetively select hot keys
	while ((keytype=selecthotkey(keycode,0,insidx))!=KEYINV) {
		// Set the key name
		switch (keytype) {
			case KEYFCT :
			sprintf(keyname,FMTSFCTKEY,ulipname,keycode);
			progname=bae_getfuncprog(keycode);
			break;
			case KEYSTD :
			if (keycode=='\t')
				sprintf(keyname,FMTSTABKEY,ulipname);
			else if (keycode==0x0D)
				sprintf(keyname,FMTSCRKEY,ulipname);
			else if (keycode==0x1B)
				sprintf(keyname,FMTSESCKEY,ulipname);
			else if (keycode=='&')
				sprintf(keyname,FMTSAMPKEY,ulipname);
			else if (keycode=='[')
				sprintf(keyname,FMTSLMWFKEY,ulipname);
			else if (keycode==']')
				sprintf(keyname,FMTSLMWBKEY,ulipname);
			else if (keycode=='{')
				sprintf(keyname,FMTSRMWFKEY,ulipname);
			else if (keycode=='}')
				sprintf(keyname,FMTSRMWBKEY,ulipname);
			else if (keycode=='(')
				sprintf(keyname,FMTSCMWFKEY,ulipname);
			else if (keycode==')')
				sprintf(keyname,FMTSCMWBKEY,ulipname);
			else if (keycode==0x7F)
				sprintf(keyname,FMTSDELKEY,ulipname);
			else if (keycode<=MAXCTRKEY)
				sprintf(keyname,FMTSCTRKEY,ulipname,
				 keycode+'A'-1);
			else if (keycode>=MINSHCKEY && keycode<=MAXSHCKEY)
				sprintf(keyname,FMTSSHCKEY,ulipname,
				 keycode+'A'-257);
			else
				sprintf(keyname,FMTSSTDKEY,ulipname,
				 keycode);
			progname=bae_getkeyprog(keycode);
			break;
			default :
			err_intern("hotkeyset");
			}
		// Build the menu header
		sprintf(header,REPPROG,
		 keyname,progname ? progname : ITMDEFAULT);
		// Select program
		if ((progname=selectprogram(header,
		 bae_swconfig(3)==BAE_WinPulldwn ||
		 bae_swconfig(3)==BAE_MotifPdwn ? 2 : 1,progname))=="")
			continue;
		// Reset program name if default call selected
		if (progname==ITMDEFAULT)
			progname="";
		// Define hot key
		switch (keytype) {
			// Function key
			case KEYFCT :
			if (bae_deffuncprog(keycode,progname) && progname)
				errormsg(ERRKEYPROG,"F"+itoa(keycode));
			sprintf(hotkeys[insidx],FMTFCTKEY,keycode,progname);
			break;
			// Standard key
			case KEYSTD :
			if (bae_defkeyprog(keycode,progname) && progname)
				errormsg(ERRKEYPROG,itoa(keycode));
			if (keycode=='\t')
				sprintf(hotkeys[insidx],FMTTABKEY,progname);
			else if (keycode==0x0D)
				sprintf(hotkeys[insidx],FMTCRKEY,progname);
			else if (keycode==0x1B)
				sprintf(hotkeys[insidx],FMTESCKEY,progname);
			else if (keycode=='[')
				sprintf(hotkeys[insidx],FMTLMWFKEY,progname);
			else if (keycode==']')
				sprintf(hotkeys[insidx],FMTLMWBKEY,progname);
			else if (keycode=='{')
				sprintf(hotkeys[insidx],FMTRMWFKEY,progname);
			else if (keycode=='}')
				sprintf(hotkeys[insidx],FMTRMWBKEY,progname);
			else if (keycode=='(')
				sprintf(hotkeys[insidx],FMTCMWFKEY,progname);
			else if (keycode==')')
				sprintf(hotkeys[insidx],FMTCMWBKEY,progname);
			else if (keycode==0x7F)
				sprintf(hotkeys[insidx],FMTDELKEY,progname);
			else if (keycode<=MAXCTRKEY)
				sprintf(hotkeys[insidx],FMTCTRKEY,
				 keycode+'A'-1,progname);
			else if (keycode>=MINSHCKEY && keycode<=MAXSHCKEY)
				sprintf(hotkeys[insidx],FMTSHCKEY,
				 keycode+'A'-1,progname);
			else
				sprintf(hotkeys[insidx],FMTSTDKEY,
				 keycode,progname);
			break;
			}
		// Create SQL database table
		if (sqlcmd(bae_planfname(),K_HELP,NULL)!=0)
			if (sqlcmd(BAEPARAMDB,K_CREATE,NULL))
				// SQL/DB error (ign. table already def. error)
				sql_dberror(25);
		// Delete old hot key from database
		sprintf(sqlcommand,K_DELETE,keytype,keycode,IPTYP);
		if (sqlcmd(BAEPARAMDB,sqlcommand,NULL))
			// SQL/DB error (ignore no delete record error)
			sql_dberror(29);
		// Insert hot key into database
		sprintf(sqlcommand,
		 K_INSERT,sql_quotestr(progname),keytype,keycode,IPTYP);
		if (sqlcmd(BAEPARAMDB,sqlcommand,NULL))
			// SQL/DB error
			sql_dberror(0);
		}
}

static void hotkeyreset()
/*
// Reset the hot keys (to default key call)
*/
{
	int keycode			/* Key code */;
	int insidx			/* Hot key insert index */;
	int i				/* Loop control variable */;
	// Create SQL database table
	if (sqlcmd(bae_planfname(),K_HELP,NULL)!=0)
		if (sqlcmd(BAEPARAMDB,K_CREATE,NULL))
			// SQL/DB error (ignore table already defined error)
			sql_dberror(25);
	// Select key type for reset
	bae_promptdialog(UPRSELKEYT);
	switch (bae_askmenu(5,UPRKEYALL,
	 UPRKEYFCT,UPRKEYSTD,UPRKEYSEL,UPRABORT)) {
		// All keys
		case 0 :
		// Reset all function keys (ignore errors)
		for (i=MINFCTKEY;i<=MAXFCTKEY;i++)
			bae_deffuncprog(i,"");
		// Reset all standard keys (ignore errors)
		for (i=MINSTDKEY;i<=MAXSTDKEY;i++)
			bae_defkeyprog(i,"");
		for (i=MINCTRKEY;i<=MAXCTRKEY;i++)
			bae_defkeyprog(i,"");
		for (i=MINSHCKEY;i<=MAXSHCKEY;i++)
			bae_defkeyprog(i,"");
		// Delete hot keys from database
		sprintf(sqlcommand,K_DELALL,IPTYP);
		if (sqlcmd(BAEPARAMDB,sqlcommand,NULL))
			// SQL/DB error (ignore no delete record error)
			sql_dberror(29);
		break;
		// Function keys
		case 1 :
		// Reset all function keys
		for (i=MINFCTKEY;i<=MAXFCTKEY;i++)
			bae_deffuncprog(i,"");
		// Delete function keys from database
		sprintf(sqlcommand,K_TDELETE,KEYFCT,IPTYP);
		if (sqlcmd(BAEPARAMDB,sqlcommand,NULL))
			// SQL/DB error (ignore no delete record error)
			sql_dberror(29);
		break;
		// Standard keys
		case 2 :
		// Reset all standard keys
		for (i=MINSTDKEY;i<=MAXSTDKEY;i++)
			bae_defkeyprog(i,"");
		for (i=MINCTRKEY;i<=MAXCTRKEY;i++)
			bae_defkeyprog(i,"");
		for (i=MINSHCKEY;i<=MAXSHCKEY;i++)
			bae_defkeyprog(i,"");
		// Delete standard keys from database
		sprintf(sqlcommand,K_TDELETE,KEYSTD,IPTYP);
		if (sqlcmd(BAEPARAMDB,sqlcommand,NULL))
			// SQL/DB error (ignore no delete record error)
			sql_dberror(29);
		break;
		// Select key
		case 3 :
		// Select hot key
		switch (selecthotkey(keycode,1,insidx)) {
			// All keys
			case KEYALL :
			// Reset all function keys
			for (i=MINFCTKEY;i<=MAXFCTKEY;i++)
				bae_deffuncprog(i,"");
			// Reset all standard keys
			for (i=MINSTDKEY;i<=MAXSTDKEY;i++)
				bae_defkeyprog(i,"");
			for (i=MINCTRKEY;i<=MAXCTRKEY;i++)
				bae_defkeyprog(i,"");
			for (i=MINSHCKEY;i<=MAXSHCKEY;i++)
				bae_defkeyprog(i,"");
			// Reset the hotkey list
			hotkeyn=0;
			// Delete hot keys from database
			sprintf(sqlcommand,K_DELALL,IPTYP);
			if (sqlcmd(BAEPARAMDB,sqlcommand,NULL))
				// SQL/DB error (ignore no delete record error)
				sql_dberror(29);
			break;
			// Function key selected
			case KEYFCT :
			bae_deffuncprog(keycode,"");
			sprintf(hotkeys[insidx],FMTFCTKEY,keycode,"");
			// Delete function key from database
			sprintf(sqlcommand,K_DELETE,KEYFCT,keycode,IPTYP);
			if (sqlcmd(BAEPARAMDB,sqlcommand,NULL))
				// SQL/DB error (ignore no delete record error)
				sql_dberror(29);
			break;
			// Standard key selected
			case KEYSTD :
			bae_defkeyprog(keycode,"");
			if (keycode=='\t')
				sprintf(hotkeys[insidx],FMTTABKEY,progname);
			else if (keycode==0x0D)
				sprintf(hotkeys[insidx],FMTCRKEY,progname);
			else if (keycode==0x1B)
				sprintf(hotkeys[insidx],FMTESCKEY,progname);
			else if (keycode=='[')
				sprintf(hotkeys[insidx],FMTLMWFKEY,progname);
			else if (keycode==']')
				sprintf(hotkeys[insidx],FMTLMWBKEY,progname);
			else if (keycode=='{')
				sprintf(hotkeys[insidx],FMTRMWFKEY,progname);
			else if (keycode=='}')
				sprintf(hotkeys[insidx],FMTRMWBKEY,progname);
			else if (keycode=='(')
				sprintf(hotkeys[insidx],FMTCMWFKEY,progname);
			else if (keycode==')')
				sprintf(hotkeys[insidx],FMTCMWBKEY,progname);
			else if (keycode==0x7F)
				sprintf(hotkeys[insidx],FMTDELKEY,progname);
			else if (keycode<=MAXCTRKEY)
				sprintf(hotkeys[insidx],FMTCTRKEY,
				 keycode+'A'-1,progname);
			else if (keycode>=MINSHCKEY && keycode<=MAXSHCKEY)
				sprintf(hotkeys[insidx],FMTSHCKEY,
				 keycode+'A'-1,progname);
			else
				sprintf(hotkeys[insidx],FMTSTDKEY,
				 keycode,progname);
			// Delete standard key from database
			sprintf(sqlcommand,K_DELETE,KEYSTD,keycode,IPTYP);
			if (sqlcmd(BAEPARAMDB,sqlcommand,NULL))
				// SQL/DB error (ignore no delete record error)
				sql_dberror(29);
			break;
			}
		break;
		}
	// Done
	bae_prtdialog("");
}

static int selecthotkey(int keycode=(-1),int allsel,int insidx=(-1))
/*
// Build hot key designator list
// Return value :
//	(-1) on abort, or key type
// Parameters :
//	int keycode=(-1)	: Key code on valid key selection
//	int allsel		: All keys selection enable flag
//	int insidx=(-1)		: Hotkey list index
*/
{
	STRINGS headl			/* Header list */;
	int headn	= 2		/* Header count */;
	string keyitem			/* Key item string */;
	double dialwidth		/* Dialog box width */;
	double dialheight		/* Dialog box height */;
	double baseheight		/* Dialog box base height */;
	double cy			/* Dialog box current y coordinate */;
	int repflag	= 1		/* Repeat flag */;
	int res				/* Dialog box result buffer */;
	int i				/* Loop control variable */;
	// Set the popup menu header
	sprintf(headl[0],REPKEY,ulipname);
	headl[1]="";
	// Store the all hot key item
	hotkeys[0]=allsel ? ITMALL : "";
	// Generate hot key list if not yet created
	if (hotkeyn==0) {
		// Init the hot key count
		hotkeyn=1;
		// Store the function keys
		for (i=MINFCTKEY;i<=MAXFCTKEY;i++,hotkeyn++)
			sprintf(hotkeys[hotkeyn],
			 FMTFCTKEY,i,keydispstr(bae_getfuncprog(i)));
		// Store the standard key items
		for (i=MINSTDKEY;i<=MAXSTDKEY;i++,hotkeyn++) {
			progname=keydispstr(bae_getkeyprog(i));
			if (i=='[')
				sprintf(hotkeys[hotkeyn],FMTLMWFKEY,progname);
			else if (i==']')
				sprintf(hotkeys[hotkeyn],FMTLMWBKEY,progname);
			else if (i=='{')
				sprintf(hotkeys[hotkeyn],FMTRMWFKEY,progname);
			else if (i=='}')
				sprintf(hotkeys[hotkeyn],FMTRMWBKEY,progname);
			else if (i=='(')
				sprintf(hotkeys[hotkeyn],FMTCMWFKEY,progname);
			else if (i==')')
				sprintf(hotkeys[hotkeyn],FMTCMWBKEY,progname);
			else if (i==0x7F)
				sprintf(hotkeys[hotkeyn],FMTDELKEY,progname);
			else
				sprintf(hotkeys[hotkeyn],FMTSTDKEY,i,progname);
			}
		sprintf(hotkeys[hotkeyn],FMTESCKEY,
		 keydispstr(bae_getkeyprog(0x1B)));
		hotkeyn++;
		for (i=MINCTRKEY;i<=MAXCTRKEY;i++,hotkeyn++)
			if (i=='\t')
				sprintf(hotkeys[hotkeyn],FMTTABKEY,
				 keydispstr(bae_getkeyprog(i)));
			else if (i==0x0D)
				sprintf(hotkeys[hotkeyn],FMTCRKEY,
				 keydispstr(bae_getkeyprog(i)));
			else
				sprintf(hotkeys[hotkeyn],FMTCTRKEY,
				 i+'A'-1,keydispstr(bae_getkeyprog(i)));
		for (i=MINSHCKEY;i<=MAXSHCKEY;i++,hotkeyn++)
			sprintf(hotkeys[hotkeyn],FMTSHCKEY,
			 i+'A'-1,keydispstr(bae_getkeyprog(i)));
		}
	// Check for dialog support
	if (bae_dialclr()) {
		// Perform hot key selection popup
		bae_setintpar(16,5026);
		if ((keyitem=popupmenu(4,UPRKEY,headl,headn,hotkeys,hotkeyn,
		 UINPOPABORT,0,-1,-1,hotkeyn+5,MAXCOLS,0,""))=="")
			// Abort
			return(KEYINV);
		}
	else {
		keyitem="";
		baseheight=DIAL_TOPMARG+3.0*DIAL_SEPVSTEP+2.0*DIAL_CTRVSTEP+
		 (allsel ? 2.0 : 1.0)*DIAL_BUTVSTEP;
		do {
			bae_dialclr();
			dial_getboxsizemin(5026,dialwidth,dialheight,
			 baegetdblpar(0),baegetdblpar(1)-DIAL_CTRVSTEP,
			 DIAL_LEFTMARG+40.0+DIAL_RIGHTSMARG,baseheight+2.0);
			// Build the dialog box
			cy=DIAL_TOPMARG;
			dial_label(0.0,cy,headl[0]);
			cy+=DIAL_CTRVSTEP;
			// Store project part list box
			bae_dialadvcontrol(
			 PA_LB|PA_OKSEL|PA_MCALLBACK|PA_HBRDREL|PA_HSCROLL,
			 (-1),0,(-1),0.0,0.0,0.0,"",0,DIAL_LEFTMARG,cy,
			 DIAL_RIGHTSMARG,dialheight-baseheight,"");
			// Store list box entries
			for (i=1;i<hotkeyn;i++)
				bae_dialaddcontrol(PA_LBE,0,0,0,0.0,0.0,0.0,
				 "",0,0.0,0.0,0.0,hotkeys[i]);
			cy+=dialheight-baseheight+DIAL_SEPVSTEP;
			// Store key edit controls
			dialkeyidx=dial_string("",1000,0.0,cy);
			if (allsel) {
				bae_dialaddcontrol(PA_ACT,0,1,0,0.0,0.0,0.0,"",
				 0,DIAL_LEFTMARG,cy,0.0,ITMDALL);
				cy+=DIAL_BUTVSTEP;
				}
			dial_hsep(cy);
			// Store OK button
			dial_okabort(cy);
			// Display dialog box
			bae_setintpar(16,5026);
			switch (bae_dialaskcall("!"+UPRKEY,0,
			 dialwidth,cy,keyactcb)) {
				// Done
				case 0 :
				bae_dialgetdata(dialkeyidx,0,0.0,keyitem);
				if (keyitem=="")
					return(KEYINV);
				repflag=0;
				break;
				// All keys
				case 1 :
				keyitem=ITMALL;
				repflag=0;
				break;
				// Resize
				case (-2) :
				break;
				default :
				error_abort();
				}
			// Stop if no further repeat requests
			} while (repflag);
		}
	// Test if abort request
	if (keyitem==UINPOPABORT)
		error_abort();
	// Check if manual function key input
	if (keyitem[0]=='f' && keyitem[1]>='1' && keyitem[1]<='9')
		strupper(keyitem);
	// Scan the hot key list
	for (insidx=0;insidx<hotkeyn && keyitem!=hotkeys[insidx] &&
	 keyitem!=getbasekey(hotkeys[insidx]);insidx++)
		;
	// Test if no hot key found
	if (insidx==hotkeyn)
		return(KEYINV);
	// Test if all hot key type
	if (allsel && insidx==0)
		return(KEYALL);
	// Test if function key type
	if (insidx<=MAXFCTKEY) {
		// Function key matched
		keycode=insidx;
		return(KEYFCT);
		}
	// Assume standard key type
	keycode=insidx-MAXFCTKEY+MINSTDKEY-1;
	if (keycode<MINSTDKEY) {
		keycode=(-1);
		return(KEYINV);
		}
	if (keycode<=MAXSTDKEY)
		// Standard key
		return(KEYSTD);
	keycode-=MAXSTDKEY+1;
	if (keycode<(MINCTRKEY-1) || keycode>MAXCTRKEY) {
		keycode+=0x100-MAXCTRKEY;
		if (keycode<MINSHCKEY || keycode>MAXSHCKEY) {
			keycode=(-1);
			return(KEYINV);
			}
		}
	if (keycode==(MINCTRKEY-1))
		keycode=0x1B;
	// Standard key
	return(KEYSTD);
}

static int keyactcb(int reason,int boxidx,int itemidx,int itemid,string itemstr)
/*
// Key list activation callback
// Return value :
//	zero if done or (-1) on data error
// Parameters :
//	int reason		: Callback reason
//	int boxidx		: Dialog box index
//	int itemidx		: Dialog box item index
//	int itemid		: Dialog list box item id
//	string itemstr		: Dialog list box item string
*/
{
	int i				/* Loop control variable */;
	if (itemid<0)
		return(0);
	if (dialkeyidx>=0) {
		// Scan the hot key list
		for (i=1;i<hotkeyn && itemstr!=hotkeys[i];i++)
			;
		// Test if hot key found
		if (i<hotkeyn)
			bae_dialsetdata(
			 dialkeyidx,PA_STR,0,0.0,getbasekey(itemstr));
		}
	return(0);
}

static string getbasekey(string keyitem)
/*
// Get display string for given key program sequence
// Return value :
//	base key string
// Parameter :
//	string keyitem		: Hotkey item list string
*/
{
	int len	= strlen(keyitem)	/* Key item string length */;
	int sidx, eidx			/* String index range */;
	// Search base key string start
	for (sidx=0;sidx<len;sidx++)
		if (keyitem[sidx]=='<' && keyitem [sidx+1]==' ')
			break;
	// Check if base key string start found
	if (sidx>=len)
		return("snix");
	// Search base key string end
	for (eidx=sidx+2;eidx<len;eidx++)
		if (keyitem[eidx]==' ' && keyitem [eidx+1]=='>')
			break;
	// Check if base key string end found
	if (eidx>=len)
		return("enix");
	// Return base key string
	return(strextract(keyitem,sidx+2,eidx-1));
}

static string keydispstr(string progseq)
/*
// Get display string for given key program sequence
// Return value :
//	display string
// Parameter :
//	string progseq		: Program sequence
*/
{
	string menustr			/* Menu string */;
	string dispstr			/* Display string */;
	curcomment="";
	dispstr=progseq;
	if (progseq[0]!='#' &&
	 (progseq[0]==':' || strscannext(progseq,":",0,1)>strlen(progseq))) {
		// Select language specific comment (ignore errors)
		if (curlanguage==UILANG_DE)
			sprintf(sqlcommand,H_SELECT_DE,sql_quotestr(progseq));
		else
			sprintf(sqlcommand,H_SELECT_EN,sql_quotestr(progseq));
		sqlcmd(BAEULHLPDB,sqlcommand,commselfunc);
		if (curcomment!="")
			dispstr+=" -- "+curcomment;
		}
	// Get menu text
	if (bae_getmenuitem(-1,menustr,progseq))
		return(dispstr);
	// Build display string
	sprintf(dispstr,"%s (%s)",dispstr,bae_plainmenutext(menustr));
	return(dispstr);
}

/*________________________________________________________________*/
// Program list routines

static string selectprogram(string header,int emode,string oldval)
/*
// Select a program for name-specified interpreter environment
// Return value :
//	program name, or empty string on abort
// Parameters :
//	string header		: Header string
//	int emode		: Extra entry mode
//	string oldval		: Old selection value
*/
{
	STRINGS headl			/* Header list */;
	int headn	= 2		/* Header count */;
	string prompt			/* Prompt string */;
	int pver			/* UL program version */;
	int ptyp			/* UL program caller type */;
	int sidx			/* String scan index */;
	int bpos			/* Frist blank position */;
	// Build the menu header
	headl[0]=header;
	headl[1]="";
	// Check the extra entry mode
	switch (emode) {
		case 0 :
		progl[0]=ITMKEYPROG;
		progl[1]=ITMMENPROG;
		progl[2]=ITMIMPPROG;
		// Generate the program list if not yet created
		if (progn==0) {
			progn=3;
			// Select program entries from database
			sprintf(sqlcommand,C_SELVER,IPVER,ULCOMPVERSION);
			sqlcmd(BAEULHLPDB,sqlcommand,progselfunc);
			}
		break;
		case 1 :
		progl[0]=ITMDEFAULT;
		progn=1;
		// Select program entries from database
		sprintf(sqlcommand,C_SELVER,IPVER,ULCOMPVERSION);
		sqlcmd(BAEULHLPDB,sqlcommand,progselfunc);
		break;
		case 3 :
		progn=0;
		// Select program entries from database
		sprintf(sqlcommand,C_SELVER,IPVER,ULCOMPVERSION);
		sqlcmd(BAEULHLPDB,sqlcommand,progselfunc);
		break;
		case 2 :
		default :
		progl[0]=ITMDEFAULT;
		progl[1]=ITMMENUQRY;
		progl[2]=ITMMACQRY;
		progl[3]=ITMGRIDQRY;
		// Generate the program list if not yet created
		if (progn==0) {
			progn=4;
			// Select program entries from database
			sprintf(sqlcommand,C_SELVER,IPVER,ULCOMPVERSION);
			sqlcmd(BAEULHLPDB,sqlcommand,progselfunc);
			}
		}
	// Check if program list is empty
	if (progn<=3 && emode==0) {
		// Append UL program database help text to header
		headl[2]=UPRULDBUPDL[0];
		headl[3]=UPRULDBUPDL[1];
		headl[4]=UPRULDBUPDL[2];
		headl[5]=UPRULDBUPDL[3];
		headl[6]=UPRULDBUPDL[4];
		headn=7;
		// Suggest UL program database update
		if (verifymenu(UPRULDBUPD,0,headl,headn)) {
			// UL program database update requested
			// Save the program entry count
			headn=progn;
			// Perform help text update incl. ulpcall update
			helpupdate();
			// Update the program list
			progl[0]=ITMKEYPROG;
			progn=1;
			// Select program entries from database
			sprintf(sqlcommand,C_SELVER,IPVER,ULCOMPVERSION);
			sqlcmd(BAEULHLPDB,sqlcommand,progselfunc);
			}
		// Restore header list
		headn=2;
		}
	// Select the program
	bae_setintpar(16,5027);
	if ((progname=popupmenu(4,UPRPROG,headl,headn,
	 progl,progn,oldval,0,-1,-1,headn+progn+2,MAXCOLS,0,""))!="") {
		// Test if abort request
		if (progname==UINPOPABORT)
			error_abort();
		// Done if first entry selected
		if ((progname==progl[0] && emode!=3) || progname==ITMMENPROG ||
		 progname==ITMIMPPROG)
			return(progname);
		// Check if menu selection
		if (progname==ITMMENUQRY) {
			// Prompt user for selection
			bae_prtdialog(UPRSELMENUFCT);
			if (bae_getmenuitem(0,"",progname)!=0)
				error_abort();
			return(progname);
			}
		// Check if macro selection
		if (progname==ITMMACQRY) {
			macn=0;
			sprintf(sqlcommand,MN_SELECT,IPTYP);
			if (sqlcmd(BAEMACRODB,sqlcommand,macselfunc)!=0)
				// SQL/DB error
				sql_dberror(27);
			if (macn==0) {
				bae_msgbox(1,ERRNOMACRO,"");
				return("");
				}
			bae_setintpar(16,5025);
			if ((progname=popupmenu(1,UPRMACSEL,macl,0,macl,macn,
			  UINPOPABORT,0,1,1,macn+2,0,0,""))=="" ||
			 progname==UINPOPABORT)
				error_abort();
			return(UL_MACRO+":'"+progname+"'");
			}
		// Check if grid selection
		if (progname==ITMGRIDQRY) {
			macn=0;
			sprintf(sqlcommand,GN_SELECT,IPTYP);
			if (sqlcmd(BAEPARAMDB,sqlcommand,macselfunc)!=0)
				// SQL/DB error
				sql_dberror(27);
			if (macn==0) {
				bae_msgbox(1,ERRNOGRID,"");
				return("");
				}
			bae_setintpar(16,5048);
			if ((progname=popupmenu(1,UPRGRIDSEL,macl,0,macl,macn,
			  UINPOPABORT,0,1,1,macn+2,0,0,""))=="" ||
			 progname==UINPOPABORT)
				error_abort();
			return(UL_FAVORITE+":\"gridset\":\""+progname+"\"");
			}
		// Extract program name (first word) from selected entry
		bpos=strscannext(progname," ",0,1);
		if (bpos<=strscannext(progname,"'",0,1) &&
		 bpos<=strscannext(progname,"\"",0,1))
			progname=strextract(progname,0,bpos-2);
		for (sidx=0;progname[sidx]!='\0';sidx++)
			if (progname[sidx]==':')
				break;
		// Test if selected program callable
		if (progname[0]!='#' && progname[sidx]!=':' &&
		 (ulproginfo(progname,pver,ptyp) || pver>IPVER ||
		  pver<ULCOMPVERSION || (ptyp & IPTYP)==0)) {
			// Program not callable; suggest ulpcall update
			sprintf(prompt,UPRUPDCALL,progname);
			if (verify(prompt,0))
				// Update the UL program call database
				ulpcallupdate();
			// Done
			bae_prtdialog("");
			exit(0);
			}
		}
	// Return the program name
	return(progname);
}

/*________________________________________________________________*/
// Help database routines

static void helpupdate()
/*
// Update help texts
*/
{
	string ulsrcdir			/* UL source directory */;
	string ulsrcdirx		/* UL source dir. without delimiter */;
	string curname			/* Current list name */;
	string comment_en		/* English help text */;
	string comment_de		/* German help text */;
	STRINGS headl			/* Header list */;
	int headn	= 2		/* Header count */;
	int updcount	= 0		/* Update count */;
	int linen			/* Line count */;
	STRINGS lines			/* Line list */;
	int i				/* Loop control variable */;
	// Init the program list
	progl[0]=ITMALLPROG;
	progn=1;
	// Perform UL source directory query
	if ((ulsrcdir=askdirectory(UPRULSRCDIR))=="")
		// Abort
		error_abort();
	// Get UL source directory without delimiter
	ulsrcdirx=ulsrcdir;
	strdelchr(ulsrcdirx,"/\\",strlen(ulsrcdirx),MAXPNLEN);
	// Get program source file name list
	filelist(progl,progn,ulsrcdirx,ULCEXT,"",0,0,0,0,1,0);
	// Test if programs found
	if (progn<1)
		progn=0;
	// Define the popup header
	headl[0]=M_REPPOPDIR(ulsrcdir);
	headl[1]="";
	// Repetively select programs for help text update
	bae_setintpar(16,5028);
	while (curname=popupmenu(1,UPRSELSRC,headl,headn,
	 progl,progn,UINPOPABORT,0,1,1,100,MAXCOLS,0,"")) {
		// Test if abort request
		if (curname==UINPOPABORT)
			error_abort();
		// Loop thru the program list
		for (i=1;i<progn;i++) {
			// Abort function on request
			if (kbhit()) {
				getchr();
				if (verify(UPRFEXIT,0))
					return;
				}
			// Continue if program not selected
			if (curname!=ITMALLPROG && progl[i]!=curname)
				continue;
			// Initialyze the comment strings
			comment_en=comment_de="";
			// Get header
			linen=getfilehead(ulsrcdir+progl[i],LGECOUNT,lines);
			if (linen>0) {
				// Get program name without extension
				progname=convstring(progl[i],0);
				strlower(progname);
				// Get English comment
				comment_en=lines[0];
				// Get German comment
				comment_de=lines[linen>=2 ? 1 : 0];
				// Store the comments
				helpstore(progname,comment_en,comment_de);
				// Increment the update count
				updcount++;
				}
			// Test if not all programs selected
			if (curname!=ITMALLPROG) {
				// Remove updated program from menu
				progn--;
				for (;i<progn;i++)
					progl[i]=progl[i+1];
				}
			}
		// Abort if no more selections available
		if (progn<1 || curname==ITMALL)
			break;
		}
	// Perform ulpcall update if any help texts updated
	if (updcount>0)
		ulpcallupdate();
}

static void helpinput()
/*
// Input of help text
*/
{
	STRINGS headl			/* Header list */;
	int headn	= 2		/* Header count */;
	STRINGS entryl			/* Entry list */;
	int entryn	= 0		/* Entry count */;
	string comment			/* Comment buffer */;
	string comment_en		/* English comment */;
	string comment_de		/* German Comment */;
	// Get program name
	if ((progname=askulprog(UPRPROGMD,ULPRGDB))=="")
		return;
	// Select old English comment (ignore errors)
	curcomment="";
	sprintf(sqlcommand,H_SELECT_EN,sql_quotestr(progname));
	sqlcmd(BAEULHLPDB,sqlcommand,commselfunc);
	comment_en=curcomment;
	// Select old German comment (ignore errors)
	curcomment="";
	sprintf(sqlcommand,H_SELECT_DE,sql_quotestr(progname));
	sqlcmd(BAEULHLPDB,sqlcommand,commselfunc);
	comment_de=curcomment;
	// Get language-specific comment
	curcomment= curlanguage==UILANG_DE ? comment_de : comment_en;
	// Build popup header
	sprintf(headl[0],REPPROGCOM,progname);
	// Check if text edit capability supported
	if (bae_swconfig(3)==BAE_StdScreen) {
		// Get old comment
		if (curcomment!="") {
			entryl[0]=curcomment;
			entryn=1;
			}
		// Get new comment
		bae_setintpar(16,5030);
		if ((comment=popupmenu(4,UPRCOMM,headl,headn,entryl,entryn,
		 UINPOPABORT,0,-1,-1,0,MAXCOLS,0,""))==UINPOPABORT)
			error_abort();
		}
	else {
		// Edit comment
		if ((comment=
		 bae_readedittext(headl[0],curcomment,MAXTEXTLEN))==UINPOPABORT)
			error_abort();
		}
	// Store new comment
	if (curlanguage==UILANG_DE)
		comment_de=comment;
	else
		comment_en=comment;
	helpstore(progname,comment_en,comment_de);
}

static void helpdelete()
/*
// Delete help text
*/
{
	STRINGS headl			/* Header list */;
	int headn	= 2		/* Header count */;
	// Init the program list
	progl[0]=ITMALLTEXT;
	progn=1;
	// Select program entries from database (ignore errors)
	sqlcmd(BAEULHLPDB,H_ALLSEL,allprogselfunc);
	// Check if program(s) found
	if (progn<=1)
		error(REPNOPROG);
	// Build menu header
	headl[0]=REPPROGL;
	headl[1]="";
	bae_setintpar(16,5031);
	if ((progname=popupmenu(1,UPRPROG,
	 headl,headn,progl,progn,UINPOPABORT,0,-1,-1,0,MAXCOLS,0,""))!="") {
		// Test if abort request
		if (progname==UINPOPABORT)
			error_abort();
		// Test if all selected
		if (progname==ITMALLTEXT)
			// Drop whole table
			sprintf(sqlcommand,H_DROP);
		else
			// Delete program help entry
			sprintf(sqlcommand,H_DELETE,sql_quotestr(progname));
		// Execute the SQL command
		if (sqlcmd(BAEULHLPDB,sqlcommand,NULL))
			// SQL/DB error
			sql_dberror(0);
		}
}

static void helpstore(string prog,string comment_en,string comment_de)
/*
// Store parameters to SQL/DB
// Parameters :
//	string prog		: Program name
//	string comment_en	: English comment
//	string comment_de	: German comment
*/
{
	// Print progress message
	message(REPHLPUPD,prog);
	// Create SQL database table
	if (sqlcmd(bae_planfname(),H_HELP,NULL)!=0)
		if (sqlcmd(BAEULHLPDB,H_CREATE,NULL))
			// SQL/DB error (ignore table already defined error)
			sql_dberror(25);
	// Delete old comment from database
	sprintf(sqlcommand,H_DELETE,sql_quotestr(prog));
	if (sqlcmd(BAEULHLPDB,sqlcommand,NULL))
		// SQL/DB error (ignore no delete record error)
		sql_dberror(29);
	// Insert comment into database
	sprintf(sqlcommand,H_INSERT,sql_quotestr(prog),
	 sql_quotestr(comment_en),sql_quotestr(comment_de));
	if (sqlcmd(BAEULHLPDB,sqlcommand,NULL))
		// SQL/DB error
		sql_dberror(0);
}

/*________________________________________________________________*/
// Program call database routines

static void ulpcallupdate()
/*
// Store ulpcall parameters to SQL/DB
// (existing ulpcall SQL/DB table will be replaced)
*/
{
	struct calldes {		// Program call descriptor
		string pname		/* Program name */;
		string phlp_en		/* Program help text */;
		string phlp_de		/* Program help text */;
		int pver		/* Program UL version */;
		int ptyp		/* Program UL interpreter type */;
		} calll[]		/* Program call list */;
	int calln	= 0		/* Program call count */;
	int pver			/* UL program version */;
	int ptyp			/* UL program caller type */;
	string curname	= ""		/* Current list name */;
	int i				/* Loop control variable */;
	// Scan programs
	message(M_REPSCANDDB(),ULPRGDB);
	while (scanddbenames(ULPRGDB,DDBCLUL,curname)==1) {
		// Abort function on request
		if (kbhit()) {
			getchr();
			if (verify(UPRFEXIT,0)) {
				// Flush scan cache
				scanddbenames(ULPRGDB,0,"");
				return;
				}
			}
		// Check the program version and caller type
		if (ulproginfo(curname,pver,ptyp))
			// Error getting program info
			continue;
		// Select English comment (ignore errors)
		curcomment="";
		sprintf(sqlcommand,H_SELECT_EN,sql_quotestr(curname));
		sqlcmd(BAEULHLPDB,sqlcommand,commselfunc);
		calll[calln].phlp_en=curcomment;
		// Select German comment (ignore errors)
		curcomment="";
		sprintf(sqlcommand,H_SELECT_DE,sql_quotestr(curname));
		sqlcmd(BAEULHLPDB,sqlcommand,commselfunc);
		calll[calln].phlp_de=curcomment;
		// Store program to call list
		calll[calln].ptyp=ptyp;
		calll[calln].pver=pver;
		calll[calln].pname=curname;
		calln++;
		}
	// Drop existing table
	if (sqlcmd(BAEULHLPDB,C_DROP,NULL))
		// SQL/DB error (ignore table not found error)
		sql_dberror(27);
	// Create SQL database table
	if (sqlcmd(BAEULHLPDB,C_CREATE,NULL))
		// SQL/DB error (ignore table already defined error)
		sql_dberror(25);
	// Insert call entries into database
	for (i=0;i<calln;i++) {
		// Abort function on request
		if (kbhit()) {
			getchr();
			if (verify(UPRFEXIT,0))
				return;
			}
		// Print progress message
		message(REPCALLUPD,calll[i].pname);
		sprintf(sqlcommand,C_INSERT,sql_quotestr(calll[i].pname),
		 sql_quotestr(calll[i].phlp_en),sql_quotestr(calll[i].phlp_de),
		 calll[i].pver,calll[i].ptyp);
		if (sqlcmd(BAEULHLPDB,sqlcommand,NULL))
			// SQL/DB error
			sql_dberror(0);
		// Store comment to ULC database
		ddbsetelemcomment(ULPRGDB,DDBCLUL,calll[i].pname,
		 curlanguage==UILANG_DE ? calll[i].phlp_de : calll[i].phlp_en);
		}
}

static void ulpcalldrop()
/*
// Drop ulpcall parameter table from SQL/DB
*/
{
	// Drop existing table
	if (sqlcmd(BAEULHLPDB,C_DROP,NULL))
		// SQL/DB error (ignore table not found error)
		sql_dberror(27);
}

/*________________________________________________________________*/
// SQL/DB selection callback functions

static int progselfunc(string dstr,int dint,double ddbl,
 int dval,int dtype,string dtable,string dfield,int didx)
/*
// Program selection callback function
// Return value :
//	zero if done or (-1) on data error
//	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
*/
{
	string entrybuf			/* Entry buffer */;
	int pver			/* UL program version */;
	int ptyp			/* UL program caller type */;
	// Store the current entry
	switch (didx) {
		// pname
		case 1 :
		curpname=dstr;
		break;
		// phlp_en
		case 2 :
		curphlp_en=dstr;
		break;
		// phlp_de
		case 3 :
		curphlp_de=dstr;
		break;
		// ptyp
		case 4 :
		// Test if program callable
		if (ulproginfo(curpname,pver,ptyp)==0 &&
		 pver<=IPVER && pver>=ULCOMPVERSION && (ptyp & IPTYP)) {
			// Store program name with comment
			sprintf(entrybuf,"%-8s : %-.*s",
			 curpname,MAXCOLS-14,
			 curlanguage==UILANG_DE ? curphlp_de : curphlp_en);
			// Insert the program to the sorted program list
			newprogram(entrybuf);
			}
		break;
		}
	// Return without errors
	return(0);
}

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

static void newprogram(string progentry)
/*
// Insert a new program entry to the sorted program list
// Parameters :
//	string progentry	: Program entry string
*/
{
	int slb		= 0		/* Search lower boundary */;
	int sub		= progn-1	/* Search upper boundary */;
	int idx				/* Search index */;
	int compres			/* Compare result */;
	// Loop until search area empty
	while (slb<=sub) {
		// Get the search index
		idx=(slb+sub)>>1;
		// Get and test the compare result
		if ((compres=numstrcmp(progentry,progl[idx]))==0)
			// Ignore multiple program entries
			return;
		// Update the search area
		if (compres<0)
			sub=idx-1;
		else
			slb=idx+1;
		}
	// Insert the new program entry to the program list
	progn++;
	for (idx=progn-2;idx>=slb;idx--)
		progl[idx+1]=progl[idx];
	progl[slb]=progentry;
}

static int allprogselfunc(string dstr,int dint,double ddbl,
 int dval,int dtype,string dtable,string dfield,int didx)
/*
// Program selection callback function
// Return value :
//	zero if done or (-1) on data error
// Parameters :
//	string dstr		: String/Date data
//	int dint		: Integer/Boolean data
//	double ddbl		: Float data
//	int dval		: Data valid flag
//	int dtype		: Data type
//	string dtable		: Data table name
//	string dfield		: Data field name
//	int didx		: Data output field index
*/
{
	// Store program name to list
	progl[progn++]=dstr;
	// Return without errors
	return(0);
}

static int commselfunc(string dstr,int dint,double ddbl,
 int dval,int dtype,string dtable,string dfield,int didx)
/*
// Comment selection callback function
// Return value :
//	zero if done or (-1) on data error
// Parameters :
//	string dstr		: String/Date data
//	int dint		: Integer/Boolean data
//	double ddbl		: Float data
//	int dval		: Data valid flag
//	int dtype		: Data type
//	string dtable		: Data table name
//	string dfield		: Data field name
//	int didx		: Data output field index
*/
{
	// Store comment
	curcomment=dstr;
	// Return without errors
	return(0);
}

/*________________________________________________________________*/
// UL interpreter list routines

string getcurulipname()
/*
// Get current UL interpreter name
// Return value :
//	interpreter name, or all if unknown
*/
{
	// Evaluate the current interpreter environment
	switch (IPTYP) {
		// Schematic Editor
		case ULIPSCM : return(M("Schaltplaneditor","Schematic Editor"));
		// Layout Editor
		case ULIPGED : return(M("Layouteditor","Layout Editor"));
		// Autorouter
		case ULIPAR  : return("Autorouter");
		// CAM Processor
		case ULIPCAM : return(M("CAM-Prozessor","CAM Processor"));
		// CAM View
		case ULIPCV  : return(M("CAM-View","CAM View"));
		// Chip Editor
		case ULIPCED : return("Chip Editor");
		}
	// Unknown BAE module
	return("Bartels AutoEngineer");
}

/*________________________________________________________________*/
// File access utilities

static string askulprog(string prompt,string filename)
/*
// Perform a User Language program selection via delayed popup menu
// Return value :
//	name of selected UL program or empty string on abort
// Parameters :
//	string prompt		: Prompt string
//	string filename		: File name
*/
{
	string ename	= ""		/* Current element name */;
	// Abort on DDB file access failure
	if (ddbcheck(filename,DDBCLUNDEF,""))
		return(UINPOPABORT);
	// Activate popup menu on request
	if (bae_askddbename(ename,filename,DDBCLUL,prompt))
		// Abort selected
		return("");
	// Reset element name on abort
	if (ename==UINPOPABORT)
		ename="";
	// Clear the dialog line
	bae_prtdialog("");
	// Return the element name
	return(ename);
}

static int getfilehead(string fname,int headmax,STRINGS headl)
/*
// Get first (header) lines of given file
// Return value :
//	header line count
// Parameters :
//	string fname		: File name
//	int headmax		: Header maximum line count
//	STRING headl		: Header line list
*/
{
	int MAXLINELEN	= 256		/* Maximum input line length */;
	int fh				/* File handle */;
	int headn	= 0		/* Header line count */;
	string header	= ""		/* Header string buffer */;
	int sl				/* String length */;
	int cpos			/* Character position */;
	int i				/* Loop control variable */;
	// Set the file error mode
	fseterrmode(0);
	// Open the input file and get the first string
	if ((fh=fopen(fname,0))==(-1))
		// File access error
		return(0);
	// Scan up to first non-blank line
	while (fgets(header,MAXLINELEN,fh)==0) {
		// Ignore empty lines
		if (header=="")
			continue;
		// Store header line
		headl[headn++]=header;
		// Done if required header length reached
		if (headn>headmax)
			break;
		}
	// Close the input file
	fclose(fh);
	// Modify the header lines
	for (i=0;i<headn;i++) {
		// Get the header line
		header=headl[i];
		// Skip newline character from header
		strdelchr(header,"\n",0,MAXPNLEN);
		// Skip comment start delimiter from header
		if ((sl=strlen(header))>=3
		 && header[0]=='/'
		 && (header[1]=='*' || header[1]=='/')
		 && header[2]==' ')
			header=strextract(header,0,sl-1);
		// Skip comment end delimiter from header
		if ((sl=strlen(header))>=3
		 && header[sl-3]==' '
		 && header[sl-2]=='*'
		 && header[sl-1]=='/')
			header=strextract(header,0,sl-4);
		// Search comment start position
		if (strmatch(header,"* -- ?*")) {
			// Get first dash position
			cpos=strscannext(header,"-",0,1);
			// Get next non-dash/non-blank position
			cpos=strscannext(header,"- ",cpos,0)-1;
			// Skip program name
			if (cpos<(sl=strlen(header)))
				header=strextract(header,cpos,sl-1);
			}
		// Skip apostrophes (to avoid SQL command syntax errors)
		strdelchr(header,"'",0,MAXPNLEN);
		// Save the header string
		headl[i]=header;
		}
	// Return the header string count
	return(headn);
}

/*________________________________________________________________*/
// User interaction and data conversion routines

static string askdirectory(string prompt)
/*
// Prompt user for directory specification
// Return value :
//	selected directory path name
// Parameters :
//	string prompt		: Prompt string
*/
{
	int popuprows	= 12		/* Popup rows count */;
	int popupcols			/* Popup columns count */;
	double mlx	= POPMIN	/* Popup window lower X percentage */;
	double mly	= POPMIN	/* Popup window lower Y percentage */;
	double mux			/* Popup window upper X percentage */;
	double muy			/* Popup window upper Y percentage */;
	string answer			/* Answer string */;
	// Init the directory name
	answer=UINPOPABORT;
	// Ask for directory
	message(M_REPSCANDIR(),CURDIR);
	if (bae_askdirname(answer,getcwd(),prompt)==0 && answer==UINPOPABORT)
		// Abort
		error_abort();
	// Directory selection done if valid answer
	if (answer!=UINPOPABORT)
		return(answer);
	// Perform special directory query
	// Set the popup columns count
	popupcols=strlen(prompt)+1;
	// Calculate and set the popup right border
	if ((mux=calcpopwidth(popupcols)+mlx)>POPMAX)
		mux=POPMAX;
	// Calculate and set the popup top border
	if ((muy=calcpopheight(popuprows)+mly)>POPMAX)
		muy=POPMAX;
	// Show the popup menu
	bae_popshow(popuprows,popupcols,mlx,mly,mux,muy);
	// Display the prompt
	bae_poptext(0,0,prompt);
	// Display the directory buttons
	bae_popcolbar(2,0,10,3,0);
	bae_poptextchoice(3,1,UINWD,UINWD);
	bae_poptextchoice(5,1,UINPD,UINPD);
	bae_poptextchoice(7,1,UINRD,UINRD);
	bae_poptextchoice(9,1,UINSD,UINSD);
	bae_poptextchoice(3,5,UPRWD,UINWD);
	bae_poptextchoice(5,5,UPRPD,UINPD);
	bae_poptextchoice(7,5,UPRRD,UINRD);
	bae_poptextchoice(9,5,UPRSD,UINSD);
	// Display the abort button
	bae_poptextchoice(11,5,M(DE_UPRPOPABORT,EN_UPRPOPABORT),UINPOPABORT);
	// Get and lowercase the answer
	strlower(answer=bae_readtext(prompt,MAXKEYLEN));
	// Restore the popup area
	bae_poprestore();
	// Check if arbitrary directory selection
	if (answer==UINSD) {
		answer=UINPOPABORT;
		if (bae_askdirname(answer,getcwd(),UPRULSRCDIR)!=0 ||
		 answer==UINPOPABORT)
			error_abort();
		}
	// Check if abort request
	if (answer==UINPOPABORT)
		return("");
	// Append directory delimiter on request
	if (strlen(answer)>0 && answer[strlen(answer)-1]!=dirdelimiter())
		answer+=dirdelimiter();
	// Return the answer
	return(answer);
}

static char dirdelimiter()
/*
// Get directory path name delimiter of current environment
// Return value :
//	directory path name delimiter character
*/
{
	string delimiter		/* Directory delimiter string */;
	// Get and return directory name delimiter char
	delimiter=bae_swversion(4);
	return(delimiter[0]);
}

static int verifymenu(string prompt,int quitenable,STRINGS headl,int headn)
/*
// Prompt user with help text for verification with yes or no
// Return value :
//	nonzero on yes answer, zero on no answer
// Parameters :
//	string prompt		: Prompt string
//	int quitenable		: Quit program enable flag
*/
{
	STRINGS strl			/* Dummy string list */;
	string answer			/* Answer string */;
	// Get the answer code via popup
	bae_setintpar(16,5029);
	if ((answer=popupmenu(0,prompt,headl,headn,strl,0,UINPOPABORT,
	 0,-1,-1,0,0,quitenable ? 2 : 1,UINPOPABORT))==UINPOPABORT)
		error_abort();
	// Return the answer code
	return(answer==M_UINYES());
}

/*________________________________________________________________*/
// Error handling routines

static void prterr(string errmsg)
/*
// Handle any program errors
// Parameters :
//	string errmsg		: Error message string
*/
{
	string msg			/* Error message */;
	// Build the error message
	sprintf(msg,M(DE_ERRFORMAT,EN_ERRFORMAT),
	 progname,pc>=0 ? ("/"+itoa(pc)) : "",errmsg);
	// Print the error message
	perror(msg);
}

// User Language program end