DrawGen - Part 2

!DrawGen - Part 2.

Text and Paths.

At the end of the first article on !DrawGen I left you to try a 'C' program which contained some commands which I hadn't explained. You may well have been able to puzzle them out already, but if not, here are the keys to the riddles... Firstly, lets look at producing text.

I have already introduced the command:

DG_text(some_text, x_position, y_position);

where the first parameter is a text string, and the other two are integers which determine where the bottom-left corner of the displayed text will appear in the drawfile. To accompany this command there is another:

DG_font(font, font_width, font_height, font_colour);

where 'font' is an integer which selects the font to be used, font_width and font_height are also integer values which set the size of the font to print (in 'points'), and font_colour is a string - e.g. "red" - which sets the colour of the font.

To see which fonts !DrawGen is using, open a task-window (press Control-F12), then type "DrawGen Help", and press return. (Note: that *is* the right way around!). If the module is active this will cause it to print some information. For the version which you can get on the Archive disc (or from the Archive WebSite) this information should read something like:

DrawGen Version 1.22 - 6nd June 1994 (c) Dr. J. C. G. Lesurf Physics & Astronomy Dept. University of St. Andrews, Fife KY16 9SS Scotland. Default linewidth = 5 decipoints. Default text width = 12 & height = 12 points. Default line style = 0 8 others defined. Default font = #1 Resident fonts: 1 = Homerton Medium 2 = Homerton.Medium.Oblique 3 = Homerton.Bold 4 = Trinity.Medium 5 = Trinity.Medium.Italic 6 = Trinity.Bold Extra fonts = 3 7 = Corpus.Medium 8 = Corpus.Medium.Oblique 9 = Corpus.Bold See !Help file for more information.

N.B. I have left the above as it appeared in the original Archive article.
However, the help text is different for the 2019 version!

In this case font '5' is Trinity.Medium.Italic, so if we want to write something in this font using characters 20 points wide and 24 points high, in blue, we'd use the command:

DG_font(5,20,24,"blue");

and then follow this with the appropriate DG_text commands. To see how this works, try the program:

* demo of text drawing 2 */ #include <stdio.h> #include "DGLib.h" int main(void) { DG_open("ram:text2"); /* Create the file */ DG_text("Hi There!",200,300); /* Print some text in the default font */ DG_font(5,18,24,"darkblue"); /* Change to 'font 5' (Trinity.Medium.Oblique), 18 points wide by 24 points high, coloured dark blue. */ DG_text("Now dark blue and new font!",200,350); /* Text is now coloured */ DG_font(7,16,16,"red"); /* now red corpus, 16*16 point */ DG_text("Now in red",200,400); DG_make(); /* Tell DrawGen to make the DrawFile */ /* That's it! */ }

This produces fig 2.1

You can now use the DG_font/DG_text commands to produce text as and how you wish in your drawfile. What's more, you aren't limited to the fonts shown above. You can add some fonts of your choice to the list that DrawGen knows about. To do this you have to alter the contents of the !Run file which is inside the !DrawGen application.

Open up !DrawGen by holding down <shift> and double-clicking on its icon with select. Now draw the !Run file and drop it onto your favourite plain text editor. (!Edit if you haven't anything better!). This will now show:

Set DrawGen$Options -F3 -D1 -L5 -W12 -H12 Set DrawGen$ExFonts Corpus.Medium/Corpus.Medium.Oblique/Corpus.Bold RMEnsure ABCLibrary 0.01 RMLoad <Obey$Dir>.ABCLib RMEnsure ABCLibrary 0.01 Error 0 Requires ABCLib. RMload <Obey$Dir>.DrawGenMod

The interesting lines here are the first two which 'set' a pair of system variables. The second of these - DrawGen$ExFonts - is a list of the fonts you want to add to the basic ones (the Homerton and Trinity families) which !DrawGen knows about. By default the extra fonts are just the Corpus family as that's the only one I can feel confident will be on most machines. You can change these if you wish to other fonts which you wish to use. For example, on my machine these lines are normally set to:

Set DrawGen$Options -F8 -D1 -L5 -W12 -H12 Set DrawGen$ExFonts Bodoni/Bodoni.Italic/Bodoni.Bold.Italic /MathPhys/MathPhys.Italic/LondonA/LondonA.Italic/LondonA.Bold

So I'd normally get the Bodoni font when I ask !DrawGen for font 7, and LondonA.Italic when I ask for font 13. To set up your own choices, change the DrawGen$ExFonts string to include the fonts you want, but keep to the following rules:

The string can't have any spaces in it, so separate the font names by using '/' slashes as shown above.
Use the *exact* names of your fonts.
The string must be less than 255 characters long
Also change the '-F' item in the DrawGen$Options line.

This final item is because the -F tells !DrawGen how many extra fonts to expect over and above those it always assumes are present. When you get !DrawGen this will be set to '-F3'. But if you were to make the change to my own font choices their would now be 8 extra fonts, so this item would have to be changed to '-F8'.

While looking at the !Run file, this is perhaps a good time to explain the other options. These are:

-D which sets the default font (normally '1' for Homerton medium)
-W which sets the default font width in points
-H which sets the default font height in points
-L which sets the default width of lines (in tenths of a point) used for commands line 'DG_rectangle', etc.

By altering these settings you can tailor the !DrawGen defaults to suite your needs.

Paths

Having dealt with text in detail we can now have a close look at how you can draw complex patterns. In the previous article I showed an easy way to draw simple shapes like rectangles and circles. However !DrawGen also provides a way to draw almost any shape, using a wide variety of lines. This more powerful level of drawing is based upon a small set of commands which set out to provide access to the DrawFile concept of a *path*. The easiest way to understand this is by looking at an example:

* demo of path drawing 1 */ #include <stdio.h> #include "DGLib.h" int main(void) { DG_open("ram:paths1"); /* Create the file */ DG_path(100,200,5,0,-1); /* Start a path at x=100, y=200 (OS units) line thickness = 5 tenths of a point line colour 0 (i.e. black) fill colour -1 (i.e. no filling) */ DG_draw(150,230); /* Draw about a bit, just like old BASIC 'PLOT' */ DG_draw(60,300); DG_draw(300,200); DG_move(320,220); /* move a bit without drawing anything */ DG_draw(400,400); /* Draw a bit more */ DG_draw(400,450); DG_end(); /* End the drawing path */ DG_make(); /* Tell DrawGen to make the DrawFile */ /* That's it! */ }

This produces the pattern shown in figure 2.2.

Although not exactly worthy of Rembrant, this drawing shows how the path drawing system works. To draw a path you start with the command:

DG_path(x_start, y_start, thickness, colour, fill);

This tells drawgen to start drawing the object or path at the location, x_start, y_start. Both these values are integers in 'OS units'. The remaining three integer values provided define the line thickness (in tenths of a point), its line colour, and the filling colour (if any). To draw out the actual shape you then use the appropriate mixture of

DG_draw(x, y);

and

DG_move(x, y);

commands. These work very much like the DRAW and MOVE commands used by BASIC to draw on the screen. We essentially draw a line from place to place using the DG_draw command, or use DG_move to move without drawing anything.

To tell !DrawGen we've finished the path, we use the command:

DG_end();

Unlike the simple commands we've used up until now, the DG_path command gives us detailed control over the colours. To do this we must use numbers define the red, green, and blue content. For example, try the program:

/* demo of path drawing 2 */ #include <stdio.h> #include "DGLib.h" int main(void) { DG_open("ram:paths2"); /* Create the file */ DG_path(100,200,10,0x0000ff00,0x00ff0000); /* Start a drawing path at x=100, y=200 (OS units) line thickness = 10 tenths of a point line colour 0x0000ff00 (i.e. red) fill colour 0x00ff0000 (i.e. green) */ DG_draw(200,200); /* Draw around the shape */ DG_draw(200,150); DG_draw(150,120); DG_close(); /* close the shape - i.e. fill it */ DG_end(); /* End the drawing path */ DG_make(); /* Tell DrawGen to make the DrawFile */ /* That's it! */ }

This produces the shape shown in figure 2.3 - a peculiar shape which shows a red line filled in green.

The colours are defined by the two values, "0x0000ff00", and "0x00ff0000" in the DG_path command. These values follow the internal Acorn standard approach, they are integers in hexadecimal form, "0xbbggrr00", where the "rr" sets the amount of red, the "gg" sets the amount of green, and the "bb" the amount of blue. On this basis we can now look back at the previous example which created fig2.2 and see that this had a line colour of "0", i.e. of "0x00000000" or "no blue, no green, no red", hence a black line. To get a 'transparent' colour we use the special value "-1". Using this as the fill colour in the earlier example ensured that the no attempt was made to fill the shape. In this newer red/green example we have specified a green fill. In principle, we can use any colours we like.

When filling in a shape it is a good idea to use the command

DG_close();

just before DG_end(). This ensures that the shape is fully closed and the chosen line runs all around the edge.

That's probably enough about drawing complex lines for now, but in part 3 we can see how it is possible to draw curved lines, and lines which have dotted/dashed patterns. Before that, however, I'll spend time in the next part explaining how to use !DrawGen from BASIC programs. (And about time, too! I hear some of you say!)

Content and pages maintained by: Jim Lesurf
using HTMLEdit3 on a StrongARM powered RISCOS machine.