Loadstar 224/224.d81/t.manual1

Text File | 2003-01-01 | 11.5 KB | 401 lines

u
    D A T A T O O L   M A N U A L
           by Franz Kottira


    The program is pretty much
self-explanitory. There is a main menu
shown at the top. Select an item,
either by using the cursor keys and
RETURN, or by using the f-keys. You
then will see a table-like user
interface. Enter a cell by pushing
RETURN. In order to store an entry,
push RETURN again. In almost any case
the CTRL-key calls a topical help
screen, showing present options and
keyboard commands.

    To step back one level, e.g. to
cancel an input, use the <BACK-ARROW>
key. If you want to stop a running
process, try the <STOP> key. This will
suspend BASIC execution, device
access, printing and some time
consuming tasks. If you suspect the
program has hung, you can use
<STOP-RESTORE>. This usually resets
the program.

    During operations that require a
rebuilding of the worksheet structure,
the reset is locked because a
disruption of this process would leave
an invalid constitution. You may
overcome this lock by hitting RESTORE
three or more times - on the risk of
losing all your data.


VIEW AND EDIT THE WORKSHEET

Column settings:
 At the top the worksheet there are a
  few items to adjust:

 Headline and Comment are informative.

 A Column is marked with a capital
  letter, ranging from A to Z, which
  means 26 available columns. The
  letter itself is fixed, but you can
  shift, clear, cut or insert the
  content of a column (see later).

 The Column Title is informative.

 The Printable cell determines whether
  a column is part of the outprint or
  not.

 The Type cell allows selection of
  Text or Number. This selection
  determines the way the data in the
  column is treated by BASIC: string
  characters or numeric values. You
  must choose the type before entering
  any data. After choosing the Column
  Type, you will need to use some
  BASIC like val() or str$() for data
  conversion.

 Layout sets the data presentation.
  This concerns firstly alignment
  (left, center or right), and
  secondly the decimal format of
  numbers (0,1 or 2 fixed decimal
  places). This has no effect on
  storage format and numeric accuracy,
  therefore the layout of a column can
  be changed any time.

 Column Width is counted in
  characters, with a range from 6 to
  35. If an entry is longer then the
  column width, it simply will break
  into another line inside the cell.

 The Variable cell links the content
  of the data-cells to a BASIC
  variable used by BASIC to read and
  to store data from and into the
  worksheet. The variable type
  (numeric or string) is determined by
  the column type. The variable name
  consists of one or two characters,
  as usual in C64 BASIC.

 Finally, the BASIC cell allows you to
  store some BASIC code that will be
  executed for each of the data-rows.
  Please note, the system uses the
  lower-case character set, and
  therefore all program statements
  must to be written in small letters.
  The syntax is the same as within C64
  BASIC. A single BASIC Line has a
  maximum length of 80 characters; you
  may string several commands using
  the colon. The memory limitation is
  about 1000 characters each BASIC
  cell.

 Because the RETURN key is assigned to
store the cell, you have to use
<Shift-RETURN> to start a new line.
Although the code is in fact a
programm, you needn't number the
lines, because they will be numbered
automatically when handing them over
to the BASIC Interpreter. If you use
GOTO or GOSUB statements, you will
have to number them by yourself, of
course.

 BASIC instructions, stored in several
cells share one memory for variables.
For example, a variable used in column
A can also be accessed in column C.
But the program code is stored in
different memory segments, therefore
it isn't possible to jump from one
BASIC-cell to another, e.g. BASIC in
column B cannot call a subroutine
stored in column A. Because column
BASIC has access to all variables, it
actually doesn't matter in which
columns the commands are stored,
except that they are called one after
another, starting with column A.

 The main principle is that the BASIC
code is executed in every single
data-row. Before executing it, the
content of the data-cell is delivered
to the specified variable. After
executing the code, the (changed or
unchanged) content of the variable is
stored in the data-cell again. That
means that the column BASIC code has
no random access to all data. It just
processes the data row by row. It
doesn't even have access to a row
number, unless you set up a counter in
BASIC by yourself.

 Example: Let's suppose you want to
enter some numeric data in column A,
in order to calculate the square root
of these data in column B. First, set
both columns to numeric type and enter
the data in column A. Then assign a
variable name to column A, for
instance, variable [x], and another
one to column B, call it [y]. Then you
enter the BASIC statement y=sqr(x).
When running the program code, the
content of the data in Column A will
be delivered to variable x, the BASIC
command will be executed, and the
content of variable y will be stored
into column B. This happens row by
row.

[NOTE]: The Run It for this file is
the DT file as described, but has not
yet been RUN. Press <R> -- the DT file
and DataTool will be loaded. Press
<F1> to see the List, then <F2> to Run
the sheet. <F8> gives you a number of
options, the last being Exit. DataTool
does not return to LOADSTAR.


ROW SETTINGS:

 At the left of each row there is a
number, ranging from 001 to 999. Due
to the memory restriction you will not
be able to fill all 26 columns and 999
rows with data, but a worksheet
with 3 numeric columns and 999 rows
would be possible with reduced BASIC
memory.

 Next to the row number there is a
cell that allows you to change the row
type.

 Data is the default row type. The
content of data-rows will be linked to
a BASIC variable, as far as there is
one defined in the column setting. A
data-cell can contain up to 255
characters if the column is set to
Text type, or one numeric value when
set to Number. Characters are limited
to the printable range, control
characters are excluded. Numbers are
stored in the same way as the C64
stores full numeric variables, not
more and not less exactly, and with
the same limitation of range.

 A nice feature for inputing numbers
is that you can do any kind of
immediate calculation during the
input: E.g. if you enter 1+2*3, the
system calculates the result of 7 and
stores it. The syntax is the same as
within the regular C64 BASIC
interpreter - which in fact does the
job.

 Label rows can be used for inserting
subheadings or explanations. These
rows are ignored by BASIC, but they
will be printed.

 Pause rows allows to insert a text
across the column boundary, up to 86
characters of length.

 BASIC rows work similar to the BASIC
in the column setting, with the very
important difference: this code is
executed only when the row is reached
during the run.

 Res(ult) rows are similar to data
rows, but they will only store the
present value of an assigned variable
into the worksheet. This makes sense
in combination with row BASIC, in
order to show the results.

 Example: in addition to the example
above, we want to calculate the sum
and the average of the data in column
A and B. Because the variables x and y
are used to read and to store the
data, we need different variables to
collect the sum, e.g. xs and ys. And
because BASIC has no direct access to
the number of rows in the worksheet,
we need a counter for that. We'll call
it variable n. The summation has to be
done each data-row, therefore we add
this task to the column BASIC, which
is executed row by row. In order to
show the sum, we have to transfer it
to the assigned column variables, x
and y in this case, and to provide a
result-row. To calculate and show the
average, we furthermore have to divide
by the value of the counter n.

[NOTE]: Again, this is included in the
Run It file.


 Please also take note of the remarks
on running the worksheet, describing
what actually happens during a run.


EDITING THE WORKSHEET -
  BUFFER OPERATIONS:

 Generally, there are two different
modes: if you enter the worksheet
through the main menu, the cursor
moves from one cell to another, and
the whole cell flashes. We'll call it
outline mode. If you enter a cell by
pressing RETURN, the cursor moves from
one character to another, and only the
character in the cursor position
flashes. We'll call it input mode.

 Inputing and editing text in input
mode is very similar to the way the
C64 screen editor works, except that
the repeat function is switched on for
all keys. Additionally there is a
little character buffer. If you DELete
a character, which moves the cursor
backwards, the deleted character is
saved to a buffer. A number of
character (up to 250) will be saved,
as long as they are deleted
continuously. To insert the deleted
characters press C= DEL. This also
allows an undo of the last deletion if
the cursor is in the same cell.

 "Continuously" means that you are not
allowed to use any other key besides
<DEL>. Example: If you delete the
characters "abc", move the cursor and
delete "xyz" from another place, then
the "abc" is lost, and the buffer
contains only "xyz".

 If you want to copy some text part
into the character buffer without
deleting it, use <C=-HOME>, which
like the <DEL> key moves the
cursor backwards - you have to start
at the end of the part you want to
copy.

 And in case you want to delete some
text without destroying the content of
the buffer, use CLR (<Shift-HOME>).
This acts like the <DEL> key, but
without feeding the buffer.
<Shift-DEL> will insert a single
space, which has no effect on the
character buffer.

 In outline mode there is a another
buffer available. It contains whole
cells, columns or rows. If you want to
delete a single cell, move the cursor
to it and press <DEL>. This will clear
the cell, and save the entry to the
cell buffer. Similar as described
above, <C=-DEL> will insert an entry
from buffer, <C=-HOME> will copy
without deleting, and <CLR> will
delete without copying. In the same
way you can delete, copy and clear a
whole row or a column. Move the cursor
to the cell which contains the column
letter or the row number. When you
delete a column or a row, the
following columns or rows will move,
in order to close the blank. You can
insert empty columns or rows using
<Shift-DEL>

[PLEASE NOTE]: <DEL> in outline mode
affects the column or row in which the
cursor is situated, which is slightly
different from the way it works in
input mode. And please take into
consideration that buffer operations
in outline mode imply a few
restrictions. First, the buffer can
hold only one item, e.g. a single
cell, a row or a column, and can only
copy into the worksheet if the
destination has the same format.

 Example: It is not possible to copy a
numeric data cell via buffer to a text
data cell. And if you want to copy a
numeric column into an empty column,
you must set the type of the empty
column to number before copying.

 Secondly copying rows or columns will
overwrite the destination cells only
if the source cells in the buffer are
filled. Consequently you can merge
partly filled rows or columns. If this
effect is undesired, and if the
destination isn't empty anyway, a row
or column should be cleared before
pasting. Finally, be prepared that
operations concerning columns or rows
may require quite some time if the
worksheet is large.


 There are a few useful key
combinations:

     <C=-CRSR Right>,
     <C=-CRSR Down>, and
     <C=-RETURN>.

The topical help pages of the program,
called by pressing <CTRL>, will tell
more about these. The usage differs in
outline-mode and in input-mode.

 FK

            [There's MORE!]