Because the procedures and functions do not form part of your program the size of its file is reduced, and if a bug is found in one of the functions it can be corrected by updating the library without having to modify each of the programs in which it is used.
You can build up your own set of such files, but BBC BASIC for SDL 2.0 is supplied with the following libraries:
The library should be loaded from your program using the statement:
INSTALL @lib$+"arraylib"
The functions contained are:
In BBC BASIC for SDL 2.0 several of these operations are incorporated within the interpreter. Using the built-in operations will be considerably faster than using the library routines; see the Array arithmetic section for details. The library routines which are not supported as built-in operations are PROC_transpose, PROC_invert and FN_det.When executed this program will print:DIM N(3) N() = 1, 2, 3, 4 PROC_add(N(), 5) PRINT N(0),N(1),N(2),N(3)
6 7 8 9
When executed this program will print:DIM N(3) N() = 1, 2, 3, 4 PROC_mul(N(), 2) PRINT N(0),N(1),N(2),N(3)
2 4 6 8
When executed this program will print:DIM N(3), S(3) N() = 1, 2, 3, 4 S() = 5, 6, 7, 8 PROC_sum(N(), S()) PRINT N(0),N(1),N(2),N(3)
6 8 10 12
When executed this program will print:DIM N(0,2), S(2,1), D(0,1) N() = 1, 2, 3 S() = 4, 5, 6, 7, 8, 9 PROC_dot(N(), S(), D()) PRINT D(0,0) D(0,1)
40 46
When executed this program will print:DIM N(1,2), T(2,1) N() = 1, 2, 3, 4, 5, 6 PROC_transpose(N(), T()) PRINT T(0,0) T(0,1) PRINT T(1,0) T(1,1) PRINT T(2,0) T(2,1)
1 4
2 5
3 6
When executed this program will print:DIM M(2,2) M() = 2,0,6,8,1,-4,0,5,7 PROC_invert(M()) PRINT M(0,0) M(0,1) M(0,2) PRINT M(1,0) M(1,1) M(1,2) PRINT M(2,0) M(2,1) M(2,2)
0.09184 0.10204 -0.02041 -0.19048 0.04762 0.19048 0.13605 -0.03401 0.00680
When executed this program will print:DIM M(2,2) M() = 2,0,6,8,1,-4,0,5,7 PRINT FN_mod(M())
13.96424
When executed this program will print:DIM M(2,2) M() = 2,0,6,8,1,-4,0,5,7 PRINT FN_det(M())
294
The library should be loaded from your program using the statement:
Some of the functions contained are:INSTALL @lib$+"dlglib"
The string title$ specifies the title of the dialogue box, which is displayed in its title bar. The parameters cx% and cy% specify the width and height, respectively, of the dialogue box in dialogue box units (see below). IF cx% and/or cy% is set to zero this signifies that the subsequently-defined controls are to be displayed on the main window rather than in a dialogue box; in that case title$ is ignored.dlg% = FN_newdialog(title$,cx%,cy%)
Dialogue boxes are automatically scaled according to the size of the font, therefore it is important that you select the required font before calling FN_newdialog. So typically the code to create a dialogue box will be something like this:
OSCLI "FONT """ + @lib$ + "DejaVuSans"",12"
dlg% = FN_newdialog("Dialogue box", 160, 140)
The size of the dialogue box, and the positions and sizes of controls within the dialogue box,
are specified in dialogue box units, each of which corresponds to approximately one-eighth
of the height of the selected font. So if the character height is 16 pixels, each dialogue box unit is 2 pixels.
However if the width and/or height of the dialogue box is set to zero, signifying that the control(s) will be
displayed on the main window, the positions and sizes of the controls are specified in pixels.
The returned value (dlg% in this case) identifies the dialogue box, and must be stored for use in the subsequent procedures. Immediately after calling FN_newdialog() you should define each of the controls in the dialogue box by calling one or more of the following procedures; again they should be called just once, during your program's initialisation phase. The order in which you define the controls is important, because it determines the tab order of the controls.
The dlg% parameter identifies the dialogue box, and is the value returned from FN_newdialog. The string text$ specifies the text to appear inside the button (e.g. "OK") or in the case of a BS_BITMAP or BS_ICON button (see below) the path and filename of the image file to be displayed in the button.PROC_button(dlg%, text$, id%, x%, y%, cx%, cy%, style%)
The x% and y% parameters specify the position of the button within the dialogue box and the cx% and cy% parameters specify the size of the button (in dialogue box units). Vertical positions are measured from the top of the dialogue box.
The id% parameter is a unique identifier of the pushbutton; all the items within a particular dialogue box must have different ID values. You can choose any value (within reason) but values 1 to 9 are special because they cause the dialogue box to be exited and control returned to your program when the button is clicked. IDs 1 and 2 are reserved for the OK and Cancel buttons respectively so should only be used for that purpose. Alternatively you can set this parameter to a value returned from FN_setproc which will cause the specified procedure to be called when the button is clicked.
The style% parameter can be zero, but other values allow you to modify the appearance or behaviour of the pushbutton. Setting style% to &80 (BS_BITMAP) or &40 (BS_ICON) indicates that the button will display the bitmap image whose filename was specified in the text$ parameter (BS_ICON differs from BS_BITMAP in suppressing the rectangle normally drawn around the button). Adding WS_DISABLED (&8000000) to the style value causes the button to be initially disabled (greyed-out); adding WS_VISIBLE (&10000000) causes it to be (initially) invisible.
The dlg% parameter identifies the dialogue box, and is the value returned from FN_newdialog. The text$ parameter specifies the text to appear alongside the checkbox, the x% and y% parameters specify the position of the checkbox within the dialogue box and the cx% and cy% parameters specify the size of the checkbox and its associated text (in dialogue box units). The id% parameter is a unique identifier for the checkbox.PROC_checkbox(dlg%, text$, id%, x%, y%, cx%, cy%, style%)
The style% parameter can be zero; setting it to 1 causes the box to be initially checked. Adding WS_DISABLED (&8000000) to the style value causes the checkbox to be initially disabled (greyed-out); adding WS_VISIBLE (&10000000) causes it to be (initially) invisible.
The dlg% parameter identifies the dialogue box, and is the value returned from FN_newdialog. The text$ parameter specifies the text to appear alongside the radio button, the x% and y% parameters specify the position of the radio button within the dialogue box and the cx% and cy% parameters specify the size of the radio button and its associated text (in dialogue box units). The id% parameter is a unique identifier for the radio button.PROC_radiobutton(dlg%, text$, id%, x%, y%, cx%, cy%, style%)
The style% parameter can be zero; setting it to 1 causes the button to be initially checked. Adding WS_DISABLED (&8000000) to the style value causes the radio button to be initially disabled (greyed-out); adding WS_VISIBLE (&10000000) causes it to be (initially) invisible.
Radio buttons defined consecutively, by calling PROC_radiobutton, are grouped: checking one automatically unchecks the others. Groups of radio buttons should be separated by at least one control of a different type.
The dlg% parameter identifies the dialogue box, and is the value returned from FN_newdialog. The text$ parameter specifies the text to appear in the top edge of the group box, the x% and y% parameters specify the position of the group box within the dialogue box and the cx% and cy% parameters specify the size of the group box (in dialogue box units). The id% parameter is an identifier for the group box (this is unlikely to be used). The style% parameter should usually be zero.PROC_groupbox(dlg%, text$, id%, x%, y%, cx%, cy%, style%)
The dlg% parameter identifies the dialogue box, and is the value returned from FN_newdialog. The text$ parameter specifies the initial text (if any) to appear in the text box, the x% and y% parameters specify the position of the text box within the dialogue box and the cx% and cy% parameters specify the size of the text box (in dialogue box units); ensure that the height is sufficient for the size of text you are using. The id% parameter is a unique identifier for the text box.PROC_textbox(dlg%, text$, id%, x%, y%, cx%, cy%, style%)
The style% parameter can be zero; setting it to ES_NUMBER (&2000) causes the text box to accept only numeric input. Adding WS_DISABLED (&8000000) to the style value causes the text box to be initially disabled (greyed-out); adding WS_VISIBLE (&10000000) causes it to be (initially) invisible.
The dlg% parameter identifies the dialogue box, and is the value returned from FN_newdialog. The text$ parameter specifies the required text, the x% and y% parameters specify the position of the rectangle within the dialogue box and the cx% and cy% parameters specify the size of the rectangle (in dialogue box units). The id% parameter is a unique identifier for the static item (this is unlikely to be used).PROC_static(dlg%, text$, id%, x%, y%, cx%, cy%, style%)
The style% parameter may be zero, but other values allow you to modify the appearance of the static item. By default text is left-justified within the rectangle but setting style% to 1 (SS_CENTER) causes the text to be centred within the rectangle and setting it to 2 (SS_RIGHT) causes the text to be right-justified within the rectangle.
The dlg% parameter identifies the dialogue box, and is the value returned from FN_newdialog. The string parameter is unused and should be set to an empty string, the x% and y% parameters specify the position of the list box within the dialogue box and the cx% and cy% parameters specify the size of the list box (in dialogue box units). The id% parameter is a unique identifier for the list box.PROC_listbox(dlg%, "", id%, x%, y%, cx%, cy%, style%)
The style% parameter can be zero; adding LBS_USETABSTOPS (&80) causes the list box to expand tab characters, adding WS_VSCROLL (&200000) includes a vertical scroll bar. Adding WS_DISABLED (&8000000) to the style value causes the text box to be initially disabled (greyed-out); adding WS_VISIBLE (&10000000) causes it to be (initially) invisible.
If the list box is created with the LBS_USETABSTOPS style, set the column positions by calling PROC_setlistboxcols() as follows:
The dlg% parameter identifies the dialogue box, and is the value returned from FN_newdialog; the id% parameter identifies the list box. The columns% array contains a zero-based list of column widths in dialogue-box units. Note that only one list box can have the LBS_USETABSTOPS style.PROC_setlistboxcols(dlg%, id%, columns%(), cols%)
To set or update the contents of the list box call PROC_setlistboxarray() as follows:
The dlg% parameter identifies the dialogue box, and is the value returned from FN_newdialog; the id% parameter identifies the list box. The string array should contain one element per list box item, with items% indicating the total number of items. Index zero is unused, so the items should be in array$(1) to array$(items%).PROC_setlistboxarray(dlg%, id%, array$(), items%)
The dlg% parameter identifies the dialogue box, and is the value returned from FN_newdialog. The text$ parameter specifies the initial text (if any) to appear in the selection field, the x% and y% parameters specify the position of the combo box within the dialogue box and the cx% and cy% parameters specify the dropped-down size of the combo box (in dialogue box units). The id% parameter is a unique identifier for the combo box.PROC_combobox(dlg%, text$, id%, x%, y%, cx%, cy%, style%)
The style% parameter can be zero; adding WS_DISABLED (&8000000) to the style value causes the combo box to be initially disabled (greyed-out); adding WS_VISIBLE (&10000000) causes it to be (initially) invisible.
To set or update the contents of the combo box call PROC_setcomboboxarray() as follows:
The dlg% parameter identifies the dialogue box, and is the value returned from FN_newdialog; the id% parameter identifies the combo box. The string array should contain one element per combo box item, with items% indicating the total number of items. Index zero is unused, so the items should be in array$(1) to array$(items%).PROC_setcomboboxarray(dlg%, id%, array$(), items%)
The dlg% parameter identifies the dialogue box, and is the value returned from FN_newdialog. The string parameter is ignored and should be set to an empty string, the x% and y% parameters specify the position of the trackbar within the dialogue box and the cx% and cy% parameters specify the size of the trackbar (in dialogue box units). The id% parameter is a unique identifier for the trackbar.PROC_trackbar(dlg%, "", id%, x%, y%, cx%, cy%, style%)
The style% parameter can be zero; adding WS_DISABLED (&8000000) to the style value causes the trackbar to be initially disabled (greyed-out); adding WS_VISIBLE (&10000000) causes it to be (initially) invisible.
To set the minimum, maximum and current values of the trackbar call PROC_settrackbarpos() as follows:
PROC_settrackbarpos(dlg%, id%, current%, minimum%, maximum%)
The dark% parameter should be set to TRUE if you want the dialogue box to use a 'dark' style, and to FALSE if you want it to use the normal 'light' style. The optional callback routine FNmycb() is called whilst the dialogue box remains open, both when a keypress is detected and periodically. This allows you to monitor activity and if necessary update the dialogue box contents as things change. See Monitoring dialogue box changes for more details.PROC_setdialogpalette(dark%) PROC_registerdlgcallback(dlg%, FNmycb()) : REM optional OSCLI "FONT """ + @lib$ + "DejaVuSans"",12"
Now you can display the dialogue box:
alternatively:result% = FN_showdialog(dlg%, x%, y%)
The dlg% parameter identifies the dialogue box, and is the value returned from FN_newdialog, the x% and y% parameters set the position of the dialogue box (top-left corner) in dialogue box units. If you set both x% and y% to &FFFFFFFF80000000 the dialogue box will be centered in the window. The optional dark% parameter should be set to TRUE if you want the dialogue box to use a 'dark' style, and to FALSE if you want it to use the normal 'light' style.result% = FN_showdialogex(dlg%, x%, y%, dark%)
The function will return when the user clicks on a button with an ID number in the range 1 to 9, with the returned value equal to that ID.
DIM Click%(2) ON MOUSE Click%() = @msg%,@wparam%,@lparam% : RETURN PROC_setdialogpalette PROC_refreshdialog(dlg%) REPEAT key% = INKEY(1) REM Do anything that you need to do periodically here result% = FN_polldialog(dlg%, key%, Click%()) UNTIL result% = 1 OR result% = 2
The routine will be called both periodically (in which case K% will be -1) or when a keypress is detected (in which case K% will be set to the key code). In both cases D% identifies the dialogue box (it is the value originally returned from FN_newdialog). If you return zero from the callback function the dialogue box will remain open; if you return a value in the range 1 to 9 it will exit, as if a button with that ID was pressed.DEF FNmycb(D%, K%) LOCAL N% ... = N%
In the callback routine you may read the contents of the various controls (see Reading the contents of a dialogue box) and if necessary update them (see Updating the contents of a dialogue box). The simplest possible callback routine results in pressing the Enter (Return) key having the same effect as clicking on the OK button:
DEF FNmycb(D%,K%) IF K% = 13 THEN = 1 = 0
PROC_refreshdialog(dlg%)
The dlg% parameter is the value returned from FN_newdialog, the id% parameter is the identifier for the item in question and text$ is the new text string to be associated with the item (or in the case of a BS_BITMAP or BS_ICON button the path and filename of the new image file).PROC_setdlgitemtext(dlg%, id%, text$)
orPROC_setlistboxarray(dlg%, id%, array$(), items%)
where the value id% is the identifier of the list box or combo box. Strictly speaking if the number of items doesn't change, and if the list box does not have the LBS_USETABSTOPS style, you can simply update the contents of the associated array, but it does no harm to call the procedure as well.PROC_setcomboboxarray(dlg%, id%, array$(), items%)
To empty a list box or combo box of its contents set all the elements of the array to a NUL string (array$() = "") and call the appropriate procedure with items% set to zero.
If you wish to set the current selection (which item in the list box or combo box is highlighted) do this:
orPROC_setlistboxselect(dlg%, id%, selitem%)
PROC_setlcomboboxselect(dlg%, id%, selitem%)
Where checked% is TRUE to set the checked state or FALSE to uncheck it. In the case of a set of radio buttons you should explicitly set only one of the buttons to the checked state and the rest to the unchecked state, the dialogue box cannot be relied upon to do this automatically.PROC_checkdlgitem(dlg%, id%, checked%)
To disable or enable an item you can use PROC_enabledlgitem():
Here id% is the identifier of the item you want to affect. To disable the item set enable% to FALSE, to re-enable it set it to TRUE.PROC_enabledlgitem(dlg%, id%, enable%)
To hide or show an item you can use PROC_showdlgitem():
Here id% is the identifier of the item you want to affect. To hide the item set show% to FALSE, to show it again set it to TRUE.PROC_showdlgitem(dlg%, id%, show%)
To read the text associated with a dialogue box item (which may for example be the contents of an edit box or the current selection of a combo box) you can use FN_getdlgitemtext():
The parameter dlg% is the value returned from FN_newdialog and the parameter id% is the identifier of the item in question.text$ = FN_getdlgitemtext(dlg%, id%)
In the case of a list box you can alternatively read the index of the selected item as follows:
where the value id% is the identifier for the list box. The returned value selected% gives the index of the currently selected item. If no item is selected, zero is returned.selected% = FN_getlistboxselect(dlg%, id%)
Similarly to determine which item is selected in a combo box do the following:
To discover the current state of a check box or radio button, you can use FN_isdlgitemchecked():selected% = FN_getcomboboxselect(dlg%, id%)
where the value id% is the identifier for the check box or radio button. The value state% is set to FALSE if the button is not checked and to TRUE if it is checked.state% = FN_isdlgitemchecked(dlg%, id%)
To discover the current setting of a trackbar, call FN_gettrackbarpos():
setting% = FN_gettrackbarpos(dlg%, id%)
The dialogue box template remains in memory, so you can display it again at any time by calling FN_showdialog.PROC_closedialog(dlg%)
The dialogue box should also be removed whenever your program returns to immediate mode (for example if an error occurs or the END statement is executed) or when your program's window is closed by the user. You will probbaly need to use ON ERROR and ON CLOSE to achieve this:
Because the dialogue box uses space on the heap, it is essential that you remove it before executing a CLEAR, CHAIN or RUN statement.ON CLOSE PROC_closedialog(dlg%):QUIT ON ERROR PROC_closedialog(dlg%):PRINT'REPORT$:END
The procedure must be defined to receive two parameters:
where D% and I% receive a value identifying the dialogue box (the value returned by FN_newdialog()) and the ID number of the button clicked respectively.DEF PROChandler(D%, I%)
BBC BASIC also lacks the UPPER$ (or UCASE$) and LOWER$ (or LCASE$) functions provided in some dialects of BASIC to convert strings to uppercase (capitals) or lowercase characters respectively.
The fnusing library provides replacements for these operations. It should be loaded from your program using the statement:
Alternatively, since the functions are quite short, you might prefer to incorporate them in your own program (use the Insert command from the File menu).INSTALL @lib$+"fnusing"
The functions contained are:
A significant difference from the conventional PRINT USING statement is that each format string can only refer to one numeric value, so you must call FNusing for each value you want to output.PRINT FNusing(fmt1$,val1) FNusing(fmt2$,val2) .....
The format string is a string literal or variable containing special formatting characters, as follows:
| # | The hash character is used to represent a digit position. Digit positions are always
filled: if the number has fewer digits than positions specified it is right-justified
(preceded by spaces) in the field. A decimal point may be inserted at any position in the field
and numbers are rounded as necessary. For example:
PRINT FNusing("##.##",.78)
0.78
PRINT FNusing("###.##",987.654)
987.65
|
| + | A plus sign at the beginning or end of the format field causes the sign of the number
(plus or minus) to be printed before or after the number. For example:
PRINT FNusing("+###.##",2.4)
+2.40
PRINT FNusing("##.##+",55.678)
55.68+
PRINT FNusing("##.##+",-3)
3.00-
|
| − | A minus sign at the end of the format field causes negative numbers to be printed
with a trailing minus sign. For example:
PRINT FNusing("##.##-",-68.95)
68.95-
PRINT FNusing("###.##-",-7)
7.00-
|
| ** | A double asterisk at the beginning of the format field causes leading spaces in the
field to be filled with asterisks. The ** also specifies two more digit positions. For example:
PRINT FNusing("**#.#",12.39)
*12.4
PRINT FNusing("**##.##",-0.9)
**-0.90
|
| $$ | A double dollar (or pound) sign at the beginning of the format field causes a dollar (or
pound) sign to be printed to the immediate left of the formatted number. The $$ also
specifies two more digit positions, one of which is the currency symbol. For example:
PRINT FNusing("$$###.##",45.67)
$45.67
PRINT FNusing("££###.##",123.45)
£123.45
|
| **$ | A **$ (or **£) at the beginning of the format field combines the effects of the previous two
formats. Leading spaces are filled with asterisks, and a dollar (or pound) sign is printed
before the number. **$ specifies three more digit positions, one of which is the currency
symbol. For example:
PRINT FNusing("**$##.##",2.34)
***$2.34
|
| , | A comma to the left of the decimal point in the format string causes a comma to be
printed between every third digit before the decimal point. For example:
PRINT FNusing("#,###.##",1234.5)
1,234.50
PRINT FNusing("##,###,###",1E6)
1,000,000
|
| ^^^^ | Four carets may be placed after the digit characters to specify exponential format.
The four carets allow space for "E-xx" to be printed. For example:
PRINT FNusing("##.##^^^^",234.56)
2.35E2
PRINT FNusing("##.##^^^^",1E-30)
1.00E-30
|
PRINT FNusing("Price ££#.## including VAT",29.99)
Price £29.99 including VAT
If the number cannot be represented in the format supplied, question marks are printed:
PRINT FNusing("##.##",123)
?????
PRINT FNlower("The Quick Brown Fox")
the quick brown fox
PRINT FNupper("The Quick Brown Fox")
THE QUICK BROWN FOX
INSTALL @lib$+"datelib"
The functions contained are:
The parameters supplied are the day of the month (1-31), the month number (1-12) and the year number (1-9999). Note that the functions in the DATELIB library will behave consistently for any date in that range (for example, converting from DMY to MJD and back will return the original values) but should not normally be used for dates prior to the introduction of the Gregorian calendar (in the UK on Thursday 14th September 1752, MJD −38779). For earlier dates the day, month and year values may not be correct, and since use of the old Julian calendar persisted in some countries until as late as 1927 care should be taken when using this function.
For example:
d Day of month as digits with no leading zero. dd Day of month as digits with leading zero for single-digit days. ddd Day of week as a three-letter abbreviation. dddd Day of week as its full name. M Month as digits with no leading zero. MM Month as digits with leading zero for single-digit months. MMM Month as a three-letter abbreviation. MMMM Month as its full name. y Year as last two digits, but with no leading zero. yy Year as last two digits, but with leading zero for years less than 10. yyyy Year represented by full four digits.
will return a string of the form "Sun 22 Feb 2004".date$ = FN_date$(mjd%, "ddd dd MMM yyyy")
The FN_readdate function attempts to make sense of the date string however it is formatted, so long as the elements are in the specified order. For example it will accept "22/2/2004", "22 Feb 04", "22-02-04" etc. If it cannot make sense of the string it will return the value &80000000.
INSTALL @lib$+"ogllib"
The functions contained are:
The hw%% parameter is the handle of the window which is to contain the 3D graphics. It should normally be set to @hwnd% if the graphics are to be displayed in BBC BASIC's main output window. Note that you cannot mix OpenGL graphics and normal BBC BASIC output (text or graphics) in the same window.
The cull% parameter specifies the culling mode, which determines whether surfaces behave as single sided or double sided. Possible values are 1 (none), 2 (clockwise) or 3 (counterclockwise). If in doubt, set to 1.
The light% parameter determines whether the lighting engine is enabled. Set to 1 to enable lighting or to 0 to disable lighting. When lighting is disabled all objects appear normally as if uniformly illuminated. When lighting is enabled it is necessary for all objects to include surface normals in the vertex description.
The pdev% parameter is the value returned from FN_initgl. The file$ parameter is the name of a file containing vertex data in Flexible Vertex Format.
The num%, fmt% and size% parameters are outputs from FN_load3d and are set to the number of vertices, the vertex format and the size in bytes of each vertex respectively.
The file format is as follows:
Number of vertices (4 bytes, LSB first) Vertex format (2 bytes, LSB first) Vertex size in bytes (2 bytes, LSB first) Data for each vertex (see below)
To obtain the vertex format code add together the codes for the items included. To obtain the vertex size add together the sizes of the items included. The XYZ position and surface normal items each consist of three 4-byte floating point numbers (see FN_f4). The diffuse colour and specular colour items each consist of 4-byte colour values (&FFrrggbb). The texture coordinates consist of a pair of 4-byte floating point numbers. The simplest vertex description consists of an XYZ position and a diffuse colour (format &042; size 16 bytes). See FN_f4 for an example of creating a file in this format.
Code Size Data Comments &002 12 XYZ position Always required &010 12 Surface normal When lighting used &040 4 Diffuse colour When neither texture nor material specified &080 4 Specular colour For shiny objects &100 8 UV texture coordinates When texture specified
The pdev% parameter is the value returned from FN_initgl. The file$ parameter is the (path and) filename of the image file.
Note that in WebGL (only) the image must have 'power-of-two' dimensions, i.e. both the width and the height must be powers of two (256, 512, 1024 etc.).
The pobj% parameter is the value returned from FN_initgl, FN_load3d or FN_loadtexture.
F% = OPENOUT"TRIANGLE.FVF" PROC4(3):REM 3 vertices PROC4(&100042):REM vertex size &10 and format &42 PROC4(FN_f4(-1.0)):PROC4(FN_f4(-1.0)):PROC4(FN_f4(1.0)):PROC4(&FF0000FF) PROC4(FN_f4(1.0)):PROC4(FN_f4(-1.0)):PROC4(FN_f4(1.0)):PROC4(&FF00FF00) PROC4(FN_f4(0.0)):PROC4(FN_f4(1.0)):PROC4(FN_f4(0.0)):PROC4(&FFFF0000) CLOSE #F% DEF PROC4(A%):BPUT#F%,A%:BPUT#F%,A%>>8:BPUT#F%,A%>>16:BPUT#F%,A%>>24:ENDPROC
Notes:
pdev% The value returned from FN_initgl. bcol% The background colour (&FFrrggbb). nlight% The number of lights. Set to zero if lighting is not used. light%() An array of adjusted pointers to light structures (see note 1). nobj% The number of objects (i.e. vertex buffers). mat%() An array of adjusted pointers to material structures (see note 2). tex%() An array of texture pointers (e.g. returned from FN_loadtexture). vbuf%() An array of vertex buffer pointers (e.g. returned from FN_load3d). vnum%() An array of vertex counts (e.g. returned from FN_load3d). vfmt%() An array of vertex format codes (e.g. returned from FN_load3d). vsize%() An array of vertex sizes (e.g. returned from FN_load3d). yaw() An array of yaw angles (rotations about the Y-axis). pitch() An array of pitch angles (rotations about the X-axis). roll() An array of roll angles (rotations about the Z-axis). X() An array of translations along the X-axis. Y() An array of translations along the Y-axis. Z() An array of translations along the Z-axis. eye() An array eye(0), eye(1), eye(2) holding the XYZ coordinates of the eye or camera. look() An array look(0), look(1), look(2) holding the XYZ coordinates of a point on the eyeline. fov The vertical field-of-view in radians (equivalent to the camera's zoom). ar The aspect ratio of the 3D graphics window (width/height). zn The distance from the camera to the near plane (objects nearer than this are invisible). zf The distance from the camera to the far plane (objects further away than this are invisible). roll The camera's roll angle (in radians).
DIM light{Type%, Diffuse{r%,g%,b%,a%}, Specular{r%,g%,b%,a%}, \
\ Ambient{r%,g%,b%,a%}, Position{x%,y%,z%}, Direction{x%,y%,z%}, \
\ Range%, Falloff%, Attenuation0%, Attenuation1%, Attenuation2%, \
\ Theta%, Phi%}
light%(0) = light{} - PAGE + !340
light.Type% = 3 : REM directional light
light.Diffuse.r% = FN_f4(1) : REM red component
light.Diffuse.g% = FN_f4(1) : REM green component
light.Diffuse.b% = FN_f4(0) : REM blue component
light.Specular.r% = FN_f4(1) : REM red specular
light.Specular.g% = FN_f4(1) : REM green specular
light.Specular.b% = FN_f4(0) : REM blue specular
light.Ambient.r% = FN_f4(0) : REM red ambient light
light.Ambient.g% = FN_f4(0) : REM green ambient light
light.Ambient.b% = FN_f4(0) : REM blue ambient light
light.Direction.x% = FN_f4(0) : REM X component of direction
light.Direction.y% = FN_f4(0) : REM Y component of direction
light.Direction.z% = FN_f4(1) : REM Z component of direction
DIM material{Diffuse{r%,g%,b%,a%}, Ambient{r%,g%,b%,a%}, \
\ Specular{r%,g%,b%,a%}, Emissive{r%,g%,b%,a%}, Power%}
mat%(0) = material{} - PAGE + !340
material.Diffuse.r% = FN_f4(0.0) : REM red component of diffuse colour
material.Diffuse.g% = FN_f4(0.7) : REM green component of diffuse colour
material.Diffuse.b% = FN_f4(1.0) : REM blue component of diffuse colour
material.Ambient.r% = FN_f4(0.25) : REM red component of ambient
material.Ambient.g% = FN_f4(0.25) : REM green component of ambient
material.Ambient.b% = FN_f4(0.25) : REM blue component of ambient
material.Specular.r% = FN_f4(1.0) : REM red component of specular colour
material.Specular.g% = FN_f4(1.0) : REM green component of specular colour
material.Specular.b% = FN_f4(1.0) : REM blue component of specular colour
material.Power% = FN_f4(100)
INSTALL @lib$+"ellipse"
The ellipse is drawn in the current graphics foreground colour and mode, as specified by GCOL.
It contains the single function FN_sortinit.INSTALL @lib$+"sortlib"
where dir% determines the sorting direction (0 = ascending, 1 = descending) and smode% is ingored in this implementation. Note that it is most important that a 64-bit variable (%% suffix) or a variant variable (no suffix) is used to contain the returned value, since this may be a 64-bit address.sort%% = FN_sortinit(dir%,smode%)
If you prefer, you can initialise it multiple times with the different options and then CALL the appropriate variable when needed:
To sort the contents of an entire array do the following:sortascending%% = FN_sortinit(0,0) sortdescending%% = FN_sortinit(1,0)
To sort the contents of a '1-based' array (where the first element has the subscript 1) do the following:C% = DIM(array(),DIM(array()))+1 CALL sort%%, array(0)
To sort only part of an array, set C% to the number of elements you want to sort and specify the first element to be sorted:C% = DIM(array(),DIM(array())) CALL sort%%, array(1)
To sort multiple arrays according to the contents of a key array do the following:C% = howmany% CALL sort%%, array(first%)
There can be any number of dependent arrays of any type. If the primary key array contains two or more identical elements, the remaining array(s) will be used as secondary keys, in the order specified.C% = size% CALL sort%%, keyarray(0), array2$(0), array3%(0)...
To sort a two-dimensional array, where the contents of the first row are used as a key for the other rows, do the following:
DIM array(2,999) C% = DIM(array(),DIM(array()))+1 CALL sort%%, array(0,0), array(1,0), array(2,0)
The library should be loaded from your program using the statement:
INSTALL @lib$+"socklib"
The functions contained are:
PROC_initsockets(100)
If the listening socket is created successfully the socket number is returned. If the call fails a negative number is returned (see the code of SOCKLIB.BBC for details). You can call FN_socketerror to discover more about the error.
If the connection is made successfully the socket number is returned. If the call fails a negative number is returned (see the code of SOCKLIB.BBC for details). You can call FN_socketerror to discover more about the error.
Note that it is possible for FN_writesocket to return a value less than the total length of the data. This indicates that only some of the data has been sent, and you should make further calls (adjusting the values of buffer% and size% accordingly) until all the data has been sent.
FN_readsocket does not wait for data to be received. If no data has been received since the last call, it returns zero.
The library should be loaded from your program using the statement:
INSTALL @lib$+"aagfxlib"
The functions contained are:
The colour must be supplied as a 32-bit integer &AABBGGRR where AA is the alpha (opacity) value in the range 0 (fully transparent) to &FF (fully opaque), and RR, GG and BB are the red, green and blue components of the colour in the range 0 (none) to &FF (maximum).
The style can be zero or a combination of one or more of the following values (note: these are not all the same values as used by the Windows GDIPLIB library):
LineEndTriangle = 1 LineEndRound = 2 LineEndArrow = 3 LineStartTriangle = &100 LineStartRound = &200 LineStartArrow = &300 LineDot = &10000 LineDash = &20000 LineDotDash = &30000
The colour and style values are the same as used with PROC_aaline, except that dotted and dashed lines are not supported.
The colour and style values are the same as used with PROC_aaline, except that dotted and dashed lines are not supported.
The colour and style values are the same as used with PROC_aaline, except that dotted and dashed lines are not supported.
The colour value is the same as used with PROC_aaline.
Note that the start angle and the length of the arc are assumed to apply to the circular arc before foreshortening to an ellipse. This is usually what is wanted if you are drawing a circular arc as if viewed obliquely (for example as in a pie-chart) but may not be how other graphics libraries interpret these parameters.
The colour and style values are the same as used with PROC_aaline, except that dotted and dashed lines are not supported.
Note that the start angle and the length of the arc are assumed to apply to the circular sector before foreshortening to an ellipse. This is usually what is wanted if you are drawing a circular sector as if viewed obliquely (for example as in a pie-chart) but may not be how other graphics libraries interpret these parameters.
The colour value is the same as used with PROC_aaline.
The colour value is the same as used with PROC_aaline.
The colour value is the same as used with PROC_aaline.
The colour value is the same as used with PROC_aaline.
The functions contained are:INSTALL @lib$+"stringlib"
PRINT FN_lower("The Quick Brown Fox")
the quick brown fox
PRINT FN_upper("The Quick Brown Fox")
THE QUICK BROWN FOX
PRINT FN_title("the quick brown fox")
The Quick Brown Fox
PRINT FN_binary(22) 10110
PRINT FN_tobase(22, 8, 4) 0026
text$ = "The quick brown fox" num% = FN_findreplace(text$, "brown", "silver", 0) PRINT text$ The quick silver fox
text$ = "The quick brown fox" num% = FN_findreplacei(text$, "BROWN", "silver", 0) PRINT text$ The quick silver fox
PRINT FN_instrr("the quick brown fox", "o", 0)
18
PRINT FN_instri("the quick brown fox", "O", 0)
13
PRINT FN_instrri("the quick brown fox", "O", 0)
18
PRINT """" FN_trim(" The quick brown fox ") """"
"The quick brown fox"
parts% = FN_split("The quick brown fox", " ", a$())
PRINT a$(1)
quick
parts% = FN_split("The quick brown fox", " ", a$())
PRINT FN_join(a$(), "+", parts%)
The+quick+brown+fox
The functions contained are: There are a few minor restrictions in its use:INSTALL @lib$+"multiwin"
Normally s% can be set to zero. The function returns the handle of the created window.
After calling PROC_selectwin all text and graphics output goes to the selected window.
You cannot close the currently-selected output window; if necessary precede the statement with a PROC_selectwin(0).
The functions contained are:INSTALL @lib$+"nowait"
The functions contained are: Since the timer interrupts available using this library may occur at rates up to 1000 Hz, the problem of stalling them is particularly severe. To ensure a timely response to the interrupts, and reduce the likelihood of flooding the event queue, you should avoid using any time-consuming statements and functions such as INKEY, INPUT, GET, SOUND or WAIT. If necessary you can make use of the replacement routines in the NOWAIT library.INSTALL @lib$+"timerlib"
Also, pay particular attention to the precautions described under Notes on the use of interrupts.
The function returns an identifier for use in a subsequent PROC_killtimer, or zero if the timer could not be created.
The functions contained are:INSTALL @lib$+"xmllib"
You can concurrently parse multiple XML files by using separate object structures for each file.
A token can be either a tag or the text contained between two tags; if it is a tag the first character of the returned string will be "<" and the last character will be ">".
At each level of nesting the value returned increases by one. If PROC_exitXML has been called the returned value will be zero.
If the third parameter is set to zero the function will scan the remainder of the file; if the third parameter is set equal to the current level (as returned by FN_getLevel) only the rest of the current 'block' will be searched.
Note that the returned string may contain Unicode characters encoded as UTF-8; see User-defined modes for how to display such characters.
The functions contained are: There are a number of limitations in the use of the ASMLIB library:INSTALL @lib$+"asmlib"
You should add a RESTORE ERROR statement after the closing bracket (]) of your assembler code, unless that is shortly followed by an ENDPROC or end-of-function (which automatically restore the ERROR status).ON ERROR LOCAL [OPT FN_asmext : ] [OPT pass% Assembler code starts here...
The returned structure contains the members A%, B%, C% and D% corresponding to the values returned in the eax, ebx, ecx and edx registers by the CPUID instruction. To test for the availability of the CMOV (conditional move) instructions use the following code:
IF FN_cpuid(1, cpuid{}) IF cpuid.D% AND &8000 THEN
REM CMOV instructions available
ELSE
REM CMOV instructions not available
ENDIF
To test for the availability of the SSE (Streaming SIMD Extension) instructions use the following code:
IF FN_cpuid(1, cpuid{}) IF cpuid.D% AND &2000000 THEN
REM SSE instructions available
ELSE
REM SSE instructions not available
ENDIF
To discover the Vendor ID string use code similar to the following:
IF FN_cpuid(0, cpuid{}) THEN
PRINT "Vendor ID string: " LEFT$($$cpuid{},12)
ELSE
PRINT "Vendor ID string not available"
ENDIF
ASMLIB2 is a superset of ASMLIB. It supports all the assembler extensions provided by ASMLIB and contains compatible functions. It is never necessary to INSTALL both ASMLIB and ASMLIB2.INSTALL @lib$+"asmlib2"
To test for the availability of the SSE2 instructions use the following code:
IF FN_cpuid(1, cpuid{}) IF cpuid.D% AND &4000000 THEN
REM SSE2 instructions available
ELSE
REM SSE2 instructions not available
ENDIF
The library should be loaded from your program as follows:
The functions contained are:INSTALL @lib$+"imglib"
The image$ parameter should contain the path and filename of the image to be loaded, which may be in BMP, GIF, JPG or PNG format (a few less common formats are also supported, such as PSD, PPM and TGA). If the format supports an alpha channel (i.e. transparency) the this will be taken into account when the image is plotted. The value returned is used to refer to the image subsequently, it must be stored in a 64-bit (%% suffix) or variant (no suffix) variable. If the value returned is zero the file could not be opened, so this must always be tested.image%% = FN_imgLoad(image$)
The anigif$ parameter should contain the path and filename of the animated GIF file; transparency, if any, will be taken into account when the image is plotted. The value returned is used to refer to the animation subsequently, it must be stored in a 64-bit (%% suffix) or variant (no suffix) variable; if zero the file could not be opened, so this must always be tested.image%% = FN_imgLoadAnimatedGIF(anigif$)
The image%% parameter should contain the value returned by FN_imgLoadAnimatedGIF and the frame% parameter the frame number (starting at zero for the first frame). The function returns the period of time, in centiseconds (1/100 second) for which that frame should be displayed. If zero is returned the requested frame does not exist, i.e. the frame number is greater than or equal to the number of frames in the animation.delay% = FN_imgFrame(image%%, frame%)
The image%% parameter is the value returned from a previous call to FN_imgLoad or FN_imgLoadAnimatedGIF; it must not be zero. The red, green, blue and alpha parameters are multiplication factors, in the range 0.0 to 1.0, which determine by how much the different components should be attenuated. For example if you want to plot a shadow you might set the red, green and blue factors to zero to suppress the colour altogether, and the alpha factor to (say) 0.5 to set the degree to which what is 'behind' the image is darkened by the shadow.PROC_imgMult(image%%, red, green, blue, alpha)
The image%% parameter is the value returned from a previous call to FN_imgLoad or FN_imgLoadAnimatedGIF; it must not be zero. The xpos and ypos parameters specify the coordinates, in BBC BASIC graphics units, of the centre of the image; they need not be integers. The xscale and yscale parameters specify by how much to scale the image in the horizontal and vertical directions respectively; the image may be reduced or increased in size. To avoid image distortion you are recommended to set xscale and yscale to the same value. If xscale or yscale (or both) are negative the image is flipped (mirrored) in that direction. The angle parameter specifies by what angle, if any, the image should be rotated around its centre; the units are degrees in a clockwise direrction.PROC_imgPlot(image%%, xpos, ypos, xscale, yscale, angle)
The image%% parameter is the value returned from a previous call to FN_imgLoad or FN_imgLoadAnimatedGIF; it must not be zero.PROC_imgSize(image%%, width%, height%)
The functions contained are:INSTALL @lib$+"utf8lib"
The library should be loaded from your program using the statement:
INSTALL @lib$+"eventlib"
The functions contained are:
If you need to be informed that the event queue overflowed, you can register a handler for that by specifying an event ID of zero:DEF PROChandler(msg%, wparam%, lparam%)
PROC_eventregister(0, PROCoverflow())
REPEAT PROC_eventpoll WAIT 0 UNTIL FALSE
INSTALL @lib$+"dlglib" INSTALL @lib$+"editbox"
The functions contained include:
The dlg% parameter identifies the dialogue box, and is the value returned from FN_newdialog. The string parameter is ignored, the x% and y% parameters specify the position of the edit box within the dialogue box and the cx% and cy% parameters specify the size of the edit box (in dialogue box units). The id% parameter is a unique identifier for the edit box.PROC_editbox(dlg%, "", id%, x%, y%, cx%, cy%, style%)
The style% parameter can be zero; adding WS_HSCROLL (&100000) includes a horizontal scroll bar and adding WS_VSCROLL (&200000) includes a vertical scroll bar. Adding WS_BORDER (&800000) disables the border normally draw around the control, adding ES_READONLY (&800) disables the ability for the user to edit the contents. Adding WS_DISABLED (&8000000) to the style value causes the edit box to be initially disabled (greyed-out); adding WS_VISIBLE (&10000000) causes it to be (initially) invisible.
The dlg% parameter identifies the dialogue box, and is the value returned from FN_newdialog; the id% parameter identifies the edit box. The lines% parameter indicates the current number of lines of text, starting at index zero, so the text, if any, should be in array$(0) to array$(lines%-1).PROC_seteditboxarray(dlg%, id%, array$(), lines%)
The dlg% parameter identifies the dialogue box, and is the value returned from FN_newdialog; the id% parameter identifies the edit box. The changed% parameter should be set to FALSE or TRUE.PROC_seteditboxchanged(dlg%, id%, changed%)
The dlg% parameter identifies the dialogue box, and is the value returned from FN_newdialog; the id% parameter identifies the edit box. The cx% and cy% parameters set the horizontal and vertical caret (text cursor) coordinates, zero-based. The ax% and ay% parameters set the horizontal and vertical anchor coordinates, zero-based. If the caret and anchor coordinates are different, the region between them is selected (highlighted).PROC_seteditboxselect(dlg%, id%, cx%, cy%, ax%, ay%)
The dlg% parameter identifies the dialogue box, and is the value returned from FN_newdialog; the id% parameter identifies the edit box. The hscroll% parameter sets the horizontal scroll position and the vscroll% parameter sets the vertical scroll position, both in pixels.PROC_seteditboxscroll(dlg%, id%, hscroll%, vscroll%)
The dlg% parameter identifies the dialogue box, and is the value returned from FN_newdialog; the id% parameter identifies the edit box. The keycode% parameter is the code of the keyboard shortcut which performs the wanted editing operation (e.g. 3 corresponding to Ctrl+C for copy, 22 corresponding to Ctrl+V for paste etc.).PROC_editboxedit(dlg%, id%, keycode%)
The dlg% parameter identifies the dialogue box, and is the value returned from FN_newdialog; the id% parameter identifies the edit box.nlines% = FN_geteditboxlinecount(dlg%, id%)
The dlg% parameter identifies the dialogue box, and is the value returned from FN_newdialog; the id% parameter identifies the edit box. The function will return TRUE if editing has taken place, and FALSE if not.changed% = FN_iseditboxchanged(dlg%, id%)
The dlg% parameter identifies the dialogue box, and is the value returned from FN_newdialog; the id% parameter identifies the edit box. The current caret position will be returned in cx% and cy%, and the current anchor position in ax% and ay%. If the caret and anchor positions are the same, no text is selected.PROC_geteditboxselect(dlg%, id%, cx%, cy%, ax%, ay%)
The dlg% parameter identifies the dialogue box, and is the value returned from FN_newdialog; the id% parameter identifies the edit box. The horizontal and vertical scroll positions are returned in hscroll% and vscroll% respectively.PROC_geteditboxscroll(dlg%, id%, hscroll%, vscroll%)
The dlg% parameter identifies the dialogue box, and is the value returned from FN_newdialog; the id% parameter identifies the edit box.canundo% = FN_editboxcanundo(dlg%, id%)
The dlg% parameter identifies the dialogue box, and is the value returned from FN_newdialog; the id% parameter identifies the edit box.canredo% = FN_editboxcanredo(dlg%, id%)
The dlg% parameter identifies the dialogue box, and is the value returned from FN_newdialog; the id% parameter identifies the edit box.selectedtext$ = FN_getselectedtext(dlg%, id%)
INSTALL @lib$+"dlglib" INSTALL @lib$+"sortlib" INSTALL @lib$+"stringlib" INSTALL @lib$+"filedlg"
The functions contained are:
The parameters are as follows:selected$ = FN_filedlg(title$, okverb$, inidir$, filetype$, filter$, flag%) selected$ = FN_filedlgex(title$, okverb$, inidir$, filetype$, filter$, flag%, dark%, xpos%, ypos%)
| title$ | The string to appear in the title bar. |
| okverb$ | The caption to be displayed in the button which confirms file or directory selection (e.g. "Open", "Save" or "Select"). |
| inidir$ | The directory to be initially displayed. Set to "" to remember the directory selected in the previous call. |
| filetype$ | The human-readable description of file type e.g. "BASIC files". This must be quite short to fit in the space available. |
| filter$ | One or more file extensions (including the dot), separated by semicolons, e.g. ".bbc;.bas".
Set to "." for a 'Browse for Folder' functionality (only directories will be listed). |
| flag% | Set to 0 to disable the 'All files' button, set to 1 to enable it. |
| dark% | Set to TRUE to enable 'dark mode', set to FALSE for the normal colour scheme (the colour palette is modified). |
| xpos% & ypos% | Set the position of the file selector, in dialogue box units (which are determined by the current font).
Set both to &FFFFFFFF80000000 to centre the dialogue in the window. |
The string value returned is the selected file or directory, or an empty string if the selection was cancelled.
INSTALL @lib$+"menulib"
The functions contained are:
The dark% parameter should be set to TRUE if you want the menus to use a 'dark' style, and to FALSE if you want them to use the normal 'light' style.PROC_setmenupalette(dark%)
menubar% = FN_createmenubar
The menubar% parameter identifies the menu bar to which the drop-down menu will be added, it is the value returned by FN_createmenubar. The two array parameters menu$() and menu%() define the items in the menu. In each case the first element (index 0) contains information about the menu, and the subsequent elements (indices 1 upwards) contain information about the individual selections within the menu.PROC_addmenu(menubar%, menu$(), menu%())
menu$(0) contains the name of the menu, which is displayed in the menu bar. This should normally be preceded and followed by at least one space, to act as a horizontal separator. To specify which character is used with the Alt key to open the menu, precede it with an ampersand (&). menu%(0) contains the number of items in the menu (these may be actual selections or separators).
The remaining elements in the arrays define the individual menu items. menu$(N%) contains the name of the selection, or an empty string in the case of a separator. It may optionally contain a Tab (CHR$9) character to separate the name from a keyboard shortcut description. To specify which character in the name is used with the Alt key to activate the selection, precede it with an ampersand (&). menu%(N%) contains a numeric ID of the menu selection (less than 4096), or zero in the case of a separator. Adding &1000 to this number causes the selection to be disabled (greyed out); adding &2000 causes a checkmark (tick) to appear to the left of the item.
A typical menu definition is as follows:
DIM filemenu$(6), filemenu%(6) filemenu%() = 6, 20, 21, &1000+22, 23, 0, 24 filemenu$() = " &File ", \ \ "&New"+CHR$9+"Ctrl+N", \ \ "&Open"+CHR$9+"Ctrl+O", \ \ "&Save"+CHR$9+"Ctrl+S", \ \ "Save &As", \ \ "", \ \ "E&xit" PROC_addmenu(menubar%, filemenu$(), filemenu%())
The menubar% parameter identifies the menu bar to be drawn, it is the value returned by FN_createmenubar.PROC_setmenupalette(dark%) PROC_drawmenubar(menubar%)
The menubar% parameter identifies the menu bar which will be polled, it is the value returned by FN_createmenubar. The function returns zero if no menu selection has been made, or the ID number of the menu item if a selection has been made.selection% = FN_pollmenu(menubar%, ^PROCcallback())
The second parameter may be zero, or the address of a callback routine that will be called in order to select the required font (note the use of the circumflex 'address-of' operator). The callback routine should be defined similar to this:
DEF PROCcallback(N%) CASE N% OF WHEN 0: OSCLI "FONT " + MenuFont$ WHEN -1: OSCLI "FONT " + NormalFont$ ENDCASE ENDPROC
The xpos% and ypos% parameters determine where the menu is displayed, specified as the top left-hand corner of the menu in BBC BASIC graphics coordinates. The menu$() and menu%() parameters define the contents of the menu, exactly as in PROC_addmenu; the menu name in menu$(0) is not displayed but it should still be set. The final parameter specifies an optional callback routine to select the required font (see FN_pollmenu); if this is not required, set the parameter to zero.selection% = FN_openmenu(xpos%, ypos%, menu$(), menu%(), ^PROCcallback())
The function returns zero if the menu is dismissed without a selection being made, or the ID number of the menu item if a selection has been made.
INSTALL @lib$+"mode7lib"
The functions contained are:
The set% parameter should be set to 0 to select English as the primary character set and to 1 to select English as the secondary character set. To use the secondary character set you must enable it using VDU 23,18,3,1| after which VDU 155 toggles between primary and secondary sets (each row starts in the primary character set).PROC_saa5050(set%)
The set% parameter acts as it does in PROC_saa5050. The language% parameter selects the desired language: 0 for English, 1 for German, 2 for Swedish, 3 for Italian, 4 for Belgian, 5 for US ASCII, 6 for Hebrew, 7 for Russian or 9 for Greek.PROC_saa505x(set%, language%)
This library is documented separately here.
|
CONTINUE
|
