TrainzOnline - User contributions [en]

Class Library

2009-09-16T01:16:52Z

Shalliwell:

*[[TrainzScript Langage Reference|API Hierarchy]]
**[[Class GSObject|GSObject]]
***[[Class GameObject|GameObject]]
****[[Class TrainzGameObject|TrainzGameObject]]
*****Library
 

* A class that provides the interface for a script Library asset.
* A library is a self-contained code module that can be accessed by the script of any other asset.
* Library assets allow content creators to create reusable code repositories that any script can access without having to include a duplicate source file into the asset folder.
* A Library class is the only way you can get an OnlineAccess object to access Planet Auran services from a Trainz script.
 

==Methods==

===GetOnlineAccess===
{{MethodHeader|native OnlineAccess GetOnlineAccess(void)}}
;Parameters
*None
;Returned Value
*An OnlineAccess reference allowing access to Planet Auran services when online.
;Syntax
OnlineAccess channel = GetOnlineAccess();
;Notes
*This method is the mechanism used to access Planet Auran via an OnlineAccess object from a script.
*Script programmers should be careful not to allow other classes access to the OnlineAccess structure, either directly or indirectly, in order to prevent asset spoofing.
*It is only through this private method that you can obtain an OnlineAccess object.
 

===GetProperties===
{{MethodHeader|public Soup GetProperties(void)}}
;Parameters
*None
;Returned Value
*The properties of this Library object in [[Class Soup|Soup]] format.
;Notes
*See [[Class PropertyObject#GetProperties|PropertyObject.GetProperties()]] for further details.
 

===LibraryCall===
{{MethodHeader|public string LibraryCall(string function, string[ ] Strings, GSObject[ ] Objects)}}
;Parameters
*'''function''' = A string identifier defining the Library function to be called.
*'''Strings''' = An array of strings to be used as determined by the script programmer.
*'''Objects''' = An array of [[Class GSObject|GSObjects]] to be used as determined by the script programmer.
;Returned Value
*A string to be interpreted as determined by the script programmer.
;Syntax
string result = Codelib.LibraryCall("AFunction",Strings,Objects);
;Notes
*This method provides a virtual function call.
*It is through this method that all library calls are processed and it must be overridden if you want your library to do anything.
*How the arguments are used and processed is left to the library author to decide.
*This means that any external code using your library would need to use the function arguments as your implementation requires.
*If your library is going to be available for use by others, then you would need to specify and document the parameters and how to interpret any returned values.
*The name of the library call is specified in the function argument while parameters for the library calls are provided for through the string and GSObject arrays.
*Some guidelines to follow if you want your library to be robust and bullet proof:
**Never assume the arguments are valid.
**When processing the arguments, make sure they are not null before using them, there is no need to check an argument you don't use.
**Make sure the elements in the parameter arrays exist before trying to use them. This can be done by verifying the size of array and making sure the element that you are about to process is not null.
**If using the GSObject array, cast the array member to the type you are expecting and verify the cast, there are no guarantees of what the object might be.
**A cast will be needed to access the objects in any event as GSObject has no methods or data members.
**If the cast fails, the object the cast was assigned to will be null.
*LibraryCall() may not be the most efficient way to handle a library function call and may seem rather crude, but this is a temporary measure that will be replaced with a more elegant direct-call interface in a future version of Trainz.
*The current library call mechanism will still remain supported so existing library assets are not broken.
 

===SetProperties===
{{MethodHeader|public void SetProperties(Soup soup)}}
;Parameters
*[[Class Soup|Soup]] database to initialise the Library's properties.
;Returned Value
*None
;Notes
*See [[Class PropertyObject#SetProperties|PropertyObject.SetProperties()]] for further details.
 

==Configuration & Examples==
===Library Configuration===
*A Library asset is defined by creating a new asset folder with a ''config.txt'' file containing these tags:
kind "Library"
script ScriptFile // the name of the *.gs file containing the library class declaration
class ScriptClass // the name of the library class itself
*Other than the standard asset tags such as kuid and username, these are the only tags required.
*The library script and ''config.txt'' are the only files necessary but the asset can contain other files and folders
 

===Client Configuration===
----
*To make use of a Library asset the calling asset must have a script of its own.
*The asset script will need a kuid-table reference to the Library script asset. These tags will therefore be required:
script assetScriptFile
class assetScriptClass
kuid-table {
codelib <kuid:1234:5678>
}
*The asset script will need a variable to hold its reference to the Library and it will need to make a call to [[Class World#GetLibrary|World.GetLibrary()]] to initialise this variable.
*In summary these are the calls required in the calling asset script to initiate Library access:
class assetScriptClass isclass whatever {

// a variable for the library reference
Library Codelib;

// initialise library access
public void Init(Asset) {
Codelib = World.GetLibrary(GetAsset().LookupKUIDTable("codelib"));
}

};
*The Library is loaded into Trainz and initialised when the first asset calls [[Class World#GetLibrary|World.GetLibrary()]]
*Subsequent calls return a reference to the Library but only one instance is ever created.
*This makes it possible for a Library to provide access to global data which can be shared between multiple objects.
*There is only one function available to access the script in a Library, LibraryCall(), any use of which returns a string result.
*An assignment to the GSObject[] or string[] remains valid until a new assignment is made, either by the Library or by the caller.
*An assignment made in the calling script becomes available to the Library on the next Library Call.
*An assigment made by the Library script becomes available to the Caller when the current LibraryCall returns.
 

===Library Script Capabilities===
----
*Reference to the included methods and Library class inheritance will show that:
**Libraries have an Init() function which can contain code to be executed on initialisation.
**Libraries can create their own variables and can save them to the Session.
**Libraries can send and receive messages and run their own threads.
**Libraries can act as repositories for sound and html resources, including text via a [[Class StringTable|StringTable]] in the Library asset config.
 

===Library Script Example===
----
*Although this code will compile it is not guaranteed to work, the intention is to demonstrate the format of a simple library script and some of the techniques that can be used.
*The code shows a Library script which maintains a list of all the client assets which make calls to it.
*The list is checked by the Library itself every ten seconds, any objects which no longer exist are removed.
*Calling scripts use the LibraryCall mechanism to obtain information, based both on the data supplied in the LibraryCall parameters, and on the GameObject list maintained by the Library code.
include "Library.gs"

class Clients isclass Library {

// member & forward method declarations, global scope
// 'Clients' holds a list of gameobjects which have made calls to this library
// if client assets make such a call in their Init() method the list will hold all client objects.
GameObject[] Clients = new GameObject[0];
int CountClients(void);

// Init sets up a message handler and posts a 'reminder' message
public void Init(void) {
inherited();
AddHandler(me,"CheckClients","","ClientHandler");
PostMessage(me,"CheckClients","",10.0);
}

// ClientHandler reacts to messages by calling CountClients to check the membership 
// of the Clients list and posting a further 'reminder' to repeat the process in 10 seconds time
void ClientHandler(Message msg) {
if (msg.major == "CheckClients") CountClients();
PostMessage(me,"CheckClients","",10.0);
}

// CountClients checks that all of the members of the Clients array still exist, if
// they have been deleted from the map they are removed from the array
int CountClients(void) {
GameObject[] NewClientList = new GameObject[0];
int n;
for (n = 0; n < Clients.size(); n++) {
if (Router.GetGameObject(Clients[n].GetId())) {
NewClientList[NewClientList.size()] = Clients[n];
}
}
int result = NewClientList.size();
if (result < Clients.size()) {
Interface.Print((Clients.size() - result) + " of our Clients have left");
}
Clients = NewClientList;
return result;
}

// Utility method to check whether or not an object is a member of an array
// This method is available throughout the class
public bool Member(GameObject[] goArray, GameObject go) {
int n;
bool result = false;
if (goArray.size() == 0) {return result;}
for (n = 0; n < goArray.size(); n++) {
if (go == goArray[n]) {
result = true;
break;
}
}
return result;
}

// Utility method to remove a member from an array, available throughout the class
public void Remove(GameObject[] goArray, GameObject go) {
int n;
if (goArray.size() == 0) {return;}
for (n = 0; n < goArray.size(); n++) {
if (go == goArray[n]) {goArray[n,n+1] = null;}
}
}

// This is the LibraryCall method, through which client scripts issue instructions
// and receive information.
public string LibraryCall(string function, string[] Strings, GSObject[] Objects) {

 // declarations local to LibraryCall
GameObject client;

 // code to execute on all calls, irrespective of function
 // This adds the Calling object to our 'membership' list
client = cast<GameObject>Objects[0];
if (client and !Member(Clients,client)) Clients[Clients.size()] = client;

 // specified library call function methods
 // Return count of members
if (function == "CountMembers") {
int count = CountClients();
return "There are currently " + (string)count + " members";
}

 // Return 'membership' number of Caller
if (function == "MembershipNumber") {
if (client) return "Your membership number is " + (string)client.GetId();
return "You are not a member";
}

 // Remove Caller from the list of members, the Caller will 'rejoin' if any
 // further LibraryCalls are made.
if (function == "Resign") {
if (client) {
Remove(Clients,client);
 // Instruct the library to update its list, just in case something went wrong
PostMessage(me,"CheckClients","",0.0);
return "Resignation accepted, Please rejoin soon";
}
return "Non members cannot resign";
}

 // code to execute if 'function' doesn't match any definition.
Interface.Exception("Unknown LibraryCall function: " + function);
return "";

}

};
*To use the Library the calling object's script must include this setup.
*We are not using the Strings array so it won't need any members, but it must be declared nonetheless
*You would need several placed instances of the asset to see a meaningful result
class client isclass MapObject {

Library Codelib;
string[] Strings = new string[0];
GSObject[] Objects = new GSObject[1];

public void Init(void) {
inherited();
// Initialise our reference to the Library
Codelib = World.GetLibrary(GetAsset().LookupKUIDTable("codelib"));
// assign a reference to ourself to the Objects array
Objects[0] = me;
// Call all of the defined methods, printing out the result
Interface.Print(Codelib.LibraryCall("CountMembers",Strings,Objects));
Interface.Print(Codelib.LibraryCall("MembershipNumber",Strings,Objects));
Interface.Print(Codelib.LibraryCall("Resign",Strings,Objects));
}

};
*Remember that, once assigned, a member of either of the array parameters will persist until changed.
*Since there is no practical limit on the size of either array there should be little need to continuously reassign array members prior to making calls.
*You will need to keep a careful track of the significance of each member of the arrays.
 

==Related Methods==
*[[Class World#GetLibrary|World.GetLibrary()]]

==Categories==
[[Category:Script Class]][[Category:Asset KIND]]

MiniBrowser

2009-09-15T23:58:51Z

Shalliwell: /* Embedded Objects */

The MiniBrowser is a trivial HTML renderer used for simple layout control within the Trainz game environment. It is specifically not a replacement for a real browser (see [[Trainz Online]] instead), is not remotely standards compliant, and does not support a full range of HTML tags, if the tag isn't mentioned here then it is NOT supported. There is no javascript support ([[Scripting|TrainzScript]] is used instead.) It is used exclusively by the Trainz [[class Browser|Browser]] script object.

Feature requests relating primarily to the MiniBrowser should be placed on the [[MiniBrowser Feature Requests]] page.

Trainz HTML is NOT standards compliant and is best thought of as an HTML-alike chosen so users and developers are familiar with the style of syntax being used.

=Supported Tags=
The MiniBrowser supports the following HTML tags:

==HTML==
This tag wraps the entire HTML document. No parameters are supported. This tag should be at the top level of the document and should contain a single '[[#BODY |BODY]]' tag.

Usage:
:<html>
::...
:</html>

==BODY==
This tag wraps the entire body of the HTML document. The 'scale' parameter is provided to force the document to be rescaled to a specified number of pixels wide, but its usage is strongly discouraged. This tag should exist within the '[[#HTML |HTML]]' tag and may contain any number of other elements.

Usage:
:<body scale=?>
::...
:</body>

==P (paragraph)==
This tag causes the contained elements to be formatted as a separate paragraph. This is similar to prefixing and suffixing the elements with a linebreak. Paragraph tag has no parameters.

Usage:
:...

==BR (linebreak)==
A forced linebreak. BR has no parameters.

BR is an unclosed tag, unlike XHTML there is no or . In fact using such a thing will most likely be interpreted as an error by the Trainz HTML parser.

Usage:
:... 

==TABLE==
This tag forms a table element. Any number of <[[#TR |TR]]> (table row) elements may be present within the 'TABLE' tag and that is all it should contain directly. Table height cannot be specified, this can be controlled by setting each <[[#TR |TR]]> element within the table to add up to the desired table height.

Table does NOT support the following parameters; rules, summary, align. Nor does it support the <TH> element (the same effect can be achieved by making the contents of a <[[#TD |TD]]> [[#B |BOLD]] or even more so by the use of [[#FONT |FONT]]). Table is best thought of as a grid, like that of a spreadsheet or a table inserted into a document. Tables are described by <[[#TR |TR]]>; a row in a table and <[[#TD |TD]]>; a cell in a row.

Tables are not askew, meaning if 1 row has 3 cells then all rows will have at least 3 cells, this does not mean the coder must put at least 3 <[[#TD |TD]]>s in each <[[#TR |TR]]> it means when formatted for display on screen the html render will organise the table as such (as it is uniform). Furthermore, cells conform to the dimensions of their siblings; meaning a cell has the same width as the widest cell in its column (controllable by width in <[[#TD |TD]]>) and the same height as the tallest cell in its row (controllable by height in <[[#TR |TR]]>). This is very important to keep in mind when using tables for formatting/layout purposes.

The documentation on <[[#TR |TR]]> and <[[#TD |TD]]> have more information about the use of tables in Trainz HTML. For more info and a place to try out some of these properties of tables try the [http://www.w3schools.com/tags/tag_table.asp w3schools table tag page], but remember Trainz HTML is not the same as HTML proper.

All parameters are optional.
*cellpadding - specifies the minimum pixel space between the cell wall and its content. Default is 0.
*cellspacing - specifies the pixels between cells. Default is 0.
*width - specifies the pixel width of the table. If none is given the table will grow to fit its content. If width is given cell content will be wrapped if it would force table width beyond that.
*border - specifies the pixel width between the table and content around it. Default is 0.

Usage:
:<table cellpadding=? cellspacing=? border=? width=? inherit-font>...</table>

==TR==
TR is Table Row. This tag forms a single horizontal row of a table. Any number of '[[#TD |TD]]' (table data) elements may be present within the 'TR' tag and that is all it should directly contain. <TR> does NOT support the following parameters; align, valign, char, charoff.

All parameters are optional. Height, if specified, will limit how many pixels high this row can be, causing cells to expand in width if they were to approach this height.

When using tables for formatting it is important to remember that cell size is dependent upon both column and row (see <[[#TD |TD]]> and/or <[[#TABLE |TABLE]]> for more info) thus it may be useful to consider creating a <TR> with no data that exists only to set up the size of the columns ie.
<pre>
<tr> <td width='20'></td> <td width='50'></td> <td width='200'></td> <td width='20'></td> </tr>
</pre>
now unless a <TR> with more than 4 <[[#TD |TD]]>s is created, the formatting for all columns is already done and as this <TR> has no height specified and no data in its <[[#TD |TD]]> cells it will take up only the space specified by the <[[#TABLE |TABLE]]>'s border, cellspacing and cellpadding (default 0).

Usage:
:<tr height=? bgcolor=?>...</tr>

==TD==
TD is Table Data. This tag forms a single cell within a table row. <TD> does NOT support for following parameters; abbr, align, axis, char, charoff, headers, height, scope, valign.

Height of a cell is controlled by the tallest cell in the row or by the <[[#TR |TR]]> height parameter if it is specified.

<TD> is the work horse of tables, as the name implies all contents of a table are contained within a <TD> tag. Anything can be placed within a cell, even a table eg.

<pre>
<html> <body>
<table border="1">
<tr>
<td>Some text </td>
<td>Some text </td> </tr>
<tr>
<td>Some text </td>
<td>Some text </td> </tr>
<tr>
<td>
<table border="1">
<tr>
<td>Some text in a sub table </td>
<td>Some other text in a sub table </td>
</tr>
</table>
</td>
<td><---Wow thats a sub table over there </td>
</tr>
</table>
</body> </html>
</pre>
coping and pasting the above into the left pane of [http://www.w3schools.com/HTML/tryit.asp?filename=tryhtml_basic this Tryit window](open it in a new tab or window) and clicking "Edit and Click me >>" button will show you a table with a table in it on the right hand side.

All parameters are optional.
*rowspan and colspan allows this cell to consume the space that would normally be allocated to neighboring cells on the right and bottom sides. Default values are 1, meaning the <TD> spans its own cell and nothing more. [http://www.w3schools.com/tags/tryit.asp?filename=tryhtml_table_span Visual example of spanning], but remember Trainz HTML is not the same as HTML proper.
*width - specifies the pixel width of this cell, useful for formatting.

Usage:
:<td rowspawn=? colspan=? width=? bgcolor=?>...</td>

==A==
A is the Anchor tag. This tag marks all contained elements as a hyperlink with the specified attributes. Hyperlinked text will be underlined.

Tooltip text will be displayed when the mouse hovers over the hyperlinked elements.

The href is the minor message in a [[Browser Messages |Browser-URL message]] sent by the [[class Browser |Browser]] to whomever is listening to it. ie. the major="Browser-URL" minor="live://button/horn" message is produced by a hyperlinked button (horn) in the driver user interface.

A hyperlink is considered clicked when the user has pressed and released mouse button 1 while over it.

Usage:
:<a href=? target=? help-label=? mousedown=? disabled-href=? tooltip=?>...</a>

==IMG==
IMG is the IMaGe tag. This tag displays an image with the specified attributes. Does NOT support the alt or title tags.

All parameters are optional however, the src or the kuid parameter needs to be filled out for anything to show up apart from a fill.

The width and height parameters define the pixel size the image will occupy on screen, these can be made larger or smaller than the image's actual size to zoom, stretch or squash the image as needed. Keep in mind that users don't all use the same resolution, so it is usually best to make pictures either fixed size in a screen position via the use of tables or calculating a pixel size relative to the current resolution.

Usage:
:<img src=? mouseover=? kuid=? width=? height=? srcwidth=? srcheight=? color=? hflip>

==TRAINZ-TEXT==
A section of text that can be changed without having to recalculate or reset the entire HTML string in a [[class Browser |browser]].

In the Driver interface the speed panel shows the selected train's current speed, the current speed limit on its segment of track and the current world time. Below is the speed HTML, which is retrieved via the localisation method described in <[[#FONT |FONT]]>;
<pre>
<trainz-text id='speed' text='0 KM/H'></trainz-text>
</pre>
This specifies green bold text that is bound to an id of "speed". Now in every heartbeat in DriverModule.gs, the currently selected train's speed is calculated and applied to this trainz-text by calling SetTrainzText("speed", "10 kph") [10 kph used only for illustrative purposes] on the [[class Browser |browser]] that contains the speed html.

The id parameter is required to be able to update this section of text via the SetTrainzText [[class Browser |browser]] call. The text parameter does not need to be filled out int HTML can be specified using the SetTrainzText method at a later time.

Usage:
:<trainz-text id=? text=?>

==B==
B is Boldface. Causes any text in contained elements to be rendered as boldface. The bold tag has no parameters.

Usage:
:...

==NOWRAP==
Suppresses automatic word wrap in the contained elements. The nowrap tag has no parameters.

Usage:
:<nowrap>...</nowrap>

==I==
I is the Italics tag. Causes any text in the contained elements to be rendered as italic. The italic tag has no parameters.

Usage:
:...

==FONT==
Causes the specified text attributes to be applied to any text in the contained elements. Text in Trainz HTML does not have to be enclosed in font tags, if none are found around any given text it will receive the default font settings.

Localisation note; the follow statement has special meaning to the Trains HTML parser;
<pre>
A_TAG
</pre>
When a tag such as this is parsed, Trainz will look in the current users selected language [[class StringTable | string table]] of the current asset for a string with the name found between the tags, in this case A_TAG. It will replace the entire statement from here "<font... " to here with what is found in the [[class StringTable | string table]]. An example of this at work is in the Driver interface where the camera types are defined in the string tables of the Driver asset [[config.txt file | config.txt]] in all available languages so that each camera button has the selected language tooltip for each camera mode.

Usage:
:...

==TRAINZ-OBJECT==
Documented below under [[#Embedded Objects |embedded objects]]. Embedded objects fill the style parameter. The width and height parameters specify the pixel size of the given object, eg. how big a button is.

Usage:
:<trainz-object width=? height=? style=?>

=Supported Characters=
The MiniBrowser parses its input from UTF-8 encoded HTML. The full range of unicode characters may be included without special escape sequences. The following escape sequences are permitted and may be necessary to prevent the characters from being parsed as HTML markup.
* &nbsp; - the HTML non-breaking space character.
* &gt; - the "greater than" character (' > ')
* &lt; - the "less than" character (' < ')
* &amp; - the "ampersand" character (' & ')
* &quot; - the "quote" character (' " ')

=Embedded Objects=
The following embedded objects are supported by the trainz-object tag:

==dial==
Works like an analogue volume knob. A dial is used in the driver interface, in the dcc panel to control the speed/power of the train. These are its settings;

<pre>
<trainz-object style=dial width=95 height=95 id='dcc'
texture='newdriver/dcc/dcc_controller.tga' min=0.1 max=0.9
valmin=-1.0 valmax=1.0 step=0 clickstep=1 value=0.5></trainz-object>
</pre>

Driver wraps the dial in an <[[#A |A]]> as to receive messages from user interactions with it, it then uses the GetElementProperty("dcc", "value") on the [[class Browser |Browser]] the dial resides in to extract its current value.

Parameters explained;
*The style, width, height and id parameters belong to the [[#TRAINZ-OBJECT |TRAINZ-OBJECT]].
*The min and max parameters specify the rotation (as a percent between 0 and 1) the dial can have in the interface. For the driver speed knob its 0.1 to 0.9; imagining this as a clock face this means the dial is allowed to rotate between approximately 7 clockwise around to approximately 5 and vice versa anticlockwise anywhere between 5 and 7. The dial's rotation can never be clockwise between 5 and 7.
*valmin and valmax specify the values returned by the dial, that is how its values map to its rotation. Using the clockface analogy again, at approximately 7 the dial will return the value of -1, at approximately 5 it will return the value 1 and at 12 it will return 0.
*step specifies the minimum change that can occur in the dial, 0 means it can move completely freely, if step were 0.1 and the user had rotated it by 0.04 no rotation would be registered and the dial would snap back to its previous position.
*clickstep TBD
*value sets the initial starting position (as a percentage 0 to 1) of its range. 0.5 being half between max and min.

:style=dial texture=? min=? max=? valmin=? valmax=? step=? clickstep=? value=?

==button==
A Button is essentially 8 [[#IMG |image]]s; where only 1 is shown at a time determined by the button's on or off-ness and the user's cursor location.

Buttons can be set either 'off' or 'on' by calling SetElementProperty("button name", "value", "1") [for on or "0" for off] on the [[class Browser |browser]] that contains the button. All buttons start in the off state.

Both 'on' and 'off' states have 4 states within them for showing interaction with the cursor. Off is explained below, on is the same replacing "off" with "on";
* "off" - button is in the off state and has no cursor interaction.
* "off-over" - button is in the off state and the cursor is hovering over the button.
* "off-down" - button is in the off state and the cursor has been clicked on the button, is held down (mouse button 1 is down) but the cursor is not (is no longer) hovering over the button meaning the user has dragged the cursor off the button after clicking it.
* "off-down-over" - button is in the off state and the cursor is hovering over the button and the cursor has been clicked on it and is being held down (mouse button 1 is down).

The size of a button is determined by the width and height parameters of its containing [[#TRAINZ-OBJECT |TRAINZ-OBJECT]] tag.

Typically a button trainz-object will be contained within an <[[#A |A]]> tag giving the appearance that buttons send messages. As buttons do not send clicked messages themselves, they do not directly know when they have been clicked on or off, this must be done manually by listening to the message that will be sent by the anchor tag and changing the buttons state using the SetElementProperty("button name", "value", "1") command on its containing browser.

Usage:
? represent image files within the asset.
:style=button id=<button name> off=? off-over=? off-down=? off-down-over=? on=? on-over=? on-down=? on-down-over=?

==video==
The curiously named MN Session Manager, uses the video trainz object to play some short clips.

*The play-on-load tag should be either '1' or '0' being yes or no respectively and it means exactly what it sounds like, should the video start playing once it has loaded.
*The is-video-looping is likewise a '1' or '0' value indicating the video should or shouldn't repeat once finished.

:style=video play-on-load=? video-filename=? is-video-looping=?

==slider==
Slider is a horizontal bar similar to a horizontal scroll bar with a linear range of values mapped to it, similar to the [[#dial |dial]].

There are several in the video settings menu/asset and those will be used as an example here. The most important attributes are;
*min the minimum value the slider represents (far left).
*max the maximum value the slider represents (far right).

:style=slider min=? max=? page-size=? draw-lines=? draw-marks=? thumb=? thumb-over=? less=? less-over=? more=? more-over=? thumb-width=? thumb-height=?

==browser==
[[class Browser |browser]] is updated through call to SetElementProperty("component-name","html",sub-browser html string) from the parent browser level. An example of this at work can be found in the waybillmanager.gs

:style=browser id='component-name' width=? height=?

==driver-menu-button==
:style=driver-menu-button name=?

==graphic-button==
:style=graphic-button name=? texture_off=? texture_on=?

==minimap==
:style=minimap

==text-line==
:style=text-line background=? align=?

==driver-order-bar==

'''Incorrect'''

Is a very specific case. As the name implies it is the list of driver commands that appears at the bottom of the screen next to the current driver image in Driver. This is already created and managed for you, users probably don't want to make these in any useful way, just to mess around or break things.

:style=driver-order-bar

'''''this isn't really accurate. i think you'll find this is already used elsewhere in the game (for example, in the driver command rule?) and in fact possibly isn't used by the main driver interface - it's likely that is not HTML although it's the same underlying control. this is a general-purpose control: the functionality is specific to assigning orders, but it should be fairly flexible what the calling script does with the orders.'''''

==clock==
:style=clock face-texture=? seconds-texture=? minutes-texture=? hours-texture=? seconds-visible=? minutes-visible=? hours-visible=? seconds=? minutes=? hours=?