<functions>
#AQL functions
#####################################################################
"abs"
function  : Absolute value of its parameter
parameter : real or integer
result    : real for real parameter, integer for integer parameter
example   : x = abs (-23.5)

"acos"
function  : Arc cosine of its parameter, in the range [0,pi]
parameter : real or integer
result    : real
example   : angle = acos (0.99)

"add_file_type"
function  : Extend 'model_load' or 'model_save_as' by new file type
parameter : string:     "r" (for model_load) or "w" (for model_save_as)
            string:     file description
            string:     file extension
            Bea_action: action for loading or saving the file
result    : -
example   : add_file_type ("r", "SigraphDesign table   (*.tab)", "tab", application.a_tab_file )

"add_function_key"
function  : Define an additional function key
            for internal use only !!!
parameter : widget, string : modifier, string : key, string : actionname
result    : -
example   : add_function_key (lay_move_sub_widget, "Ctrl+Alt", "s", "layer_save_external")
            Attention: - create a 'FormMenu' before (see #/basic/aql/menu_bar.aql)
                       - no blanks allowed in modifier name

"aql"
function  : Start an AQL program
parameter : filename
result    : 0 (no errors detected) or  !=0 (errors detected)
example   : res = aql ("!my_prog", "Arg1", "Arg2")

"aql_special"
function  : For internal use only !!!
parameter : ...
result    : ...

"asin"
function  : Arc sine of its parameter, in the range [-pi/2,pi/2]
parameter : real or integer
result    : real
example   : angle = asin (0.99)

"atan"
function  : Arc tangent of its parameter, in the range [-pi/2,pi/2]
parameter : real or integer
result    : real
example   : angle = atan (0.99)

"atan2"
function  : Arc tangent of y/x, in the range (-pi,pi], using the signs of both
            arguments to determine the quadrant of the return value
parameter : real or integer y, real or integer x
example   : angle = atan2 (1.75, -2.5)

"bin_close"
function  : Close a file which was opened for binary input/output
parameter : file descriptor (see bin_open)
result    : -
example   : bin_close (fd)

"bin_open"
function  : Open a file for binary input/output
parameter : string: filename, string "output", "append" or "input"
result    : file descriptor (= pointer to a file)
example   : fd = bin_open ("test_file", "output")

"bin_read_byte"
function  : Read a byte in binary format
parameter : file descriptor (see bin_open)
result    : integer

"bin_read_int"
function  : Read an integer in binary format
            The file pointer will be positioned behind.            
parameter : file descriptor (see bin_open)
result    : integer
example   : i = bin_read_int (fd)

"bin_read_short"
function  : Read the first two bytes in binary format
parameter : file descriptor (see bin_open)
result    : integer

"bin_write"
function  : Write each argument in binary format
parameter : file descriptor, integer/real/string, integer/real/string, ...
            file descriptor: see bin_open
result    : -
example   : bin_write (fd, 99, 123.98, "abc")

"bin_write_byte"
function  : Write the first byte of each argument in binary format
parameter : file descriptor, integer, integer, ...
            file descriptor: see bin_open
result    : -

"bin_write_short"
function  : Write the first two bytes of each argument in binary format
parameter : file descriptor, integer, integer, ...
            file descriptor: see bin_open
result    : -


"bitmap_change_icon"
function  : Store bitmap as icon (for experts)
parameter : string:src_bitmap_filename | node_type:src_bitmap_node
            string:application name, e.g. "basic"
            node_type:dest_bitmap_node | integer:dest_bitmap_index
result    : -

"bitmap_convert"
function  : Convert a bitmap file into another bitmap file
parameter : string:input_bitmap_file
            string:output_bitmap_file (may same as input_bitmap_file)
            string:bitmap_output_type ("tif", "xbm", "gif", "aql")
            (optional) integer:output_width
            (optional) integer:output_height
            (optional) boolean:mirror_at_x_axis
            (optional) boolean:mirror_at_y_axis
result    : boolean (= true if no error occured)
example   : ok = bitmap_convert ("my_bitmap.tif", "my_gif.gif", "gif", 57, 48) 

"bitmap_draw"
function  : Draw a bitmap file in a widget
parameter : string:input_bitmap_file
            string:widget (Forms*, Bea_viewport_window, Window)
            string:bitmap_output_type ("tif", "xbm", "gif", "aql")
            (optional) integer:x (start of bitmap relative to widget)
            (optional) integer:y (start of bitmap relative to widget)
            (optional) integer:w (size of bitmap image on widget)
            (optional) integer:h (size of bitmap image on widget)
            (optional) boolean:transparent (don't draw background of 'input_bitmap_file')
result    : -
example   : my_form = FormDialog (400, 400, true)
            bitmap_draw ("my_bitmap.tif", my_form, 5, 5, 40, 40, true)


"bitmap_draw_in_bitmap"
function  : Draw bitmap file into a second bitmap file
parameter : string:input_bitmap_file
            string:src_filename   : this bitmap will be drawn
            string:dest_filename  : into this bitmap 'arg0' will be drawn
            string:result_filename: name of the resulting bitmap file
            (optional) string:type of the resulting bitmap file (default: type of 'src_filename')
            (optional) integer:x (start of bitmap relative to 'dest_filename')
            (optional) integer:y (start of bitmap relative to 'dest_filename')
            (optional) integer:w (size of bitmap image in 'dest_filename')
            (optional) integer:h (size of bitmap image in 'dest_filename')
            (optional) boolean:transparent (don't draw background of 'src_filename')
result    : -
example   : bitmap_draw_in_bitmap ("cat53.tif", "product.tif", "cat53_in_product.tif", "tif", 10, 40, 200, 200, true)
            
"bitmap_info"
function  : Get info about a bitmap file
parameter : string:bitmap_file
result    : group
            { string:type, integer:width, integer:height, integer:number_of_colors, <palette> }
            palette: { {r,g,b}, {r,g,b}, {r,g,b}, {r,g,b}, ... }
example   : info = bitmap_info ("cat53.tif")
            
"bitmap_save_icons"
function  : Save the icons of an application
parameter : string:application_name
result    : -
example   : bitmap_save_icons ("basic")
            
"bitmap_show"
function  : Show a bitmap file in a viewer
parameter : string:bitmap_file
            (optional) string:comment
result    : -
example   : bitmap_show ("my_bitmap.tif", "my comment")

"bitmap_sub_image"
function  : Get the sub-image of a bitmap file
parameter : string:input_filename
            string:output_filename
            string:output_type (case insensitive): "gif", "xbm", "tif", "bitm"
            integer:offset_x
            integer:offset_y
            integer:output_width
            integer:output_height
            (optional) real:scale
result    : boolean (true if ok)
example   : ok = bitmap_sub_image ("my_big_bitmap.gif", "my_small_bitmap.tif", "tif", 10, 10, 30, 30, 1.0)

"bitmap_to_aql"
function  : Extract AQL code from bitmap file
parameter : string:input_filename
            (optional) boolean:colored (default: true)
result    : group
            Syntax: see parameter 'Data' of function FormBitmap()
example   : my_aql_pixels = bitmap_to_aql ("my_bitmap.tif")

"break"
function  : Set a break point in AQL program
parameter : [prompt string] specials: %f, filename; %n, line number; %l curent word
result    : -
example   : break ()
            break ("%l >")

"cd"
function  : Change directory
parameter : string: pathname
result    : boolean: true if successful
example   : ok = cd ("/usr/home/beatles")

"chr"
function  : Character value corresponding to the ASCII code
parameter : integer in the range (0, 255)
result    : string
example   : A = chr (65)

"close"
function  : Close the input file
parameter : -
result    : boolean: true if successful
example   : close ()

"cos"
function  : Cosine of its parameter, measured in degrees
parameter : real or integer
result    : real
example   : x = cos (75.2)

"copy_value"
function  : Copy a Bea_value
parameter : Bea_value:val_dest
            Bea_value:
result    : boolean (true if no error occurred)
example   : // copy contents of 'val_src' to 'val_dest':
            ok = copy_value (val_dest, val_src) 

"date"
function  : The current date
parameter : [ integer ]
result    : date  (if no params)
            group (if param value is 1)
            This group contains 2 groups,
            the first group is the date group, the second is the time group
            Date group : group of strings
                         {day,month,year,dayname,full-dayname,monthname,full-monthname}
            Time group : group of strings
                         {hour,minute,second}

example   : x = date ()   result: Thu Nov 03 18:24:42 2005
            x = date (1)  result: { { "03", "10", "2005", "Thu", "Thursday", "Nov", "November" }, { "18", "24", "42" } }

"define_aql_object"
function  : For internal use only !!!
parameter : ...
result    : ...

"define_atom"
function  : Register an atom with a specified name at the X-server
parameter : string: atom name
            (predefined atom name of this application: BEA_DESIGN)
result    : -

"delete_wastebasket"
function  : Delete the content of the wastebasket
parameter : -
result    : boolean: true if successful
example   : ok = delete_wastebasket ()

"dir"
function  : List of the specified directory
parameter : string: pathname [, string: wildcard] [, string: "dir"|"fil"]
result    : group of strings
example   : grp = dir ()
            grp = dir ("c:\beatles", "*.aql")

"dllcall"
function  : Call an object code function located in a DLL
parameter : integer: handle to dll from load_library
            string:  name of the function to call, exported in DLL
            ..any..: parameter list of AQL-symbols that will be passed to
                     the function. 
                     Permitted types: integer, real, boolean, string
result    : integer, real, boolean, string: set in DLL function
example   : ret = dllcall (load_library ("THE_DLL.DLL"), "testfunc", 5.5)

"edit_last_obj"
function  : Activate function to edit last object
parameter : -
result    : -

"empty"
function  : Test if a group is empty
parameter : group expression
result    : boolean: true if empty group
example   : ok = empty (<grp_name>)

"enum_forms"
function  : Query all available forms and their dimensions in the system for the
            specified printer;
            for internal use only !!!
parameter : string: printer_name (specified by enum_printers)
result    : UNIX      : invalid
            Windows NT: {{"form_name", {width, height}, {printable width, 
                          printable height}}, {..}..}

"enum_printers"
function  : Query all available print queues in the system you can print to;
            for internal use only !!!
parameter : -
result    : UNIX      : invalid, 
            Windows NT: group of strings

"error_response"
function  : Control error processing: stop or continue
parameter : string: "stop" or "continue"
result    : -
example   : error_response ("continue")

"eval"
function  : Interpret the string as AQL-expression
parameter : string
result    : symbol
example   : res = eval (read_string ("Enter expression string or 'end' for exit => ")

"exec"
function  : Execute an external program
parameter : string: pathname, string: arg1, string: arg2, ...
result    : -
example   : exec ("/bin/ls", "-al", "*")

"existd"
function  : Test if the specified directory exists
parameter : string: pathname
result    : boolean: true if directory exists
example   : ok = existf ("/tmp/elvis")

"existf"
function  : Test if the specified file exists
parameter : string: pathname
result    : boolean: true if file exists
example   : ok = existd ("/usr/home/dylan")

"exp"
function  : Real exponential function ex of its argument
parameter : real or integer
result    : real
example   : x = exp (1.23)

"fcopy"
function  : Copy a file
parameter : string: fromname, string: toname
result    : integer
            1  input file couldn't be opened
            2  output file couldn't be opened
            3  in- and output file couldn't be opened both
            4  internal buffer allocation error
            5  write or read error (disk full, file locked..)
            0  ok
example   : err_code = fcopy ("/tmp/elvis", "/usr/home/dylan")

"file_access"
function  : Check access rights
parameter : string: filename,
            string: "r" | "w" | "x"  (read, write, executable)
result    : boolean
example   : ok = file_access ("~/bands/stones/jagger", "w")

"file_basename"
function  : Extract the basename from a filename.
parameter : string: filename
result    : string: basename
example   : my_basename = file_basename ("~/bands/stones/jagger") Result: "jagger"

"file_basename"
function  : Extract the basename from a filename.
parameter : string: filename
result    : string: basename
example   : my_basename = file_basename ("~/bands/stones/jagger") Result: "jagger"

"file_check_applications"
function  : Check if the currently used product contains all required 
            Bea_applications to load the specified model file.
parameter : filename of (Bea-)model
result    : boolean
example   : ok = file_check_applications ("welle3D.udo")

"file_dirname"
function  : Extract the dirname from a filename.
parameter : string: filename
result    : string: dirname
example   : my_dirname = file_dirname ("~/bands/stones/jagger") Result: "~/bands/stones"

"file_edit"
function  : Start editor, file will be created if not exists.
parameter : string: filename
result    : string: the edited text
example   : my_text = file_edit ("my_filename.txt")

"file_extend"
function  : Replace special characters (#,+,~) in front of filename
parameter : string: filename
result    : string: filename
example   : pathname = file_extend ("~/bands/stones/jagger")

"file_get_extension"
function  : Get file extension (suffix) of the specified filename
parameter : string: filename
result    : string: extension
example   : ext = file_get_extension("my_filename.txt") // result: "txt"

"file_is_unix_file"
function  : Check if a file was stored in UNIX- or DOS-format.
parameter : string: filename
result    : boolean
example   : is_unix = file_is_unix_file ("~/bands/stones/jagger")

"file_move"
function  : Move a file from a to b,
            or copies the file if moving not possible
parameter : string: source file, string: destination file
result    : boolean
example   : ok = file_move ("std", "~/bands/stones/jagger")

"file_normalize"
function  : Expand a filename, also starting with './' (in addition to 'file_extend')
            Useful to check, whether two filenames mean identical files.
parameter : string: filename (must exist)
result    : string: expanded filename
example   : file1 = file_normalize ("./stones/jagger")
            file2 = file_normalize ("c:\\music\\bands\\stones\\jagger")
            are_equal = file1 = file2 // check if equal

"file_read"
function  : Store the contents of a file in a string.
parameter : string: filename
result    : string: contents of the file
example   : ok = file_read ("./a_long_text.txt")  Result: "Date: 15-5-98\netc. etc. ......."

"file_remove_extension"
function  : Remove file extension (suffix) from the specified filename.
parameter : string: filename
result    : string: filename without extension
example   : ok = file_read ("my_text.txt")  Result: "my_text"

"file_show"
function  : Show any file in the viewer.
parameter : string: filename
result    : -
example   : ok = file_show ("xxx.abc")

"file_translate_slash"
function  : Replace (back)slashes according to conventions of current operating system.
parameter : string: filename
result    : string: filename with modified (back)slashes
example   : fnam = file_translate_slash ("./a\\b/c")  Result on Unix: "./a/b/c", on Windows: ".\\a\\b\\c"

"file_unix_to_win"
function  : Convert a UNIX textfile to a Windows textfile. This is useful,
            because many Windows programs (e.g. editors) need textfiles 
            according to Windows conventions.
parameter : string: filename of UNIX    file (source)
            string: filename of Windows file (target) (optional)
result    : boolean: true, if conversion succeeded
example   : ok = file_unix_to_win ("./a_unix_text.txt", "./a_windows_text.txt")

"file_win_to_unix"
function  : Convert a Windows textfile to a UNIX textfile. This is useful,
            because almost all UNIX programs (e.g. editors) need textfiles 
            according to UNIX conventions.
parameter : string: filename of Windows file (source)
            string: filename of UNIX    file (target) (optional)
result    : boolean: true, if conversion succeeded
example   : ok = file_win_to_unix ("./a_windows_text.txt", "./a_unix_text.txt")

"tmpnam"
function  : This function generates a file name that can safely be used for a
            temporary file.
parameter : none
result    : string
example   : tmpnam()      Result: "/usr/tmp/aaaa004da"

"fremove"
function  : Remove a file from the disc
parameter : string: filename
result    : boolean
example   : ok = fremove ("/tmp/bands/biermoeslblosn")

"free_library"
function  : Reduce the reference count to the library with the handle.
            Unload the library when no references to it are left
parameter : integer: handle to library
result    : -
example   : free_library (hLib)

"get"
function  : Read the next AQL-symbol from the current position or from an absolute
            line position of the input file.
            The file pointer will be positioned behind.            
parameter : [line number]
result    : AQL-symbol
example   : sym = get ()
            sym = get (5)

"get_lock_info"
function  : Information about reservations for write access
parameter : string: filename
result    : string: fullpath, string: user, string: date, string: computername,
            string: productname, string: in use
example   : InfoGrp = get_lock_info ("/usr/standard/DIN933/din933.mod")

"get_lock_info_unchecked"
function  : For internal use only.

"get_wastebasket_info"
function  : Show content of the wastebasket
parameter : -
result    : List of original filenames
example   : WasteGrp = get_wastebasket_info ()

"getenv"
function  : Get the value of an (UNIX) environment variable
parameter : string: name of the variable
result    : string: value of the variable
example   : str = getenv ("KONSYS_HOME")

"putenv"
function  : Set an (UNIX) environment variable
parameter : string: environment variable setting
result    : -
example   : putenv ("MY_ENV=xxxx")   ATTENTION: blanks are not allowed!

"index"
function  : N-th element of a group or ASCII code number of the n-th character of a 
            string
parameter : group_or_string, integer
result    : AQL-symbol
example   : res = index ({1, "abc", 50.0}, 2)    Result: "abc"
            res = index ("abc", 2)               Result: 98

"int"
function  : Convert a real or a string (or an integer, Bea_object, node_type) 
            into an integer
parameter : real or string or integer or Bea_object or node_type
            - Bea_object, node_type  - for detection of null pointers            
            - string means: numbers as string or hex;
              string with leading 0x is interpreted as hex;
              if the hex number is greater than 0x07ffffffe please call 
              "int (eval (nr))"
result    : integer
example   : i = int (10.6)    Result:  10
            i = int ("10.6")  Result:  10
            i = int ("0x6a")  Result: 106

"layer_status"
function  : Activate the layer state dialog
parameter : -
result    : -

"len"
function  : Number of characters in a string
parameter : string 
result    : integer
example   : i = len ("abcde")   Result: 5

"line"
function  : Actual line number of the input file
parameter : -
result    : integer
example   : i = line ()

"ln"
function  : Natural logarithm of x; the value of x must be positive
parameter : real
result    : real
example   : x = ln (23.12)

"load_library"
function  : Load a Windows NT dynamic link library (dll) into memory
parameter : string: filename
result    : integer: handle to the library

"log"
function  : Logarithm base ten of x; the value of x must be positive
parameter : real
result    : real
example   : x = log (23.12)

"lowercase"
function  : Convert a string into all lowercase characters; 
            ATTENTION: counting starts at zero!
parameter : string [, integer: start position] [, integer: end position]
result    : string
example   : str = lowercase ("Good MORNING")        Result: good morning
            str = lowercase ("Good MORNING",6,11)   Result: Good Morning

"new_aql_special"
function  : For internal use only !!!
parameter : ...
result    : ...

"max"
function  : Maximum of a list of reals or integers
parameter : real | integer, real | integer, ..., real | integer
result    : real
example   : x = max (1.4, 99, 34.12, 7.8, 21)   Result: 99

"min"
function  : Minimum of a list of reals or integers
parameter : real | integer, real | integer, ..., real | integer
result    : real
example   : x = max (1.4, 99, 34.12, 7.8, 21)   Result: 1.4

"mkdir"
function  : Create a subdirectory
parameter : string: directoryname
result    : boolean
example   : ok = mkdir (file_extend ("~/bands/gallagher"))

"mod"
function  : Remainder of the division from x by y
parameter : real/integer x, real/integer y
result    : real/integer
example   : x = mod (41, 12.9)   Result: 2.3

"open_url"
function  : Open file or URL with standard browser.
parameter : string: file_or_url [, boolean: new_window]
            'file_or_url' ... file on your local computer or
                              URL (Uniform Resource Locator)
            'new_window' .... "true"  - Use a new browser window (default)
                              "false" - don't use a new browser window
result    : boolean: true  - file or URL opened
                     false - error during opening
example   : open_url ("http://www.eucad-software.de")

"parse_back_blanks"
function  : For internal use only !!!
parameter : ...
result    : ...

"parse_comment"
function  : Skip all kinds of comments from the input file starting at the current file
            pointer position. To skip a comment the start position must contain a comment.
            The file pointer will be positioned behind.            
parameter : -
result    : boolean: true   if comment skipped
                     false  if no comment found
example   : parse_comment ()

"parse_keyword"
function  : (Try to) read a keyword from the input file at the current file pointer
            position.
            The file pointer will be positioned behind.            
parameter : string: keyword
result    : boolean: true   if keword found at current position
                     false  if no keyword found
example   : ok = parse_keyword ("guitar")

"parse_line"
function  : Read the remainder of the line from the input file (up to newline character
            or end of file) starting at the current file pointer position.
            The file pointer will be positioned behind.            
parameter : -
result    : string | invalid
example   : str = parse_line ()

"parse_move"
function  : For internal use only !!!
parameter : ...
result    : ...

"parse_name"
function  : Read the next AQL-symbol from the input file starting at the current file
            pointer position.
            The name matches the following regular expression : [A-Za-z$][A-Za-z_0-9]*
            The file pointer will be positioned behind.            
parameter : -
result    : string | invalid
example   : str = parse_name ()

"parse_number"
function  : Read the next real or integer from the input file starting at the current
            file pointer position..
            The file pointer will be positioned behind.            
parameter : -
result    : real | integer | invalid
example   : x = parse_number ()

"parse_string"
function  : Read the next AQL-symbol as string (between "" or until next blank) from the
            input file starting at the current file pointer position.
            The file pointer will be positioned behind.            
parameter : -
result    : string | invalid
example   : str = parse_string ()

"pos"
function  : 1) Position of the first occurrence of the searchstring in the targetstring
            2) Position of the first occurrence of a symbol in a group
parameter : 1) string: targetstr, string : searchstr
            2) group, any AQL symbol
result    : integer
example   : 1) i = pos ("/usr/home/bands/beatles", "/")                       Result: 1
            2) i = pos ({"John", "Paul", "Ringo", "Paul", "George"}, "Paul")  Result: 2

"put_in_wastebasket"
function  : Put a file into the wastebasket
parameter : string: filename
result    : boolean: ok
example   : Ok = put_in_wastebasket ("/usr/secrets/step1.mod")

"quick_edit"
function  : Activate quick edit mode
parameter : -
result    : -
example   : quick_edit ()

"quit_application"
function  : Quit the application
parameter : -
result    : -
example   : quit_application ()

"RecentFileListGetSize"
function  : get number of file names stored in the RecentFileList
parameter : -
result    : integer: number
example   : nr = RecentFileListGetSize()

"RecentFileListAdd"
function  : add one or more file names to the RecentFileList
parameter : a. string: filename
            or b. group : { string: file1, string: file2, .... }
result    : boolean: true if ok, else false
example   : ok = RecentFileListAdd( { "a.mod", "c:\b.mod" } )

"RecentFileListRemove"
function  : remove one or more file names from the RecentFileList
parameter : a. string: filename
            or b. group : { string: file1, string: file2, .... }
result    : boolean: true if ok, else false
example   : ok = RecentFileListRemove( "c:\b.mod" )

"RecentFileListOpenModel"
function  : open one or more files stored in the RecentFileList
            similar to 'model_load', but following differences:
            - automatically remove from RecentFileList if open failed
            - automatically load 'read_only' if no write_access
            - load more than one models at once
parameter : a. string: filename
            or b. group : { string: file1, string: file2, .... }
result    : boolean: true if ok, else false
example   : ok = RecentFileListOpenModel( { "a.mod", "c:\b.mod" } )

"RecentFileListClean"
function  : remove invalid or all files from the RecentFileList
parameter : boolean: invalid_filenames_only  OPTIONAL
result    : boolean: true if ok, else false
example   : ok = RecentFileListClean( true ) // remove invalid files

"RecentFileListRead"
function  : read contents of RecentFileList
parameter : [integer nr] [, string sort_method]
            'nr' ........... read the 'nr' newest files from the list
                             default: 'nr' = 0: read all files from the list
            'sort_method' .. defines the order of the returned data:
                                "date"     sorted by date (default)
                                "name"     sorted by full pathname
                                "type"     sorted by type (file extension)
                                "basename" sorted by filename, 
                                           don't consider directory name
result    : group of strings
example   : my_list = RecentFileListRead() // read the complete list

"RecentFileListWrite"
function  : write RecentFileList
parameter : group of strings (file names)
result    : boolean: true if ok, else false
example   : ok = RecentFileListWrite ( { "a.mod", "c:\b.mod" } ) // rebuild the complete list

"RecentFileListEdit"
function  : interactively edit RecentFileList
parameter : -
result    : boolean: true if ok, else false
example   : ok = RecentFileListEdit ()

"random"
function  : Random number between 0 and 1
parameter : -
result    : real
example   : x = random ()

"read"
function  : Read an AQL-symbol from the text box (in batch mode: from the process
            window)
parameter : string: prompt [ | <default> ]
            you may offer a default
result    : AQL-symbol
example   : res = read ("Please enter your name: ")
            res = read ("Please enter a number => | 5.5")

"read_string"
function  : Read a string from the text box (in batch mode: from the process window)
parameter : string: prompt [ | <default> ]
result    : string
example   : res = read_string ("Please enter your name: ")
            res = read_string ("The name of the best CAD system? => | EUKLID Design")

"real"
function  : Convert an integer or a string (or a real) into a real
parameter : integer or string (or real)
              string means: numbers as string or hex;
              string with leading 0x is interpreted as hex;
              if the hex-number is greater than 0x07ffffffe please call 
              "real (eval(nr))"
result    : real
example   : i = real (10)      Result:  10
            i = real ("10.6")  Result:  10
            i = real ("0x6a")  Result: 106


"replicate"
function  : Replicate one character n times
parameter : string with one char, integer
result    : string
example   : replicate ("-",12)   Result: "------------"

"relget"
function  : Read the next AQL-symbol from the input file. Position the file pointer
            relative to the current line position.
            The file pointer will be positioned behind.            
parameter : integer: line offset
result    : AQL-symbol
example   : sym = relget (15)

"return_code"
function  : Set the return-code of a separate AQL program.
            Attention: Don't use this to return from functions!
parameter : integer
result    : -
example   : return_code (99)

"rmdir"
function  : Remove a directory
parameter : string: directory name
result    : boolean
example   : ok = rmdir ("/tmp/bands/deep_purple")

"round"
function  : The nearest integer of x
parameter : real  or  real as string
result    : integer
example   : i = round (10.6)    Result: 11
            i = round ("10.6")  Result: 11

"rpos"
function  : 1) Position of the last occurrence of the searchstring in the targetstring
            2) Position of the last occurrence of a symbol in a group
parameter : 1) string: targetstr, string : searchstr
            2) group, any AQL symbol
result    : integer
example   : 1) i = rpos ("/usr/home/bands/beatles", "/")                      Result: 16
            2) i = rpos ({"John", "Paul", "Ringo", "Paul", "George"}, "Paul") Result:  4

"sdIamAlive"
function  : Called from partner application to show that it is alive.
            (Don't call directly); for internal use only !!!
parameter : string: Name_of_Partner_application
result    : -

"sdInit"
function  : Initialize the session dialog module with the KONSYS manager;
            for internal use only !!!
parameter : string: KONSYS-manager NIP-ID, string: my NIP-ID (get from program.args
            -konmgr kNID mNID)
result    : boolean

"sdIsInitialized"
function  : Query if the session dialog communication works;
            for internal use only !!!
parameter : -
result    : boolean

"sdMapKM"
function  : Map the KONSYS-manager on top;
            for internal use only !!!
parameter : -
result    : -

"sdPartnerAlive"
function  : Check if the partner is running and has a valid process connection;
            for internal use only !!!
parameter : string: Name_of_Partner_application, integer: seconds_to_wait_for_response
result    : boolean

"sdSend"
function  : Send a command string to another application via the session dialog module;
            for internal use only !!!
parameter : string: toPartner, string: command
result    : boolean

"sdWithGeometry"
function  : Query the state of the mailbox toggle-button, true means transfer geometry
            to partner; for internal use only !!!
parameter : -
result    : boolean

"search"
function  : Search an object in the datastructure
            For compatibility only !!!
parameter : string: objectname
result    : object

"send_event"
function  : Send an X-event to another running application window via atom with
            a specified name
parameter : string: case 1: send to own display:    <atomname>
                    case 2: send to remote display: <hostname>:<server>.<screen>.<atomname> 
                            (cf. environment variable DISPLAY)
            int   : client_format (8,16,32; 32 recommended in most cases)
            string: message
result    : -

"set"
function  : Set the n-th element of a group
parameter : group, integer, symbol
result    : -
example   : set ({true, true, false, false}, 3, true)

"set_help_button"
function  : For internal use only !!!
parameter : -
result    : -

"show_history"
function  : Show the history and the preview of model files
parameter : string: filename
            [, boolean: show popup (default: true)]
                        true  = show in any case
                        false = show if popup is already open
result    : -
example   : show_history ("p:\samples\A02K4711.mod")

"sin"
function  : Sine of its parameter, measured in degrees
parameter : real or integer
result    : real
example   : x = sin (45.9)

"sleep"
function  : Let the program sleep for some seconds
parameter : integer: seconds
result    : -
example   : sleep (3)

"sqrt"
function  : Non-negative square root of x; the value of x may not be negative
parameter : real or integer
result    : real  or  invalid
example   : x = sqrt (36)

"string"
function  : Convert an AQL-symbol into a string
parameter : symbol [, fieldwidth] [, precision] [, format]
result    : string
example   : str = string (123.99)
            str = string (123.99,,4,"f")

"subobject"
function  : Returns a group of subobjects
parameter : object
result    : group
example   : grp = subobject (obj)

"substr"
function  : Build a substring of a string
parameter : string, integer: start position [, integer: end position]
result    : string
example   : str = substr ("Yellow Submarine", 8, 10)   Result: "Sub"

"system"
function  : Let the shell execute a command (see also exec)
parameter : string
result    : integer (0 = ok, others = error)
example   : i = system ("/bin/ls -l *.aql")

"tan"
function  : Tangent of its parameter, measured in degrees
parameter : real or integer
result    : real
example   : x = tan (1.75)

"test_property_suppressed"
function  : Is a property of an actions result or effect suppressed?
parameter : action node, property node [, object (in edit mode)]
result    : boolean
example   : ok = test_property_suppressed (act, par)

"translate"
function  : Translate a string by ASCII value using a translation table
parameter : string
result    : string
example   : translation_table ({{97,"aa"}{98,"boe"}})
            str = translate ("abba")   Result: "aaboeboeaa"

"translate_filename"
function  : Use the file translation table (see action 'admin') to define the area of 
            files to be used. The system will find the corresponding drive.
parameter : string: filename, string: source computer [, string: target computer
            (default: local computer)]
result    : string: filename of target computer
example   : translate_filename ("f:\\tests\\tmp\\std.mod", "pc_3")

"translation_table"
function  : Define the ASCII string translation table
parameter : group of group of integer and string
result    : -
example   : translation_table ({{97,"aa"}{98,"boe"}})
            see also function 'translate()'

"type"
function  : Type of an AQL-symbol
parameter : symbol
result    : string: "real", "integer", "string", "boolean", "date", "group", 
                    "Bea_object", "Bea_action", "node_type", "invalid" or other 
                    application defined types
example   : if (type (top.list_point.first) = "Bea_object") then ...

"uppercase"
function  : Convert a string into all uppercase characters
            ATTENTION: counting starts at zero!
parameter : string [, integer: starting position] [, integer: endposition]
result    : string
example   : str = uppercase ("good morning")        Result: GOOD MORNING
            str = uppercase ("good morning",5,6)    Result: good MOrning

"valid"
function  : Test if an AQL-symbol or AQL-expression has a valid value
parameter : AQL-symbol or AQL-expression
result    : boolean: true if valid value
example   : ok = valid (application.["v_piano"])

"verbose"
function  : Report all about opening and closing AQL files
parameter : boolean: true  = report
                     false = don't report
result    : -
example   : verbose (true)

"wastebasket_undo"
function  : Undo last operation in the wastebasket
parameter : -
result    : boolean
example   : Ok = wastebasket_undo ()

"wd"
function  : Current working directory
parameter : -
result    : string
example   : actdir = wd ()

"who"
function  : User name
parameter : -
result    : string
example   : iam = who ()

"write_gif_data"
function  : Write ASCII icon data into a file in GIF(c) format
parameter : string: filename [, group: asciidata]
result    : -
example   : write_gif_data ("xxx", { 5, 5, "00000","10101","01010","22222","33333" })

"write_filename_memory"
function  : 'filename_memory' is a file located in the user's configuration 
            directory. It has the purpose to find models quickly by their 
            unique number.
            This function writes the contents of the filename_memory 
            into file './filename_memory.debug' for information purposes.
parameter : none
result    : system will write following message into background pad:
            'Info about hashtable was written on file filename_memory.debug'


"viewport_split_hor"
function  : Split viewport horizontal into two viewports.
parameter : view object, selection_rec
result    : none

"viewport_split_ver"
function  : Split viewport vertical into two viewports.
parameter : view object, selection_rec
result    : none

"xml_add_attribute"
function  : Adds an attribute to an existing XML element
parameter : xml_identifier, xml_element, attribute
            xml_identifier : type -> xml_descriptor
                             used to identify the XML file
                             (see xml_open / xml_new)
            xml_element    : type -> group|string
                             identifies an element in the xml file
                             string - name of the element
                             group  - name of a subelement
                                      e.g.: {"Mainentry", "Subofmain", "SubofSub"}
            attribute      : type -> group
                             attributegroup(s) must be allways a pair of values (attributename and attributvalue)
                             e.g.: {"Attrib1", "Value1", "Attrib2", "Value2"}
result    : type -> boolean
                             true  - attribute added
                             false - add attribute failed

"xml_add_element"
function  : Adds an element to an existing XML file
parameter : xml_identifier, xml_element [, attribute]
            xml_identifier : type -> xml_descriptor
                             used to identify the XML file
                             (see xml_open / xml_new)
            xml_element    : type -> group|string
                             element in the xml file
                             string - name of the element ("root" element)
                             group  - name of a subelement
                                      e.g.: {"Mainentry", "Subofmain", "SubofSub"}
                                      creates all elements or adds subelements to existing elements
            attribute      : type -> group
                             attributegroup(s) must be allways a pair of values (attributename and attributvalue)
                             e.g.: {"Attrib1", "Value1", "Attrib2", "Value2"}
                             all attributes are added to the last element in the xml_element group.
result    : type -> boolean
                             true  - element added
                             false - add element failed

"xml_close"
function  : Closes an XML file
            the file will not be saved, all changes will be discarded
parameter : xml_identifier
            xml_identifier : type -> xml_descriptor
                             used to identify the XML file
                             (see xml_open / xml_new)
result    : -

"xml_delete_attribute"
function  : Deletes an attribute in an existing XML file
parameter : xml_identifier, xml_element, attribute
            xml_identifier : type -> xml_descriptor
                             used to identify the XML file
                             (see xml_open / xml_new)
            xml_element    : type -> group|string
                             element in the xml file
                             string - name of the element ("root" element)
                             group  - name of a subelement
                                       e.g.: {"Mainentry", "Subofmain", "SubofSub"}
            attribute      : type -> string
                             name of the attribute     
result    : -

"xml_delete_element"
function  : Deletes an element in an existing XML file
parameter : xml_identifier, xml_element
            xml_identifier : type -> xml_descriptor
                             used to identify the XML file
                             (see xml_open / xml_new)
            xml_element    : type -> string|group
                             element in the xml file
                             string - name of the element ("root" element)
                             group  - name of a subelement
                                      e.g.: {"Mainentry", "Subofmain", "SubofSub"}
result    : -

"xml_new"
function  : Creates a new XML file
parameter : filename [, encoding, comment]
            filename       : type -> string
                             name of a new XML file
            encoding       : type -> string
                             encoding of the XML file (e.g. "ISO-8859-1" or "UTF-8")
            comment        : type -> string
                             comment written as first element in the XML file
result    : xml_identifier : type -> xml_descriptor
                             identifies the XML file
                             all XML manipulation functions need the xml_descriptor
                             to identify the XML file

"xml_open"
function  : Opens an existing or creates a new XML file
parameter : filename [, encoding, comment]
            filename       : type -> string
                             name of the XML file
            encoding       : type -> string
                             encoding of the XML file (e.g. "ISO-8859-1" or "UTF-8")
            comment        : type -> string
                             comment written as first element in the XML file
result    : xml_identifier : type -> xml_descriptor
                             identifies the XML file
                             all XML manipulation functions need the xml_descriptor
                             to identify the XML file

"xml_print"
function  : Print a XML file
            Useable for test purposes, prints the file formatted in the background window (stdout)
parameter : xml_identifier
            xml_identifier : type -> xml_descriptor
                             used to identify the XML file
                             (see xml_open / xml_new)
result    : -

"xml_read"
function  : still in progress

"xml_read_attribute"
function  : Reads an attribute in an existing XML file
parameter : xml_identifier, xml_element, attribute
            xml_identifier : type -> xml_descriptor
                             used to identify the XML file
                             (see xml_open / xml_new)
            xml_element    : type -> group|string
                             element in the xml file
                             string - name of the element ("root" element)
                             group  - name of a subelement
            attribute      : type -> string
                             name of the attribute
result    : value          : type -> string
                             Value of the attribute
example   : xml_read_attribute {XML, {"Mainentry", "Subofmain", "SubofSub"}, "Value")

"xml_read_element"
function  : still in progress

"xml_save"
function  : Saves an XML file
parameter : xml_identifier
            xml_identifier : type -> xml_descriptor
                             used to identify the XML file
                             (see xml_open / xml_new)
result    : -


#BASIC functions
#####################################################################
"analyse_basket"
function  : For internal use only !!!
parameter : ...
result    : ...

"analyse_model"
function  : For internal use only !!!
parameter : ...
result    : ...

"applic_action"
function  : For internal use only !!!
parameter : ...
result    : ...

"applic_obj"
function  : For internal use only !!!
parameter : ...
result    : ...

"calculate_objval"
function  : Calculate the value if this action would be executed
parameter : string: name of the action
          : list of the necessary parameters for this action
result    : the value, as defined for the input

"calculate_objval_all"
function  : Calculate the values of result and all effects if this action
            would be executed
parameter : string: name of the action
          : list of the necessary parameters for this action
result    : Group of values of result and effects, as defined for the input.
            Because of effects the result group looks like
            {result.value, {effect.type, effect.id_value, effect.value}, {...}, ... }
            Please note that some information about objects and actions
            inside 'result.value' or 'effect.id_value' are not longer valid because
            the action used for calculate_objval_all is already destroyed after leaving
            this AQL function.

"copy_user_atts"
function  : Copy all attributes of the source object to the destination object
parameter : destination object, source object, 
            boolean: uneval [default: true, for compatibility only !!!]
            Warning: if parameter 'uneval' is 'true', the function may be very slow.
result    : -

"create_attrib"
function  : Create an attribute for this object.
            The attribute value can be specified in this function or with 'set_attrib'
parameter : 1. object, string: attributename
               This form sets the attribute value to the empty string
            2. object, string: attributename, integer | real | boolean | string,
               boolean: uneval [default: true, for compatibility only !!!]
            3. object, string: attributename, object: reference,
               string: reference attribute name,
               boolean: uneval [default: true, for compatibility only !!!]
               This form specifies that the value for this attribute is:
                  the value of the attribute <name> of the object <reference> 
            Warning: if parameter 'uneval' is 'true', the function may be very slow.
result    : -

"create_attrib_expr"
function  : Create an attribute for this object.
            The attribute value can be specified in this function or with 'set_attrib'
parameter : 1. object, string: attributename
               This form sets the attribute value to the empty string
            2. object, string: attributename, string : expression, 
               boolean: uneval [default: true, for compatibility only !!!]
            3. object, string: attributename, object: reference, string: reference
               attribute name
               This form specifies that the value for this attribute is:
                  the value of the attribute <name> of the object <reference> 
               boolean: uneval [default: true, for compatibility only !!!]
            Warning: if parameter 'uneval' is 'true', the function may be very slow.
result    : -

"delete"
function  : Delete an object or a group of objects
parameter : object | group of objects
result    : -

"delete_attrib"
function  : Delete an attribute
parameter : object, string: attributename,
            boolean: uneval [default: true, for compatibility only !!!]
            Warning: if parameter 'uneval' is 'true', the function may be very slow.
result    : -

"define_fun_key"
function  : Connect an action to a function key
parameter : string: key, string: modifier, string: actionname
result    : -
example   : define_fun_key ("J", "Ctrl+Alt", "output_plotscaled")
            ATTENTION: - write key name in uppercase character
                       - no blanks allowed in modifier name

"disable_messages"
function  : Disable the output of mes_report_error in AQL
parameter : -
result    : -
example   : disable_messages ()

"display_error"
function  : Display a message in a box on the screen and waits until the user confirms
            via mouse click
parameter : string (% is interpreted as a newline character)
result    : -
example   : display_error ("No object selected!")

"edit"
function  : Edit an object, depending on the number of parameters
            object:   start the interactive editor for this object;
                      not allowed in batch mode
            prop_or_par_node, object, parameter: 
                      change that property or parameter of that object
            object, parameters
                     change the parameters of the create action of that object 
            action, parameters
                     change the parameters of the action
            absolute object, value
                      change the absolute object (not valid (object.created_by) )
            layer_object, string: name, state, boolean: is_locked,
                      state is one of "selectable", "visible", "active", "inactive"
parameter : see 'function'
result    : -

"enable_messages"
function  : Enable the output of 'mes_report_error' in AQL
parameter : -
result    : -

"eval_history_entry"
function  : Split history_entry into group.
parameter : string (as delivered by function get_history())
result    : group of strings:
            { version, user, computer, program_version, date, filename, comment }
example   : history = get_history ("flange.mod")
            [  eval_history_entry(history.el_3)  ] nl
            -> { "2", "mueller", "indigo1", "ObjectD-SGI-970529", "Thu May 26 12:53:22 1997", 
                 "Y:\\basic\\parts\\flange.mod", "some comment" }
            
"flush"
function  : Force all graphic commands to be executed
parameter : -
result    : -

"sync"
function  : Synchron mode of graphics (for test purposes)
            not allowed in batch mode
parameter : boolean: synchron mode ON (default) or OFF
                     ON has same effect start option -sync
result    : -
example   : sync (true)  // switch synchron mode ON
            ...          // do something
            sync (false) // switch synchron mode OFF

"file_has_duplicates"
function  : Check, whether there are models with same unique number.
parameter : filename of (Bea-)model
result    : group of duplicates
example   : group_of_duplicates = file_has_duplicates ("welle.udo")
            -> result: { "welle.udo.SAV", "welle.udo.1" }


"file_is_unique"
function  : Check, whether there are models with same unique number.
parameter : filename of (Bea-)model
result    : boolean:
            'true', if file is unique, 'false' if not, 'invalid' if filename represents
            no EUKLID Design model (Bea_model).
            To get the duplicates, please use function file_has_duplicates().
example   : is_unique = file_is_unique ("welle.udo")


"get_filename_memory"
function  : store the contents of the filename_memory in a group of AQL groups
parameter : none
result    : {  { <group_1> } , { <group_2> } , { <group_3> }, ....... , { <group_n> }  }

            <group_1> ... < group_n> possess the following structure:              
            {  {<group_of_strings>}  , <int1> , <int2> , <int3> , <int4> }          
      
            {<group_of_strings>}  : This group contains all filenames of models with 
                                    the same unique number.
                                    It thus has following structure:
                                    { <filename1> , {filename2> , ... }
            <int1> ... <int4>     : The 4 components of the unique number.     
   
example   : my_info_group = get_filename_memory()

"get_history"
function  : Get the history of a 'model' 
            The following types may have a history: model, udx, external layer,
            user_config, system_config .
parameter : filename of the model (string)
result    : group of strings: { string 0, string 1, string 2, ... string n }
            These strings contain the following informations:

            string 0 : header
                       "______________________________________________ ...

                        History                  Model-Type: model
                        _______________________________________________..."

            string 1 ... string (n-1) : versions
                       "[   1] user 'joe' on 'indigo4' [ObjectD-SGI-970...
                               FILENAME: /usr/home/joe/tmp/model_area/...."
                               new part for ......
                       "[   2] user 'maier' on 'indigo1' [ObjectD-SGI-9...
                               changed for customer xx ...
                                        ..........
            string n : 
                       "last saved as: /usr/home/mueller/tmp/...._part.mod"

example   : history = get_history ("flange.mod")
            See also eval_history_entry().

"get_latest_version_string"
function  : Return history_entry of last stored version.
            The following types may have a history: model, udx, external layer,
            user_config, system_config .
parameter : filename of the model (string)
result    : string
example   : latest_version = get_history ("flange.mod")
            See also eval_history_entry().

"get_backup_version_strings"
function  : Get history_entries of all versions, which are stored as internal backup.
            The following types may have backup versions: .mod, .udo, .uda, .ext.
            The LATEST version (on file) is also included, as first element.
parameter : filename of the model (string)
result    : group of strings
example   : versions = get_backup_version_strings("flange.mod")

            { "[   5] user 'zim' on 'indigo1' [ObjectD-SGI-970529] Thu May 29 15:58:32 1997",
              "[   2] user 'zim' on 'indigo1' [ObjectD-SGI-970529] Thu May 26 12:53:22 1997",
              "[   1] user 'zim' on 'indigo1' [ObjectD-SGI-970529] Thu May 24 17:59:53 1997" }

            See also eval_history_entry().

"get_locator_table"
function  : Get the contents of one of the two locator tables
parameter : type: 'string', possible are 'user' (user specific locator table)
            or 'system' (system locator table)
result    : value 'loc_table'

"get_optional"
function  : Get the optional object/value/enum for the specified parameter or property
            node in the AQL program or in the model file
parameter : <node> [where] [bring message]
               <node>         : par or prop node
               <where>        : "aql" (default) or "model"
               <bring message>: false or true (default)
result    : object/value/node

"history_viewer_visible"
function  : Return true, if the history viewer is mapped.
parameter : -
result    : boolean

"iconify_window"
function  : Iconify the window;
            not allowed in batch mode
parameter : -
result    : -

"id"
function  : 1. used to identify effects but ONLY in UDA with AQL
            2. used to find an identified object (e.g. by the protocol generator)
parameter : <kind>, [<action>,] [<basket>,] <semantic_number> [ ,<object-1>, ... ]
            where 
               <kind>  : "effect" or "effect action"
                            effect       : absolute object     as effect
                            effect action: object with action  as effect
               <action>: The action that created this effect
                         default: current UDA
               <basket>: If specified, the layer of the action is required.
                         if result is of type UDO, then UDO itself is also possible
                         default: 1. current uda.basket
                                  2. active layer
               <semantic_number>: an integer (short)
               <object-x>: one or several referenced objects (x=1,...,n)
                  The combination of <semantic_number> and <object-1>...<object-n>
                  must be unique to identify the created effect.
result    : id_type

"inpar"
function  : Set the (group of) object as inputparameter. See also inpar_ttype
            For compatibility only !!!
parameter : object or group of objects
result    : -

"inpar_icon"
function  : Define an icon of an input parameter
            For compatibility only !!!
parameter : inpar-number, icon
result    : -

"inpar_iconascii"
function  : Define an icon in ASCII format of an input parameter
            For compatibility only !!!
parameter : inpar-number, icon
result    : -

"inpar_ttype"
function  : Set the n-th parameter of the input parameter
            For compatibility only !!!
parameter : object, number of the parameter
result    : -

"layer_change_access"
function  : Change access of layer from "write" to "read_only" and vice versa
parameter : layer
result    : -

"layer_normal"
function  : Create a layer
            For compatibility only !!!
parameter : string: layername, string: "selectable", "inactive", "active",
            boolean: locked
result    : object: layer

"layer_set_color"
function  : Set layer color
parameter : layer: layer to set, color: color of layer
result    : -

"layer_get_color"
function  : get layer color
parameter : layer: layer 
result    : { {red, green, blue} }: color of layer

"load_actions_of_ag"
function  : Load the actions of the specified actiongroup
parameter : node: actiongroup_node
result    : -

"load_ag_of_menu"
function  : Load the actiongroups of the specified menu
parameter : node: menu_node
result    : -

"load_objects_of_og"
function  : Load the objects of the specified objectgroup
parameter : node: objectgroup_node
result    : -

"lower_window"
function  : Lower the window;
            not allowed in batch mode
parameter : -
result    : -

"map_window"
function  : Map the window;
            not allowed in batch mode
parameter : -
result    : -

"memory_use"
function  : Returns the used memory
parameter : -
result    : integer

"model"
function  : Returns the model corresponding to the specified name or the active model
            if no name is specified
parameter : string: modelname | none 
result    : object: the model

"move_object_to_layer"
function  : Move the object to a layer
parameter : object: object to be moved, layer: destination layer
result    : -

"move_set_to_layer"
function  : For compatibility only !!!
            use 'layer_move_objects'
parameter : -
result    : -

"move_sublayer_to_layer"
function  : For compatibility only !!!
            use 'layer_move_sublayer'
parameter : -
result    : -

"name"
function  : Give a name to an object
parameter : object, namestring
result    : -

"object_type"
function  : Returns the corresponding aql_meta_object
parameter : object
result    : aql_meta_object_type

"optional_set"
function  : Returns true if the specified parameter or property is optional
            for the AQL program or in the model file
parameter : <node> [where]
               <node> : par or prop node
               <where>: "aql" (default) or "model"
result    : true if successful

"peek_cursor"
function  : Current cursor position;
            not allowed in batch mode
parameter : -
result    : group { x, y, view }

"peek_key"
function  : Currently pressed key;
            not allowed in batch mode
parameter : -
result    : string with the typed key

"pick"
function  : Lets the user pick an object;
            not allowed in batch mode
parameter : - string: layer  (optional)
            - (group of) string: typename of allowed object(s)
            - pick coordinate: { x, y, [view]}   (optional)
result    : object

"pick_group"
function  : Lets the user pick one or more objects by specifying a rectangular area;
            not allowed in batch mode
parameter : - user object (optional): if not specified, objects of all layers can 
              be selected
            - string/group of strings: name of one type/the types of objects 
                      that is/are allowed
            - 2 pick coordinates: {{x1, y1, [view]}, {x2, y2, [view]}}   (optional)
result    : group of selected objects

"pick_rectangle"
function  : Lets the user pick objects by the normal group_rec selection menu;
            not allowed in batch mode
parameter : - layer object (optional)
            - string/group of strings: name of one type/the types of objects 
                      that is/are allowed
            - 2 pick coordinates: {{x1, y1, [view]}, {x2, y2, [view]}}   (optional)
result    : group of selected objects

"pick_multiple_objects"
function  : Lets the user pick objects by multi selection mode;
            not allowed in batch mode
parameter : - node (optional)
            - group of nodes: types of objects that are allowed
            - group of objects: objects that are initially selected
result    : group { boolean, selected objects }
            The boolean is true when finished with ok, false for cancel

"pick_mouse"
function  : Wait for user's mouse input in the drawing area and returns the picked 
            screen coordinates;
            not allowed in batch mode
parameter : -
result    : group of real x, real y and view object

"popup_3choices"
function  : Open a form with 3 choices and waits until the user chooses one;
            not allowed in batch mode
parameter : 4 strings: title, choice1, choice2, choice3
result    : integer (1, 2 or 3)

"popup_boolean"
function  : Open a form with 2 choices;
            not allowed in batch mode
parameter : string: title, string : true_choice, string: false_choice
result    : boolean (true  if the first choice is selected,
                     false if the second choice is selected)

"popup_color"
function  : Open the color form to select a color;
            not allowed in batch mode
parameter : -
result    : group: rgb-value {red, green, blue}

"popup_filename"
function  : Open the files form to select/input a file name;
            not allowed in batch mode
parameter : 4 or 5 strings: title, file filter, initial directory name, 
            initial file name, io_reason
result    : string: selected file

"popup_language"
function  : Open the language-popup and waits until the user selects a language;
            not allowed in batch mode
parameter : -
result    : string: selected language

"popup_largelist"
function  : Open a form with a number of possibilities and waits for user input;
            not allowed in batch mode
parameter : string: title, string: button, group of strings: entries
result    : string: selected entry

"popup_multiplelist"
function  : Open a form with a number of possibilities and waits for user input;
            not allowed in batch mode
parameter : string: title, string: ok button, string: cancel button, 
            boolean: multiple selection allowed, 
            group of strings: pre selected, group of strings: entries,
result    : group of strings: selected entries

"popup_list"
function  : Open a form with a number of possibilities and waits for user input;
            not allowed in batch mode
parameter : string: title, group of strings: entries
result    : string: selected entry

"popup_sel_name"
function  : Select Bea_objects by name.
            not allowed in batch mode
parameter : bea_node_rec: type of objects to select
result    : group of selected Bea_objects
example   : my_selected_circles = popup_sel_name(application.o_circle)

"prompt"
function  : Display a message in the text box (in batch mode: in the process window)
parameter : message string
result    : -

"prompt_comment"
function  : Display a message in the message box (in batch mode: in the process window)
parameter : message string
result    : -

"protocol_set_attrib"
function  : For internal use only !!!
parameter : ...
result    : ...

"protocol_set_attrib_expr"
function  : For internal use only !!!
parameter : ...
result    : ...

"protocol_delete_attrib"
function  : For internal use only !!!
parameter : ...
result    : ...

"raise_window"
function  : Raise the window;
            not allowed in batch mode
parameter : -
result    : -

"read_config"
function  : Reread the config file and resets the value of it
parameter : -
result    : -

"read_cursor_pos"
function  : Current cursor position
parameter : -
result    : group: viewobject and 6 reals (posx, posy, posz, dirx, diry, dirz)

"read_key"
function  : Wait until the user presses a key
            not allowed in batch mode
parameter : -
result    : string with the typed key

"read_value"
function  : Read a value via text box, drawing area or form
parameter : node of the value
            initial value content (syntax depends on value type) (optional)
            prompt string (optional - initial value must be there)
result    : value see table 'defined values'

"redefine"
function  : Change the action of an object or make an object absolute
parameter : object to change, object with the changed action | "ABSOLUTE"
result    : -

"redefine_effect"
function  : Change the action of an effect object or make an effect object absolute
parameter : effect object to change, object with the changed action | "ABSOLUTE"
result    : -

"redraw"
function  : Redraw all objects
parameter : -
result    : -

"redraw_param_column"
function  : Redraw the parameter(3rd) column
            (e.g. remove parameter set implicit out of parameter column)
parameter : -
result    : -

"remove_manipulator"
function  : Remove manipulator
parameter : action: manipulator
result    : -

"reset_fun_keys"
function  : Remove all function key definitions
parameter : -
result    : -

"search_action"
function  : For internal use only !!!
parameter : ... 
result    : ...

"search_obj"
function  : Search the object by name (or by id-number) in the specified UDO 
parameter : string: objectname (or group: identification number)
            object: user (optional)
result    : object

"sel_name_preselect_only"
function  : For internal use only

"set_active_model"
function  : Set a model active
parameter : string            : modelname, or object: model
            boolean (optional): true : restore the active layer in the 
                                       model
                                false  (default): set top layer of the 
                                       model active                                                                      
result    : -

"set_attrib"
function  : Set the value of an attribute
parameter : 1. object, string: attributename, integer | real | boolean | string, 
               boolean: uneval [default: true, for compatibility only !!!]
            2. object, string: attributename, object: reference, string: name,
               boolean: uneval [default: true, for compatibility only !!!]
               this 2nd form specifies that the value for this attribute is:
                  the value of the attribute <name> of the object <reference> 
            Warning: if parameter 'uneval' is 'true', the function may be very slow.
result    : -

"search_effect"
function  : For internal use only !!!
            search an effect by ID in the specified basket (ID)
parameter : ID
result    : effect object

"set_attrib_expr"
function  : Set the value of an attribute to the expression
parameter : object, string: attributename, AQL-expression

parameter : 1. object, string: attributename, AQL-expression 
               boolean: uneval [default: true, for compatibility only !!!]
            2. object, string: attributename, object: reference, AQL-expression,
               boolean: uneval [default: true, for compatibility only !!!]
               this 2nd form specifies that the value for this attribute is:
                  the value of the attribute <name> of the object <reference> 
            Warning: if parameter 'uneval' is 'true', the function may be very slow.
result    : -

"set_icon"
function  : Set or modify the icon of a node
parameter : node, icondescription
result    : -

"set_objval"
function  : Set the object value for the object
parameter : object, string: objval_name, AQL_symbol: objectvalue
result    : -

"set_objval_in_user"
function  : Set the object value for the object that belongs to a UDO
parameter : user object, object, string: objval_name, AQL_symbol: objectvalue
result    : -

"set_optional_off"
function  : Set optional to off for the specified parameter or property
            in the AQL program and in the model file
parameter : <node>  [where]
               <node>: par or prop node
               <where>: "aql"  : only for the AQL program
                        "model": only for the model file
result    : -

"set_optional_on"
function  : Set optional to on for the specified parameter or property
            in the AQL program and in the model file
parameter : <node> <optional> [where]
               <node>: par or prop node
               <optional>: optional object, value or enumeration (string or node)
               <where>: "aql"  : only for the AQL program
                        "model": only for the model file
result    : -

"show_highlighted"
function  : Highlight an (group of) object in the drawing area
parameter : object or group of objects
result    : -

"show_normal"
function  : Draw an (group of) object in the drawing area
parameter : object or group of objects
result    : -

"show_status_percent"
function  : For compatibility only !!!
parameter : ...
result    : ...

"switch_show_activity"
function  : For compatibility only !!!
parameter : ...
result    : ...

"undo_delete"
function  : Undo a delete action
parameter : object or group of objects
result    : -

"update_graphics"
function  : Force AQL to wait until the graphics system has finished
            all pending commands.
parameter : -
result    : -

"update_mode"
function  : Flush the graphic on the screen
parameter : boolean: true  = flush graphic immediately
                     false = flush graphic only if buffer is full
result    : -

"viewport_redefine_propor"
function  : Change size and position of a Bea_viewport_window.
parameter : Bea_viewport_window:vp
            real:x, real:y, real:width, real:height
            Note: x, y, width, height are proportions
result    : -
example   : // make 'vp' half as big as the working window:
            viewport_redefine_propor (vp, 0.1, 0.1, 0.5, 0.5)

"view_reset"
function  : Reset all viewports;
            for compatibility only !!!
            not allowed in batch mode
parameter : -
result    : -

"viewport_set_model"
function  : Change model of a Bea_viewport_window
parameter : Bea_viewport_type:vp
            Bea_object:model | string:model_name
result    : -

"view_translate"
function  : Pan all viewports;
            for compatibility only !!!
            not allowed in batch mode
parameter : { {integer: from_x, from_y}, {integer: to_x, to_y}}
result    : -

"view_unzoomrectangle"
function  : Zoom out on all viewports;
            for compatibility only !!!
            not allowed in batch mode
parameter : { {integer: from_x, from_y}, {integer: to_x, to_y} }
result    : -

"view_zoomrectangle"
function  : Zoom in on all viewports;
            for compatibility only !!!
            not allowed in batch mode
parameter : { {integer: from_x, from_y}, {integer: to_x, to_y} }
result    : -

"viewport_to_world"
function  : Transform viewport coordinates into (world) coordinates
            See also 'world_coord_type' for more details !
parameter : view object, { <real/integer: x> <real/integer: y> }
result    : { <real: x> <real: y> <real:z> <real: dir x> <real: dir y> <real: dir z> }
            x,y,z are the transformed coordinates; dir_x,y,z is the view direction
            (in 2D always: z=0.0, dir_x,y,z=(0,0,1) )

"work_areas_set"
function  : For internal use only 

"world_to_viewport"
function  : Transform (world) coordinates into viewport coordinates 
            See also 'world_coord_type' for more details !
parameter : view object, { <real: x> <real: y> <real:z> } 
result    : { <real: x> <real: y> }

"write_config"
function  : Rewrite the config file and save global setups
parameter : -
result    : -

"write_name"
function  : Write the program name into the text box;
            (in batch mode: in the process window)
parameter : -
result    : -

"new_aql"
function  : Create a program_area from AQL-file 
            Functions defined inside the AQL-file can be used as methods of the
            program_area.
            Data may be changed by return value of these functions or var parameters.
            The program_area should be deleted with delete_aql().
parameter : filename
result    : program_area

"make_ok_button"
function  : For internal use only !!!
parameter : ...
result    : ...

"make_cancel_button"
function  : For internal use only !!!
parameter : ...
result    : ...

"layer_is_a"
function  : For internal use only !!!
parameter : ...
result    : ...

"is_bea_model"
function  : Returns unique number (consisting of 4 integers) and node_type
            of a 'bea_model' (.mod, .udo, .uda, .udv, 
            .udt, .ext, .cfg, .agp, .ogp, .mnu, .lta ...)
parameter : filename
result    : if it is a bea_model indeed:
            { <int1>, <int2>, <int3>, <int4>, <node_type> }    
            if it is no bea_model: invalid
example   : res = is_bea_model("gear.udo")

"is_d23_model"
function  : Check, if specified file is a bea_model, which requires the 
            3d application (d23).
parameter : filename
result    : boolean
example   : needs_d23 = is_d23_model("box3D.mod")

"icon_editor"
function  : For internal use only !!!
parameter : ...
result    : ...

"icon_height_in_gui"
function  : For internal use only !!!

"icon_width_in_gui"
function  : For internal use only !!!

"id_session_table"
function  : Get currently used sessions, for experts.
parameter : -
result    : group: {  {s1,s2,s3,index,hashed,file_nr}, ... }

"is_in_area"
function  : For internal use only !!!

"highlight_icon"
function  : For internal use only !!!
parameter : ...
result    : ...

"heap_remove_data"
function  : For internal use only !!!
parameter : ...
result    : ...

"heap_put_data"
function  : For internal use only !!!
parameter : ...
result    : ...

"heap_get_data"
function  : For internal use only !!!
parameter : ...
result    : ...

"hatch_icon"
function  : For internal use only !!!
parameter : ...
result    : ...

"encrypt"
function  : For internal use only !!!
parameter : 1. string: name of file to be encrypted
            2. string: name of generated encrypted file
            3. string: keyword, should be name of company
            4. string: another keyword
result    : -

"check_license"
function  : For internal use only !!!
parameter : integer: number of licensed application
result    : boolean: true if license available

"menu_load"
function  : load a menu (list of actiongroups) and append it in the menu node
parameter : node_type:menu_node
result    : node_type:list_of_ag (menu_node->down->right)

"new_object"
function  : Create a new, absolute object in the active layer
parameter : node_type:object_type
result    : Bea_object
example   : my_object = new_object (application.o_line)

"new_value"
function  : Create a new value
parameter : node_type:object_type
            value content (syntax depends on value type) (optional)
result    : Bea_value
example   : my_value = new_value (application.v_filename, "abc.txt")

"read_icon_file"
function  : For internal use only.

"remove_file_type"
function  : Tell model_load / model_save_as no longer to support a file type.
            Cf. add_file_type
parameter : string:"r" (model_load) or "w" (model_save_as)
            string:file description
result    : -
example   : remove_file_type ("r", "SigraphDesign table   (*.tab)"


"drawn_in_viewport"
function  : For internal use only !!!
parameter : ...
result    : ...

"draw_icon"
function  : For internal use only !!!
parameter : ...
result    : ...

"display_warning"
function  : Display a message in a box on the screen and waits until the user confirms
            via mouse click. The warning is marked with an exclamation mark
parameter : string (% is interpreted as a newline character)
result    : -
example   : display_warning ("Object has no color")

"display_info"
function  : For internal use only !!!
parameter : ...
result    : ...

"delete_aql"
function  : Delete program_area
parameter : program_area
result    : -

"call_by_group"
function  : For internal use only !!!
parameter : ...
result    : ...

"uda_load"
function  : For internal use only !!!
parameter : symbolic_name
result    : -

"udo_load"
function  : For internal use only !!!
parameter : symbolic_name
result    : -

"udo_is_a"
function  : For internal use only !!!
parameter : ...
result    : ...

"insensitive_cursor"
function  : Standard cursor routine for uda_pars with cursor attribute
parameter : (real x, real y) ... current cursor position
result    : -

"crosshair_cursor"
function  : Standard cursor routine for uda_pars with cursor attribute
parameter : (real x, real y) ... current cursor position
result    : -

"horizontal_cursor"
function  : Standard cursor routine for uda_pars with cursor attribute
parameter : (real x, real y) ... current cursor position
result    : -

"vertical_cursor"
function  : Standard cursor routine for uda_pars with cursor attribute
parameter : (real x, real y) ... current cursor position
result    : -

"point_cursor"
function  : Standard cursor routine for uda_pars with cursor attribute
parameter : (real x, real y) ... current cursor position
result    : -

"lu_corner_cursor"
function  : Standard cursor routine for uda_pars with cursor attribute
parameter : (real x, real y) ... current cursor position
result    : -

"rb_corner_cursor"
function  : Standard cursor routine for uda_pars with cursor attribute
parameter : (real x, real y) ... current cursor position
result    : -

"drag_line_cursor"
function  : Standard drag routine for uda_pars with cursor attribute
parameter : (real x, real y) ... current cursor position
result    : -

"drag_rect_cursor"
function  : Standard drag routine for uda_pars with cursor attribute
parameter : (real x, real y) ... current cursor position
result    : -

"drag_prop_rect_cursor"
function  : Standard drag routine for uda_pars with cursor attribute
parameter : (real x, real y) ... current cursor position
result    : -

"traverse_values_function"
function  : For internal use only !!!
parameter : ...
result    : ...

"translate_message"
function  : For internal use only !!!
parameter : ...
result    : ...

"short_messages"
function  : Switch on/off the automatic AQL-error output 
                ( +++ xxx.aql --- line y : ....)
parameter : boolean (on/off)
result    : boolean ... state before call of this function

"remove_action"
function  : For internal use only !!!
parameter : ...
result    : ...

################################################################################
<type attributes>
"aql_form"
.  "cancel"
               "widget"
               "Command button corresponding to cancel button"
.  "combined"
               "boolean"
               "'true' if form is actually combined"
.  "dialog"
               "Form"
               "The dialog window"
.  "ok"
               "widget"
               "Command button corresponding to ok button"
.  "par_or_prop_node"
               "node_type"
               "The node associated with the form"
.  "resizable"
               "boolean"
               "'true' if form is resizable;"
               "read/write attribute."
               "Makes only sense for non combinable forms"
.  "value"
               "value"
               "read/write attribute"
               "read  : value"
               "write : see syntax for value"
"Basic_act_grp_rec"
.  "is_edit"
               "boolean"
               "'true' when action group is just about to be edited;"
               "for internal use only !!!"
.  "act_grp"
               "node_type"
               "Action group node;"
               "for internal use only !!!"
.  "menu"
               "node_type"
               "Menu of the action group;"
               "for internal use only !!!"
.  "previous"
               "node_type"
               "Previous action group node;"
               "for internal use only !!!"
"Basic_attrib_value"
.  "obj"
               "Bea_object"
               "The object with which the attribute is associated"
"Basic_boolean"
.  "data"
               "boolean"
               "The boolean"
.  "no_checkbox"
               "boolean"
               "Don't create checkbox"
.  "text"
               "string"
               "Additional text"

"Basic_color"
.  "name"
               "string"
               "The name of the color"
.  "blue"
               "integer"
               "The blue intensity ( 0 .. 255)"
.  "red"
               "integer"
               "The red intensity ( 0 .. 255)"
.  "green"
               "integer"
               "The green intensity ( 0 .. 255)"
.  "vp_backgrounds"
               "group"
               "Background colors of all viewports"
               "{ {red, green, blue}"
               "  ..."
               "}"
               "red, green, blue : integer 0..255"

"Basic_comment"
.  "data"
               "string"
               "Form to input a file history;"
               "you may use a tiny editor in AQL: "
               "xx = read_value (application.v_comment)"

"Basic_dreal"
.  "data"
               "real"
               "The real value"

.  "norm"
               "real"
               "For compatibility only !!!"

"Basic_dynstring"
.  "data"
               "string"
               "The string"
"Basic_filename"
.  "backuponly"
               "boolean"
               "Create backup dialog only"
.  "data"
               "string"
               "The filename"
.  "dir_name"
               "string"
               "Directory name"
.  "file_desc"
               "string"
               "Currently selected file description in the combobox"
               "Example: 'DESIGN AQL program    (*.aql) '"
.  "file_ext"
               "string"
               "Filename extension"
.  "file_name"
               "string"
               "Filename"
.  "file_types"
               "group of file_description strings"
               "Example for a file description string: see attribute .file_desc"
               "File types selectable in the combo box."
.  "io_reason"
               "string"
               "r : readonly"
               "w : write"
               "a : append"
               "o : overwrite"
.  "dir_filter"
               "string"
               "Directory name filter"
.  "file_filter"
               "string"
               "Filename filter"
.  "preview"
               "boolean"
               "Preview of model file; for internal use only !!!"

.  "remove_backup"
               "for internal use only"
.  "remove_backup_button"
               "boolean"
               "Switch on or off remove_backup_button"
.  "store_backup"
               "boolean"
               "Store last version as internal backup version"
.  "store_backup_button"
               "boolean"
               "Switch on or off store_backup_button"
.  "version"
               "string"
               "version of the file"
               "Examples: '1' = first version, '' or 'LATEST' = latest version"
.  "version_button"
               "boolean"
               "Switch version-list on or off"


"Basic_formstring"

"Basic_group_rec"
.  "list"
               "group"
               "List of objects that belongs to this group"
.  "is_ok_name_allowed"
               "boolean"
               "Button 'ok+name' visible or not"
.  "initial_sel_types"
               "group"
               "Group of object nodes specifying selected object types"
.  "allowed_types"
               "group"
               "Group of object nodes specifying allowed object types"

"Basic_help_rec"

"Basic_int"
.  "data"
               "integer"
               "The integer value"

"Basic_language_rec"
.  "default_language"
               "group"
               "First group element  : nls name"
               "Second group element : plain language name"

"Basic_layer_obj_rec"

"Basic_layer_ref"
.  "data"
               "Bea_object"
               "Object of type user"

"Basic_loc_table"
.  "check_duplicates"
               "boolean"
               "For internal use only !!!"
.  "list_duplicates"
               "group of strings"
               "For internal use only !!!"
.  "nr_files"
               "integer"
               "For internal use only !!!"
.  "stop_token"
               "string"
               "For internal use only !!!"

"Basic_lockfile"

"Basic_lockinfo"
.  "col1"
               "integer"
               "For internal use only !!!"
.  "col2"
               "integer"
               "For internal use only !!!"
.  "col3"
               "integer"
               "For internal use only !!!"
.  "is_admin"
               "boolean"
               "For internal use only !!!"
.  "list_areas"
               "group of strings"
               "For internal use only !!!"
.  "list_internal"
               "group of strings"
               "For internal use only !!!"
.  "list_new"
               "group of strings"
               "For internal use only !!!"
.  "list_session"
               "group of strings"
               "For internal use only !!!"
.  "list_tmp"
               "group of strings"
               "For internal use only !!!"
.  "user_or_system"
               "boolean"
               "For internal use only !!!"

"Basic_longstring"
.  "data"
               "string"
               "The string"

"Basic_matrix_4_by_4"

"Basic_menu_rec"
.  "is_edit"
               "boolean"
               "Menu which is just about to be edited"
.  "menu"
               "node_type"
               "Node associated with the menu"
.  "previous"
               "node_type"
               "Previous menu"

"Basic_message_rec"
.  "message"
               "string"
               "Message text"
.  "ok"
               "string"
               "Text for 'ok_button'"
.  "cancel"
               "string"
               "Text for 'cancel_button'"

"Basic_model_ref"
.  "data"
               "Bea_object"
               "Bea model (object of type user)"

"Basic_name_list"
.  "name"
               "string"
               "Selected name of group 'name_group'"
.  "name_group"
               "group"
               "Group with data (e.g. string)"

"Basic_node_reference"

"Basic_obj_name_rec"

"Basic_object_reference"
.  "data"
               "Bea_object"
               "Bea object"

"Basic_objgrp_rec"
.  "is_edit"
               "boolean"
               "Object group which is just about to be edited"
.  "obj_grp"
               "node_type"
               "Node associated with the object group"
.  "previous"
               "node_type"
               "Previous object group"

"Basic_par_reference"

"Basic_prop_or_par_rec"

"Basic_real"
.  "data"
               "real"
               "The real value"

"bea_reason"

"Basic_rm_ag_rec"

"Basic_scheme_rec"
.  "default_scheme"
               "string"
               "Name of the active color scheme"

"Basic_sel_name"
.  "group"
               "group"
               "Selected objects;"
               "for internal use only !!!"
.  "model"
               "Bea_object"
               "For internal use only !!!"
.  "node_list"
               "group"
               "Group of nodes;"
               "for internal use only !!!"
.  "node_type"
               "node_type"
               "For internal use only !!!"
.  "null_null_is_all"
               "boolean"
               "For internal use only !!!"

"Basic_selection_rec"
.  "view_press"
               "Bea_object"
               "The view in which the cursor is located when the mouse"
               "button is pressed"
.  "view_release"
               "Bea_object"
               "of type view"
               "The view in which the cursor is located when the mouse"
               "button is released"
.  "x_press"
               "real"
               "x coordinate of the cursor position when the mouse"
               "button is pressed"
.  "x_release"
               "real"
               "x coordinate of the cursor position when the mouse"
               "button is released"
.  "y_press"
               "real"
               "y coordinate of the cursor position when the mouse"
               "button is pressed"
.  "y_release"
               "real"
               "y coordinate of the cursor position when the mouse"
               "button is released"

"Basic_shortstring"
.  "data"
               "string"
               "The string"

"Basic_sys_globals"

"Basic_ud_fil_tab"

"Basic_ud_frm_dta"
.  "event_ok"
               "boolean"
               "For internal use only !!!"

"Basic_uda_rec"
.  "edit"
               "boolean"
               "Is just about to be edited"
.  "interactive_effects"
               "group"
               "Group of Bea_objects representing effects;"
               "not yet implemented !!!"
               "for internal use only !!!"
.  "node"
               "node_type"
               "Corresponding node"
.  "last_par"
               "node_type"
               "For internal use only !!!"
.  "result_object"
               "Bea_object"
               "Object in master model representing the result;"
               "for internal use only !!!"
.  "with_AQL"
               "boolean"
               "UDA with AQL"

"Basic_uda_ref"

"Basic_udot_rec"
.  "edit"
               "boolean"
               "Is just about to be edited"
.  "init_uda"
               "boolean"
               "UDOT definition does automatically initialize an UDA"
               "definition;"
               "for internal use only !!!"
.  "node"
               "node_type"
               "Corresponding node"
.  "last_prop"
               "node_type"
               "For internal use only !!!"
.  "list_vis"
               "group"
               "Group of Bea_objects of type group;"
               "for internal use only !!!"
.  "subclass_of"
               "node_type"
               "The node of the subclass"

"Basic_udot_ref"
.  "programmed_too"
               "boolean"
               "Programmed UDOTs too;"
               "for internal use only !!!"

"Basic_udv_def"
.  "node"
               "node_type"
               "Corresponding node"

"Basic_udv_rec"
.  "*"
               "all types"
               "Value of attribute with name corresponding to *"
               " "
               "UDV is a new defined value (record) with components"
               "of existing values:                                "
               "  { { <string:name of component>,                  "
               "      <node_type:type of component>,               "
               "      <content of value 'name' as actual value> }  "
               "    { .... }                                       "
               "    ...                                            "
               "..}                                                "
               " "
               "example:                                              "
               "  my_value =                                          "
               "  { { 'options',    application.v_dynstring, 'hugo' },"
               "    { 'output_dir', application.v_boolean,   true   },"
               "    { 'sort_dir',   application.v_boolean,   true   },"
               "    { 'sum',        application.v_boolean,   true   },"
               "    { 'lines',      application.v_int,       10     } "
               "  } "

"Basic_univ_ptr"

"Basic_user_rec"
.  "el_*"
               "Bea_object"
               "Object with identification numer corresponding to *"
.  "is_a_list"
               "group"
               "Group of node_types."
               "List of all classes from which the object inherits"

"Basic_value_data"

"Basic_view_rec"
.  "active"
               "boolean"
               "'true' when the viewport is active"
.  "add_data"
               "value"
               "Viewport type specific information"
.  "dir"
               "world_coord_type"
               "Direction coordinates of the viewport"
.  "layer_spec"
               "group"
               "Group of groups"
               "  of boolean (selectable), boolean (visible) and "
               "     Bea_object (layer)"
.  "left_bottom"
               "world_coord_type"
               "Left bottom coordinates of the viewport"
.  "left_top"
               "world_coord_type"
               "Left top coordinates of the viewport"
.  "model"
               "Bea_object"
               "The model"
.  "right_bottom"
               "world_coord_type"
               "Right bottom coordinates of the viewport"
.  "vis_meth_spec"
               "group"
               "Group of groups"
               "  of node (object type) and node (visualisation method)"
.  "vp_type"
               "node_type"
               "Viewport type"
.  "zoom_factor"
               "real"
               "Zooming factor in this viewport"

"Basic_vis_meth_rec"

"Basic_vptype_rec"
.  "default_vp"
               "node_type"
               "Viewport type of currently opened viewports"

"Basic_waste_rec"
.  "clean_name"
               "string"
               "For internal use only !!!"
.  "list_internal"
               "group of strings"
               "For internal use only !!!"
.  "put_name"
               "string"
               "For internal use only !!!"
.  "restore_name"
               "string"
               "For internal use only !!!"
.  "waste_dir"
               "string"
               "For internal use only !!!"

"Bea_action"
.  "allpars"
               "group"
               "Group of object, value and enum parameters."
               "Sequence and star parameters are returned as subgroups."
               "See also: Bea_action.par_*"
.  "first_exec"
               "boolean"
               "For AQL programs associated with an UDA."
               "'true' when the action is executed for the first time"
.  "evaluated"
               "boolean"
               "'true' if the action was evaluated"
.  "valid"
               "boolean"
               "'true' if that action can be calculated"
               "('evaluated' must also be true)"
.  "has_changed_*"
               "boolean"
               "For AQL programs associated with an UDA."
               "'true' when the parameter <*> has been changed since"
               "the previous evaluation of this UDA"
.  "inherited"
               "boolean"
               "'true' if the action is inherited from user master"
               "model"
.  "is_set_*"
               "boolean"
               "For AQL programs associated with an UDA."
               "'true' when the parameter <*> has been set since the"
               "previous evaluation of this UDA"
.  "layer"
               "Bea_object"
               "The layer to which this action belongs"
.  "list_all_effects"
               "group"
               "Group of Bea_objects."
               "List of all (also hidden) effect objects of the action"
.  "list_effects"
               "group"
               "Group of Bea_objects."
               "List of effect objects of the action"
.  "list_parameter"
               "group"
               "Group of parameter objects."
               "The parameter list of the action"
.  "par_*"
               "any"
               "Value of the parameter <*>, depending on the type:"
               "   for object parameters: Bea_object"
               "   for enum parameters  : string"
               "   for value parameters : Bea_value"
               "   for list parameters (star, sequence):"
               "   group (or invalid, if the list is empty)"
.  "result"
               "Bea_object"
               "The result object of the action."
               "'invalid' is returned for void actions"
.  "type"
               "node_type"
               "The node representing the type of the action"
.  "under_evaluation"
               "boolean"
               "'true' if the action is just evaluated"

"Bea_object"
.  "absolute"
               "boolean"
               "This object is absolute (no created_by action)"
.  "active_layer"
               "Bea_object"
               "Only for Bea_objects, which are models."
               "The layer in the model, which is or was (as long"
               "as the model was active) the active layer of"
               "the session."
.  "actual_type"
               "node_type"
               "The node that describes the actual type of an object."
               "To query the base type of an object use '.type'."
.  "allpars"
               "group"
               "for compatibility only !!!"
               "(group of common_type, subgroups and values)"
               "See also: Bea_action.par_*"
.  "attrib_*"
               "any"
               "The value for the attribute with name <*> as"
               "expression."
               "For user attributes which are not referenced to"
               "attributes of other objects: the same as 'exp_user_*'"
.  "attribs_user"
               "group"
               "List of user definied attributes"
.  "attribs_ref_user"
               "group"
               "List of user definied attributes that are references to"
               "attributes of other objects"
.  "attribs_symbol"
               "group"
               "List of internal attributes"
.  "bea_value"
               "Bea_value"
               "The Bea_value of the object"

.  "color"
               "color_type"
               "Values between 0 and 63"

.  "corresponding_master_obj"
               "Find the corresponding Bea_object in the udo-/uda-master."
               "Only valid for objects in user-instances."

.  "created_by"
               "Bea_action"
               "The action that has created this object"
.  "def_type"
               "string"
               "For compatibility only !!!"
.  "defnode"
               "node_type"
               "For compatibility only !!!"
.  "del_by_close_def"
               " "
               "For internal use only !!!"
.  "deleted"
               "boolean"
               "'true' if deleted"
.  "evaluated"
               "boolean"
               "'true' if the object was brought into its latest state"
.  "exp_user_*"
               "string"
               "The value for the user defined attribute with name <*>"
               "returned as expression of the internal format:"
               "- If the attribute is a reference to an attribute of"
               "  another object it returns the name of that other"
               "  attribute."
               "- If the attribute is defined as expression it returns"
               "  the expression itself."
               "- If the attribute is defined as a constant it returns"
               "  that constant converted to a string."
               "This attribute returns the same information as"
               "'attrib_*' except for referenced user attributes."
.  "extended"
               "boolean"
               "'true' if user is extended by open instance."
               "Only valid for instances of type user"
.  "filename"
               "string"
               "The pathname where the model/UDx/external layer/... was"
               "read or saved last time."
               "Only valid for instances of type 'user' which have the"
               "attribute 'external'"
.  "first_eval_on"
               "boolean"
               "Very first evaluation of the object is running."
.  "has_changed_*"
               "boolean"
               "For AQL programs associated with an UDA."
               "'true' when the property or parameter '*' has been"
               "changed since the previous evaluation of this UDA"

.  "is_temporary"
               "boolean"
               "'true' if the object is a temporary object."
               "Temporary objects exist only for a short time and"
               "are used for sketching and similar purposes."

.  "is_programmed"
               "boolean"
               "'true' if the object is a programmed object."
               "Programmed objects are not created by the user,"
               "but by the system."

.  "is_application_programmed"
               "boolean"
               "'true' if the object is an application programmed."
               "Application programmed objects are created by the"
               "system for initializing new models."

.  "is_result"
               "boolean"
               "'true' if the object is a result object."
               "A result object is created by an action,"
               "and is the result of this action."

.  "is_effect"
               "boolean"
               "'true' if the object is an effect object."
               "An effect object is created by an action,"
               "but is not the result of this action."

.  "hidden"
               "boolean"
               "'true' if the object is a hidden effect"
.  "id_value"
               "group"
               "For internal use only !!!"
               "  { <action>, <semantic_number>, <number object"
               "    references>, { <object-1>, <object-2>, ... } }"
               "If no references exist the last element is an empty"
               "group"
.  "inherited"
               "boolean"
               "'true' if the object is inherited from UDx master model"
.  "just_loaded"
               "boolean"
               "First time evaluated after loading"
.  "invisible"
               "boolean"
               "This object is valid, not deleted, not hidden, but "
               "invisible. In the moment implemented for users or "
               "layers in users only."
.  "is_layer"
               "boolean"
               "This object is a layer (only useful for user/layer)"
.  "is_par_of"
               "group"
               "{ Bea_action, ...}"
               "The actions that use this object as parameter"
.  "is_prop_of"
               "group"
               "{ Bea_object, ...}"
               "The objects that use this object as property"
.  "is_attrib_of"
               "group"
               "{ Bea_object, ...}"
               "The objects that use this object for referenced user"
               "attributes"
.  "layer"
               "Bea_object"
               "The layer to which this object belongs"
.  "list_parameter"
               "group"
               "Parameters of the object"
.  "list_parnode"
               "group"
               "The parameters (group of node_type)"
.  "list_property"
               "group"
               "Properties of the object"
.  "manip_by"
               "group"
               "Group of Bea_actions."
               "The action which manipulated this object"
.  "master_node"
               "node_type"
               "Node of UDO definition"
.  "name"
               "string/invalid"
               "The name"
.  "number"
               "string"
               "The unique number in hex format"
.  "object_only"
               "boolean"
               "For internal user only !!!"
.  "open_userinstance"
               "boolean"
               "'true' if a layer is created as a UDO 'converted to"
               "layer'."
               "Only valid for instances of type user"
.  "par_*"
               "any"
               "The parameter with name <*>."
               "See also: Bea_action.par_*"
.  "pick_pos"
               "group"
               "Coordinates where the object was picked  "
               "{ <real:x>,<real:y>,<real:z>,            "
               "  <real:dir_x>,<real:dir_y>,<real:dir_z>,"
               "  <real:vpx><real:vpy>,  "
               "  <Bea_object:view_object> }       
               "     x,y,z are the picked coordinates   "
               "     dir_x,y,z is the view direction    "
               "     (in 2D always: z=0.0, dir_x,y,z=(0,0,1) )"
               "     vpx,vpy are the viewport coordinates"
               "     view_object is the picked view"
               "  only valid"
               "    after the AQL function pick() was called"
               "    for an object parameter of an UDA with AQL"
               "    for an object that was selected in a '$' parameter"
               "        of an action"
.  "pick_through"
               "boolean"
               "'true' if internal objects can be picked."
               "Only valid for instances of type user"
.  "read_only"
               "boolean"
               "'true' if internal objects are read only."
               "Only valid for instances of type user"
.  "prim_type"
               "string"
               "For compatibility only !!!"
.  "primnode"
               "node_type"
               "For compatibility only !!!"
.  "ref_symbol_*"
               "Bea_object"
               "The value for the user definied attribute with name <*>"
               "which is a reference to another objects attribute"
.  "ref_user_*"
               "Bea_object"
               "The value for the user definied attribute with name <*>"
               "which is a reference to another objects attribute"
.  "required_udx_nodes"
               "group"
               "{ node_type, ... }"
               "List of user defined nodes needed for this object"
.  "session_number"
               "integer"
               "Object identification number."
               "Only valid within a session."
               "For a long term identification use "
               "'session_value' and 'session_offset' "
.  "session_offset"
               "integer"
               "Identification within the session"
.  "session_value"
               "group"
               "{ <integer> <integer> <integer> }"
               "Session identification"

.  "skip"
               "boolean, read/write access"
               "Set an object 'skip': "
               "will be ignored in evaluation history."

.  "sons"
               "group"
               "List of all directly dependent objects"
.  "allsons"
               "group"
               "List of all recursively dependent objects"
.  "suppressed"
               "boolean, read/write access"
               "object belongs to a suppressed (rolled back)"
               "part of a branch and hence will not be evaluated."

.  "symbol_*"
               "any"
               "The value for the internal attribute with name <*>"
.  "symbolic_name"
               "symbolic_name"
               "The symbolic name of the model or the extern user"

.  "tooltip"
               "string, read/write access"
               "Get or set the tooltip of a Bea_object."
               "Example: my_circle.tooltip = 'Circle for special purposes'"

.  "type"
               "node_type"
               "The node that describes the BASE type of an object."
               "To query the actual type use 'actual_type'"
.  "user"
               "Bea_object"
               "common_type, layer_user_type, user_type "
               "The user (model) object to which this object belongs"
.  "user_*"
               "any"
               "The value for the user definied attribute with name <*>"
.  "valid"
               "boolean"
               "'true' if that object can be calculated"
               " ('evaluated' must also be true)"
.  "value"
               "any"
               "The contents of the value of this object."
               "The format is the same used for the input of a value"
               "(see DEFINED values)"

"Bea_value"
.  "value_type"
               "node_type"
               "The node that describes the actual type of a value"
.  "alldata"
               "any"
               "Depends on the value_type."
               "The format is the same used for the input of a value"
               "(see DEFINED values)"

"Bea_viewport_window"
.  "corresponding_view"
               "Bea_object"
               "Reference to the corresponding view object in in bearun"
               "data base"
.  "cursor_gc"
               "GC"
               "X Graphical Context for cursor routines in AQL"
.  "display"
               "Display"
               "X-Display for graphical routines in AQL"
.  "model"
               "Bea_object"
               "get model which is displayed in this viewport"
.  "type"
               "node_type"
               "get type of this viewport"
.  "number"
               "integer"
               "number, which can be seen in the title bar of"
               "the viewport"
.  "number_in_stack"
               "integer"
               "get position of this viewport in the stack"
               "'1' = lowest viewport (hidden by all others)"
.  "minimized"
               "boolean"
               "Read : check, if the viewport is minimized"
               "Write: minimize (true) or restore (false) the viewport"
               "Example: my_viewport.minimized = true"
.  "maximized"
               "boolean"
               "Read : check, if the viewport is maximized"
               "Write: maximize (true) or restore (false) the viewport"
               "Example: my_viewport.maximized = true"
.  "restored"
               "boolean"
               "Read : check, if the viewport is not minimized and"
               "       not maximized"
               "Write: restore the viewport"
               "Example: my_viewport.restored = true"
.  "gc"
               "GC"
               "X Graphical Context for graphical routines in AQL"
.  "window"
               "Window"
               "X-Window for graphical routines in AQL"
.  "bgcolor"
               "group"
               "Background color of viewport window (rgb-value)"

"action node"

"appl_type"
.  "list_*"
               "group"
               "For compatibility only !!!"
               "<*> = prim  : List of all objects (group of node_type)"
               "<*> = ttype : List of all values (group of node_type)"
               "<*> = enum  : List of all enums (group of node_type)"
               "<*> = com   : List of all actiongroups in the temporary"
               "              menus (group of node_type)"

.  "list_ados"
               "group"
               "For future use; not yet implemented"
               "   list of all ADOs (AQL defined objects)"
.  "list_appl"
               "group"
               "List of all applications (group of node_type)"
.  "list_parttype"
               "group"
               "List of all values used as parameter"
               "  (group of node_type)"

"application"
.  "name"
               "string"
               "Name of the application"
.  "version"
               "string"
               "Version of the application"

"aql_meta_object_type"
.  "attributes"
               "group"
               "List of all attributes (group of strings)"
.  "name"
               "string"
               "Name of the 'aql_object_type'"
.  "base_class_list"
               "group"
               "Group of 'aql_object_type' representing the base"
               "classes"
.  "methods"
               "group"
               "Group of 'aql_meta_method_type' representing the"
               "methods"

"aql_meta_method_type"
.  "name"
               "string"
               "Name of the method"
.  "pars"
               "group"
               "Parameter types of the method"
               "(strings or 'aql_object_types')"
.  "result"
               "str / obj"
               "String or object type representing the result type"

"aql_program"
.  "*"
               "any"
               "Not yet released !"

"container_value"
.  "list_*"
               "group"
               "Group of Bea_objects"
               " "
               "<*> = <name of an object> :"
               "    List of objects of that type in the UDO or layer"
               "<*> = <name of an action> : "
               "    List of actions of that type in the UDO or layer"
               "<*> = 'all' : "
               "    List of all objects in the UDO or layer"
               "<*> = 'actions' : "
               "    List of all actions in the UDO or layer"
               "<*> = 'out' : "
               "    The same as 'all' but in dependency order"
               "<*> = 'layer' : "
               "    List of all layers in the UDO or layer"
               "<*> = 'basket' : "
               "    List of all objects in the UDO or layer"
               "    but not in sub-layers (or in UDO instances)"
               "<*> = 'recursive' : "
               "    List of all objects in the UDO or layer and"
               "    in all sub-layers and in all UDO instances"
.  "obj_*"
               "Bea_object"
               "The object with name <*> in the UDO or layer."
               "'invalid' is returned if no object with that name"
               "exists. If more objects with that name exist the"
               "behaviour is undefined"

"Display"
.  "name"
               "string"
               "name of a Display, e.g. 'pc27:0.0' "
"def_type"
.  "par_*"
               "node_type"
               "The node for the parameter <*>"

"enum_type"
.  "asciiicon_*"
               "group"
               "The icon for the value <*>"
               "Syntax: see parameter 'Data' of function FormBitmap()"
.  "hexicon_*"
               "group"
               "The icon in hex for the value <*>"
               "(group of strings)"
.  "icon_*"
               "group"
               "The icon in hex for the value <*>"
               "(group of strings)"
.  "inverseicon_*"
               "group"
               "The inverted icon in hex for the value <*>"
               "(group of strings)"
.  "monochromeicon_*"
               "group"
               "The monochrome icon in ascii for the value <*>"
               "(group of strings)"
.  "values"
               "group"
               "List of possible values (group of strings)"

"errmes record"
.  "file"
               "string"
               "Name of the AQL-file in which the error occurred"
.  "line"
               "integer"
               "Line number in the AQL-file where the error occurred"
.  "text"
               "string"
               "Text of the error message"
.  "code"
               "integer"
               "The identification number of the error message"

"event node"

"file_descriptor"

"GC"

"group_value"
.  "list"
               "group"
               "List of objects in the group"

"IconEditor"
.  "copy_paste_box"
               "group"
               "read / write access"
               "{ integer:x, integer y }"
               "box for copy-paste operations"
.  "foreground"
               "integer"
               "read / write access"
               "current drawing color (first index = 0)"
               "index into the palette of the user interface"

.  "palette"
               "group"
               "read / write access"
               "{ {r,g,b}, {r,g,b}, {r,g,b},... } "
               "current palette for drawing in the icon editor"

.  "preview_size"
               "group"
               "read / write access"
               "{ width, height } "
               "size of the little icon in the icon editor"

.  "text_angle"
               "real"
               "read / write access"
               "current angle (degrees) for texts in the icon editor"

"layer_type"
.  "layername"
               "string"
               "The name of the layer"
.  "locked"
               "boolean"
               "'true' if locked"
.  "external"
               "boolean"
               "'true' if external"
.  "loaded"
               "boolean"
               "'true' if loaded"
.  "status"
               "string"
               "'active', 'selectable', 'inactive' or 'visible'"

"node_type"
.  "a_*"
               "node_type"
               "The action with name <*>."
               "Only valid for nodes of type 'application'"
.  "ag_*"
               "node_type"
               "The actiongroup with name <*>;"
               "Only valid for nodes of type 'application'"
.  "applic_name"
               "string"
               "Name of the application to which this node belongs"
.  "aql_par"
               "boolean"
               "Only valid for parameter nodes of UDAs"
               "'true' if it is a parameter which has no equivalent"
               "in the master model."
               "This means the parameter is only used by AQL"
.  "asciiicon"
               "group"
               "Syntax: see parameter 'Data' of function FormBitmap()"
               "The icon of the node"
.  "att_*"
               "boolean"
               "The value for the attribute <*>"
               "(see also 'DEFINED SYSTEM ATTRIBUTES' below)"
.  "base_object_of_subclass"
               "node_type"
               "The node of the subclass."
               "Only valid for nodes of type 'object'"
.  "bitmap"
               "integer"
               "The offset in the bitmap for the icon;"
               "for compatibility only !!!"
.  "content"
               "string"
               "The name;"
               "for compatibility only !!!"
.  "down"
               "node_type"
               "The first subelement."
               "NO compatibility guaranteed !!!"
.  "ef_*"
               "node_type"
               "The enumeration field with name <*>."
               "Only valid for nodes of type 'application'"
.  "en_*"
               "node_type"
               "The enumeration type with name <*>."
               "Only valid for nodes of type 'application'"
.  "ev_*"
               "node_type"
               "The event with name <*>."
               "Only valid for nodes of type 'application'"
.  "file"
               "string"
               "Filename - only if not internal"
.  "form_x_pos"
               "integer"
               "Position of associated form (value nodes only)"
.  "form_y_pos"
               "integer"
               "Position of associated form (value nodes only)"
.  "frame_user_help"
               "group"
               "{ <documentname>, <tagname> }"
               "for internal use only !!!"
.  "hatchicon"
               "group"
               "Group of strings."
               "The hatched icon in hex format"
.  "hexicon"
               "group"
               "The icon in hex for the node"
               "(group of strings)"
.  "icon"
               "Group"
               "Group of strings."
               "The icon in hex format"
.  "internal"
               "boolean"
               "UDx is stored internally in model file"
.  "inverseicon"
               "group"
               "group of strings"
               "The inverted icon in hex format"
.  "is_subclass_of_of_object"
               "node_type"
               "The node."
               "Only valid for nodes of type 'object'"
.  "list_actiongroups"
               "group"
               "Group of node_type."
               "List of loaded actiongroups."
               "Only valid for nodes of type 'application'"
.  "list_actions"
               "group"
               "Group of node_type."
               "List of loaded actions."
               "Only valid for nodes of type 'application'"
.  "list_appl"
               "group"
               "List of all applications (group of node_type)"
.  "list_aql_attributes"
               "group"
               "Group of node_type."
               "List of the predefined AQL attributes."
               "Only valid for nodes of type 'value'"
.  "list_attributes"
               "group"
               "Group of strings representing BEATOOL attribute names"
.  "list_entries"
               "group"
               "Group of node_type."
               "List of subnodes of a popup menu."
               "Only valid for nodes of type 'popup_menu'"
.  "list_enum_fields"
               "group"
               "Group of node_type."
               "List of possible alternatives for enumeration type."
               "See also 'values'."
               "Only valid for nodes of type 'enum'"
.  "list_enums"
               "group"
               "Group of node_type."
               "List of enumeration types in the loaded applications."
               "Only valid for nodes of type 'application'"
.  "list_events"
               "group"
               "Group of node_type."
               "List of events."
               "Only valid for nodes of type 'application'"
.  "list_fields"
               "group"
               "Group of node_type."
               "Only valid for nodes of type UDV"
.  "list_has_subclasses"
               "group"
               "Group of node_type."
               "List of subclass nodes."
               "Only valid for nodes of type 'object'"
.  "list_menus"
               "group"
               "Group of node_type."
               "List of loaded menus."
               "Only valid for nodes of type 'application'"
.  "list_objectgroups"
               "group"
               "group of node_type."
               "List of loaded objectgroups."
               "Only valid for nodes of type 'application'"
.  "list_objects"
               "group"
               "Group of node_type."
               "List of loaded object types."
               "Only valid for nodes of type 'application'"
.  "list_objvals"
               "group"
               "Group of node_type."
               "List of objval nodes."
               "Only valid for nodes of type 'object'"
.  "list_par"
               "group"
               "Group of node_type."
               "List of parameter and property nodes for the action."
               "Only valid for nodes of type 'action'"
.  "list_pars"
               "group"
               "Group of node_type."
               "List of first level parameter nodes for the action."
               "Only valid for nodes of type 'action'"
.  "list_popup_menus"
               "group"
               "Group of node_type."
               "List of popup menus."
               "Only valid for nodes of type 'application'"
.  "list_properties"
               "group"
               "Group of node_type."
               "List of property nodes."
               "Only valid for nodes of type 'object'"
.  "list_rec_actions"
               "group"
               "Group of node_type."
               "List of action nodes with the specified object type as"
               "result type."
               "Only valid for nodes of type 'object'"
.  "list_ref_actiongroups"
               "group"
               "Group of node_type."
               "List of action groups stored in the menu."
               "Only valid for nodes of type 'menu'"
.  "list_ref_actions"
               "group"
               "Group of node_type."
               "List of actions (objects) stored in the group."
               "Only valid for nodes of type 'action_group'"
.  "list_ref_objects"
               "group"
               "Group of node_type."
               "List of object nodes stored in the group."
               "Only valid for nodes of type 'object_group'"
.  "list_ref_viewporttypes"
               "group"
               "Group of node_type."
               "List of viewports corresponding to a visualisation"
               "method."
               "Only valid for nodes of type 'vis_method'"
.  "list_values"
               "group"
               "Group of node_type."
               "List of values in the loaded applications."
               "Only valid for nodes of type 'application'"
.  "list_viewporttypes"
               "group"
               "Group of node_type."
               "List of viewport types."
               "Only valid for nodes of type 'application'"
.  "list_visualisation_methods"
               "group"
               "Group of node_type."
               "List of visualisation method nodes."
               "Only valid for nodes of type 'object'"
.  "m_*"
               "node_type"
               "The menu with name <*>."
               "Only valid for nodes of type 'application'"
.  "master"
               "Bea_object"
               "Master model of UDO / UDA"
.  "monochromeicon"
               "group"
               "The monochrome icon for the node"
               "(group of strings)"
.  "name"
               "string"
               "The name of the node"
.  "next"
               "node_type"
               "The next element in the list."
               "NO compatibility guaranteed !!!"
.  "node_*"
               "node_type"
               "The subnode with name <*>"
.  "number"
               "integer"
               "The unique number (in the application)."
               "This number is not constant for user defined nodes."
               "For compatibility and application defined nodes only"
.  "expanded_number"
               "group"
               "{ <integer: session1>, <integer: session2>,   "
               "  <integer: session3>, <integer: offset>    } "
               "Only for experts who will create user defined UDx"
               "  ('admin')."
               "Not for application defined nodes"
.  "o_*"
               "node_type"
               "The objecttype with name <*>."
               "Only valid for nodes of type 'application'"
.  "obj_in_master"
               "Bea_object"
               "Corresponding object in master model."
               "For internal use only !!!"
.  "og_*"
               "node_type"
               "The objectgroup with name <*>."
               "Only valid for nodes of type 'application'"
.  "p_*"
               "node_type"
               "The node of the parameter/property with name <*>."
               "Only valid for nodes of type 'action'/'object'"
.  "pm_*"
               "node_type"
               "The popup menu with name <*>."
               "Only valid for nodes of type 'application'"
.  "prompt"
               "node_type"
               "The prompt string of parameter and property nodes."
               "Only valid for nodes of type 'parameter' and 'property'"
.  "ref_additional_value_of_viewporttype"
               "node_type"
               "The node of the additional value of the viewport type."
               "Only valid for nodes of type 'viewporttype'"
.  "ref_popup_of_viewporttype"
               "node_type"
               "The popup associated with the viewport type."
               "Only valid for nodes of type 'viewporttype'"
.  "ref_result_of_action"
               "node_type"
               "The node for the action result type."
               "Only valid for nodes of type 'action'."
               "'invalid' for void actions"
.  "ref_to"
               "node_type"
               "Relation between nodes."
               "NO compatibility guaranteed !!!"
.  "ref_value_of_event"
               "node_type"
               "The value node associated with the event."
               "Only valid for nodes of type 'event'"
.  "ref_value_of_objval"
               "node_type"
               "The node of the value that represents the objval."
               "Only valid for nodes of type 'objval'"
.  "related_AQL_file"
               "string"
               "For future use; not yet implemented"
               "Related AQL-file of ADO (AQL defined object)"
.  "representation_of_enum"
               "node_type"
               "type='value'"
               "Value type associated with the enumeration type."
               "'invalid' in case of no association."
               "Only valid for nodes of type 'enum'"
.  "required_udx_nodes"
               "group"
               "Group of nodes of all user defined objects, actions,"
               "values ..."
               "Needed for this UDx node"
.  "right"
               "node_type"
               "The next element in the list."
               "NO compatibility guaranteed !!!"
.  "udx_rec"
               "Bea_value"
               "Only for UDx definitions"
               "  UDOT: Basic_udot_rec"
               "  UDA : Basic_uda_rec"
               "  UDV : Basic_udv_rec"
.  "sub"
               "node_type"
               "The first subelement;"
               "NO compatibility guaranteed !!!"
.  "symbolic_name"
               "symbolic_name"
               "The symbolic name of the extern UDx"
.  "type"
               "string"
               "Type of the node, one of:"
               ""application", "object", "enum", "action", "menu","
               ""actiongroup", "objectgroup", "viewporttype", "event","
               ""popup_menu", "objval", "vis_method", "enum_field","
               ""par", "sequence", "star", "alt", "any", "value","
               ""ref_value", "ref_enum", "ref_object", "ref_action","
               ""ref_actiongroup", "ref_popupmenu", "ref_event","
               ""ref_viewporttypes", "user_action","
               "... (undocumented types) "
.  "user_defined"
               "boolean"
               "This action/object/value is user defined"
.  "v_*"
               "node_type"
               "The value with name <*>."
               "Only valid for nodes of type 'application'"
.  "value_symbol"
               "meta_object_type"
               "The meta_object_type that corresponds with this objval."
               "Only valid for nodes of type 'objval'"
.  "values"
               "group"
               "Group of strings."
               "List of possible alternatives for enumeration type"
               "in string format."
               "Only valid for nodes of type 'enum'"
.  "vm_*"
               "node_type"
               "The node of the visualisation method with name <*>."
               "Only valid for nodes of type 'object'"
.  "vp_*"
               "node_type"
               "The viewporttype with name <*>."
               "Only valid for nodes of type 'application'"

"object node"

"parameter"
.  "has_changed"
               "boolean"
               "For AQL programs associated with an UDA only."
               "'true' when this parameter has been changed since the"
               "previous evaluation of this UDA"
.  "is_set"
               "boolean"
               "For AQL programs associated with an UDA only."
               "'true' when this parameter has been set since the"
               "previous evaluation of this UDA"
.  "kind"
               "string"
               "Decribes the type of parameter,"
               "e.g. 'objectparameter of type <typename>',"
               "     'valueparameter of type <typename>',"
               "     'starparameter', ..."
.  "type"
               "node_type"
               "The node associated with this parameter"
.  "value"
               "any"
               "Value of this parameter depending on the type:"
               "   for object parameters: Bea_object"
               "   for enum parameters  : string"
               "   for value parameters : the values AQL representation"

"pcl action identifier"

"pcl object identifier"

"program"
.  "action_group_node"
               "node_type"
               "Node of the active action group."
               "For internal use only: NO compatibility guaranteed !!!"
.  "action_node"
               "node_type"
               "Node of the active action."
               "For internal use only: NO compatibility guaranteed !!!"
.  "active_action"
               "Bea_action"
               "The action that is just about to be prepared by the"
               "dialog manager."
               "for internal use only: NO compatibility guaranteed !!!"
.  "active_object"
               "Bea_object"
               "The object that is just about to be prepared by the"
               "dialog manager."
               "For internal use only: NO compatibility guaranteed !!!"
.  "active_objval"
               "value"
               "The object value that is just about to be handled."
               "For internal use only: NO compatibility guaranteed !!!"
.  "active_par_or_prop"
               "node_type"
               "The active parameter."
               "For internal use only: NO compatibility guaranteed !!!"

.  "active_uda_master"
               "group"
               "{Bea_object master,node_type uda_node,uda_rec val}"
               "Get info about currently edited uda master."
               "One or all of the group members may be invalid."

.  "active_udot_master"
               "group"
               "{Bea_object master,node_type udot_node,udot_rec val}"
               "Get info about currently edited udo master."
               "One or all of the group members may be invalid."

.  "admin"
               "boolean"
               "For internal use only !!! (see also 'own_risk')"
.  "args"
               "group"
               "Group of strings."
               "Each string represents a program argument"
.  "batch"
               "boolean"
               "'true' if the system runs in batch mode"
               "(start option -batch)"
.  "build_date"
               "string"
               "The program's build date"
.  "cleanup"
               "boolean"
               "'true' if the system runs in cleanup mode"
               "(start option -cleanup)"
.  "config_dir_system"
               "string"
               "Pathname of current system configuration directory"
               "Example: #/design_config"
.  "config_dir_name"
               "string"
               "Name of configuration directories (user/system)"
               "Example: design_config"
.  "config_dir_user"
               "string"
               "Pathname of user configuration directory"
               "Example: ~/design_config"
.  "color_schemes"
               "group"
               "Group of strings."
               "Each string represents a color scheme"
.  "current_selection"
               "group"
               "Group of Bea_objects."
               "The set of objects that are currently selected can be"
               "used in a 'select by attribute' expression."
               "For internal use only: NO compatibility guaranteed !!!"
.  "d23_active"
               "boolean"
               "current program is d23"
.  "debug"
               "boolean"
               "'true' if the system runs in debug mode"
               "(start option -bug)."
               "For internal use only !!!"
.  "directory"
               "string"
               "The installation directory."
               "Corresponds to the '#' directory"
.  "EDM"
               "string"
               "Identifies the running Embedded Data Manager:"
               " <empty> no EDM is active"
               " ManageR  for running with CIM-DB"
.  "error_output_file"
               "string"
               "The name of the AQL error output file"
.  "fileaql"
               "boolean"
               "'true' if an AQL file must be called around I/O of"
               "a model (start option -access)"
.  "filelog"
               "boolean"
               "'true' if the system runs in protocol mode"
               "(start option -protocol)"
.  "filenamesize"
               "integer"
               "For compatibility only !!!"
.  "give_node_number"
               "group"
               "{ <integer: session1>, <integer: session2>,   "
               "  <integer: session3>, <integer: offset>    } "
               "Only for experts who will create user defined UDx"
               "  ('admin')"
.  "glob_fun_key_defs"
               "group"
               "{ <key > , <mode>, <node_type>}, ... }"
               " key : string"
               " mode : string : ctrl, alt, ..."
               " node_type : associated action, object or event."
               " node_type may be null if the UDx has not been loaded"
.  "hard_coded_fun_keys"
               "group"
               "{ <key > , <mode>, <node_type>}, ... }"
               " key : string"
               " mode : string : ctrl, alt, ..."
               " node_type : associated action, object or event"
               " node_type may be null if the UDx has not been loaded"

.  "home"
               "string"
               "The home directory."
               "Corresponds to the '~' directory"
.  "host"
               "string"
               "The host name"
.  "icon_colors"
               "group"
               "{ foreground, background, top_shadow, bottom_shadow,"
               "  highlight, default_highlight }"
               "Group with colors of icon in RGB-value groups {R,G,B}"
               "Values for Red, Green, Blue from 0 to 255"
               "default_highlight always set also if no_highlight"
               "is set"

.  "icon_properties"
               "group"
               "Ask and set properties of icons (tool buttons) "
               "{  integer:icon_width_without_frame, "
               "   integer:icon_height_without_frame, "
               "   boolean:rounded_edges, "
               "   boolean:frameless, "
               "   boolean:no_highlight, "
               "   boolean:monochrome_only, "
               "   integer:icon_width_with_frame, "
               "   integer:icon_height_with_frame  "
               "} "

.  "input_file"
               "string"
               "The name of the current AQL input file"
.  "is_browse_mode"
               "boolean"
               "'true' when the system is in browse mode."
               "For internal use only: NO compatibility guaranteed !!!"
.  "is_hold_mode"
               "boolean"
               "'true' when system is in hold mode."
               "For internal use only: NO compatibility guaranteed !!!"
.  "is_par_prop_or_objval"
               "string"
               "The state of the active parameter ("no_node","
               ""par_node", "prop_node", "objval_node")."
               "For internal use only: NO compatibility guaranteed !!!"
.  "is_temp_mode"
               "boolean"
               "'true' when the system is in temp mode."
               "For internal use only: NO compatibility guaranteed !!!"
.  "l5n"
               "group"
               "Group of node_type."
               "The last 5 actions"
.  "language"
               "string"
               "The current language"
.  "library"
               "string"
               "The library directory."
               "Corresponds to the '+' directory"
.  "languages"
               "group"
               "Group of strings."
               "Each element represents the nls name of a language"
.  "language_strings"
               "group"
               "Group of strings."
               "Each element represents the plain name of a language"
.  "list_appl"
               "group"
               "Group of application type."
               "List of applications the program is built from"
.  "list_highlighted_objects"
               "group"
               "Group of Bea_object."
               "List of currently highlighted objects"
.  "list_viewports"
               "group"
               "Group of Bea_viewport_window."
               "List of currently visible viewports"
.  "list_viewport_stack"
               "group"
               "Sorted group of Bea_viewport_windows (lowest first)"
.  "look_and_feel"
               "string"
               "read / write access"
               "Query and set current look and feel."
               "Possible values at the moment: "
               "'win' or 'motif' or empty string (= use default)."

.  "machine"
               "string"
               "Processor name of the computer returned by the"
               "operating system command 'uname'"
.  "menu_node"
               "node_type"
               "Node of the active menu."
               "For internal use only: NO compatibility guaranteed !!!"

.  "menu_is_on_the_left"
               "boolean"
               "vertical toolbars (4-column-menu) on the left side"
.  "menu_*"
               "aql_program"
               "AQL program area representing the menu bar for"
               "application *"
.  "mode"
               "string"
               "The current mode ("create", "edit", "delete","
               ""not_active")."
               "For internal use only: NO compatibility guaranteed !!!"
.  "name"
               "string"
               "The name of the program"
.  "newfile"
               "boolean"
               "'true' during a new model initialisation"
.  "nodename"
               "string"
               "Name of the computer returned by the operating system"
               "command 'uname'"
.  "no_interaction"
               "boolean"
               "'true' if no interactivity is allowed"
               "(start option -writeback)"
.  "object_group_node"
               "node_type"
               "Node of the active object group (in edit)."
               "For internal use only: NO compatibility guaranteed !!!"
.  "object_node"
               "node_type"
               "Node of the active object."
               "For internal use only: NO compatibility guaranteed !!!"
.  "output_file"
               "string"
               "The name of the AQL output file"
.  "own_risk"
               "boolean"
               "For internal use only !!!"
               "(old style, better use 'admin')"
.  "par_prop_or_objval_node"
               "node_type"
               "Node of the active parameter, property or objval."
               "For internal use only: NO compatibility guaranteed !!!"
.  "pid"
               "integer"
               "Process ID"
.  "postread"
               "boolean"
               "'true' just after  reading a model"
.  "postwrite"
               "boolean"
               "'true' just after  writing a model"
.  "preread"
               "boolean"
               "'true' just before reading a model"
.  "prewrite"
               "boolean"
               "'true' just before writing a model"
.  "product_name"
               "string"
               "Name of the product"
.  "read_active"
               "boolean"
               "'true' during reading a model"
.  "release"
               "string"
               "Name of the operating system release returned by the"
               "operating system command 'uname'"
.  "ruler_on"
               "boolean"
               "'true' if the ruler is switched on"
.  "keypad_on"
               "boolean"
               "'true' if the keypad is visual"
.  "cursor_icon_on"
               "boolean"
               "'true' if the icons of the action and the parameter"
               "are shown together with the cursor"
.  "execcursor_on"
               "boolean"
               "'true' if the Execcursor is switched on"
.  "short_help_on"
               "boolean"
               "'true' if the Short Help is switched on"
.  "screen_position"
               "group"
               "{ <integer: x> <integer: y> }"
               "Position of the working window"
.  "screen_size"
               "group"
               "{ <integer: width> <integer: height> }"
               "Pixel size of the window"
.  "scrolled"
               "boolean"
               "read / write access"
               "Ask and set scroll behaviour of the working window"
.  "status_win_at_bottom"
               "boolean"
               "Ask if the status window is at the bottom"
               "of the working window
.  "store_geometry"
               "boolean"
               "read / write access"
               "Ask and set if geometry of application window"
               "should be restored at restart of the program."
.  "sysname"
               "string"
               "Name of the operating system returned by the operating"
               "system command 'uname'"
.  "tooltips_properties"
               "group"
               "Ask and set properties of tooltips"
               "{  boolean:tooltips_on,"
               "   integer:tooltips_start_delay_milliseconds"
               "   integer:tooltips_hold_delay_milliseconds"
               "   integer:tooltips_min_delay_milliseconds"
               "}"

.  "version"
               "group"
               "Group of strings."
               "Modules and compiler dates"
.  "version_date"
               "group"
               "Group of groups."
               "Each subgroup contains a modulename and compiler date"
.  "win32"
               "boolean"
               "Check if the current operating system is Win"
"rgb list"
.  "nr_rgb_values"
               "integer"
               "Number of entries in the list with rgb values"
               "(rgb = red green blue)"
.  "value_*"
               "group"
               "{r,g,b} (three integers <256)"
               "rgb value of entry * in the rgb list"
               "* is an integer between 0 and nr_rgb_values-1"

"standard function"

"UDV_field"
.  "name"
               "string"
               "Name of the UDV field"
.  "node"
               "node_type"
               "Node describing the type of the UDV field"

"Window"
.  "frame_h"
               "real"
               "height of the window frame"
.  "frame_w"
               "real"
               "width of the window frame"
.  "h"
               "real"
               "height of the window"
.  "w"
               "real"
               "width of the window"
.  "x"
               "real"
               "absolute x-position of the window"
.  "y"
               "real"
               "absolute y-position of the window"

"world_coord_type"
.  "x"
               "real"
               "x coordinate"
.  "y"
               "real"
               "y coordinate"
.  "z"
               "real"
               "z coordinate"


################################################################################
<type input>

"boolean"
 <boolean>

"browser_config"
 >>> USER DEFINED VALUE <<<
 { <browser_tool>, <browser_option>, <win_browser>, <browser_program path> }

   <browser_tool>         = kind of browser (dynstring)
   <browser_option>       = option how to start the browser (dynstring)
   <win_browser>          = installed browser, Windows NT only (dynstring)
   <browser_program path> = pathname of browser program (dynstring)

"color"
 <string: colorname> or <integer: color number> or
   { <integer: red> <integer: green> <integer: blue> }
   when "" is specified, standard color is used

"comment"
 Form to input a file history

"dir_name"
 <string: directory name>

"dreal"
 <real> or <integer>

"dynstring"
 <string>, no maximum length

"filename"
 a. <filename> 
 or 
 b. { <filename>, <io_reason>, [, <version>] [, <store_backup>] }

 <filename>     - string:  filename of the model
 <io_reason>    - string:  "write" or "read" or "append" or "overwrite"
 <version>      - string:  version of the model  OPTIONAL
                           examples: "1"      - load version 1, "" or
                                     "LATEST" - load last version
 <store_backup> - boolean: store last version as internal backup version  
                           OPTIONAL

 Examples: see actions model_load and model_save .

"group_rec"
 { <object1> <object2> ...}

"int"
 <integer>

"layer_ref"
 <object>

"loc_table"
 { {<string1>,<bool1>}, {<string2>,<bool2>},  ... }  | "NULL"
 string1, string2, ...    string       names of the directories 
 bool1, bool2, ...        boolean      false: non-recursive entry
                                       true: recursive entry
 If the value shall not be changed the whole loc_table may be substituted by
 "NULL" as a dummy for value input.

"lockinfo"
 for internal use only !!!

"matrix_4_by_4"
 { {<real> <real> <real> <real>: row0} {<real> <real> <real> <real>: row1}
   {<real> <real> <real> <real>: row2} {<real> <real> <real> <real>: row3} }

"message_rec"
 { } or { <string> message text,
          <string> ok_button text, <string> cancel_button text }

"model_ref"
 <object>

"name_list"
 <string>, selected name of list

"object_reference"
 <object>

"real"
 <real>
  
"selection_rec"
 { [<object: view>] <real|integer: x> <real|integer: y> 
  [[<object: view>] <real|integer: x> <real|integer: y>] }
   The first (view, x, y) specifies the PRESS position,
   The second (view, x, y) specifies the RELEASE position.

"shortstring"
 <string>, maximum 31 characters

"longstring"
 <string>, maximum 255 characters

"symbolic_name"
 for internal use only !!

"uda_rec"
 { <node_uda> <node_result> <codeset> <icon> <result>
      <parameters> <effects> <uda name> <with AQL> <docu> }
    
 <codeset>
     =  { <string>, <string>, ... }
 <icon>
     =  { "user_icon" { <int: #char/line> <int: #lines> #lines*<string>}}
     or { "std_icon" [node] }
     or { "no_icon" }
 <result>
     =  { "uda_result_obj" <object> }
     or { "uda_result_node" false <node> }
     or { "uda_result_node" true }
        "uda_result_node" only allowed when <with AQL?> true
        { "uda_result_node" true } means no result
 <parameters>
     =  { <par_node> "prop_or_par_obj" <object> <parameter_spec>}
     or { <par_node> "prop_or_par_obj_prop" <object> <node> <parameter_spec>}
     or { <par_node> "prop_or_par_act_par" <action> <node> <parameter_spec>}
     or { <par_node> "prop_or_par_node" <node> <parameter_spec>}
     or { <par_node> "prop_or_par_star" { ... } }
     or { <par_node> "prop_or_par_alt" { ... } }
 <parameter_spec>
     =  { <integer: codeset> <string: name> <icon>}
 <effects>
     = { <group object> }
 [docu] is optional
     = { <string: help document name> <string: tag name> }

 -----------------------------------------------------------------------------
 Example: bom_tomodel.uda (from D2-Application)
   
 uda_name = "bom_tomodel"
   
 node_uda  = { 1070473454, 797176186, 453710954, 145 }
 node_res  = { 1070473454, 797176186, 453710954, 146 }
 node_par1 = { 1070473454, 797176186, 453710954, 147 }
 node_par2 = { 1070473454, 797176186, 453710954, 148 }
 node_par3 = { 1070473454, 797176186, 453710954, 149 }
 node_par4 = { 1070473454, 797176186, 453710954, 150 }
 node_par5 = { 1070473454, 797176186, 453710954, 151 }
 node_par6 = { 1070473454, 797176186, 453710954, 152 }
 node_par7 = { 1070473454, 797176186, 453710954, 153 }
 node_par8 = { 1070473454, 797176186, 453710954, 154 }
 node_par8_alt   = { 1070481680, 797255230, -1788144286, 138 }
 node_par8_alt_1 = { 1070481680, 797255230, -1788144286, 139 }
 node_par8_alt_2 = { 1070481680, 797255230, -1788144286, 140 }
 node_par8_alt_3 = { 1070481680, 797255230, -1788144286, 141 }
     
 i_xxx = { "user_icon",  { 48, 48, " ..... " } }
   
 node_options = eval("application.v_bom_options")
     
 uda_define       
   ( {
       /* uda node, result node */
       node_uda, node_res,
       /* codeset, icon */
       { "void", "user", "edit_not_allowed" }, i_bom_tomodel,
       /* result */
       { "uda_result_node", true },
       /* parameters */
       { { node_par1, "prop_or_par_node", node_options          , { },
                      "options"  , i_options },
         { node_par2, "prop_or_par_node", application.v_font_rec, { },
                      "font"     , i_font    },
         { node_par3, "prop_or_par_node", application.o_angle   , { },
                      "italic"   , i_italic  },
         { node_par4, "prop_or_par_node", application.o_prop    , { },
                      "signprop" , i_mode    },
         { node_par5, "prop_or_par_node", application.o_prop    , { },
                      "frameprop", i_hframe  },
         { node_par6, "prop_or_par_node", application.o_length  , { },
                      "height"   , i_height  },
         { node_par7, "prop_or_par_node", application.o_point   , { },
                      "point"    , i_point   }
         { node_par8, "prop_or_par_star",
           {
             node_par8_alt, "prop_or_par_alt",
             {
               { node_par8_alt_1, "prop_or_par_node", application.o_symbol,
                                  { }, "bal"  , i_bal      },
               { node_par8_alt_2, "prop_or_par_node", application.o_part,
                                  { }, "part" , i_bom_part },
               { node_par8_alt_3, "prop_or_par_node", application.o_user,
                                  { }, "user" , i_user     }
    
             }, {}, "alternative", i_alt
           }, {}, "star", { "no_icon" }
         }
       }
       /* effects */
       { },
       /* uda name */
       uda_name,
       /* with AQL */
       true,
       /* documentation */
       { uda_name, "" }
     }
   )

"uda_ref"
 <node> of type action

"udot_rec"
 { <node_udot> <node_objval> <codeset> <icon> <parameters> <visualisation>
     <subclasses> <udot name> <integer: 0> <docu> }
   
   <codeset>           See uda_rec
   <icon>              See uda_rec
   <parameters>        See uda_rec
   [docu] is optional, See uda_rec
   <visualisation>
       =  { <object: Bea_group> ... }"
   <subclasses>
       =  { <node: node of object of which this UDO is subclass> ... }
 -----------------------------------------------------------------------------
 Example: Zeichnungsrahmen
   
 udot_name = "z_rahmen"
     
 node_udot   = { 1070473454, 797176186, 453710954, 201 }
 node_objval = { 1070473454, 797176186, 453710954, 202 }
 node_prop1  = { 1070473454, 797176186, 453710954, 203 }
 node_prop2  = { 1070473454, 797176186, 453710954, 204 }
 node_subcl  = { 1070473454, 797176186, 453710954, 205 }
    
 user_icon_prop_s = { "user_icon",  { 48, 48, " ..... " } }
    
 udo_define
   ( {
       /* UDOT node, object_value node */
       node_udot, node_objval,
       /* codeset */
       { "selectable", "state_change", "drawable", "special_values", "user" },
       /* icon */
       { "no_icon" }, 
       /* parameters */
       {
         { node_prop1, "prop_or_par_obj", application.o_point
           {  }, "point", { "std_icon", application.o_point }
         }
         { node_prop2, "prop_or_par_obj", application.o_string,
           {  }, "s", { "user_icon", user_icon_prop_s } 
         }
       }, 
       /* visualisation */
       {  }, 
       /* subclasses */
       { node_subcl, application.o_user }, 
       /* UDOT name */
       udot_name, 
       /* integer 0 */
       0, 
       /* documentation */
       { "", "" } 
     } )

"udot_ref"
 <node> of type object

"udv_def"
 { <name>,
   { <field_name>, <field_type> },
   { <field_name>, <field_type> },
   ...
 }
 <name>         string : name of the UDV
 <field_name>   string : name of one of the fields
 <field_type>   application description node of type value
 -----------------------------------------------------------------------------
 Example: bom_options.udv (from D2-Application)
    
   udv_name = "bom_options"
   
   udv_node = { 1070473454, 797176186, 453710954, 144 }
   
   udv_master ( udv_name, 
                { udv_name, udv_node,
                  { "options"    , application.v_dynstring },
                  { "output_dir" , application.v_boolean   },
                  { "sort_dir"   , application.v_boolean   },
                  { "sum"        , application.v_boolean   },
                  { "lines"      , application.v_int       }
                }

"udv_ref"
 <node> of type value

"user_rec"
 {}

"view_rec"
 { <coord: viewdir> <coord: left bottom> <coord: right bottom>
   <coord: left top> <node: viewporttype> <bea_object: model>
   <layerstate> <visualisation> <options> }
   .
   <coord>
       = { <real: dir.x> <real: dir.y> <real: dir.z> }
   <layerstate>
       = { <boolean: selectable> <boolean: selectable> <object: layer>
           <boolean: selectable> <boolean: selectable> <object: layer>
           ...
         }
   <visualisation>
       = { <node: objecttype> <node: visualisationtype>
           <node: objecttype> <node: visualisationtype>
           ...
         }
   <options>
       = see manual

"waste_rec"
 for internal use only !!!

################################################################################
<actions>

"model_load"
Load a model.
Examples:  // load latest version of model 'abc.mod':
           model_load ( "abc.mod",                         false )   

           // load version '3' of abc.mod:
           ignored = "write" // ignored (io_reason)
           model_load ( { "abc.mod", ignored, "3" } ,      false )   

           // load latest version of model 'abc.mod':
           model_load ( { "abc.mod", ignored, "LATEST" } , false )   

"model_save"
Save a model.
Examples: eval = false // should always be 'false'       
          // save model "abc.mod":
          model_save ( top, true, eval, "abc.mod", "what has changed" )

          // save model "abc.mod" with internal backup:
          ignored  = "read" // ignored (io_reason)
          ignored2 = "1"    // ignored (version)
          model_save ( top, true, eval, { "abc.mod", ignored, ignored2 , true }, 
                       "what has changed" )


"uda_define"
Define of an User-Action

################################################################################
<events>

"act_or_obj_event"
function   : Press icon in the 2nd column

"act_rec_event"
function   : Select an (sub)action in the 2nd column

"actgr_event"
function   : Press icon of action group in the 1st column

"action_event"
function   : Start new action for redefine; for internal use only !!!

"add_object_event"
function   : Select object type

"alt_unexpand_event"
function   : Unexpand an alternative parameter

"app_prop_or_par_event"
function   : Append property or parameter (UDx definition)

"append_is_subcl_event"
function   : Append UDOT to subclass list (UDx definition); for internal use only !!!

"append_vis_meth_event"
function   : Append visualization method to the list (UDx definition);
             for internal use only !!!

"base_obj_event"
function   : Show base class of selected UDOT (see popup menu on 1st column)

"bea_group_rec_event"
function   : Handle an object (e.g. quick edit mode with nearest object)

"cancel_act_event"
function   : Cancel an action (see popup menu on 2nd column)

"cancel_event"
function   : Cancel a form

"change_act_grp_event"
function   : Change the content of an action group

"change_menu_event"
function   : Change the content of a menue

"change_objgrp_event"
function   : Change the content of an object group

"create_event"
function   : Switch dialog to create mode

"ctrl_button1_event"
function   : Select additional object type

"del_obj_event"
function   : Delete an object (see popup menu on action icon in 2nd column)

"del_prop_or_par_event"
function   : Delete property or parameter (UDx definition)

"delete_event"
function   : Switch dialog to delete mode

"delete_vis_meth_event"
function   : Delete visualization method from the list (UDx definition);
             for internal use only !!!

"down_event"
function   : Descending through the datastructure

"edit_AQL_file_event"
function   : Call editor with AQL file of UDx

"edit_event"
function   : Switch dialog to edit mode

"enum_event"
function   : Select an enumeration type in the 4th column

"help_event"
function   : Call the online help

"hide_menu_event"
function   : Hide a menu (see popup menu on menu icon)

"hide_objgrp_event"
function   : Hide an object group (see popup menu on menu icon)

"hold_event"
function   : Switch on/off the hold mode

"key_seq_pressed"
function   : Press a function key

"layer_delete_event"
function   : Delete a layer and containing objects

"layer_info_event"
function   : Display information before deleting a layer

"layer_move_event"
function   : Delete a layer and move up containing objects

"layer_move_with_substruct"
function   : Delete a layer and move up containing sublayers and objects

"layer_mvob_event"
function   : Move objects to another layer

"manip_event"
function   : For future use only!

"menu_event"
function   : Change menu

"move_prop_or_par_event"
function   : Move property or parameter (UDx definition)

"obj_rec_event"
function   : Select object indirect (see right mouse button in drawing area)

"object_event"
function   : Press icon of object in the 1st column; switch on EDIT mode before!

"objgr_event"
function   : Change to object group

"prop_or_par_event"
function   : Press property or parameter icon in 3rd column

"pseudo_temp_act_event"
function   : Perform any action from anywhere

"pseudo_temp_obj_event"
function   : For future use only!

"quit_browse"
function   : Interrupt the browse mode (see menu->browse or click on browse icon)

"recurs_act_event"
function   : Implicit construction (call action via 4th column)

"redefine_event"
function   : Redefine an action

"redraw_event"
function   : Call the redraw

"refresh_event"
function   : Call the refresh

"remove_action_event"
function   : Delete action via popup menu on the 2nd column

"remove_manip_event"
function   : Remove manipulator from action

"remove_object_event"
function   : Deselect object type

"result_event"
function   : for internal use only !!!

"rm_act_grp_event"
function   : Remove an action group from menu (see popup menu on action group icon)

"rm_menu_event"
function   : Remove a menu (see popup menu on menu icon)

"rm_objgrp_event"
function   : Remove an object group (see popup menu on menu icon)

"sel_acc_event"
function   : Accept the selection set (see right mouse button in drawing area)

"sel_acc_name_event"
function   : Give a name to a group object

"sel_ancest_event"
function   : Select ancestor objects of specified object (see right mouse button in 
             drawing area)

"sel_attr_event"
function   : Select object by attribute (see right mouse button in drawing area)

"sel_by_group_event"
function   : Select object by group (see right mouse button in drawing area)

"sel_cancel_event"
function   : for internal use only !!!

"sel_delete_all_event"
function   : Delete all selected objects (see right mouse button in drawing area)

"sel_deselect_event"
function   : Deselect all (see right mouse button in drawing area)

"sel_give_name_event"
function   : Give a name to a group object (see right mouse button in drawing area)

"sel_group_cont_event"
function   : Select object as content of a group object

"sel_grp_mod_event"
function   : Select objects in multi selection mode (see right mouse button in drawing
             area)

"sel_in_user_event"
function   : Select object in UDO (see right mouse button in drawing area)

"sel_indirect_event"
function   : Select object indirect which is parameter of an other object
             (see right mouse button in drawing area)

"sel_name_event"
function   : Select object by name (see right mouse button in drawing area)

"sel_next_event"
function   : Select next object in the selection set (see right mouse button in drawing
             area)

"sel_previous_event"
function   : Select previous object in the selection set (see right mouse button in 
             drawing area)

"sel_show_allson_event"
function   : Show all dependent objects (e.g. popup menu on action icon in 2nd column)
             ATTENTION: Event new in version 2002. Function has same function like old
             sel_show_son_event ()

"sel_show_ancest_event"
function   : Show ancestors (see popup menu on action icon in 2nd column)

"sel_show_par_event"
function   : Show environment of length or angle parameter object (see popup menu 
             on icon in 2nd column)

"sel_show_son_event"
function   : Show directly dependent objects (e.g. popup menu on action icon in 2nd
             column)
             ATTENTION: Event changed in version 2002. Old function now in
             sel_show_allson_event ()

"sel_sin_mod_event"
function   : Select objects in single selection mode (see right mouse button in drawing
             area)

"sel_sons_event"
function   : Select dependent objects of specified object (see right mouse button in 
             drawing area)

"sel_undo_del_all_event"
function   : Undo delete all selected objects (see right mouse button in drawing area)

"sel_unsel_event"
function   : for internal use only !!!

"select_event"
function   : Select objects determined by selection_rec value

"set_language_event"
function   : Set the specified language (see menu bar: options)

"set_name_event"
function   : Give a name to an object (see popup menu on 2nd column)

"set_obj_event"
function   : Define object (e.g. result object of an UDA, object for iterate)

"set_par_name_event"
function   : Give a name to a parameter (see popup menu on 3rd column)

"set_prop_or_par_event"
function   : Set property or parameter (UDx definition)

"set_result_event"
function   : Define result object of an UDA (UDx definition)

"set_scheme_event"
function   : Set color scheme

"set_vptype_event"
function   : Set default viewport type (see menu->options)

"shift_button1_event"
function   : Select some object types

"shift_tab_event"
function   : Press <Shift> + <Tab> keys to go to previous element in selection set

"star_append_event"
function   : Append an element to a list parameter

"star_delete_event"
function   : Delete the selected element of a list parameter

"star_first_event"
function   : Select the first element of a list parameter

"star_insert_event"
function   : Insert an element to a list parameter

"star_last_event"
function   : Select the last element of a list parameter

"star_next_event"
function   : Select the next element of a list parameter

"star_ok_event"
function   : Press the closing icon of list parameter (=star)

"star_pos_event"
function   : Select the given object in a list parameter

"star_prev_event"
function   : Select the previous element of a list parameter

"star_redefine_event"
function   : Start a new list of elements of a list parameter

"stop_draw_event"
function   : Stop the redraw via stop icon; for internal use only !!!

"stop_event"
function   : Quit the application

"stop_icon_event"
function   : Press the STOP icon

"stop_load_event"
function   : Stop loading models via stop icon; for internal use only !!!

"stop_locator_event"
function   : Stop the locator function for via stop icon; for internal use only !!!

"stop_temp_event"
function   : Stop the temp mode

"stop_zoom_event"
function   : for internal use only

"sub_obj_event"
function   : Show subclass of selected UDOT (see popup menu on 1st column)

"switch_opt_off_event"
function   : Switch on optional of a parameter or property

"switch_opt_on_event"
function   : Switch off optional of a parameter or property

"tab_event"
function   : Press <Tab> key to go to next element in selection set

"temp_act_event"
function   : Call an action (e.g. press right mouse button in text area)

"temp_event"
function   : Switch dialog to temp mode

"temp_obj_event"
function   : Create a temporary absolute object; for internal use only !!!

"text_event"
function   : Put in a text

"toggle_event"
function   : Press middle mouse button to select or deselect object

"top_obj_event"
function   : Show top object class of selected UDOT (see popup menu on 1st column)

"undo_del_mul_obj_typ_event"
function   : Undo delete the latest deleted object(s)

"undo_del_obj_event"
function   : Undo delete objects in EDIT mode, see popup menu on action icon
             (also used internally: UDx definition in case of cancel)

"undo_event"
function   : Undo delete objects in EDIT mode, see menu->Undo

"unhide_menu_event"
function   : Unhide a menu (see popup menu on menu icon)

"unhide_objgrp_event"
function   : Unhide an object group (see popup menu on menu icon)

"up_event"
function   : Ascending through the datastructure

"value_event"
function   : Put required data into value

"copy_event"
function   : Copy into the paste buffer

"cut_event"
function   : Cut into the paste buffer

"dynzoom_event"
function   : Zoom dynamically

"hidden_event"
function   : Switch to hidden line mode

"logo_event"
function   : Create the 'About' dialog

"new_event"
function   : Create new model

"open_event"
function   : Open a model

"pan_event"
function   : Pan

"paste_event"
function   : Paste from the paste buffer

"print_event"
function   : Print

"save_event"
function   : Save a model

"shaded_event"
function   : Switch to shaded mode

"viewface_event"
function   : Zoom a face of a body

"viewske_event"
function   : Zoom a sketchplane

"viewrotate_event"
function   : Rotate a view

"winhori_event"
function   : Tile the viewports horizontally

"winoverlap_event"
function   : Cascade the viewport

"winstandard_event"
function   : Tile the viewports using the standard scheme

"winvert_event"
function   : Tile the viewports vertically

"wire_event"
function   : Switch to wire frame mode

"zoomall_event"
function   : Zoom all

"zoomin_event"
function   : Zoom in

"zoomobject_event"
function   : Zoom a Bea_object

"zoomout_event"
function   : Zoom out

"zoomundo_event"
function   : Undo zoom operations

################################################################################
<variables>

"aql_argument_list"
type   : group
meaning: Group of strings containing all arguments passed to the AQL program

"aql_function_list"
type   : group
meaning: Group of all existing AQL functions

"aql_object_type_list"
type   : group
meaning: Group of all existing aql_meta_object_type's

"aql_symbol_source_list"
type   : group
meaning: Group of all existing aql_meta_symbol_source's

"aql_arg_<nr>"
type   : string
meaning: Argument with number <nr> in string format;
         aql_arg_0 contains the name of the AQL program

"application"
type   : node_type
meaning: The top of the application description tree

"program"
type   : program
meaning: All global settings of the program

"top"
type   : Bea_object of type user
meaning: The active model

"models"
type   : a group of Bea_objects of type user
meaning: The loaded model

"active_layer"
type   : Bea_object of type layer or user
meaning: The active layer

"root"
type   : container_value
meaning: Root container in which all loaded models, UDOs and UDAs are stored

################################################################################
<hide actions>

"udo_dissolve"
"view_rotate"
"view_rotx"
"view_roty"
"view_rotz"
"udo_master_of_layer"
"uda_master_of_layer"
