!Help file for !Sudoku12

!Sudoku12 is an application for (assistance in) solving,and creating sudokus.
What sudokus are, is better explained elsewhere, for instance www.angusj.com, or 
em_wikipedia_org.wiki/Sudoku.
A few months ago the name was !Sudoku but as there appear to be so many 
!sudoku programs for the Riscos platform, a different name was chosen in order 
not to cause problems with iconbar icons etc.
Currently you can use this one for (more than) 12 types (hence the name!)
     classic 9 X 9 sudoku
     9 X 9 with 2 extra boxes in X-shape, ie.X-sudoku
     9 X 9 ; box in the lower right corner is identical to the upperleft one
     twin A, ie. 2 classic sudokus with 4 common boxes; 14 boxes in total
     twin B  ie.2 classic sudokus with 1 box in common, ie. 17 in total
     triple (3D) sudoku,= 3 sudokus,each with 1 box in common, 25 boxes in all
     quadruplet -- 4 sudokus with overlapping cells
     another quadruplet ,as seen in Algemeen Dagblad
     samurai sudoku, ie 5 overlapping sudokus with 4 boxes in common
     'NRC Handelsblad' sudoku,or sudoku-13, a classic sudoku with 4 extra boxes
     16 X 16 hexadoku, ie, 4 by 4 boxes containing 0--9 and A--F (hence the
          name 'hexadoku' from 'hexadecimal'
     16 X 16 supersudoku,characters A..P instead of 1..9/A..F
                (plus some twin-variations added..)
     25 X 25 alfadoku, 5 by 5 boxes containing the characters A..Y
     from 7 upto 32 sudokus without boxes/jigsaw/rectangular boxes with/without X
Furthermore, variations on these types are possible. For instance to create 
jigsaw sudokus, slash sudokus, toroidal sudokus.
Instead of alphanumeric characters for 16X16 or 25X25 it's als possible to choose
decimal characters, from 1 to number_of_characters (11,12,.. up to 16 or 25).
The shape of the boxes can be modified in order to get what's called in Dutch 
'vormsudoku's' ('jigsaw sudokus'). And extra cells can be dragged on the 
playing field, for instance in the shape of a diagonal. At Saturdays, 
The Volkskrant newspaper publishes a twinB sudoku consisting of a jigsaw sudoku 
and an X- sudoku. Using the Box mode, slash- and toroidal sudokus can be created.
The characters can be interchanged before a sudoku is chosen; thus sudokus with
other characters than 1..9 are possible.

The sudokus can be stored as textfiles and as sprites. !ChangeFSI or (Select)
!Paint can transform these sprites into a more international format e.g.JPEG.

The application has been tested on an Archimedes (RiscOS 3.10), an Iyonix 
and an A9home. And on Beagleboard and RaspberryPi.

The !Sudoku12 application directory should contain:

!Boot
!Run
!RunImage: the program itself
!RunImage': the compressed program, runs faster
!Sprites : contains the !Sudoku sprite
alphanumrs:data for the characters 0..Z in the cells
Sprites:   more sprites
!Templates:the templates
!Help:     the file you are reading now.
Messages:Textfile with messages for the !Help application
directory sudokus with some example sudokus.  The program does not
use or expect this directory , it is unnecessary for the correct working.



How to use the application.
--------------------------

Start up the application by double clicking on its icon in a filer window.
It detects another !Sudoku12 application running already. It's icons and menus
are able to give interactive help, so maybe it's a good idea to run the
!Help application too, initially.
Clicking the right or left mousebutton ('Adjust'/'Select') on its iconbar-
icon initially opens a Setup window where you can choose a sudoku variant.
The numbers you see at the right are mainly used for dragging to the mainwindow,
therefore an button above this collection lets you choose whether you want to
get a warning if you drag a character that does not fit in that place in the 
main window. The check if the cell is free, is fairly superficial. (If you
doubt, it's better to do a uniqueness test after the drag and redo the
operation if the sudoku under investigation, is not unique anymore. )
As long as the OK button has not been clicked, the characters 0..9 and A--Z 
can be interchanged by dragging them to other locations in the 6X6 grid.
This can be undone by dragging them back, of course, but clicking Default is
faster.
To 'construct' a sudoku, the main window, of course, must be open first, so click 
'OK' when you have made your choice of sudoku variant.
The Main window is now opened; if all went well there is a grid of cells and
above it some icons to click. The setup window is a lot smaller now, too.
You can return to the setup window with its choice-buttons by pressing the
MouseMenu button over the IconbarIcon,and doing Reset. This Menu also leads 
to Info and Quit options. Adding extra cells (eg. to make it an X-sudoku) and
dragging box-borders to create jigsaw-sudokus can be achieved in Box mode, see
further.

The mainwindow cells are still empty now.
To get something meaningful inside the cells:

(1) Drag numbers from the Setup window to the Main window. In doing so, you 
   will see that the counter at the top of the window will change. If you want 
   to delete the contents of a cell, (a) drag it from the mainwindow to outside
   the grid; or (b) click mouse Menu over a cell, and choose Remove; or (c) drag a 
   character from one cell to another one. A cell in the main window with a big 
   number in it, is called a 'given'.
(1a) Press Mouse-Menubutton while pointer is over a cell, and choose Gain caret.
   (Alternatively clicking on a cell activates the caret. Clicking on some areas
   outside the grid loses the caret). Having the caret ('input focus') allows
   you to enter characters via the keyboard; use the arrow keys for
   navigation, Backspace/Delete for deleting; right arrow or Space to advance one 
   cell. Choose Menu-->LoseCaret or click outisde the cell grid to end this 
   method of character-entering. If the number of different characters in the grid
   is less than than the number of possible different characters, (e.g. less than 9
   in a classic grid) the program adapts the character set from the characters in 
   the grid. E.g. you have a classic sudoku, characters 0-9 as default, but you
   type A--I, then A--I will be used as the characters. In decimal mode for
   16X16 or 25X25, if you enter '1' (or '2' too, in 25X25) the next character 
   entered completes the number and only then it advances one position. If
   '1' or'2' were the characters you meant, press Space or right arrow to advance.
(2) Drag a sudoku file onto the mainwindow, setupwindow or iconbar icon. 
   These are simple textfiles with a degree of syntax which is detailed later.
(3) Create a new sudoku. The application itself constructs one.
   For this, you press mouseMenu somewhere on the mainwindow but not directly over
   a cell. As you will have noticed, there are 2 menus available in the main window.
   If you wish to have characters different than the ones that are highlighted in the
   setup window for this type of sudoku, (a) first choose the type of sudoku (b) press
   OK in the setup window and (c) select-mouseclick somewhere in the grid and type the
   characters you want. Only then, do Menu outside the grid and choose Create sudoku.

The first menu is a menu over a cell:
    Remove--> Removes the contents of a cell and sets it to 'Empty'
    Colours --> Leads you to a submenu to colour a cell. Or reset this
    cell, or all the cells, to normal background colour.
    Gain caret: To type into a cell directly.
    
The second menu is opened when clicked inside the main window but not over a cell.
    Save --> leads to a dialogwindow where a textfile can be saved containing a
       description of the sudoku. Or the sudoku in the main window can be stored
       as a sprite. If it has an irregular form, a mask can be given to it; in
       appropriate cases and if the shape of the box has not been altered, the
       boxes can be chequered, ie. alternately coloured gray.
    Solve --> This solves the sudoku. Mostly it's quick but in special cases
       it can take some time, especially when run on slow hardware. 'Solve' does 
       not check for uniqueness of the answer; it gives you the first answer it 
       can find. So it will also 'solve' a totally empty Sudoku.
    Uniqueness--> Checks if the solution will be unique -- a proper Sudoku should
       behave like this. It walks the solution tree up to the first solution, 
       and then back, and sees where it stops; if another solution is found, 
       it's a non-unique solution. If the tree walker goes back past where it 
       began to solve, the solution is unique. If a solution is never reached, 
       the sudoku is unsolvable.
    Create Sudoku --> it creates a new sudoku. The submenu has a choice of 
       difficulty and a pattern option.
  --- The pattern option: 
         Symmetric.. the cells at the beginning and at the end are symmetrically
            empty or filled. E.g if cell 1 has a value, cell 81 has one too; if 
            cell 15 is empty, cell 65 (=80-15) is empty too.
         Keep Pattern: The pattern that's in the grid is preserved,if the program
         finds an other sudoku with this same pattern, only the characters are
         changed. The probability of finding such a pattern is very small; the
         probability increases if you start with a reasonably full sudoku. For 
         instance, for a normal 9X9 sudoku, 24 filled cells is rather normal, but
         to make a chance of finding a sudoku with the same pattern you would need
         some 30 filled cells.
         
  --- The difficulty levels: 
         Light has only 'singles' as its solution method.
         Medium has singles and hidden singles.
         Advanced: in the creation, lockedcandidates ,hidden- and naked pairs
           (up to 6 deep) have been used .. as you always solve the cells in a 
           different order it's not guaranteed that you will encounter these
           same types. With Advanced mode, solving/checking for unicity can take
           a long time.
         Heavy has locked candidates,naked pairs/triples/quads,guessing and 
           whatever else usable as a solving strategy. The fast assembler 
           solver basically only knows singles and hidden singles; for 
           reasons of speed and simplicity of programming it reverts to guessing 
           if singles and hidden singles (hs) can't do the job. After a creation,
           it just solves the sudoku thrice and notes which methods it needs for 
           that; if guessing is needed, it calls the sudoku 'Heavy', as it is
           blissfully ignorant of advanced stategies.  For big sudokus (alfadoku)
           and irregularly-shaped boxes, again this methoud can be very sluggish.
         The program not always gives back a sudoku with the difficulty level 
         you required. This is caused by the different methods used in creating
         and solving the sudoku. It will not give you a heavy sudoku when you 
         asked for a light one, but a light one instead of a medium or heavy one
         is very well possible. Your solution is: try again. 
         While the program is creating a sudoku you can safely break off the 
         calculation (Menu-->Create:Stop) and end up with a slightly less 
         difficult sudoku.
         To create a fresh sudoku, the program first 'solves' an empty sudoku
         and then makes a list with two pointers: the pointer on top removes
         a cell value;if the sudoku can't be solved anymore the value is re-
         inserted and the cell is placed at the bottom pointer. That pointer
         is advanced. If the sudoku can be solved while the cellvalue is away,
         the top pointer comes down and removes the next cell value. Where the 
         two pointers meet, the sudoku is 'ready'. 
         At times, the program cannot recreate the filled-in sudoku that it uses 
         to remove cells from.  In such cases, break off the calculation and 
         press Create again. By default, the initial creation time is limited
         to 8 seconds, this can be too low a value (big sudoku, or slow machine)
         or to short. Just experiment what befits you.
         
   Exchange -- exchanges the contents of cells with other contents. Basically 
      the sudoku remains the same, but the content of the cells changes.
   
   A submenu for flipping and rotating; the submenu enables horizontal,vertical
      flipping and rotating.Not all sudokus can do this because of their shape,
      of course. 

   Enable swapping of colums or rows, or even columns or rows of boxes. This is 
      only accepted if it's a very regular sudoku, ie. no overlapping rows,
      columns or boxes and square of rectangular boxes only. If this option is 
      enabled, you can pick cell and drop in on another location and the program
      works out which rows, etc to swap to get the cell there, while preserving 
      the validity of the grid.
   
   Highlight --> Empty cells have one or more values that could fit in them.
      Highlight highlights a particular value that could possibly fit in that cell.
      Needless to say, if a particular value lights up in only one cell of a box
      (or a row, or a column..) then that value is the one to assign to that cell.
      The same highlighting effect can be achieved by clicking Adjust 
      (right mousebutton) over a cell in the Setup window. A quick way of 
      resetting the highlighted values is clicking Adjust over greyed-out icons in
      the Setup window.
      
   Chequering: Does an attempt of chequering the backgrounds of the cells.
      The same chequering as the one that can be applied to saved sprites.
      A submenu lets you choose which of the boxes should be chequered, or not.
   
   Eliminate: The same as Create sudoku, the difference being that in Create,
   a fresh, randomly-chosen sudoku is made first, while in Eliminate, you have
   to supply a completely-filled sudoku first. This gives you the opportunity
   for instance, to create a different sudoku with the same solution, or to 
   fill in some rows or columns with words,(consisting of unique characters,
   of course) then solve the thing, and turn it into a sudoku puzzle.
   
There is a dialog window when your mousepointer is moved to the right over 
the Solve menu option; in there you can (a) set the number of iterations 
between two Wimp poll calls; too low a number makes solving sluggish, too
high makes the computer inresponsive. This is, of course, machine-dependent.
A second option is to set up a timeout for the initial creation of the sudoku.
As said, when creating a sudoku, first an empty grid is 'solved' randomly; 
resulting in a valid sudoku. The steps taken hereafter are, to delete as many
cell contents as possible. This initial solving step can be difficult if there
are many constraints, like irregular box shapes, large grids,overlapping rows/
columns and extra boxes. It proves to be useful to often start anew, to get
the sudoku solved. The timeout time can be set from 1 second up to 999 seconds.
You can reach this dialogwindow while creating, so you can toggle the timeout
feature as well, while the program is calculating.
      
Colouring cells (via the menu over the Cell) and Highlighting are of help
when you use your own brains for solving sudokus. There is one more aid: 
click on the round icon at the left side, at the top of the main window. 
Now you will see small print in the empty cells, indicating which of the 
values are still possible. A small character, if alone and blue/green , 
indicates a Single, if red and accompanied by more black ones, a Hidden 
single. You can remove characters in an Empty cell by clicking Menu, 
following Remove to the Submenu and click on one of the shown Possible 
values. This will remove that Possible value. If enough are removed,
you could end up with singles or hidden singles, at which point it is safe to
appoint a value to the cell.  If you try a guess and drag some character onto
an empty cell with more possibilities, it's useful to check for Uniqueness. 
(from the Main menu,see above). If the sudoku now is not unique anymore,
the guess was wrong; so click Undo (see further) and make a different guess.
This sequence: consult small-printed possibilities ;guess; Uniqueness test and 
Undo one step if Uniqueness is lost, is very advisable.
A further option is, to click Select over the icon left of the Hint icon.
This shows six methods, choosing one of them tells you whether that method is
applicable. The faintly-red coloured cells are the ones where zero or more bits 
could be deleted, by applying the method.
Where appropriate (ie. Locked Candidates,Naked Pairs..) the redundant bits are 
removed automatically from the faintly-red-coloured cells. The reddish cells are
the ones with the redundant bits; the other coloured ones have the Locked
Candidates, or the Naked Pairs/Triples etc. If the Apply button is ungreyed now,
you can add the cells with only one possibility left, to the group of givens.
In some cases, clicking Adjust on an empty cell with a Single, fills in that cell.

The other Icons at the top of the window:

The round one at the left is for indicating Possible Values for 'empty' cells.
It toggles to a shape with 9 small-printed characters. The latter is the active 
state.

Hint, the third from the left, colours the cell or cells that it thinks you 
could be interested in. The algorithm also processes Locked candidates and Naked 
pairs etc. but how it reached its conclusions, you might find out for yourself. 
After all, you had good reasons not to hit Solve (in Menu) in the first place.
If you really want to know, hit Redo once, and click the second icon at the left,
and investigate the methods step by step. 

The fourth icon is ungreyed after the previous,Hint, is finished. It assigns
the unique values (Single,H.S) after Hint has found them for the cells.

The fifth icon is the Undo level counter. When clicked, it assumes that you 
want to fix that value as a reference and makes it green. Undo levels 
less than this value will be red, above it will be 'normal' grey.  If the 
undolevel is greater than the 'green' value, if you click and hold 'Undo',
the undoing will stop at this level. (If you wait for half a second then, and
again press Undo,it will go on below the level).

Undo undoes the previous operation if clicked with Select, and it 
redoes the previous Undo operation if clicked with Adjust.

Box leads you to the Box mode. In this mode, you can manipulate the 
boxes of the sudoku: change their shape or add new ones.
The various Boxes are coloured; you can drag cells from one box to 
another so that cells become part of the box(es) they are dragged onto. 
Also, you can drag cells from the Setup window onto the Main window. 
By doing so, you can add extra boxes to the sudoku, to make 
X-sudokus for instance. Dragging inside the mainwindow, is the method to 
create 'vormsudokus' (jigsaw sudokus) and toroidal sudokus.
Basically, in box mode, the memberships of the cell you are dragging, are
communicated to the cell where the mouse dragging ends.
As an example, let's assume that cell 4 is a member of boxes 1 and 10.
Dragging it stops at cell 36; cell 36 was a member of box 5. Now cell 4
remains a member of boxes 1 and 10; nothing changes for it; but cell 36 
now also is a member of boxes 1 and 10,and has left box 5.
If you want cell 36 back in box 5, drag another member of box 5 
onto cell 36. For instance its left neighbour,cell 35. Then, cell 36
is part of box 5 again and loses membership of boxes 1 and 10.
If you made a mistake, or for whatever other reason, you can remove
the membership of a box from a cell by pressing Menu over that cell, 
going to Remove, follow the submenu and remove the listed group. When 
leaving Box mode, (by again clicking Box,it's a toggle icon), you are 
reminded if a box does not have the correct number of members.
When you drag a cell from the setup window on top of a cell in mainwindow,
that cell acquires membership of the new box you are creating, in addition
to the boxes it was a member of already. So dragging a cell on top of 36
in the example above, and when the box in creation is box 21, taht gives it 
membership of boxes 1,10 and 21.
A somewhat faster method of creating oblique lines is, to drag one cell from
the setup window to one intended corner of the oblique line, and another
cell to the opposite end of the line, the program then tries to add all 
the cells for that line. In two steps it's possible to create an X.

The files that the program saves are text, spritefiles or jpegs. The 
spritefiles contain one sprite, can have a mask and are 4-colour.
To convert the format into something more international you could 
use unrelated programs like Translatr, Paint (e.g.Select edition, 
with PNG and JPEG output) or ChangeFSI.  Format of the textfiles: see below.
For Jpeg, the program needs 2 Mb of memory (for the biggest possible file)
this boils down on a wimplsot (in !Run) of 3500K. The JCompMod module
must be able to be found inside 'system: ', otherwise the program cannot
save as jpeg; strange enough if it is not there startup of !sudoku12 stops, 
i have no idea why because with other modules and other programs, a missed 
module does not prevent program startup. Strange. Remove the 2 lines that 
check for JCompMod in the !Run file if this is an embarassment.  
If the wimpslot is too small (automatic check) then !Sudoku12 also 
cannot save in this jpg format.  

Jan de Boer fecit anno 2006,2007,2018,2024
www.tellima.nl/riscos/
----------------------------------------------------------------------------------
Postscript 1: Fast method to create 'classic' sudokus of any size
Sudoku12 creates sudokus by trial and error, and for variant sudokus I did not
come across a better method, which there surely must be. 
For the usual sudoku, with non-overlapping square boxes there is a better algorithm:
Suppose the cells are numbered 0 .. numberofcells-1, and 'row' is the row number,
'col' is the column number of a cell; 'boxw' is the width of a box and 'boxh' is
the height of a box. The number of character possibilities, nchars, is boxw * boxh.
For instance, for a 9X9 standard sudoku a bos is 3 high, 3 wide so boxw=3,boxh=3
The number of rows and columns are the same, let us call them 'gridsize'. 
Of course,gridsize = boxw * boxh.
The total number of cells is gridsize X gridsize.
For each cell(i=0..numberofcells-1) then, the contents are:
row=i DIV gridsize
col=i MODULO gridsize
Contents[i]=(row*boxw + col +(row DIV boxh))MODULO gridsize
E.g. in aforementioned 9X9 grid, cell 41 is in row (40div9)=4, column (40MOD9)=5
Contents of cell 41 is (4*3+5+(4DIV3))MOD9=18MOD0   = 0, as in a std sudoku we 
begin counting at 1, it becomes : 0+1=1

1 2 3 4 5 6 7 8 9 (cells 0--8)
4 5 6 7 8 9 1 2 3 (cells 9--17)
7 8 9 1 2 3 4 5 6 (cells 18-26)
2 3 4 5 6 7 8 9 1 (cells 27-35)
5 6 7 8 9 1 2 3 4 (cell 41 in 6th column (5+1) if you start counting columns at 1.
8 9 1 2 3 4 5 6 7
3 4 5 6 7 8 9 1 2
6 7 8 9 1 2 3 4 5
9 1 2 3 4 5 6 7 8 

Now you may interchange cell contents (e.g. make every 'A' a '7' and every '7' an'A')
swap rows and colums as long as each cell stays in the box where it was before
(eg. in a 9X9 you may swap rows 0 and 2,0 and 1,1 and 2 but --not-- 0 and 3)
swap rows of boxes or columns of boxes.

To get an X-sudoku a bit of extra swapping has to be done e.g.
1 2 3 4 5 6 7 8 9 
4 5 6 7 8 9 1 2 3 
7 8 9 1 2 3 4 5 6 
8 9 4 2 3 7 5 6 1 
2 3 7 5 6 1 8 9 4 
5 6 1 8 9 4 2 3 7 
6 7 5 9 1 8 3 4 2 
9 1 8 3 4 2 6 7 5 
3 4 2 6 7 5 9 1 8 

Postscript 2: Format of the textfiles.

This is not a generally-accepted format amongst sudoku programs, most seem to
favour comma-separated textfiles; this program needs 2 extra lines, which are easy
to add.
The textfiles used by !Sudoku have this format:
A line with Sudoku
A line with Type <n$> where <n$> is a textual description as in the Setup window.
Currently the list is:CLASSIC
                      XSUDOKU
                      SUDOKU13
                      CORNER
                      TWINA
                      TWINB
                      TRIPLE
                      QUADRUPLE
                      SAMURAI
                      HEXADOKU
                      SUPERSUDOKU
                      ALFADOKU
                      QUADAD
                      HEXATWINA
                      HEXATWINB
                      HEXATWINC
                      SUPERTWINA
                      SUPERTWINB
                      SUPERTWINC
                      OTHER/nXn  (where n is 7..32)
The characters in the description are case-independent, so 'Classic' of 'ClAsSiC'
are acceptable too.
Optionally one or more lines starting with 'Boxes','Chequered','Charset' and/or
'Coloured' (Case-independent)
Lines with comma-separated numbers with the contents of the cells.

In these lines with the 'content', empty cells are denoted as  - (minus character)
the others (givens) have the same value as they have in the sudoku. As said, 
they are separated by commas.

If there are irregular boxes or extra boxes, an inventory of the cells
in all the boxes is required. Otherwise, the program would not have any idea
which cells belong to which box. In this case the file has the form:
line with Sudoku
line with Type <n>  (or Type <sudokudescription> )
line with Boxes <n> where <n> is the number of boxes.
Lines with all the cells belonging to each box.

So, in a 'classic' sudoku we would have, as an example of course, :

Sudoku

Type classic

Boxes 9
20,19,18,11,10,9,2,1,0
5,23,22,21,14,13,12,4,3
15,6,7,8,26,25,24,17,16
47,46,45,38,37,36,29,28,27
50,49,48,41,40,39,32,31,30
53,52,51,44,43,42,35,34,33
74,73,72,65,64,63,56,55,54
77,76,75,68,67,66,59,58,57
80,79,78,71,70,69,62,61,60

-,-,-,-,-,-,-,-,-
-,-,-,-,-,-,-,-,-
-,-,-,-,-,-,-,-,-
-,-,-,-,-,-,-,-,-
-,-,-,-,-,-,-,-,-
-,-,-,-,-,-,-,-,-
-,-,-,-,-,-,-,-,-
-,-,-,-,-,-,-,-,-
-,-,-,-,-,-,-,-,-

Note that in a single box, the order of the cells does not matter.
For box 0, the sequence 0,1,2,9,10,11,18,19,20, or any order, would also be right
From the type of the sudoku, the program knows how many cells to 
expect in a box. So it knows where the boxes end and cell values begin.


It is possible to store chequering too; it requires a line between Type and the 
cell values ,with: Chequered, and the chequered boxes in the  same line, 
separated by commas. Box numbering starts from 0
E.g. Chequered 0,2,4,6,8
If there is(are)(a) 'Box' line(s), The Chequered line should be placed AFTER the
Box line(s). 

If you want to colour cells individually, use a line with COLOURED. If there is
a Chequered line, use it after the Chequered line.
The Coloured line has :
Coloured <number of coloured cells><comma>|<cellnumber><comma><colournumber between 
0 and 6><comma if more cells/colours follow>|     
This can be handy if you want to indicate which cells must be quoted when sending
in a solved sudoku.
If characters other than the default ones are used, this can be stored in 
a line beginning with Charset and followed by 36 numbers, separated by commas,
representing the changed character sequence. This is not always necessary, especially
if the textfile contains as many different characters as is possible in the game,
e.g. in a 9X9 grid, with nine different characters, if all characters are used the
program can find out by itself which characters to use.
If all this is unclear, experiment with the program and have a look at the saved
textfiles.
A slightly different, but more readable textfile is made when you drag out the
text icon with mouse-Adjust pressed, instead of Select. You can choose in the Save 
dialogue window which characters should act as line delimiters (&A,&D/&A/&D/&D,&A)
and whether some sort of lines-between-the-characters-consisting-of-characters should
be used.
