Here is the standard docs you were looking for. DO NOT send me spelling mistakes as the FrontPage Express does not contain a spell checker (Damn MS Crap). ~~ Dan ~~Title: DHOS Shell Sscripting Language Working DraftEditor:
DHOS Shell Scripting Language Working Draft
Editor: Daniel
T. Hable
Contributors:
Jonathan Kaus
Document Revisions]
24 August 1998 - Draft 1 Generated and posted for commentary.
This document is being provided to the developers of DHOS and the user community of shell-developers@lists.ticalc.org for the basis of discussion. This document does not imply that any of the ideas are final. Please send all feedback (comments, questions, additional ideas, etc.) to Dan at dthable@students.wisc.edu .
Introduction
The DHOS is being developed as a shell for the TI-85 calculators, which are produced by Texas Instruments, INC. Part of the original development ideas that DHOS wanted to incorporate was a shell that could be changed without users needing assembly programming experience. The DHOS Shell Scripting Language was designed to accomplish this task.
Basis of DHOS Shell Scripting Language
The Shell Scripting Language divides the user interface into three different subsections - the logical layout, the appearance, and the kernel. These different portions of the shell will interact to design a complete, seamless shell for the user. The kernel is being developed by other and is not part of the scripting language. Please see other documentation on using the kernel.
Logical Layout
The logical layout is the portion of the document that we will be encoding in XML. By using XML for the encoding of the shell layout, we can enforce certain rules. The current list of shell rules are as follows:
1) Upon boot, the shell will load a logical layout named MainForm. Any user who wants to change this method must overwrite this logical layout.
2) Any MainForm must contain a shut down object that allows the user to quit the current shell and return back to the TI OEM shell.
3) All objects must be contained in an object called Form. This will prevent strange user interfaces and force the user to make a Windows-like shell.
We can other basic rules, but remember that the rules are general and should apply to the entire user interface. Once we have the general rules for the shell down, we will need to write and test a DTD for the logical format. I have not yet started on the DTD but I have a general idea as to how to proceed. The logical objects that will be available for the user to use will be as follows:
Form
Button
Text
TextField
Menu
MenuItem
Each of the elements will have formatting properties that can be used with them also. As you can see, we have just defined a set of common objects that the user can use to build custom dialog boxes. This will assist the user in developing programs but does not give freedom to non-programmers. To regain this freedom, we have defined a common set of dialogs that the shell will call. The user can overwrite these to make the shell custom to that user. The standard forms include the following:
MainForm
RunForm
OkForm
ErrorForm
AlertForm
QuitForm
SDForm - (Shut Down Form)
Appearance Layout
So far the standard has defined how we will represent the layout of the shell to the user. We have not given the user the ability to format the design of the buttons or forms. This gives the user partial control over the shell's appearance. To compensate for the lack of appearance, we define a subset language of XSL called DHOS-XSL.
We can't use the XSL language as it appears right now because it has been designed for the formatting of text data. With realive ease, though, we can change the language to suit our need. The details for DHOS-XSL cannot be developed until the rest of the Shell Scripting Language is developed.
Processing the Shell Scripting Language
This section of the document defines how we should be processing the Shell Scripting Language. This defines how the OS will interface with the shell and how the user should go about generating the shell.
Pre-OS Processing
The user must take the following steps for generating the shell and loading it on the TI-85 so it can be used.
1) The user will generate the shell using the Shell Scripting Language. Either the user will make a new logical layout using the XML defined by us or a new appearance using DHOS-XSL.
2) The user will then run the XML and DHOS-XSL files through our compiler. The compiler will validate the XML and DHOS-XSL and tell the user if any errors have occurred. The output from the compiler will be two .bin files with binary data about the shell.
3) The user then needs to run a simple program to download the .bin files onto the calculator into the correct locations so that they DHOS will be able to find them.
OS-Boot Processing
1) When the OS boots, it must bind the system functions to the binary functions. This will make the association necessary.
2) DHOS will then need to process the binary files and load them to the screen as the resulting shell. This takes a burden of the processing away from the DHOS program.
Notice that we don't actually compile the shell into assembly code and that DHOS needs to make the function binding at run-time. This is the best way (it will make the shell the most stable) for this kind of solution.