Chapter 1: Multi-tasking Programs

An important aspect of Wimp-based applications is that they are multi-tasking, which means that they can run at the same time as other programs. At its simplest, this means that you can load and use a program without having to shut down one which is already running. It also makes it easy to transfer data between programs and to use several programs at the same time.

A One-line Multi-tasking Program

DIM b% 255:SYS "Wimp_Initialise",200,&4B534154,"MyApp":t%=TIME:REPEAT SYS "Wimp_Poll",,b%:WHILE TIME>t%+100:VDU 7:t%+=100:ENDWHILE:UNTIL FALSE

Note that this should all be typed in as one line. If you press Return after "SYS", the program won't work.

You won't be able to run it from the command line. Typing it in inside a task window would prove nothing because programs in a task window multi-task anyway. You'll have to type it into your text editor, save it as a Basic file and run it by double-clicking on the file icon.

Before we run it, let's examine how it works. The easiest way to do this is by splitting it up into separate lines, so that it looks like this:

   10 DIM b% 255
   20 SYS "Wimp_Initialise",200,&4B534154,"MyApp"
   30 t%=TIME
   40 REPEAT
   50   SYS "Wimp_Poll",,b%
   60   WHILE TIME>t%+100
   70     VDU 7
   80     t%+=100
   90   ENDWHILE
  100 UNTIL FALSE

The line numbers have been shown purely to make it easier to explain how the program works. We'll be doing this with all the listings in this guide. If you type in your own listings and find that your line numbering is a little different from the numbering in the guide, it could be because you tried your own modification to the program and left an extra line in; alternatively, it might be because you left a line out! Depending on the editor that you use to type in programs, you may even find that your own lines are numbered consecutively in 1s rather than in 10s (assuming the numbers are even displayed by default). Line numbers are present in this guide so that the text can refer to specific lines in the listings, but you don't actually need to type in the line numbers yourself.

Telling RISC OS About Our Program

The operating system has to be told to run our program at the same time as other multi-tasking programs. This is the job of the instruction in line 20; it's also our first use of a software interrupt for real. The SWI "Wimp_Initialise" adds our program to a list of those which the machine runs in turn. Before we call it, though, we have to pass certain numbers to various registers.

The first of these, in R0, is 200. This is the number of the earliest version of RISC OS which the program will run under, multiplied by 100. As there is nothing particularly advanced in this program, it could be run on the earliest version of RISC OS that was produced, which was v2.00 (in an Acorn Archimedes, from 1988 onwards); hence the number 200.

Next, in R1, we put the four-byte hexadecimal number &4B534154, which is the ASCII codes for the word "TASK" (reading from right to left). This is a kind of "magic number" which tells the machine that the program was written to run under RISC OS, rather than the earlier "Arthur" operating system, fitted to the first Archimedes computers in 1987.

Note, by the way, that a multi-byte hexadecimal number is stored in memory with the least significant byte having the lowest address and the most significant byte having the highest, but we write it high byte first, low byte last. The lowest byte, &54, is the code for 'T', the highest byte, &4B, the code for 'K'.

The string in R2 is the name of the application for use in the Task display window. Obviously, the register cannot store a whole string; in this case the number which the SYS command puts into the register is the address where Basic has stored the string.

These numbers, in their respective registers, tell the operating system what we're doing when we call Wimp_Initialise.

Round and Round the Poll

When we call Wimp_Poll, we pass the address of a block of memory that we set up earlier in R1. This is a very common practice in Wimp SWIs.

The WHILE ... ENDWHILE structure between lines 60 and 90 is used here because, you will remember, this program started out as a one-line program. Normally, we would use an IF ... THEN ... ENDIF structure, but that would have presented difficulties in a one-line program.

What actually happens is that we set variable t% to the current TIME count before we start running the polling loop. Each time we go round the loop, we check the current value of TIME to see if has exceeded its old value, t%, by 100. Because TIME is a count of centiseconds, this happens after one second. If this has occurred, we increment t% to make it the new value of TIME, then make the machine beep with a VDU 7 command. In short, this program produces a beep once a second.

If you now run the file, you'll find that the computer will start beeping once a second. It's also possible, though, to do word-processing and run other programs at the same time. These programs are running and behaving normally but our program is also running, making the machine beep once a second. In other words, all these programs, including our own, are multi-tasking.

If you open the Tasks display window, you will see the program listed as "MyApp", the result of the string which was passed in R2 in line 20. You'll also notice that the program has a surprisingly large amount of memory allocated to it, probably 640K. We'll find out how to limit this to a more reasonable figure in the next section.

What you won't be able to do, though, is shut down the program. With properly-written applications, you can click the Menu button over their name in the Task display window and go to a sub-menu with a Quit option. This option won't work with our program because there's no provision written into it to make it shut down. Lines 40 to 100 keep REPEATing the loop until FALSE changes to TRUE and nothing's going to make that happen.

Even if you shut down the machine, you'll find that it will still beep until you reboot it or, of course, switch it off. If you have RISC OS 3.5 or later, you can press Alt-Break and look for the message, "Press Stop to terminate MyApp", but otherwise, you will have to reboot.

So much for our one-line program. Now to make a start on writing an application properly...