NeoDesk 4: Secrets Part 1.2

 "Cream rises to the top. But then, so does scum."

                      SECRETS OF NEODESK 4
                 PART ONE: A GUIDE TO NEODESK 4
             (Covering NeoDesk 4 up to release 002)
                           Sub-Part 2
                          by Al Fasoldt

PART 4: A WINDOW ON THE FUTURE

How GEM ought to be

 The  first graphical user interfaces were welcome  changes  from
the  character-based command-line systems that were common  until
the  1990s.  But as intuitive as a window is as a bordered  space
for file and program activity, a window in itself is just a fancy
box.  Working  within that box makes sense up to a point --  that
point being the difficulty of accessing menus at another place on
the screen just to manipulate the contents of a window.

 That's  the  way Atari's GEM works,  and how the  Mac's  desktop
works,   too.  Under  a  single-tasking  operating  system,  this
limitation  is perhaps too minor to worry about,  but it  becomes
quite a liability under a multitasking system such as the Geneva-
NeoDesk  4 combination.  Each desktop window in such a system  is
potentially  active  even if it is not  in  the  foreground,  but
working  in separate windows becomes an exercise in  eye-and-hand
coordination if the only menus available are in a shared GEM menu
bar at the top of the screen.

 NeoDesk  4 removes that limitation in its enhanced GEM  windows.
Each one is a full GEM window,  complete with menu bar and menus,
instead  of  a box where file operations  take  place.  You  will
notice  that some menus in NeoDesk 4's windows are duplicated  in
the main menu bar,  but many are not. This frees up the main menu
for  options  and  functions that pertain  to  NeoDesk's  general
operation.

PART 5: GROUP THERAPY

Why didn't Microsoft do it as well?

 NeoDesk   4   differs  radically  from  the   TOS   desktop   by
incorporating  Groups.  These are files and folders that  can  be
displayed in special Group windows on the NeoDesk desktop.

 What's this all about?  What's wrong with file and folder icons?
Why use Groups?

 In one way,  NeoDesk's Groups resemble Program Manager groups in
Microsoft  Windows.  Windows 3.1 and 3.11 (the  current  consumer
versions  of  Windows as of the first half of 1995)  split  file-
copying  operations from program-launching functions through  two
main  applications -- File Manager and Program  Manager.  Despite
the  size  of  Microsoft's software  engineering  staff  and  the
hundreds  of  millions of dollars the  company  spent  developing
Windows,   Microsoft's  dual-function  treatment  of  files   and
programs  in  Windows  is confusing  and  ineffectual.  (A  large
software  industry  specializing in replacements  for  those  two
Windows  applications  has  made a lot  of  PC  software  writers
wealthy.)

 But  what  makes  the  Windows  Program  Manager  attractive  to
untutored  PC  users  is its grouping function.  If  you  drag  a
program  out  of  a File Manager window into  a  Program  Manager
window,  the  program file itself stays in its original  location
while  Windows  creates an alias for that program --  a  launcher
icon -- within the Program Manager window.  If you have two  word
processors, you could create a Program Manager group called "Word
Processors"  and place an icon for each one in that  group.  This
way,  no  matter where those applications are on  disk,  you  can
launch either of them from one location.

 That's  what  NeoDesk  4's Groups allow  you  to  do,  too.  But
NeoDesk's Groups are much more powerful. NeoDesk's Groups contain
active aliases,  not just program launchers, and, also unlike the
groups in Windows, they can contain folders in addition to files.
And NeoDesk 4 Groups can be nested hierarchically;  Groups can be
placed within other Groups at any time.

Getting rid of FOOBAR3.PRG and THSBGFIL.DOC

 NeoDesk  4  Groups also surmount one of the oldest  problems  of
every  DOS  and DOS-like computer disk operating  system  --  the
limitation on the length of filenames.  PCs and Ataris both labor
under that restriction (under MS-DOS for PCs and TOS for Ataris),
which limits the main part of a filename to eight characters  and
the extension -- the part of the name that follows a period -- to
three  characters.  This  limitation  is  removed  in  all  Group
windows.  Whether the items in the Group window are displayed  by
icons or by text, the names can be normal words. They can contain
capital  and lower-case letters,  spaces,  punctuation marks  and
even  special characters such as trademark or copyright  symbols.
Furthermore,  whenever  Groups  are listed in regular  NeoDesk  4
desktop file-and-folder windows,  their names are also  displayed
in normal language, not as such filenames as MYWORDP.GRP (as they
are in Microsoft Windows).

Try it - you'll like it

 NeoDesk 4 Groups are easy to create.  Every desktop file  window
has  a "New Group" option in its File menu.  Groups can  also  be
created  automatically  by  NeoDesk when it  performs  a  search.
Groups must be given a name before they can be saved.

 Because  the  notion of groups is new to Atarians (at  least  to
those who have not used Microsoft Windows on a PC),  I'll explain
the  uses of NeoDesk Groups in some detail.  If you have not  yet
created and used NeoDesk Groups, you may discover a new dimension
to everyday computing.

 The primary function of a group in NeoDesk 4 is obvious: It puts
programs,  data  files  and  folders where  they  can  be  easily
located. Here's the most basic example: If you create a Group for
all your graphics applications,  all you need to do to run one of
them  is to open the Graphics group and double-click on the  icon
or name of the one you want to run.  This Group can be made up of
programs stored in different locations on your hard drive, and it
can  also  contain folders for various kinds  of  graphics  files
(Spectrum  512 pictures,  GIF photos and so on) no  matter  where
they are located.

 Here's another example,  taken from my own setup. All my primary
utility  programs and configuration files have been placed  in  a
Group called Quick Utils.  By opening that Group window,  I  have
easy access to all the utilities and data files.  (The data files
include  the  ASSIGN.SYS file that GDOS uses,  the  GEM.CNF  file
needed by Geneva and the NEOD1024.INF file used for my  standard-
display mode in NeoDesk 4,  among many other files.) These  files
are located in scattered folders on various drives,  but they are
all accessible from one Group window.

 The  icons (or names,  in a text display) in a Group window  are
active.  That is,  they do not simply launch a program.  They are
capable of all the drag-and-drop operations that can be performed
by  the  files to which they refer.  The only limitation  in  the
functionality  of  Group  members  is  that  renaming,  deleting,
copying  or moving them does not perform those operations on  the
original files.  (This is intentional,  of course;  you would not
want  to endanger the original files in this way.) They are  also
linked  immediately  to  their original files if  you  press  the
Control  key and double-click on a Group member.  This  operation
opens a new window on the desktop to the location of the original
file or folder,  making file functions very simple when you  need
to rename, delete, copy or move those items.

Grouüs that care for MIAs

 Yet  Groups  are even more powerful than  these  examples  show.
While it is clear that Group members represent files and  folders
in  another  location,  it  may  not be  obvious  that  they  can
represent items that are NOT locally stored.  In other words, you
could create Groups for every floppy disk in your collection. You
could then open those Group windows and use them either as a  way
of  checking for files without needing to access the floppies  or
as  a way of providing quick access to the contents of  any  disk
you put in the floppy drive.  In my setup,  I have created Groups
for every CD-ROM disk in my collection.  When I put a  particular
disk  in  the  CD-ROM  drive,  I merely  open  the  Group  window
corresponding to that CD-ROM and get instant access to the entire
contents  -- without opening any file-and-folder windows  on  the
CD-ROM itself.

 I  also use Group windows to catalog my secondary backup  disks.
(Secondary  backups,  in my system,  are disks  holding  archived
files  created  with  a standard archiver  instead  of  a  backup
program.  These  are held offline as insurance  against  problems
with  the  primary  backups,  which are  created  with  a  backup
program.) If one of my backups fails,  I have to do nothing  more
than  open a set of Group windows to determine which backup  disk
(a Floptical) contains the file I need.

 Another  Group  I use was automatically created by  NeoDesk  4's
search function. I have a lot of GDOS, Degas (Warp 9), Speedo and
TrueType fonts in dozens of locations on my main  drives.  Rather
than  trying to move them all to a single set of folders  on  one
drive,   I   had  NeoDesk  4  search  for  files   matching   the
specifications for these fonts.  I saved the search results as  a
Fonts  Group.  Now any font is just a click away,  after  opening
just a single window.

 And another Group holds entries for all my articles about  Atari
computers. Most are stored in Calligrapher's own file format, but
some  are  ASCII texts and others are saved in  the  Atari  Works
format.  Yet they are all in the same Group window,  and all have
descriptive  names (not WHAT_DA.CAL or GENSECR.STW and that  kind
of thing). Because these Group members are aliases for files that
NeoDesk already associates with their applications, all I have to
do  is  double-click on any Group entry and it will appear  in  a
second or two inside the application that created it originally.

 This is an important function of Groups that many users may  not
understand.  Groups do not have to be made up of  programs;  they
can be put together from any items stored on disk. A common use I
make  of  a  Group I call New Docs is the  temporary  listing  of
documentation for new programs.  Rather than digging out the  doc
file  in  a folder half-lost somewhere on one  of  my  drives,  I
merely  drag the document icon to the Group window and access  it
from there. It is always instantly available that way.

 You may want to consider creating a Master Group that holds  all
your other groups.  If you place the icon for the Master Group on
the  desktop,  you will always be able to open any  Group  window
quickly.

PART 6: CUSTOMIZED LAUNCHERS

Pass parameters and collect $200

 When  Atari created TOS,  its software engineers designated  two
very different ways programs could run.  They could be mouse-and-
window applications -- PRoGrams,  which had to have names  ending
in  ".PRG" -- or they could be text-based applications  that  did
not  use the mouse and its associated  paraphernalia.  These  are
called  TOS applications,  and they look for all the  world  like
programs that run under the standard PC operating system, MS-DOS.
(They are, in fact, quite similar to DOS programs in some ways.)

 But  Atari  did something unknown in the MS-DOS  world  when  it
settled   on   TOS  programs  as  the  non-mouse   (or   non-GEM)
applications that would run on the ST.  It made two categories --
one for TOS programs that needed parameters and one for the  ones
that didn't.  If this is all gobbledegook to you,  stick with me;
TOS programs can be very important,  and the way they run can  be
applied in a more general way,  too,  now that Atari  programmers
have  learned how to unleash the full power of both GEM and  non-
GEM software.

 I remember how disappointed I was the first week I spent with my
new  520ST nine years ago when I discovered that  least  friendly
version of all Atari programs,  the .TTP monster. Double-clicking
on  a  .TOS program made it run,  but double-clicking on  a  .TTP
program  made  a  box  appear on the screen  asking  me  to  type
something.  If I'd wanted to type something at a command line,  I
would  have  stuck  with  my  Atari  130XE  and  its  wonderfully
adaptable operating system, SpartaDOS. Here was a computer with a
graphical user interface that suddenly reverted to the old  type-
in-your-favorite-command system -- that is,  if you were able  to
remember the command you were supposed to type in. If you ran the
early version of ARC in those days,  you were supposed to type in
"-X" or "-E" or just "X" or "E" (I'm glad I've forgotten which it
was!) followed by the path and filename to extract a  file,  like
this: -X A:\ARCFILES\THISFILE.ARC.

 I hated .TTP programs. Under later versions of TOS, I found that
I  could drag the icon of a file to the icon of the .TTP  program
and get at least part of the command line filled in by TOS. But I
had to do the rest.  Even NeoDesk 3,  the first modern version of
Gribnif's desktop,  wouldn't free me from this horrible backwater
world  of command lines and parameters;  it still acted like  TOS
did,  forcing me to fill out the rest of the command  line.  (And
NeoDesk 4 still acts the same way,  unless you do something about
it.  The  problem is not with the desktop but with the  rules  of
TOS;  a .TTP file needs parameters. That's what .TTP means, after
all  -- TOS Takes Parameters -- and so if you double-click  on  a
.TTP file or drop another file onto it,  even NeoDesk 4 will poke
a  dialog box in your face and tell you to fill it out.)  In  yer
face, indeed! This is NOT my idea of a user-friendly system.

 It  doesn't have to be that way.  I'll tell you how you can  get
around this inconvenience shortly.

You use parameters every day

 But first we need to look at parameters another way. They're not
just instructions on a command line you type in.  And they  don't
just go with .TTP programs.  Any Atari program can be written  to
use parameters,  and most major pieces of software are,  in fact,
written  that  way.  We  usually don't think  of  them  as  using
parameters unless we encounter one of those rare .GTP programs --
a  GEM program that Takes Parameters.  But  parameter-passing  is
common,  and  it's exactly what takes place any time you drop  an
icon  for a data file onto the icon for a program.  (My  favorite
example is dropping the icon for a ZIP archive onto the icon  for
STZIP.PRG.  The  operating  system runs STZIP and passes  it  the
parameter of the path and filename of the ZIP file.  But  another
common  example  is dropping the icon for a text  file  onto  the
STeno icon or the icon of any other word processor.)

 This  is a simple kind of parameter  passing.  Some  specialized
programs  such  as LHARC.TOS (which is generally  distributed  as
LHARC.TTP  for  no good reason) allow a dozen  or  more  separate
parameters  to  be  passed to the  program  when  it  runs.  Some
programs  almost beg for parameters in order to run  properly.  A
good   example  is  JonDOS,   one  of  the  better   command-line
interpreters  for the Atari,  which will misbehave  under  Geneva
unless it is run with "-t" as the parameter. This tells it to act
like  a TOS program -- no mouse,  with all  operations  occurring
within  a  standard  TOS  25-line display --  instead  of  a  GEM
program.

 (A digression is again in order.  LHARC takes parameters,  so it
is  normally distributed as a .TTP program.  But this can  defeat
one  of  the  cleverest  features  of  LHARC,   its  ability   to
automatically  run  and either extract an archive's  contents  or
compress  a file or folder without a need for any action  by  the
user.  LHARC does this by examining the parameters the  operating
system  passes to it.  If the parameters include a filename  with
the extension ".LZH," LHARC extracts the archive to a folder.  If
the  parameters do not include ".LZH," LHARC creates  an  archive
and compresses the file or folder listed in the parameters.  This
is all very elegant; drop a folder on the LHARC icon, and it does
the rest,  creating an archive.  Or drop the icon for an LZH file
onto  the LHARC icon,  and it extracts the contents to a  folder.
But  this  will NOT happen so elegantly if you  insist  on  using
LHARC  with its original filename extension,  .TTP,  because  the
operating system will stick that dialog box in front of your face
and tell you to fill it out, as it must do with .TTP programs.)

 To  a word processor,  a text file can be a parameter.  But  the
same kind of operation can take place with other  software,  too.
You  can run Flash,  the original  high-power  telecommunications
program for the Atari, by passing it a parameter that consists of
the name of one of its DO files.  (DO files are scripts that tell
Flash what to do.) You can run STalker,  a modern Atari  telecomm
program, with a parameter that consists of the name of a BackTALK
script;  STalker  will run,  load the script  automatically,  and
execute the instructions in the script. There are countless other
examples.

 But  how do you do that?  Ordinarily,  you look at the icon  for
STalker,  and you see only one thing you can do with it to get it
to run -- you double-click on it. But you could drag the icon for
a  BackTALK script onto the STalker icon (or onto its name  in  a
text-only window display, of course) and it would run and execute
the instructions in the script.  You could do it that  way,  that
is,  if you have the script icons and the STalker icon handy; you
can't drag something that's not available on the desktop or in  a
window.

Give me an N! Give me a P!

 NeoDesk 4 offers an easier way.  It's also a more powerful  way.
It's called the NeoDesk Program Information file.  An NPI can  do
much more than what I have suggested here -- there is probably no
limit to the inventiveness you could put an NPI to -- but at  its
most  basic  it  can  readily  automate  such  tasks  as  passing
parameters.  When  you  set up an NPI,  you'll see a  dialog  for
entering the parameters.  Keep in mind that some programs do  not
behave as you might expect when they receive parameters, so you'd
be  wise  to experiment.  (You can't hurt anything.)  Start  with
something  simple,  such as passing a script name to  a  telecomm
program,  and then graduate to something more complicated.  (With
LHARC,  you could create one NPI that ran LHARC in minimal-memory
mode,  another that ran it in maximum-memory mode,  and so on. If
you  double-click on LHARC.TOS with no parameters,  you'll see  a
list  of  possible  commands  that can  be  passed  to  LHARC  on
startup.)

 NPIs can be named by normal-language conventions  ("Mini-LHarc,"
for   example)  instead  of  by  the   8-and-3   ("MINILHAR.NPI")
requirement of normal filenames.  Unfortunately,  NeoDesk 4 has a
bad  habit of overriding the name you have chosen and  using  its
own best-guess filename,  which uses the old 8-and-3  convention.
If this happens, change the name NeoDesk assigns back to a normal
phrase.  (Note that a file display under NeoDesk 4 shows the name
you  assigned,  not the 8-and-3 filename,  but a display using  a
utility  such as MaxiFile or the Geneva item selector  will  show
the TOS filename.)

 Because   NPIs  are  program-launching  instructions   and   not
executable files per se,  they are very small, taking up only one
sector,  the  minimum  amount  of individual space  that  can  be
allotted on a floppy disk or hard disk.  This means you can store
all your NPIs in one place without a problem.  It also means  you
can place them in Groups easily. But try to resist the temptation
of creating a Group just for NPIs.  It makes no sense having  one
icon in a Group run LHARC and another run STalker;  rather, place
your NPIs into the Groups they naturally fit into, with archivers
in  one  Group  and telecomm  software  in  another,  or  utility
software in one Group and applications in another, and so on.

PART 7: MEMORY LANE

RAM cram can be a thing of the past

 A  powerful desktop shell can be a hungry  one,  too.  It  could
require a lot of memory,  depending on how it is set up.  In  one
installation I configured,  NeoDesk 4 was running in 15-bit color
mode  (more than 32,000 colors visible at once) on a  Falcon  and
displaying a large background picture;  it had 400 to 450  icons,
and booted up with six desktop windows open, each of them full of
files and folders. I probably don't have to add that this NeoDesk
4  setup  took a lot more memory than the setup I use on  my  ST,
which has no extra icons,  boots up with no desktop windows  open
and has only a simple desktop pattern.

 But this is one of the strengths of NeoDesk 4.  It can be  large
and impressive or lean and mean. NeoDesk 4 does this many ways.

 First, NeoDesk 4 can be set up like my ST instead of my friend's
Falcon.  You  can  choose to leave out extra  icons  and  desktop
pictures,  and you can keep extra desktop windows closed when you
do  not need them.  (A desktop window that displays 100  or  more
files consumes extra memory. Add four or five of them at the same
time and memory consumption rises quite a bit --  needlessly,  in
most cases.)

 Second,  NeoDesk  4  lets the user specify how  much  memory  it
should take, in two separate approaches. You can limit NeoDesk to
a specific maximum amount of memory or you can tell it to take  a
minimum at all times.  (You can also set no limits,  which is the
preferred way for those with four or more megabytes of RAM.) This
may be confusing, so I'll try to explain.

 The  first approach,  which limits the total amount  of  memory,
keeps  NeoDesk  4  from  using memory  that  may  be  needed  for
applications  that do not behave properly when run under a  shell
such as NeoDesk.  Behavior such as this is also influenced by the
version of TOS that NeoDesk 4 is running under. Applications that
are  well behaved in terms of memory usage normally won't have  a
problem  with NeoDesk 4's preferred setting,  which is to let  it
take all the memory it needs.

 The second approach,  which specifies a precise amount of memory
that  NeoDesk 4 should always occupy,  may work better  than  the
others if your Atari's RAM tends to become fragmented over a long
period of time.  (If you reboot often, fragmentation probably can
be ignored. But if you regularly run your computer for weeks at a
time  without rebooting,  you may want to begin checking  on  the
amount  of  fragmentation.)  Many of  the  operations  NeoDesk  4
performs require extra memory from the operating system's pool of
RAM,  and  this memory is always released back to  the  operating
system  later.  But in a multitasking system (and within  NeoDesk
alone,  which  always  is  able to multitask its  file  and  disk
operations  even  without Geneva),  the operating system  may  be
supplying  memory  to more than one process at  a  time.  Because
there  is  no way to know whether these  operations  will  return
their blocks of RAM in the same order they obtained  them,  there
is  no  way  to control possible fragmentation of  RAM  in  these
situations.  (There are ways to defragment RAM in some  operating
systems, but none that have been implemented on Ataris so far.)

 This second approach,  setting NeoDesk 4's memory consumption to
a  specific minimum figure,  prevents NeoDesk 4 from  asking  for
extra  memory  during  desktop  operations  and  keeps  it   from
shrinking  its memory consumption during idle time,  and this  is
what  can help reduce fragmentation.  In a typical desktop  file-
copying  operation,  NeoDesk 4 will otherwise try to  appropriate
nearly all available memory, using RAM as a copying buffer.

 There are no hard and fast rules for the memory settings. If you
choose to limit NeoDesk's memory, try settings that are quite low
and see if NeoDesk complains.  (If NeoDesk runs out of memory for
its  own operations,  it will alert you to that.) You may  notice
that file-copying and -moving operations are  slower,  especially
when NeoDesk 4 is dealing with a lot of small files or a few very
large files.  This could be an acceptable tradeoff, especially in
light  of  NeoDesk  4's  ability to do  file  operations  in  the
background.  Since  you are able to continue other  tasks  during
these functions, you may not care if they run slowly.

PART 8: BACKGROUNDER

Getting NeoDesk 4 to work with both hands

 Even  when  Geneva  is not running,  NeoDesk 4  has  an  amazing
ability  to  perform background file  operations.  Files  can  be
copied  or moved while you do other operations at the desktop  --
creating Groups,  setting up NPI files,  formatting floppy disks,
and so on.  If you are copying or moving files from one folder to
another and begin another copying or moving operation,  NeoDesk 4
will  add  that operation to its queue and perform  it  when  the
first operation is done.  (NeoDesk 4 cannot perform more than one
file operation at a time, even under Geneva.)

 Floppy  formatting is a special case.  Not only can you do  file
operations in the background while formatting a floppy;  you  can
format a floppy disk AND do file operations while doing  anything
else  at the desktop.  This facile manipulation of the  generally
uncooperative  floppy-disk controller is one of  Gribnif's  minor
triumphs  in NeoDesk 4,  and I know few Atarians or PC users  who
are not amazed when they see NeoDesk 4's background formatting in
action.

Geneva adds the muscle

 But NeoDesk 4's ability to place such tasks in the background is
most  useful  under  Geneva.   Background  file  operations   are
particularly handy during telecommunications sessions,  when  you
can move downloaded files to separate folders,  for example,  and
they  are just as useful at many other times.  NeoDesk 4 and  its
partner,  Geneva,  will let you create archives with STZIP or the
superb  LHarc-Shell while formatting floppy disks to place  those
archives on -- and while doing any other tasks as well. In my own
systems, I regularly download files from GEnie using a background
telecommunications   program   while   performing    file-copying
operations  and writing in Calligrapher or Atari  Works.  Because
NeoDesk  4 provides a user-adjustable control over the amount  of
processor time given over to file operations,  you can  fine-tune
the  background  response  of NeoDesk for  your  own  setup.  The
slowest (leftmost) setting of the background adjustment frees  up
the  CPU for other tasks with minimal intrusion even on  an  8MHz
ST;  on my 48MHz TT, it exacts no apparent toll, even when the TT
is  formatting a floppy at the same time.  (I generally  set  the
adjustment  at  the  second button,  which seems  to  be  a  good
compromise between background speed and foreground operations  on
both my 16MHz ST and on my TT.)

PART 9: SEARCH AND REJOICE

Finding a way to locate files singly or in groups

 Hard-disk  space is cheaper than ever,  and that means more  and
more Atari users have big hard drives. And that, of course, means
those  disks  are getting filled with all sorts  of  stuff.  (The
phenomenon  of Fibber McGee's Closet -- the drive that is  always
full  no  matter  how big it is -- is worth  looking  at  another
time.)  All that space is great,  but how do you find  those  odd
files  you stuck in a folder deep inside some other  folder  five
months ago? How do you ferret out all those strange-looking "*.C"
files  and  ".PRJ"  files  that  you've  accumulated  with  every
download of one of those big German applications?  And how do you
check your entire file system, every drive, every folder, to make
a list of all your GIF graphics?

 NeoDesk 4 has the answer.  In NeoDesk's Search function, you are
offered  the power to locate any file or combination of files  on
every drive in your system. And you can even automatically create
a  Group  out  of every file search just by  choosing  the  Group
option.

 NeoDesk  4's  Search function offers the  old-fashioned  set  of
wildcards  that  every  other  search method  has  --  using  the
question mark and the asterisk to represent single characters  in
filenames  (the  question mark) or any group of  characters  (the
asterisk). The asterisk, as most users may already know, can even
denote the absence of characters.

 But NeoDesk 4 goes further.  Using advanced wildcards common  in
Unix  but largely unknown in TOS,  NeoDesk 4 lets you  specify  a
range  of characters that should be included or excluded  in  the
search,  so that you could,  for example, have NeoDesk 4 find all
files that begin with "A" or "B" but not "C" or other letters and
that have "DOC" or "TXT" as their filename extensions.

 Setting up searches this complicated can take a lot of time  and
keystrokes,  so NeoDesk 4 also lets you save the search criteria.
The next time you need to do the same kind of search,  you simply
load the particular Search file.

 The  addition of the automatic Group creation makes NeoDesk  4's
Search method an ideal way to create Group files  quickly.  After
the Group has been set up, you can edit it to take out extraneous
files and to add descriptions. Let's look at an example.

 Suppose you have a lot of shareware programs,  each in their own
folders.  Most of them come with short "README" files and  longer
documentation texts, but they never seem to be where you can find
them when you need them. You could, of course, make copies of all
of them and put the copies in a central folder, but that would be
an immense waste of space.  You could also print all of them out,
but that would be an even bigger waste;  after all,  you may  not
need to have more than a few of them handy as printed  documents.
But you do need to be able to get at any of them.

 A Group file is the perfect answer. Just set up a search for all
"READ*.* files and all "DOC" and "TXT" files and save the results
in a Group. Put that Group file in a convenient location, and all
your  documentation  files  will be  available  for  browsing  in
seconds.

 TIP:  Make  sure  you save that Group with  the  full  pathnames
displayed  so  you can tell the difference between  one  "README"
file and another.  You may want to save the group with the  text-
display option rather than iconic display, because text mode will
show the locations of the files instantly.

PART 10: FONT OF PLENTY

Using GDOS bitmapped and Speedo scalable fonts in windows

 NeoDesk 4 offers many ways to dress up your desktop, but the one
that  can add a finishing touch is its employment of as  many  as
four  separate fonts for the displays within windows,  in  window
information  bars and on the desktop itself.  You do not have  to
choose  these fonts,  of course;  NeoDesk will use  its  defaults
ordinarily, but you can achieve some stunning effects if you play
around  with GDOS bitmapped or Speedo scalable fonts for  any  or
all of the four selections.

What GDOS is and why it's not built into the computer

 Users who are new to GDOS fonts may need a brief explanation  of
what's  needed  to get them to work.  (If you're an old  hand  at
this,  just skip to the next section.) GDOS (the Graphics  Device
Operating  System)  is a much-maligned add-on part of  the  Atari
operating system that,  in fact, is an amazingly powerful feature
in  all Ataris.  Atari had planned to incorporate GDOS  into  the
ROMs of all STs (hard-coded into the computer's operating system,
in  other words),  but left GDOS out at what was practically  the
last minute.  In place of a ROM-based GDOS, Atari supplied a GDOS
program on disk.  The first version slowed down the operation  of
the ST horribly, but an improved GDOS was quickly issued by Atari
and by others.  (AMCGDOS is one of the most popular improved GDOS
programs and is free,  but there are others that are  better,  as
we'll see in a moment.)

 GDOS is something like a translator for devices attached to  the
computer -- printers,  the display screen, plotters, that sort of
thing.  It  handles  most of the work involved  in  getting,  for
example,  characters of various sizes and types on the screen and
on  the printed page.  (GDOS is MUCH more complicated than  this,
but  I'm  trying to keep things simple so we can  concentrate  on
fonts.) Regular GDOS supports fonts that are stored as  graphical
dot-by-dot images. These generally come in in two basic versions,
one  for screen characters and one for  printed  characters,  and
they are not resizeable. (They actually can be made twice as big,
to  give  an  example of apparent  resizing,  but  they  are  not
resizeable  in any manner that retains their  appearance.)  These
dot-by-dot-image  fonts are called bitmapped fonts  because  each
part of every character is mapped to a grid of dots on the screen
or on the page. Bitmapped fonts work very well but have a single,
very  significant drawback:  Since each character is stored as  a
collection  of dots for a single size on the screen or on  paper,
the  only  way to get characters of differing sizes is  to  store
separate  versions of each character for every size you may  want
to use.  In other words,  you'd need a separate font file for 12-
point  type,  14-point type,  18-point type,  and so on.  If  you
really want to have a lot of choices in font sizes,  you'll  need
to store a lot of fonts.

 Font  technology  improves  year  by  year.  The  most  dramatic
improvement  for  all  computer systems  is  the  development  of
scalable fonts,  which are stored not as dot-by-dot graphics  but
as mathematical codes.  These codes can be very complicated,  but
that  sort  of thing is relatively easy for a  computer  to  deal
with.

 The  good  part of scalable-font technology is  that  characters
that  are stored as expressions of curves and straight lines  can
be made any size without changing their basic  appearance.  (This
is  technically oversimplified,  because the  best  scalable-font
systems actually DO change the way characters are drawn at  small
sizes  to  keep them readable,  in a  process  called  "hinting."
Speedo  GDOS and the TrueType system both use  hinting.)  Because
only  the  mathematical  codes are stored  and  not  the  bitmaps
themselves,  a single scalable font file can replace the dozen or
more  bitmapped  font files that would have been needed  to  make
sure  all  typical sizes are available  in  that  font.  And,  of
greater importance to a desktop publisher,  that single  scalable
font  file  can be used to make ANY size  characters,  whereas  a
bitmapped font file is limited to one size only,  preventing  the
user  from  altering  documents  for  a  more  pleasing  fit  and
appearance if the ideal font size is not available.

 The  bad  part  of  scalable-font  technology  is  that  scaling
characters  on  the fly takes time.  A 16MHz ST or Falcon  and  a
32MHz TT will generally work fast enough with scalable fonts, but
8MHz  STs may bog down quite a bit.  That does not mean  scalable
fonts can't be used with 8MHz STs;  instead,  it means users with
slower STs should do everything possible to speed things up -- by
eliminating desk accessories that are taking up processing  time,
for  example,  or  by using the  fastest  available  font-scaling
systems.  NVDI 3 is generally considered one of the most flexible
GDOS  systems,  and is highly recommended,  especially  since  it
handles both Speedo and TrueType fonts.

 Fonts of both types are drawn under the control of GDOS.  In the
past,  most  applications that took advantage of GDOS  were  word
processors  and  desktop-publishing applications,  but  this  has
changed  with  continual  improvements  in  both  GDOS  and  font
technology.  Today  it's  not uncommon to  find  applications  of
nearly all kinds supporting a range of fonts.  The popular LHarc-
Shell  is  one example of a relatively  simple  application  that
allows full control, through GDOS, of the fonts used in its file-
display lists.

 NeoDesk 4 uses GDOS to provide a choice of fonts and font  sizes
for these distinct display areas:

 - Captions (descriptions) under the desktop icons.
 - Small-text listings in desktop file-and-folder windows.
 - Large-text listings in desktop file-and-folder windows.
 - Information  lines near the top and at the bottom  of  desktop
windows.

 You  should  note that even without GDOS,  NeoDesk  4  lets  you
change the size of the font used for any of these  displays.  The
font will always be one the system fonts.  (In some  resolutions,
you  will not have all of the system fonts available.)  But  with
GDOS,  you  can  change both the appearance and the size  of  the
fonts.

It's all a matter of proportions

 The  standard fonts built into all Atari computers  have  evenly
spaced  characters,  each  the same width and the  same  distance
apart,  within  a single font.  This is how a  typewriter's  font
looks,  but it is not the way most published documents in  books,
newspapers and magazines look. They use fonts that have variable-
width characters, with the "m," for example, taking up a lot more
space than the "i" and "t" characters.  These proportional  fonts
add a finished,  professional look to the screen display, and can
be  used in two of the display areas in NeoDesk 4 -- the  caption
line under desktop icons and the information line above and below
desktop windows.  These do not have to be Bitstream Speedo fonts;
they  can be proportional bitmapped GDOS fonts.  You may have  to
experiment  quite  a bit to find a proportional font  that  looks
good and is readable as the icon caption font,  but you shouldn't
have any difficulty assigning a proportional font in the range of
9 to 12 points for the information line.

 Proportional fonts cannot be used for the small- and  large-text
listings in desktop windows.  If you select non-system fonts  for
these  displays,  try to use fonts that have thick letterings  to
enhance readability.

GUI or not, sometimes text is a better choice after all

 NeoDesk  4 normally displays files and folders as  icons  within
each desktop window.  This is often the most informative type  of
display because icons can be uniquely shaped and colored for each
item they represent. (After all, this is part of what a graphical
user  interface  is all about -- graphics!) But there  are  times
when an icon-based display is not the best method. A text display
can show many more items,  of course,  but the main point is that
in  a window in which all items are of the same kind of  file  (a
group of GIF pictures,  for example), an iconic display will have
no graphical advantage,  since the icons will all look alike.  In
that kind of situation, a text display makes more sense.

 NeoDesk  4  allows  mix-and-match selection  of  icon  and  text
displays within desktop windows. This can be especially handy for
ST Medium Resolution screens,  where icon displays take up a  lot
of room,  and can be useful in ST High Resolution mode, too, when
many windows are open.  NeoDesk 4's Group windows take up only  a
small  amount of space in text mode,  permitting a  desktop  with
dozens  of  applications and other items to be  listed  in  group
windows even in ST Medium Resolution.

Note this, please

 NeoDesk 4 also uses modern font technology to good effect in its
Desktop Notes, a feature that has long been one of the trademarks
of  NeoDesk.   (This  is  literally  true;   "Desktop  Notes"  is
copyrighted  by  Gribnif.) Whereas previous versions  of  NeoDesk
limited  Desktop Notes to a few brief messages in a  plain  Atari
system  font,  NeoDesk  4 allows lengthy notes in  any  Bitstream
Speedo  font,  large or small,  in addition to any of the  system
fonts.  In order to use Speedo fonts with NeoDesk 4,  you'll need
Speedo  GDOS  or NVDI version 3 or newer.  (Although  the  latest
versions  of  Speedo GDOS and NVDI also  support  other  scalable
fonts,  NeoDesk  4  cannot display Desktop Notes in  TrueType  or
PostScript formats.)

 Proportional Speedo fonts look especially good in Desktop Notes.
Most Speedo fonts are proportional, so, if you already have a set
of   Speedo  fonts,   you  no  doubt  have   proportional   ones.
(Regrettably,  the  non-proportional font originally  distributed
with Speedo GDOS, Monospaced 821, is one of the worst examples of
monospaced  fonts I have ever seen.  Bitstream's Courier is  much
better.)

 When  you choose a Speedo font for Desktop Notes,  you may  find
that a sans-serif font looks better than a serif font. Serifs are
tiny   strokes  that  generally  make  each  letter   look   more
interesting,  and usually make the text more readable. But if you
use serif fonts at smaller sizes on a typical Atari display,  the
serifs  are  too small to be accurately rendered.  On  the  other
hand,  a serif font such as Bitstream's Charter or Windsor can be
very attractive on the screen at larger sizes.

 Keep  in  mind  that NeoDesk 4 places its Desktop  Notes  on  an
unseen  grid  based on the height of the font,  so if you  put  a
Desktop  Note in small type on the bottom of the screen and  then
use the Desktop Notes dialog to make the type larger, NeoDesk may
place it off the bottom of the display.  If this happens, set the
size back to what it was and erase the note, then change the size
and  write it where you want it to appear.  (If you don't  do  it
this  way,  you'll  never  be able to get at  the  Desktop  Notes
because they'll stay hidden off-screen!)

 If  you use Speedo GDOS,  which generally takes up  considerable
memory,  you  may  not want to have a  Speedo-font  Desktop  Note
displayed all the time.  If your Desktop Notes are used more  for
display  than  for quick note-writing --  if,  for  example,  you
create Desktop Notes that show a permanent message -- you can use
Imagecopy  or any other good snapshot utility to create an  image
of the part of your screen containing the Desktop Notes; this can
then  be used as a desktop background when your computer  is  not
running Speedo GDOS.