@database scout-39.guide
@Master scout.texi
@Width 72
This is the AmigaGuide® file scout-39.guide, produced by Makeinfo-1.55 from
the input file scout.texi.
@Node Main "scout-39.guide"
@Next "Introduction"
Scout 37.204
Release 2.10
User's Manual
Copyright (C) 1994-97 Andreas Gelhausen, Richard Körber
@{" Introduction " Link "Introduction"} What is @{b}Scout@{ub}?
@{" Copyright " Link "Copyright"} Please read this first!
@{" System Requirements " Link "System Requirements"} What your system should have
@{" Installation " Link "Installation"} Installing @{b}Scout@{ub}
@{" Using Scout " Link "Using Scout"} How to use @{b}Scout@{ub}
@{" Scout and AmiTCP " Link "Scout and AmiTCP"} @{b}Scout@{ub} as @{b}AmiTCP@{ub} service
@{" Scout without MUI " Link "Scout without MUI"} @{b}MUI@{ub} is not necessary!
@{" Options " Link "Options"} You can set some variables.
@{" Commands " Link "Commands"} ARexx and shell commands
@{" Updates " Link "Updates"} How to get updates
@{" Credits " Link "Credits"} Thanks are going to...
@{" Author Info " Link "Author Info"} How to reach the author
@{" Index " Link "Index"} Contents index
@EndNode
@Node "Introduction" "scout-39.guide/Introduction"
@Next "Copyright"
@Prev "Main"
@Toc "Main"
What is Scout?
==============
@{b}Scout@{ub} is a tool that allows you to monitor your computer system. It
displays many different things -- like tasks, ports, assigns, expansion
boards, resident commands, interrupts, etc. -- and you can perform
some certain actions on them.
For example you can freeze tasks, close windows and screens, release
semaphores or remove locks, ports and interrupts.
Through @{b}AmiTCP@{ub} it's also possible to use @{b}Scout@{ub} as an TCP/IP service.
Since version 2.0 of @{b}Scout@{ub} you can use nearly all implemented
functions through shell parameters. Therefore it's not necessary to
install @{b}MUI@{ub} for using @{b}Scout@{ub}, but you will need @{b}MUI@{ub}, if you want to use
@{b}Scout@{ub} with its graphical user interface.
@EndNode
@Node "Copyright" "scout-39.guide/Copyright"
@Next "System Requirements"
@Prev "Introduction"
@Toc "Main"
Copyright
=========
Please read the following parts carefully. You accept the following
terms by starting the software, even for a test drive only.
@{i}COPYRIGHT@{ui}
Scout 37.204 (Release 2.10) - Copyright (C) 1994-97 by Andreas
Gelhausen and Richard Körber, all rights reserved.
You only have the right to use the software, but no rights on the
software itself. Disassembling, resourcing and all other ways of
reverse engineering is forbidden.
@{i}FREEWARE@{ui}
Scout is FreeWare. You are allowed to use the packet without
paying a fee or similar to the authors. Of course we would
appreciate a small donor! ;-)
@{i}COPYING@{ui}
You can copy the packet as long as it remains entire and unchanged.
You are allowed to compress the packet using a customary
compression software (as lha, lzh, lzx, dms). You must not
compress single files of the packet (e.g. PowerPacker or Imploder).
@{i}DISTRIBUTION@{ui}
You must not exceed an usual price on the market for your working
and material. This means a maximum of 5 DM (or the equivalent
amount in other currencies, including all taxes) for disks and 35
DM for CD-ROMs containing a PD software collection.
In any case, you need a written permission from us if you want to
include Scout on a cover disk or in connection with a commercial
product.
We explicitly permit the distribution via AmiNet, Meeting Pearls
and Fred Fish.
@{i}LIABILITY@{ui}
You are using the program as it is, with all flaws, and on your
own risk! We grant no warranty for the software meeting a special
purpose. This software may cause financial damage or harm people.
@{i}LIMITATIONS@{ui}
You are not allowed to use this software and its results
@{b}*@{ub} for fascism or military purposes
@{b}*@{ub} if you do not agree to the copyright note
In this case you must delete the software and all related and
generated files immediately!
@{i}CONTENTS OF THE PACKET@{ui}
The Scout packet is @{i}only@{ui} entire with these files:
Scout/arexx/activatetask.scout
Scout/arexx/arexx.readme
Scout/arexx/arexx.readme.info
Scout/arexx/breaktask.scout
Scout/arexx/freezetask.scout
Scout/arexx/poptofront.scout
Scout/arexx/settaskpri.scout
Scout/arexx/startup.scout
Scout/arexx.info
Scout/help/deutsch/scout-39.guide
Scout/help/deutsch/scout-39.guide.info
Scout/help/deutsch/scout.doc
Scout/help/deutsch/scout.doc.info
Scout/help/deutsch/scout.dvi
Scout/help/deutsch/scout.guide
Scout/help/deutsch/scout.guide.info
Scout/help/deutsch.info
Scout/help/english/scout-39.guide
Scout/help/english/scout-39.guide.info
Scout/help/english/scout.doc
Scout/help/english/scout.doc.info
Scout/help/english/scout.dvi
Scout/help/english/scout.guide
Scout/help/english/scout.guide.info
Scout/help/english.info
Scout/help.info
Scout/icons/icons.readme
Scout/icons/icons.readme.info
Scout/icons/Scout.info
Scout/icons/ScoutDock
Scout/icons/ScoutDock.info
Scout/icons.info
Scout/libs/identify.library
Scout/libs/identify.readme
Scout/libs/identify.readme.info
Scout/libs.info
Scout/Product-Info
Scout/Scout
Scout/Scout.info
Scout/scout.history
Scout/Scout.history.info
Scout/Scout.readme
Scout/Scout.readme.info
Scout.info
@{i}TRADEMARKS@{ui}
All copyrights and trademarks are held by their owners.
@EndNode
@Node "System Requirements" "scout-39.guide/System Requirements"
@Next "MUI"
@Prev "Copyright"
@Toc "Main"
System Requirements
===================
@{b}Scout@{ub} only requires Amiga operating system version 2.04. The
@{b}identify.library@{ub} V8 is not required, but I strongly suggest to install
it to give Scout its full power. See also @{"Identify" Link "Identify"}.
If you want to use @{b}Scout's@{ub} graphical user interface, you also have
to install @{b}MUI@{ub} version 2.1 or higher. See also
@{"MUI and where you can get it" Link "MUI"}.
The TCP/IP features of @{b}Scout@{ub} are only available, if you have
installed the version 4.0 of @{b}AmiTCP@{ub}. See also
@{"AmiTCP and where you can get it" Link "AmiTCP"}.
@EndNode
@Node "MUI" "scout-39.guide/MUI"
@Next "Identify"
@Prev "System Requirements"
@Toc "System Requirements"
MUI - MagicUserInterface
========================
(C) Copyright 1992-97 by Stefan Stuntz
MUI is a system to generate and maintain graphical user interfaces.
With the aid of a preferences program, the user of an application has
the ability to customize the outfit according to his personal taste.
MUI is distributed as shareware. To obtain a complete package
containing lots of examples and more information about registration
please look for a file called @{b}muiXXusr.lha@{ub} (XX means the latest version
number) on your local bulletin boards or on public domain disks.
If you want to register directly, feel free to send DM 30.- or US$
20.- to
Stefan Stuntz
Eduard-Spranger-Straße 7
80935 München
GERMANY
@EndNode
@Node "Identify" "scout-39.guide/Identify"
@Next "AmiTCP"
@Prev "MUI"
@Toc "System Requirements"
Identify
========
Copyright (C) 1996-97 Richard Körber
@{b}Identify@{ub} is a Shared Library that decodes expansion IDs, guru codes
and library functions, and identifies your system.
@{b}Identify@{ub} is FreeWare. You can find a complete package in the AmiNet
(@{b}util/libs/Identify.lha@{ub}) or on the author's home page:
@{b}http://www.is-koeln.de/einwohner/shred/@{ub}. To get in contact, write to
@{b}shred@chessy.aworld.de@{ub}.
@EndNode
@Node "AmiTCP" "scout-39.guide/AmiTCP"
@Next "Installation"
@Prev "Identify"
@Toc "System Requirements"
AmiTCP
======
@{b}AmiTCP@{ub} is a TCP/IP protocol stack for the Amiga. The demo version
4.0 (or higher) should be available in greater public domain
collections or on the AmiNet. Ask your preferred Amiga dealer. =:^)
@EndNode
@Node "Installation" "scout-39.guide/Installation"
@Next "Using Scout"
@Prev "AmiTCP"
@Toc "Main"
Installing Scout
================
You only have to copy the program @{b}scout@{ub} to your favourite directory,
and @{b}identify.library@{ub} to @{b}libs:@{ub}. Then you can start it.
@EndNode
@Node "Using Scout" "scout-39.guide/Using Scout"
@Next "Allocations"
@Prev "Installation"
@Toc "Main"
How to use Scout
****************
This chapter describes the usage of @{b}Scout@{ub} through its graphical user
interface. This graphical user interface is based on the @{b}Magic User
Interface@{ub} (@{b}MUI@{ub}) and @{b}MUI@{ub} have to be installed in your system, if you
want to use @{b}Scout@{ub} trough windows and so on.
If you don't like @{b}MUI@{ub}, you should see @{"Scout without MUI" Link "Scout without MUI"}.
If you start the program, you will get the main window with these
Gadgets:
@{" Libraries " link "Libraries" }
@{" Devices " link "Devices" }
@{" Resources " link "Resources" }
@{" Semaphores " link "Semaphores"}
@{" Allocations " link "Allocations" }
@{" Tasks " link "Tasks" }
@{" Ports " link "Ports" }
@{" Commodities " link "Commodities" }
@{" Interrupts " link "Interrupts"}
@{" Vectors " link "Vectors" }
@{" ScreenMode " link "ScreenMode" }
@{" Windows " link "Windows" }
@{" Fonts " link "Fonts" }
@{" BoopsiClasses " link "BoopsiClasses" }
@{" InputHandlers " link "InputHandlers" }
@{" Assigns " link "Assigns" }
@{" Locks " link "Locks" }
@{" Mounted Devs " link "Mounted Devs" }
@{" Resident Cmds " link "Resident Cmds" }
@{" Timer " link "Timer" }
@{" System " link "System" }
@{" Expansions " link "Expansions" }
@{" Memory " link "Memory" }
@{" LowMemory " link "LowMemory" }
@{" Residents " link "Residents" }
Every gadget you see represents a certain kind of system structures.
Click one of these gadgets and another window will be opened with a
list of the structure type that is indicated on the pressed gadget.
@{i}Example:@{ui} Press the task gadget and you will get a window with the
list of tasks and processes.
You can also select these functions by pressing the underlined key
you see on each gadget or by using the right mousebutton menu.
If you wish to handle/remove a given structure, you should know what
you do.
@{i}Warning:@{ui} Wrong handling of the showed structures can crash your
system. At the worst you will lose your data.
@{i}Please note:@{ui} You should not be surprised, if you don't find a certain
detail information in this manual, because it's to much work to explain
each element of all the structures you could see in this program.
Many books are written about these things and if you want to have
more information about them, you should have a look in the specialized
literature.
@EndNode
@Node "Allocations" "scout-39.guide/Allocations"
@Next "Assigns"
@Prev "Using Scout"
Allocations
===========
This window informs about who allocated what hardware resource.
CIA
---
The Amiga owns two CIA to control its hardware, the keyboard and the
printer interfaces. Additionally, it contains a couple of timer. This
window shows which parts of the CIA are not yet allocated, or which
program allocated the resource.
@{b}Timer A@{ub}
@{b}Timer B@{ub}
This are two 16bit timer. They can also be coupled to a 32bit
timer.
@{b}Alarm@{ub}
This resource informs if a third timer reached an alarm value.
@{b}Serial@{ub}
This is a simple serial interface. Usually, the CIA-A one's is used
for communicating with the keyboard. The CIA-B serial interface
will not be allocated in most cases.
@{b}Flag@{ub}
This is a special control line. It is connected from the CIA-A to
the Index line of the floppy disk drives.
Note: newer DraCos do not contain the CIA chips. Thus, these
hardware resources will be emulated or are even not offered.
Ports
-----
This are the resources for the internal parallel and serial
interfaces.
@{b}Serial Port@{ub}
This are the plain data transfer registers (transmitting and
receiving).
@{b}Serial Control@{ub}
This are the serial control lines, as Carrier Detect.
@{b}Parallel Port@{ub}
This are the data lines of the parallel port.
@{b}Parallel Control@{ub}
This are the control lines of the parallel port, as Busy or Paper
Out.
Actions
-------
@{b}Update@{ub}
The window is updates each time you press this button.
@{b}Print@{ub}
The window's contents are printed or saved to a file of your
choice.
@{b}Exit@{ub}
The window will be closed.
@EndNode
@Node "Assigns" "scout-39.guide/Assigns"
@Next "BoopsiClasses"
@Prev "Allocations"
Assigns
=======
This type of structure assigns a logical name to a directory.
If you assign the directory @{b}dh0:data/documents@{ub} the logical name
@{b}texts:@{ub}, you will also be able to choose a file @{i}filename@{ui} in that
directory with the path `texts:@{i}filename@{ui}'.
Column items
------------
@{b}Address@{ub}
Address of the assign structure.
@{b}Name@{ub}
Logical name of a directory
@{b}Path@{ub}
Here you will find the path of the directory.
Actions
-------
@{b}Update@{ub}
Selecting this gadget updates the list of assigns.
@{b}Print@{ub}
This function allows you to send the list of @{b}Assigns@{ub} to printer or
a selected file.
@{b}Remove@{ub}
The selected assign will be removed with this function.
@{b}Exit@{ub}
The @{b}Assigns@{ub} window will be closed.
@EndNode
@Node "BoopsiClasses" "scout-39.guide/BoopsiClasses"
@Next "Commodities"
@Prev "Assigns"
BoopsiClasses
=============
BOOPSI classes are object oriented classes. The classes in this list
are all classes that are publically available from intuition.
Column items
------------
@{b}Address@{ub}
This is the address of the @{b}IClass@{ub} structure, which contains all
data of this class.
@{b}Objects@{ub}
Shows the current amount of objects constructed by this class.
@{b}Subclasses@{ub}
Shows the current amount of sub classes (public and private) which
are derived from this class.
@{b}Superclass@{ub}
A pointer to the @{b}IClass@{ub} structure of the parent class.
@{b}Dispatcher@{ub}
A pointer to the dispatcher code, which realizes all methods of
the class.
@{b}Name@{ub}
The name of the class.
Actions
-------
@{b}Update@{ub}
The list will be updated.
@{b}Print@{ub}
This function allows you to send the list to printer or a selected
file.
@{b}Remove@{ub}
Removes the selected class from the system. This is only possible
if neither objects nor sub classes exist from this class.
@{b}More@{ub}
Opens a window with further information.
@{b}Exit@{ub}
Closes the window.
@EndNode
@Node "Commodities" "scout-39.guide/Commodities"
@Next "Devices"
@Prev "BoopsiClasses"
Commodities
===========
Commodities are small utilities. Most of them react on the input
stream, or manipulate it.
You can find some commodity examples in the @{b}Tools@{ub} drawer of your
Workbench.
Column items
------------
@{b}Address@{ub}
Points to the @{b}CxObj@{ub} structure of the commodity, containing all
data about it.
@{b}ln_Type@{ub}
Structure type. Usually, it will be @{b}Broker@{ub}.
@{b}ln_Pri@{ub}
Priority of the commodity broker.
@{b}Flags@{ub}
Flags describing the broker.
@{b}Port@{ub}
All messages of the broker are sent to this MessagePort.
@{b}Name@{ub}
Name of the commodity.
Actions
-------
@{b}Appear@{ub}
@{b}Disappear@{ub}
Let the selected commodity's GUI pop up or disappear. Some
commodities do not have a GUI.
@{b}Enable@{ub}
@{b}Disable@{ub}
The commodity will be enabled or disabled.
@{b}Kill@{ub}
Let the selected commodity remove itself in a clean way.
@{b}ListChg@{ub}
@{b}Unique@{ub}
The commodity is notified that the list has been changed or that
another commodity with the same name was about to be added. This
is only useful for programmers to test out their commmodities.
@{b}Update@{ub}
The list will be updated.
@{b}Print@{ub}
This function allows you to send the list to printer or a selected
file.
@{b}Priority@{ub}
This function allows you to change the priority of a commodity.
@{b}Remove@{ub}
Removes the selected commodity from the system. Please try a
frienly remove before, using @{b}Kill@{ub}. Maybe the commodity removes
itself voluntarily. =;^)
@{b}More@{ub}
Opens a window with further information.
@{b}Exit@{ub}
Closes the window.
@EndNode
@Node "Devices" "scout-39.guide/Devices"
@Next "Expansions"
@Prev "Commodities"
Devices
=======
A device is -- like a library (see @{"Libraries" Link "Libraries"}) -- a collection of
functions/procedures, which have to do certain jobs.
E.g. the @{b}trackdisk.device@{ub} includes functions for the floppy disk
handling.
Column items
------------
@{b}Address@{ub}
Address of the device structure
@{b}ln_Name@{ub}
Name of a device
@{b}ln_Pri@{ub}
Priority of a device
@{b}OpenC@{ub}
This element shows how often the device was opened.
@{b}RPC@{ub}
@{b}RPC@{ub} means @{b}RAM Pointer Count@{ub} and shows how many jump addresses of
the device point into RAM. In this way many programs -- like the
@{b}setpatch@{ub} command from Commodore -- patch the system.
Many viruses patch the system in this way too, but don't panic now.
If you check your system in regular intervals with a current virus
killer, it should be out of danger.
If the whole program code of the device is located in RAM, you will
find a dash (minus sign) here, because in this case it's
unimportant how many jump addresses point into RAM.
@{b}ln_Type@{ub}
Type of this structure (usually @{b}device@{ub})
Actions
-------
@{b}Update@{ub}
If you select this gadget, the list of devices will be updated.
@{b}Print@{ub}
This function allows you to send the list of @{b}Devices@{ub} to printer or
a selected file.
@{b}Remove@{ub}
The selected device will be removed with this function provided
that no program uses this device anymore and the @{b}OpenC@{ub} is zero.
@{b}Priority@{ub}
Herewith the priority of the device can be changed. A little
window will be opened, that asks you for a new priority. Through
the new priority it can happen that the device gets a new place in
the device list.
@{b}More@{ub}
Another window will be opened and you will see more informations
about the selected device.
You will have the same effect, if you doubleclick an element of the
device list.
@{b}Functions@{ub}
All device function offsets and addresses are shown up in a
subwindow. If an appropriate @{b}.fd@{ub} file exists and an @{b}FD:@{ub} assign
points to its directory, then you will also see the function names.
@{b}Exit@{ub}
The @{b}Devices@{ub} window will be closed.
@EndNode
@Node "Expansions" "scout-39.guide/Expansions"
@Next "Fonts"
@Prev "Devices"
Expansions
==========
@{i}IMPORTANT:@{ui} All Scout releases before 2.10 are not compatible to this
release! So if you want to read this list using TCP/IP, make sure that
the remote system runs the latest version as well!
This window shows a list about all your expansion boards (graphic
boards, memory expansions and so on) too.
Column items
------------
@{b}Address@{ub}
The address of the expansion structure.
@{b}BoardAddr@{ub}
Usually you will find the ROM of the card here. If this address
points into RAM, the card is a memory expansion.
@{b}Type@{ub}
Information about the board. See the More window for further
information.
@{b}Manufacturer@{ub}
Name of the board manufacturer.
@{b}Product@{ub}
Name and class of the product.
Additional information
----------------------
If you select one item from the list, the text field below shows up
some additional information:
@{b}Size@{ub}
If the entry belongs to a memory expansion, the size of the memory
is displayed here. Otherwise it's the ROM size of the card.
@{b}Flags@{ub}
See the More window.
@{b}ID@{ub}
ManufacturerID, assigned by Commodore, followed by the
Productnumber, assigned by the manufacturer of the board.
@{b}SN@{ub}
Serialnumber of the card (usually unused)
Actions
-------
@{b}Print@{ub}
This function allows you to send the list of @{b}Expansions@{ub} to printer
or a selected file.
@{b}More@{ub}
Now a window will be opened, that includes more informations about
the selected expansion board.
Doubleclick an element of the @{b}Expansions@{ub} list and you will have
the same effect.
@{b}Exit@{ub}
The @{b}Expansions@{ub} window will be closed.
Unknown expansion boards
------------------------
If you select an expansion board by selecting its list item, you will
get the name of the manufacturer and the card in the textfield you find
below the list, provided that the installed version of @{b}identify.library@{ub}
knows about these data.
If no information is available in this textfield or the given
information is wrong, you should send me the following data, please.
1. ManufacturerID (Manufacturer)
2. ProductID (Product)
3. Name of the company
4. Name of your expansion card
5. Function of your card
If you send me these data, the next version of @{b}Identify@{ub} will include
your expansion boards. Please be as precise you can.
@EndNode
@Node "Fonts" "scout-39.guide/Fonts"
@Next "InputHandlers"
@Prev "Expansions"
Fonts
=====
This function will show you all fonts existing in your system.
Column items
------------
@{b}YSize@{ub}
Vertical size of the font
@{b}Count@{ub}
Here you can see how many programs use the font.
@{b}Type@{ub}
@{b}ROMFONT@{ub} means the font is located in ROM and @{b}DISKFONT@{ub} means the
font was loaded from disk/harddisk.
@{b}Name@{ub}
Name of the font
Actions
-------
@{b}Update@{ub}
The list of fonts will be updated.
@{b}Print@{ub}
This function allows you to send the list of @{b}Fonts@{ub} to printer or a
selected file.
@{b}Close@{ub}
The font will be closed by using this function.
@{b}Remove@{ub}
It is possible to remove a font from system, provided that no
program uses it and it's no @{b}ROMFONT@{ub}.
@{b}Exit@{ub}
The @{b}Fonts@{ub} window disappears.
@EndNode
@Node "InputHandlers" "scout-39.guide/InputHandlers"
@Next "Interrupts"
@Prev "Fonts"
InputHandlers
=============
Input handlers take care of all user input arriving in system
(pressed keys, mouseclicks, inserted disks, etc.). They stand one
behind the other like on a production line and analyze the user input.
The input handler with the highest priority gets the `events' first and
if it doesn't know how to react on these `events', the second input
handler gets them, and so on.
Usually the system input handler has a priority of 50. Every input
handler, that wants to get the user input before the system, must have
a higher priority.
Column items
------------
@{b}ln_Name@{ub}
Name of the input handler
@{b}ln_Pri@{ub}
Its priority
@{b}is_Data@{ub}
This address points to some data needed by the input handler.
@{b}is_Code@{ub}
The program code starts here. If the code is located in RAM, the
address is of different color. Otherwise you can find the code in
ROM. Some viruses install an input handler in system. In this
case the @{b}is_Code@{ub} address points into RAM, but many other programs
uses input handlers, too. Don't panic!
Actions
-------
@{b}Update@{ub}
The list of input handlers will be updated when you select this
gadget.
@{b}Print@{ub}
This function allows you to send the list of @{b}InputHandlers@{ub} to
printer or a selected file.
@{b}Remove@{ub}
Removes an input handler from system.
@{b}Priority@{ub}
Changes the priority of an input handler.
@{b}Exit@{ub}
The window will be closed.
@EndNode
@Node "Interrupts" "scout-39.guide/Interrupts"
@Next "Libraries"
@Prev "InputHandlers"
Interrupts
==========
Interrupts are important events the computer system has to react on.
It exists a list of interrupt routines for each interrupt type. If a
certain interrupt occurs, all these interrupt routines will be called.
During their execution the running program will be interrupted.
Column items
------------
@{b}ln_Name@{ub}
Name of the interrupt
@{b}ln_Pri@{ub}
Its priority
@{b}is_Data@{ub}
At this address you find the data of the interrupt.
@{b}is_Code@{ub}
Address of the interrupt code. If this address points into RAM,
it's of a different color.
@{b}NUM@{ub}
This number represents the type of event the interrupt routine is
called on. The @{b}IntName@{ub} you find in the interrupt detail window
gives you a little bit more information about it.
@{i}Example:@{ui} Number 5 means that the interrupt is called at every
vertical blank interval.
Actions
-------
@{b}Update@{ub}
The list of interrupts will be updated.
@{b}Print@{ub}
This function allows you to send the list of @{b}Interrupts@{ub} to printer
or a selected file.
@{b}Remove@{ub}
If the interrupt is a server you can remove it from system. An
interrupt handler can't be removed by @{b}Scout@{ub}.
If you call @{b}avail flush@{ub} and the audio.device isn't used, the
interrupt handlers of the audio.device will be removed.
@{b}More@{ub}
Now a window will be opened that includes more details of the
interrupt.
@{b}Exit@{ub}
Selecting this gadget will close the @{b}Interrupts@{ub} window.
@EndNode
@Node "Libraries" "scout-39.guide/Libraries"
@Next "Locks"
@Prev "Interrupts"
Libraries
=========
A library is a collection of functions/procedures, which have to do
certain jobs. E.g. the `graphics.library' includes routines for
graphical display.
Column items
------------
@{b}Address@{ub}
Adress of the library structure
@{b}ln_Name@{ub}
Name of a library
@{b}ln_Pri@{ub}
Priority of a library
@{b}OpenC@{ub}
Here you see, how often the library was opened.
@{b}RPC@{ub}
@{b}RPC@{ub} means @{b}RAM Pointer Count@{ub} and shows how many jump addresses of
the library point into RAM. In this way many programs -- like the
@{b}setpatch@{ub} command from Commodore -- patch the system.
Many viruses patch the system in this way too, but don't panic now.
If you check your system in regular intervals with a current virus
killer, it should be out of danger.
If the whole program code of the library is located in RAM, you
will find a dash (minus sign) here, because in this case it's
unimportant how many jump addresses point into RAM.
@{b}ln_Type@{ub}
Type of this structure (usually @{b}library@{ub})
Actions
-------
@{b}Priority@{ub}
Herewith the priority of the library can be changed. A little
window will be opened, that asks you for a new priority. Through
the new priority it can happen that the library gets a new place
in the list of libraries.
@{b}Close@{ub}
A library must be closed by all programs, if you want to remove it
from system. In this case the @{b}OpenC@{ub} is zero.
If you select this function, you will be asked, how often you want
to close it. You can choose between @{b}Once@{ub} and @{b}All@{ub}.
Select @{b}All@{ub} and the library will so often be closed till the @{b}OpenC@{ub}
is zero.
@{b}Remove@{ub}
The selected library will be removed with this function provided
that no program uses this library anymore and the @{b}OpenC@{ub} is zero.
Some libraries can't be removed from system without a reset. So
you shouldn't wonder about it, if this happens.
@{b}Functions@{ub}
All library function offsets and addresses are shown up in a
subwindow. If an appropriate @{b}.fd@{ub} file exists and an @{b}FD:@{ub} assign
points to its directory, then you will also see the function names.
@{b}Update@{ub}
The list of libraries will be updated.
@{b}Print@{ub}
This function allows you to send the list of @{b}Libraries@{ub} to printer
or a selected file.
@{b}More@{ub}
A window will be opened that includes more details of the library.
@{b}Exit@{ub}
Selecting this gadget will close the @{b}library@{ub} window.
@EndNode
@Node "Locks" "scout-39.guide/Locks"
@Next "LowMemory"
@Prev "Libraries"
Locks
=====
A lock structure shows you, that a program reads from or perhaps
write into a file or a directory. With this type of structure the
system prevents, that a file will be deleted while another program gets
some data from it.
Column items
------------
@{b}Access@{ub}
Here you can see the type of access. This could be @{b}READ@{ub}, @{b}WRITE@{ub} or
@{b}OWN@{ub}. @{b}OWN@{ub} stands for a lock @{b}Scout@{ub} created to get the elements of
this list.
@{b}Path@{ub}
Path of the file or directory
Actions
-------
@{b}Update@{ub}
The list of @{b}Locks@{ub} will be updated.
@{b}Print@{ub}
This function allows you to send the list of @{b}Locks@{ub} to printer or a
selected file.
@{b}Remove@{ub}
A lock will be removed through dos.library's `UnLock()' function.
@{b}Pattern@{ub}
If you give @{b}Scout@{ub} a pattern, only the locks with a matching path
will be shown.
@{b}Exit@{ub}
The @{b}Locks@{ub} window will be closed.
@EndNode
@Node "LowMemory" "scout-39.guide/LowMemory"
@Next "Memory"
@Prev "Locks"
LowMemory
=========
This list contains all low memory handler known to the system.
These handlers are called in their sequence if a memory allocation
is about to fail due to missing resources. The handlers try to free as
much unused memory space as possible.
`ramlib' is such a low memory handler removing unused libraries and
devices from the system's memory. It is always present.
@{i}Note:@{ui} Low memory handlers are only available since AmigaOS 3.0. On
older systems this list will always be empty.
Column items
------------
@{b}Address@{ub}
Address of the low memory handler structure.
@{b}ln_Name@{ub}
Name of the handler.
@{b}ln_Type@{ub}
Type of the handler.
@{b}ln_Pri@{ub}
Priority of the handler. All handlers are called in their priority
sequence.
@{b}is_Data@{ub}
A pointer to some handler's private data.
@{b}is_Code@{ub}
A pointer to the low memory handler code.
Actions
-------
@{b}Update@{ub}
The list will be actualized.
@{b}Print@{ub}
This function allows you to send the list to printer or a selected
file.
@{b}Remove@{ub}
The low memory handler will be removed from system.
@{b}Priority@{ub}
Changes the priority of the selected handler.
@{b}Exit@{ub}
The window will be closed.
@EndNode
@Node "Memory" "scout-39.guide/Memory"
@Next "Mounted Devs"
@Prev "LowMemory"
Memory
======
In this list you will find the segments of your memory. At least you
will find an entry for your chip memory.
Column items
------------
@{b}ln_Name@{ub}
Name of the memory segment (e.g. @{b}chip memory@{ub})
@{b}ln_Pri@{ub}
Priority of memory
@{b}mh_Lower@{ub}
First address of memory
@{b}mh_Upper@{ub}
Last address of memory
Actions
-------
@{b}Print@{ub}
This function allows you to send the list of the memory segments to
printer or a selected file.
@{b}Priority@{ub}
This function allows you to change the priority of a memory
segment. The memory segment with the highest priority will be
preferred from system, provided that no certain type of memory is
demanded.
@{b}More@{ub}
Another window will be opened. This window includes more
information about the memory segment.
@{b}Exit@{ub}
The window will be closed.
@EndNode
@Node "Mounted Devs" "scout-39.guide/Mounted Devs"
@Next "Ports"
@Prev "Memory"
Mounted Devices
===============
In this list you will find all your devices like disk drives, printer
devices, etc.
Column items
------------
@{b}Name@{ub}
Name of the device
@{b}Unit@{ub}
Unit number
@{b}Heads@{ub}
Number of heads
@{b}Cyl@{ub}
Number of cylinders
@{b}State@{ub}
The state shows you for example, if a disk is in drive.
@{b}DiskType@{ub}
Type of a disk (e.g. OFS (OldFileSystem), FFS (FastFileSystem),
...)
@{b}Handler or Device@{ub}
The handler or the device you find here has to manage the stream of
data from and to the device.
Actions
-------
@{b}Update@{ub}
The list will be updated.
@{b}Print@{ub}
This function allows you to send the list of @{b}Mounted Devs@{ub} to
printer or a selected file.
@{b}Exit@{ub}
The window will be closed.
@EndNode
@Node "Ports" "scout-39.guide/Ports"
@Next "Resident Cmds"
@Prev "Mounted Devs"
Ports
=====
Programs are able to communicate together through ports.
Column items
------------
@{b}Address@{ub}
Here you will find the port structure.
@{b}ln_Name@{ub}
Name of port
@{b}ln_Pri@{ub}
Priority of port
@{b}mp_SigTask@{ub}
The task is communicating through the port.
Actions
-------
@{b}Update@{ub}
The ports list will be updated.
@{b}Print@{ub}
This function allows you to send the list of @{b}Ports@{ub} to printer or a
selected file.
@{b}Remove@{ub}
The port will be removed.
@{b}Priority@{ub}
Herewith the port priority can be changed.
@{b}Exit@{ub}
The @{b}Ports@{ub} window will be closed.
@EndNode
@Node "Resident Cmds" "scout-39.guide/Resident Cmds"
@Next "Residents"
@Prev "Ports"
Resident Commands
=================
This list includes all resident commands. That means all commands you
find in ROM and the commands you made `resident' through the @{b}resident@{ub}
command.
Positions and sizes of their hunks you will find here, too.
Column items
------------
@{b}Name@{ub}
Name of the command
@{b}UseCount@{ub}
Here you can see, how often a command was being executed at the
time the list was build.
@{b}Lower@{ub}
First address of hunk in memory
@{b}Upper@{ub}
Last address of hunk in memory
@{b}Size@{ub}
Size of hunk (upper - lower - 8 bytes overhead)
Actions
-------
@{b}Update@{ub}
The list of @{b}Resident Commands@{ub} will be updated.
@{b}Print@{ub}
This function allows you to send the list of @{b}Resident Commands@{ub} to
printer or a selected file.
@{b}Remove@{ub}
The selected command will be removed with this function provided
that no program uses this command anymore and the @{b}UseCount@{ub} is zero.
@{b}Exit@{ub}
The window disappears.
@EndNode
@Node "Residents" "scout-39.guide/Residents"
@Next "Resources"
@Prev "Resident Cmds"
Residents
=========
Resident modules are reset-protected segments (code and data). In
the list of @{b}Residents@{ub} you usually find libraries, devices and
resources. A programmer has the possibility to make his own programs
reset-protected. He has to initialize a resident structure for it and
then he can link the program through the kick-vectors (see @{"Vectors" Link "Vectors"}) to
the list of the resident modules. The residents you linked to system
are usually located in RAM and are of a different color.
If you find a resident module that points into RAM and you don't know
which program has created it, you should start your favourite virus
detector and let it check your memory. Many viruses prefer this way to
travel around.
Column items
------------
@{b}Address@{ub}
At this address the resident module is located.
@{b}ln_Name@{ub}
Name of the resident module
@{b}rt_Pri@{ub}
Priority
@{b}rt_IdString@{ub}
Identity string of the resident module.
Actions
-------
@{b}Update@{ub}
The list of @{b}Residents@{ub} will be updated.
@{b}Print@{ub}
This function allows you to send the list of @{b}Residents@{ub} to printer
or a selected file.
@{b}More@{ub}
Selecting this gadget opens a new window with more information
about the selected resident module.
@{b}Exit@{ub}
The @{b}Residents@{ub} window will be closed.
@EndNode
@Node "Resources" "scout-39.guide/Resources"
@Next "ScreenMode"
@Prev "Residents"
Resources
=========
Usually a resource is -- like a library (see @{"Libraries" Link "Libraries"}) -- a
collection of functions/procedures, which have to do certain jobs.
E.g. the `filesystem.resource' includes functions for the filesystem
handling.
Column items
------------
@{b}Address@{ub}
Address of the resource structure
@{b}ln_Name@{ub}
Name of a resource
@{b}ln_Pri@{ub}
Priority of a resource
@{b}OpenC@{ub}
This element shows how often the resource was opened.
@{b}RPC@{ub}
@{b}RPC@{ub} means @{b}RAM Pointer Count@{ub} and shows how many jump addresses of
the resource point into RAM. In this way many programs -- like
the @{b}setpatch@{ub} command from Commodore -- patch the system.
Many viruses patch the system in this way too, but don't panic now.
If you check your system in regular intervals with a current virus
killer, it should be out of danger.
If the whole program code of the resource is located in RAM, you
will find a dash (minus sign) here, because in this case it's
unimportant how many jump addresses point into RAM.
@{b}ln_Type@{ub}
Type of this structure (usually @{b}resource@{ub})
Actions
-------
@{b}Update@{ub}
The list of @{b}Resources@{ub} will be updated.
@{b}Print@{ub}
This function allows you to send the list of @{b}Resources@{ub} to printer
or a selected file.
@{b}Remove@{ub}
The selected resource will be removed with this function, provided
that no program uses it anymore and the @{b}OpenC@{ub} is zero.
@{b}Priority@{ub}
Herewith the priority of the resource can be changed. A small
window will be opened, that asks you for a new priority. Through
the new priority it can happen that the resource gets a new
position in the list of resources.
@{b}More@{ub}
Select this gadget and you get a new window with more information
about the selected resource.
@{b}Functions@{ub}
All resource function offsets and addresses are shown up in a
subwindow. If an appropriate @{b}.fd@{ub} file exists and an @{b}FD:@{ub} assign
points to its directory, then you will also see the function
names. Note that some resources do not have functions.
@{b}Exit@{ub}
The @{b}Resources@{ub} window will be closed.
@{i}Please note:@{ui} If you should find three dashes (minus signs) at @{b}OpenC@{ub}
and/or @{b}RPC@{ub}, the resource has no typical library structure. This
happens for example at the `FileSystem.resource'.
@EndNode
@Node "ScreenMode" "scout-39.guide/ScreenMode"
@Next "Semaphores"
@Prev "Resources"
ScreenMode
==========
Screen modes define all monitor resolutions that the system is able
to show up.
You surely have already selected a screen mode before. In this list,
you will find all available modes. Most of the programs filter out some
of them when they do not meet their purpose.
Column items
------------
@{b}ModeID@{ub}
An identification number, unique to each mode.
@{b}Width@{ub}
Nominal width of the resolution in pixeln.
@{b}Height@{ub}
Nominal height of the resolution in pixeln.
@{b}Depth@{ub}
Maximum number of planes. The amount of colors which can be
simultaneously displayed depends on this.
@{b}ScreenMode@{ub}
Name of the screen mode. Some modes do not have a real name, so
Scout will generate it. Then it might differ from the name
generated by other programs or screen mode requesters.
Actions
-------
@{b}Update@{ub}
The list will be updated.
@{b}Print@{ub}
This function allows you to send the list to printer or a selected
file.
@{b}More@{ub}
Further information about the screen mode are displayed in a
subwindow. This includes the overscan resolutions and the
frequencies. Due to an inaccuracy of the operating system, the
real frequencies might be a little bit different to those
displayed.
@{b}Exit@{ub}
The window will be closed.
@EndNode
@Node "Semaphores" "scout-39.guide/Semaphores"
@Next "System"
@Prev "ScreenMode"
Semaphores
==========
The use of semaphores is a way of single-threading critical
sections. For example only one program is allowed to use the printer
at one time, otherwise the texts would be mixed.
Column items
------------
@{b}ln_Name@{ub}
Name of a semaphore
@{b}Nest@{ub}
This item counts how often the semaphore has been obtained by the
owner task.
@{b}Queue@{ub}
This counter shows you, how many programs want to obtain the
semaphore.
@{b}Owner@{ub}
Here you will find the name of the task that owns the semaphore.
Actions
-------
@{b}Update@{ub}
The list of @{b}Semaphores@{ub} will be updated.
@{b}Print@{ub}
This function allows you to send the list of @{b}Semaphores@{ub} to printer
or a selected file.
@{b}Obtain@{ub}
This function is used to gain access to a semaphore. The @{b}NestCnt@{ub}
will be increased at one by this call.
@{b}Release@{ub}
Herewith you can make a signal semaphore available to others.
@{b}Exit@{ub}
The @{b}Semaphores@{ub} window will be closed.
@EndNode
@Node "System" "scout-39.guide/System"
@Next "Tasks"
@Prev "Semaphores"
System
======
Actions
-------
@{b}Print@{ub}
This function allows you to send the list to printer or a selected
file.
@{b}Exit@{ub}
The window will be closed.
Entry items
-----------
In this window you will find some (partially technical) information
about your computer. Please excuse the ordinary look of the window, but
it is very easy to add more lines this way.
@EndNode
@Node "Tasks" "scout-39.guide/Tasks"
@Next "Timer"
@Prev "System"
Tasks
=====
In this window you find a list of all tasks and processes being in
system. Each program you start will be executed as a task or process.
Column items
------------
@{b}ln_Name@{ub}
Name of the task/process
@{b}ln_Type@{ub}
Type of the structure (@{b}task@{ub} or @{b}process@{ub})
@{b}ln_Pri@{ub}
Priority of the task/process
@{b}NUM@{ub}
If a non detaching program was started from shell, you will find
here the number of the process. Programs you started from
Workbench have a dash here.
@{b}State@{ub}
Here you see the state of the task or process. You will find
Scout's own process on the top of the list with a @{b}run@{ub} at this
place, because this process is always running when it gets the
task list.
@{b}ready@{ub} means the task wants to work, but it's interrupted by the
execution of another task.
A task that is waiting for a certain signal is in the state @{b}wait@{ub}.
In this case it doesn't need processing time.
@{b}SigWait@{ub}
Signalmask the task is waiting for.
Actions
-------
@{b}Print@{ub}
This function allows you to send the list of @{b}Tasks@{ub} to printer or a
selected file.
@{b}Freeze@{ub}
With this function you freeze the selected task. It can still be
found in the list of tasks, but it gets no processing time from
system.
@{i}Warning:@{ui} If you try to freeze tasks essential to the system
like `input.device', you should have saved all important
data, cause a RESET is the only way out!
@{b}Activate@{ub}
A frozen task can be activated here.
@{b}CPU@{ub}
Here you will find a text field and a cycle gadget. This text field
displays -- dependent on the state of the cycle gadget -- the CPU
load in percent.
For the cycle gadget you can choose between three states:
@{b}off@{ub}
In this case the CPU load won't be displayed. If you select
another state, @{b}Scout@{ub} will patch some system functions to
calculate the CPU load of all tasks.
@{b}full@{ub}
If you select this state, @{b}Scout@{ub} sets the real cpu load to
100%. That means the total of the CPU loads of all tasks and
processes will be 100%. Therefore nothing will be displayed
in the text field.
@{b}in %@{ub}
@{b}Scout@{ub} starts a task named @{b}« Scout's cheat task »@{ub} to
calculate the real CPU load and it will be displayed in the
text field.
@{b}Secs@{ub}
This string gadget allows you to set the intervall time for
updating of the CPU load display.
@{b}Update@{ub}
The list will be updated.
@{b}Remove@{ub}
A task will be removed from the list. You should prefer the freeze
function, if you perhaps need this task again.
See also @{b}Break@{ub}!
@{b}Signal@{ub}
If you select a signal mask, it will be send to the task.
@{b}Break@{ub}
A signal mask that includes the signals CTRL-C and CTRL-D will be
send to the task you selected. Many tasks and processes end, if
they receive these signals.
@{b}Priority@{ub}
The priority of a task can be changed with this function.
@{b}More@{ub}
Selecting this gadget will open another window that displays more
informations about the task or the process.
@{b}Exit@{ub}
The window will be closed.
@EndNode
@Node "Timer" "scout-39.guide/Timer"
@Next "Vectors"
@Prev "Tasks"
Timer
=====
This window lists all current requests of the timer.device.
Column items
------------
@{b}Address@{ub}
Address of the IO request structure.
@{b}ReplyPort@{ub}
Address of the port the request will be replied to.
@{b}Time@{ub}
Time that this request will stay in this list.
@{b}Unit@{ub}
There are two different measures: VBlank (which has less overhead)
and MicroHz (which is more accurate).
@{b}Task@{ub}
Name of the requesting task.
Actions
-------
@{b}Print@{ub}
This function allows you to send the list to printer or a selected
file.
@{b}Update@{ub}
The list will be updated.
@{b}Exit@{ub}
The window will be closed.
@EndNode
@Node "Vectors" "scout-39.guide/Vectors"
@Next "Windows"
@Prev "Timer"
Vectors
=======
Actions
-------
@{b}Update@{ub}
The displayed vectors will be updated.
@{b}Print@{ub}
This function allows you to send the list of @{b}Vectors@{ub} to printer or
a selected file.
@{b}Exit@{ub}
The window will be closed.
Reset Vectors
-------------
A program can make itself reset-protected by using the reset vectors.
If the vectors are unused, they have a value of zero. The programs
which use the Kick-Vectors (KickTagPtr, KickMemPtr and KickCheckSum)
can also be found in the list of resident structures. See also
@{"Residents" Link "Residents"}.
Auto Vector Interrupts
----------------------
In a computer system with a MC68000 processor you will find the seven
@{b}Auto Vector Interrupts@{ub} from address $64 to address $7c. Higher
processors (MC68010, etc.) have the VBR (Vector Base Register) that
allows you to move the interrupt table to FAST-MEM. The system will be
a little bit faster then. @{b}Scout@{ub} uses the VBR if it exists.
Interrupt Vectors
-----------------
Here you see 16 interrupt vectors (IntVecs). These vectors are
located in the `ExecBase' (base structure of the exec.library).
@EndNode
@Node "Windows" "scout-39.guide/Windows"
@Next "Scout and AmiTCP"
@Prev "Vectors"
Windows
=======
All screens with the windows opened on them are listed here. Screens
are of a different color as windows.
Column items
------------
@{b}Pos(x,y)@{ub}
x and y position of the screen/window
@{b}Size(x,y)@{ub}
x and y size of the screen/window
@{b}Title@{ub}
Title of the screen/window
Actions
-------
@{b}Update@{ub}
The list will be updated.
@{b}Print@{ub}
This function allows you to send the list of @{b}Windows@{ub} to printer or
a selected file.
@{b}Close@{ub}
With this function it is possible to close screens and/or windows.
If you close a screen, all windows on it will be closed too.
@{b}To Front@{ub}
The selected screen/window will be popped to front.
@{b}More@{ub}
If you select this gadget another window will be opened that
displays more informations about the window or the screen.
@{b}Exit@{ub}
The window will be closed.
@EndNode
@Node "Scout and AmiTCP" "scout-39.guide/Scout and AmiTCP"
@Next "Scout without MUI"
@Prev "Windows"
@Toc "Main"
Scout and AmiTCP
================
This section will show you what you have to do for using @{b}Scout@{ub} as a
TCP/IP service through @{b}AmiTCP@{ub}. Nearly all functions of @{b}Scout@{ub} can also
be used via @{b}AmiTCP@{ub}.
Now some knowledge will be assumed. If you don't know, what kind of
program @{b}AmiTCP@{ub} represents, you should read @{b}AmiTCP's@{ub} user's manual
before. (See also @{"AmiTCP" Link "AmiTCP"}.)
If you have installed @{b}AmiTCP@{ub}, you can use @{b}Scout@{ub} as client and
server. Except the installed programs of @{b}AmiTCP@{ub} you don't need another
program for using @{b}Scout@{ub} on networks.
If you want to make your computer available for other systems on the
network, you have to do following two steps:
1. Add the line @{b}scout 6543/tcp@{ub} to file @{b}AmiTCP:db/services@{ub}.
2. Now please add the line @{b}scout stream tcp nowait root dh0:scout@{ub} to
file @{b}AmiTCP:db/inetd.conf@{ub}. Make sure that the path at the end of
this line is the right path for @{b}scout@{ub}.
That's it! If you start @{b}AmiTCP@{ub} now, your computer is available for
other systems through using the options @{b}HOST@{ub}, @{b}USER@{ub} and @{b}PASSWORD@{ub}.
@{i}Example:@{ui} If I want perform some actions on some system structures
of my own system for example, I have to start @{b}Scout@{ub} through
something like:
1> scout HOST crash.north.de USER atte PASSWORD secret
If you leave out option @{b}PASSWORD@{ub}, you will be asked for the correct
password through the @{b}password:@{ub} prompt. In this case nobody can see your
password, because it won't be displayed in shell.
If you don't use option @{b}USER@{ub}, @{b}AmiTCP@{ub} takes the username that is
actually available in system.
The usage of @{b}AmiTCP@{ub} doesn't provide the installation of @{b}MUI@{ub}. All of
@{b}Scout's@{ub} shell commands (see also @{"Commands" Link "Commands"}) can be used via network
through @{b}AmiTCP@{ub}.
@{i}Example:@{ui} If I want to get the task list of my system, I have to
use something like:
1> scout HOST crash.north.de USER atte PASSWORD secret Tasks
You and all other users must always identify themselves through
their usernames (option @{b}USER@{ub}) and their passwords (option @{b}PASSWORD@{ub}).
It's also possible to allow or deny certain systems the usage of some
services through the file @{b}AmiTCP:db/inet.access@{ub}. See also the user's
manual of @{b}AmiTCP@{ub}.
If you want to get more informations about the implemented options
and commands, you should also see @{"Options" Link "Options"} and @{"Commands" Link "Commands"}.
@{i}NOTE:@{ui} Please take care that the remote system runs the latest Scout
version as well, to avoid incompatibilities.
@EndNode
@Node "Scout without MUI" "scout-39.guide/Scout without MUI"
@Next "Options"
@Prev "Scout and AmiTCP"
@Toc "Main"
Scout without MUI
=================
Nearly all through the graphical user interface available functions
of @{b}Scout@{ub} are also available via shell. Therefore you don't really need
@{b}MUI@{ub} for using @{b}Scout@{ub}. But if you want to use @{b}Scout's@{ub} graphical user
interface, you must have @{b}MUI@{ub} in your system.
@EndNode
@Node "Options" "scout-39.guide/Options"
@Next "Commands"
@Prev "Scout without MUI"
@Toc "Main"
Options
*******
There are some options for @{b}Scout@{ub} which you can use, when you start
the program. The following options are available from shell and as
tool types from Workbench.
@{b}ICONIFIED@{ub}
@{i}Usage:@{ui} @{b}ICONIFIED@{ub}
If this option is activ, @{b}Scout@{ub} starts iconified.
@{b}PORTNAME@{ub}
@{i}Usage:@{ui} @{b}PORTNAME@{ub}=@{i}portname@{ui}
The name of Scout's ARexx port can be changed into @{i}portname@{ui}.
Without this option the ARexx port is called `SCOUT.X'. The @{b}X@{ub}
stands for a decimal number that will be incremented, if a so
called port already exists.
@{b}TOOLPRI@{ub}
@{i}Usage:@{ui} @{b}TOOLPRI@{ub}=@{i}value@{ui}
This option allows you to change the priority of Scout's process
into @{i}value@{ui}.
@{b}STARTUP@{ub}
@{i}Usage:@{ui} @{b}STARTUP@{ub}=@{i}command@{ui}
The variable @{i}command@{ui} should be an ARexx script or a single ARexx
command. Both (script or command) will be executed, when @{b}Scout@{ub}
will be started. In this way you can open more than only the main
window by starting. Try for example the command @{b}OpenWindow Tasks@{ub}
and you will get two windows by starting (the main window and the
task list window).
(See also @{"ARexx port" Link "Commands"}.)
@{b}INTERVALTIME@{ub}
@{i}Usage:@{ui} @{b}INTERVALTIME@{ub}=@{i}seconds@{ui}
This options allows you to save your preferred update time for the
list of tasks. (See also @{"Secs" Link "Tasks"}.)
@{b}CPUDISPLAY@{ub}
@{i}Format:@{ui} @{b}CPUDISPLAY@{ub}=@{i}value@{ui}
Through the variable @{i}value@{ui} you can select the state of the @{b}CPU@{ub}
cycle gadget you find in the @{b}Tasks@{ub} window. (See also @{"CPU" Link "Tasks"}.)
@{b}*@{ub} @{b}1@{ub} means @{b}CPU: full@{ub}
@{b}*@{ub} @{b}2@{ub} means @{b}CPU: in %@{ub}
@{b}HOST@{ub}
@{i}Format:@{ui} @{b}HOST@{ub}=@{i}hostname@{ui}
This options allows you to specify the system (@{i}hostname@{ui}) you want
to manipulate via network through @{b}AmiTCP@{ub}.
@{b}USER@{ub}
@{i}Format:@{ui} @{b}USER@{ub}=@{i}username@{ui}
You have to use this option to identify yourself by using @{b}Scout@{ub} as
a TCP/IP service.
@{b}PASSWORD@{ub}
@{i}Format:@{ui} @{b}PASSWORD@{ub}=@{i}password@{ui}
Without a password @{b}Scout@{ub} can't connect to another system via
network. This option allows you to set the correct password.
@{b}COMMAND@{ub}
@{i}Format:@{ui} @{b}COMMAND@{ub}=@{i}commandline@{ui}
Nearly all of @{b}Scout's@{ub} implemented functions are available from
shell through this option. You don't need the @{b}COMMAND@{ub} key to use
this option. (See also @{"Commands" Link "Commands"}.)
@{b}SINGLEWINDOWS@{ub}
@{i}Format:@{ui} @{b}SINGLEWINDOWS@{ub}
Some users don't like to handle the many windows of Scout. This
option solves the problem of too many windows. If this option is
selected, only one list window and only one detail window is
opened at a time.
@{b}SORT#?TYPE@{ub}
@{i}Format:@{ui} @{b}SORT#?TYPE@{ub}=@{i}number@{ui}
Many of @{b}Scout's@{ub} lists have a cycle gadget below themselves. With
these gadgets you can select, how a certain list will be sorted.
@{b}SORT#?TYPE@{ub} stands for each of the following options:
@{b}SORTLIBRARIESTYPE@{ub}, @{b}SORTDEVICESTYPE@{ub},
@{b}SORTRESOURCESTYPE@{ub}, @{b}SORTTASKSTYPE@{ub}, @{b}SORTPORTSTYPE@{ub},
@{b}SORTCOMMANDSTYPE@{ub}, @{b}SORTASSIGNSTYPE@{ub}, @{b}SORTLOCKSTYPE@{ub},
@{b}SORTCOMMODITIESTYPE@{ub}, @{b}SORTSCREENMODETYPE@{ub} and @{b}SORTCLASSESTYPE@{ub}.
@{b}SORT#?TYPE@{ub} should follow a decimal number, which selects the kind
of sorting.
Here are some examples for the list of tasks:
@{b}SORTTASKSTYPE=1@{ub} the tasks will be sorted by their names.
@{b}SORTTASKSTYPE=2@{ub} the tasks will be sorted by their priorities.
@EndNode
@Node "Commands" "scout-39.guide/Commands"
@Next "Updates"
@Prev "Options"
@Toc "Main"
Scout's commands via ARexx and shell
************************************
@{b}Scout@{ub} supports two kinds of commands:
1. commands only available from shell
2. commands available from ARexx and shell
ARexx port
----------
It's a feature of @{b}MUI@{ub} to give each application its own ARexx port.
Therefore @{b}Scout@{ub} also has an ARexx port that usually has the name
@{b}SCOUT.X@{ub}. The @{b}X@{ub} stands for a decimal number that will be
incremented, if a so called port already exists.
You will find the name of @{b}Scout's@{ub} ARexx port in the window you get,
if you select the @{b}Project/About@{ub} menu.
Using tasknames:
----------------
If a task or a process was started from shell and hasn't detached
itself, you will find the name of the command being executed, where
usually the taskname is displayed. The real name of those tasks
usually is something like @{b}Background CLI@{ub}, but such a taskname isn't
useful.
@{i}Example:@{ui} If you start a non detaching task like @{b}DH0:Debug/Sushi@{ub}
from shell, you will see @{b}DH0:Debug/Sushi@{ub} as taskname.
Some ARexx commands need a taskname as parameter. You have to select
those from CLI started self detaching tasks by using their command
names like @{b}Scout@{ub} displays them in the lists of tasks.
Commands only available from shell
==================================
@{b}Help@{ub}
@{i}Format:@{ui} @{b}Help@{ub}
This command is the most important one and it doesn't need
parameters. If you try @{b}Help@{ub}, @{b}Scout@{ub} prints a list of all available
commands to shell. =:^)
Now 18 commands follow. These commands allow the user to get all
lists of system structures from shell. Therefore you only need to
install @{b}MUI@{ub} for using @{b}Scout's@{ub} graphical user interface.
Each of the following commands has a shortened form that stands
behind the command in parentheses.
@{b}Allocations@{ub} (a), @{b}BoopsiClasses@{ub} (b), @{b}Commands@{ub} (c), @{b}Devices@{ub} (d),
@{b}Timer@{ub} (e), @{b}Fonts@{ub} (f), @{b}Assigns@{ub} (g), @{b}InputHandlers@{ub} (h), @{b}Interrupts@{ub}
(i), @{b}LowMemory@{ub} (j), @{b}Commodities@{ub} (k), @{b}Libraries@{ub} (l), @{b}Memory@{ub} (m),
@{b}Mounts@{ub} (n), @{b}Locks@{ub} (o), @{b}Ports@{ub} (p), @{b}Residents@{ub} (r), @{b}Semaphores@{ub} (s),
@{b}Tasks@{ub} (t), @{b}Resources@{ub} (u), @{b}Vectors@{ub} (v), @{b}Windows@{ub} (w), @{b}Expansions@{ub}
(x), @{b}System@{ub} (y) and @{b}ScreenMode@{ub} (z).
@{i}Example:@{ui} To get the list of ports, you only have to use @{b}scout
ports@{ub} or @{b}scout p@{ub} from shell.
Commands available from ARexx and shell
=======================================
@{b}FindTask@{ub}
@{i}Usage:@{ui} @{b}FindTask@{ub} @{i}task@{ui}
This command allows you to check, if task @{i}task@{ui} exists in system or
not. The result is the address of the task @{i}task@{ui}, if it has been
found. @{i}task@{ui} can be the name or the address of a task.
@{b}FreezeTask@{ub}
@{i}Usage:@{ui} @{b}FreezeTask@{ub} @{i}task@{ui}
The task @{i}taskname@{ui} will be frozen. After that it will still be
found in system's task list, but then it doesn't need processing
time. You can choose the name or the address of a task for @{i}task@{ui}.
@{b}ActivateTask@{ub}
@{i}Usage:@{ui} @{b}ActivateTask@{ub} @{i}task@{ui}
If task @{i}task@{ui} was frozen, it will be activated, otherwise an error
occured. @{i}task@{ui} is again a task's name or an address.
@{b}RemoveTask@{ub}
@{i}Usage:@{ui} @{b}RemoveTask@{ub} @{i}task@{ui}
This command removes the task @{i}task@{ui}. It's lost forever.
@{b}BreakTask@{ub}
@{i}Usage:@{ui} @{b}BreakTask@{ub} @{i}task@{ui}
@{b}Scout@{ub} sends the task @{i}task@{ui} a certain signal mask that includes the
signals CTRL-C and CTRL-D. Many programs support these signals and
finish themselves, if they receive one of them.
@{b}SignalTask@{ub}
@{i}Usage:@{ui} @{b}SignalTask@{ub} @{i}task@{ui} @{i}hexsignal@{ui}
This command allows you to send a signal @{i}hexsignal@{ui} to the task
@{i}task@{ui}. The signal must specified as a hexadecimal number.
@{i}Example:@{ui}
SendSignal 'scout' 0x001000
sends task @{b}scout@{ub} a CTRL-C and after that @{b}Scout@{ub} ends.
@{b}SetTaskPri@{ub}
@{i}Usage:@{ui} @{b}SetTaskPri@{ub} @{i}task@{ui} @{i}priority@{ui}
The task @{i}task@{ui} gets a new priority (@{i}priority@{ui}).
@{b}RemovePort@{ub}
@{i}Usage:@{ui} @{b}RemovePort@{ub} @{i}port@{ui}
The port @{i}port@{ui} will be removed from @{b}Scout@{ub}. @{i}port@{ui} can be the name of
a port or its address.
@{b}GetLockNumber@{ub}
@{i}Usage:@{ui} @{b}GetLockNumber@{ub} @{i}lockpattern@{ui}
This command returns the number of locks which have paths matching
to the pattern @{i}lockpattern@{ui}.
@{i}Example:@{ui} Use the command
GetLockNumber 'WORK:Utilities/#?'
and you will know, how many locks are currently used for files in
the directory @{b}WORK:Utilities/@{ub}.
@{b}RemoveLocks@{ub}
@{i}Usage:@{ui} @{b}RemoveLocks@{ub} @{i}lockpattern@{ui}
Use this command and all locks which have paths matching to the
pattern @{i}lockpattern@{ui} will be removed. (See also @{b}GetLockNumber@{ub}.)
@{b}RemoveLock@{ub}
@{i}Format:@{ui} @{b}RemoveLock@{ub} @{i}lockaddress@{ui}
The lock at adress @{i}lockaddress@{ui} will be removed.
@{b}FindNode@{ub}
@{i}Usage:@{ui} @{b}FindNode@{ub} @{i}nodetype@{ui} @{i}nodename@{ui}
This command allows you to find a certain node. You only have to
know its name (@{i}nodename@{ui}) and its type (@{i}nodetype@{ui}).
@{i}Nodetype@{ui} can have following values: @{b}LIBRARY@{ub}, @{b}DEVICE@{ub}, @{b}RESOURCE@{ub},
@{b}MEMORY@{ub}, @{b}SEMAPHORE@{ub}, @{b}PORT@{ub} or @{b}INPUTHANDLER@{ub}.
@{i}Example:@{ui} If you want to get the address of the @{b}disk.resource@{ub} you
must use:
FindNode RESOURCE 'disk.resource'
@{b}GetPriority@{ub}
@{i}Usage:@{ui} @{b}GetPriority@{ub} @{i}nodeaddress@{ui}
This command allows you to check the priority of a certain node
structure. This includes all following structure types: tasks,
libraries, devices, resources, ports, residents, input handlers,
interrupts, semaphores and the elements of the memory list.
You only have to know the address (@{i}nodeaddress@{ui}) of that structure.
@{i}Example:@{ui} The following ARexx commands store the priority of your
chip memory in the variable @{b}pri@{ub}:
FindName MEMORY 'chip memory'
addr = result
GetPriority addr
pri = result
@{b}SetPriority@{ub}
@{i}Usage:@{ui} @{b}SetPriority@{ub} @{i}nodetype@{ui} @{i}nodename@{ui}
If you want to change the priority of the node @{i}nodename@{ui}, you can
use this command. Again @{i}nodetype@{ui} can have following values:
@{b}LIBRARY@{ub}, @{b}DEVICE@{ub}, @{b}RESOURCE@{ub}, @{b}MEMORY@{ub}, @{b}SEMAPHORE@{ub}, @{b}PORT@{ub} or @{b}INPUTHANDLER@{ub}.
@{b}CloseLibrary@{ub}
@{i}Format:@{ui} @{b}CloseLibrary@{ub} @{i}library@{ui}
The library @{i}library@{ui} will be closed once. @{i}library@{ui} can be the name
of the library or its address.
@{b}RemoveLibrary@{ub}
@{i}Format:@{ui} @{b}RemoveLibrary@{ub} @{i}library@{ui}
The library @{i}library@{ui} will be removed, if no program uses it.
@{b}RemoveDevice@{ub}
@{i}Format:@{ui} @{b}RemoveDevice@{ub} @{i}device@{ui}
The selected device @{i}device@{ui} will be removed. For @{i}device@{ui} use the
name or the address of the device.
@{b}RemoveResource@{ub}
@{i}Format:@{ui} @{b}RemoveResource@{ub} @{i}resource@{ui}
The resource @{i}resource@{ui} will be removed.
@{b}ObtainSemaphore@{ub}
@{i}Format:@{ui} @{b}ObtainSemaphore@{ub} @{i}semaphore@{ui}
This command allows you to obtain the given semaphore. @{i}semaphore@{ui}
can be the semaphore's name or address.
@{b}ReleaseSemaphore@{ub}
@{i}Format:@{ui} @{b}ReleaseSemaphore@{ub} @{i}semaphore@{ui}
The semaphore @{i}semaphore@{ui} will be once released.
@{b}RemoveSemaphore@{ub}
@{i}Format:@{ui} @{b}RemoveSemaphore@{ub} @{i}semaphore@{ui}
You are able to remove the semaphore @{i}semaphore@{ui} by using this
command.
@{b}RemoveInputhandler@{ub}
@{i}Format:@{ui} @{b}RemoveInputhandler@{ub} @{i}inputhandler@{ui}
The input handler @{i}inputhandler@{ui} selected through name or address
will be removed.
@{b}FindResident@{ub}
@{i}Usage:@{ui} @{b}FindResident@{ub} @{i}resident@{ui}
This command returns the address of the resident structure
@{i}resident@{ui}.
@{b}FindInterrupt@{ub}
@{i}Usage:@{ui} @{b}FindInterrupt@{ub} @{i}interruptname@{ui}
The address of the interrupt @{i}interruptname@{ui} will be returned.
@{b}RemoveInterrupt@{ub}
@{i}Format:@{ui} @{b}RemoveInterrupt@{ub} @{i}interruptname@{ui}
The interrupt you have selected through @{i}interruptname@{ui} will be
removed.
@{b}FlushDevs@{ub}
@{i}Usage:@{ui} @{b}FlushDevs@{ub}
All not used devices will be removed. The used memory will be
freed.
@{b}FlushFonts@{ub}
@{i}Usage:@{ui} @{b}FlushFonts@{ub}
If a diskfont is in memory, but no program uses it, it will be
removed.
@{b}FlushLibs@{ub}
@{i}Usage:@{ui} @{b}FlushLibs@{ub}
All not used libraries will be removed. The used memory will be
freed.
@{b}FlushAll@{ub}
@{i}Usage:@{ui} @{b}FlushAll@{ub}
This function includes @{b}FlushDevs@{ub}, @{b}FlushFonts@{ub} and @{b}FlushLibs@{ub}. All
not used devices, libraries and fonts will be removed and the used
memory will be freed.
@{b}ClearResetVectors@{ub}
@{i}Usage:@{ui} @{b}ClearResetVectors@{ub}
The six reset vectors will be cleared, if you select this function
(see @{"Vectors" Link "Vectors"}).
@{b}PopToFront@{ub}
@{i}Usage:@{ui} @{b}PopToFront@{ub} @{i}title@{ui}
This command allows you to pop a screen or window to front. You
only have to know its (@{i}title@{ui}).
@{b}CloseWindow@{ub}
@{i}Usage:@{ui} @{b}CloseWindow@{ub} @{i}windowtitle@{ui}
This command closes the window that is specified through its title
(@{i}windowtitle@{ui}).
@{b}CloseScreen@{ub}
@{i}Usage:@{ui} @{b}CloseScreen@{ub} @{i}screentitle@{ui}
If you select this command, the screen (@{i}screentitle@{ui}) will be
closed with all its windows.
@{b}CloseFont@{ub}
@{i}Format:@{ui} @{b}CloseFont@{ub} @{i}address@{ui}
The font at address @{i}address@{ui} will be closed once.
@{b}RemoveFont@{ub}
@{i}Format:@{ui} @{b}RemoveFont@{ub} @{i}address@{ui}
This command removes the font at address @{i}address@{ui}, if it's not used
by any program.
@{b}RemoveCommand@{ub}
@{i}Format:@{ui} @{b}RemoveCommand@{ub} @{i}address@{ui}
@{b}Scout@{ub} makes the resident command at address @{i}address@{ui} not resident.
@{b}RemoveAssign@{ub}
@{i}Format:@{ui} @{b}RemoveAssign@{ub} @{i}name@{ui}
With this command you're able to remove the assign @{i}name@{ui}.
@{b}RemoveAssignList@{ub}
@{i}Format:@{ui} @{b}RemoveAssignList@{ub} @{i}name@{ui} @{i}address@{ui}
This command removes the directory at address @{i}address@{ui} from assign
@{i}name@{ui}. You will find the address of that directory in the list of
assigns.
@{b}PrintList@{ub}
@{i}Format:@{ui} @{b}PrintList@{ub} @{i}listcharacter@{ui} @{i}filename@{ui}
This command allows you to print a list (specified by the
listcharacter) into the file @{i}filename@{ui}.
@{i}Example:@{ui}
PrintList t 'ram:tasklist'
will print the list of tasks into the file 'ram:tasklist'.
@{b}OpenWindow@{ub}
@{i}Usage:@{ui} @{b}OpenWindow@{ub} @{i}windowid@{ui}
All windows you get if you select a gadget of @{b}Scout's@{ub} main window,
can be opened with this command. The @{i}windowid@{ui} is the same text you
find on the main window gadgets.
@{i}Example:@{ui}
OpenWindow 'Mounted Devs'
will open the window with the list of mounted devices.
@{b}CxAppear@{ub}
@{b}CxDisappear@{ub}
@{b}CxEnable@{ub}
@{b}CxDisable@{ub}
@{b}CxKill@{ub}
@{b}CxListChg@{ub}
@{b}CxUnique@{ub}
@{i}Format:@{ui} @{b}Cx...@{ub} @{i}name@{ui}
Sends the command to the commodity named @{i}name@{ui}.
@{b}RemoveCx@{ub}
@{i}Format:@{ui} @{b}RemoveCx@{ub} @{i}commodity@{ui}
Removes the appropriate commodity from the list. Please consider
this as `emergency break'. Use it only if @{b}CxKill@{ub} failed.
@{b}SetCxPri@{ub}
@{i}Format:@{ui} @{b}SetCxPri@{ub} @{i}commodity@{ui} @{i}priority@{ui}
Sets the priority of a commodity.
@{b}RemoveClass@{ub}
@{i}Format:@{ui} @{b}RemoveClass@{ub} @{i}class@{ui}
The appropriate BOOPSI class is removed, if no objects and no
subclasses are existing.
@EndNode
@Node "Updates" "scout-39.guide/Updates"
@Next "Credits"
@Prev "Commands"
@Toc "Main"
How to get updates
==================
The newest version of @{b}Scout@{ub} should always be available on AmiNet or
Public Domain collections, which are up-to-date.
You can also find the latest version on my home page:
http://www.is-koeln.de/einwohner/shred/
@EndNode
@Node "Credits" "scout-39.guide/Credits"
@Next "Author Info"
@Prev "Updates"
@Toc "Main"
Credits
=======
Now we have to thank some people for supporting the development of
@{b}Scout@{ub} on many different kinds:
@{b}*@{ub} Klaus `gizmo' Weber, he was always available to Atte and his many
questions (not a few) during the programming of @{b}Scout@{ub}.
@{b}*@{ub} Christian `cosinus' Stelter, he gave the permission to use his
many manuals.
@{b}*@{ub} Stefan Stuntz for his great @{b}MagicUserInterface@{ub}
@{b}*@{ub} all (hopefully still) bug reporting and feature requesting people:
Kai `wusel' Siering, Martin Hauner, Peter Meyer, Karl `Charly'
Skibinski, Michael `Mick' Hohmann, Thore Böckelmann, Bernardo
Innocenti, Daniel Lundberg, ...
and last but not least
@{b}*@{ub} all the others we've forgotten for reporting bugs, sending
expansion boards data and so on.
@EndNode
@Node "Author Info" "scout-39.guide/Author Info"
@Next "Index"
@Prev "Credits"
@Toc "Main"
How to reach the author
=======================
If you have questions, suggestions, bug reports or anything else, you
can contact me at:
Richard Körber
Hornstraße 20
51465 Bergisch Gladbach
- Germany -
E-Mail: shred@chessy.aworld.de
richard.koerber@koeln.netsurf.de
Send E-Mails whenever possible..
If you want to contact Andreas Gelhausen, you can reach him at:
Andreas Gelhausen
Graf Spee Str. 23b
26123 Oldenburg
- Germany -
E-Mail: atte@crash.north.de
Please do not contact him for bug reports, suggestions and similar.
But if you feel the urge to send a gift, then he is the right address!
That's it! =:^)
@EndNode
@Node "Index" "scout-39.guide/Index"
@Prev "Author Info"
@Toc "Main"
Index
*****
@Index "Index"
@{" Allocations " Link "Allocations"} Allocations
@{" AmiTCP " Link "AmiTCP"} AmiTCP
@{" ARexx " Link "Commands"} Commands
@{" ARexx port " Link "Commands"} Commands
@{" Assigns " Link "Assigns"} Assigns
@{" Author Info " Link "Author Info"} Author Info
@{" Boards " Link "Expansions"} Expansions
@{" BoopsiClasses " Link "BoopsiClasses"} BoopsiClasses
@{" Command " Link "Commands"} Commands
@{" Command Line Options " Link "Options"} Options
@{" Commodities " Link "Commodities"} Commodities
@{" Contents " Link "Copyright"} Copyright
@{" Copying " Link "Copyright"} Copyright
@{" Copyright " Link "Copyright"} Copyright
@{" Copyright " Link "Copyright"} Copyright
@{" Credits " Link "Credits"} Credits
@{" Device names, logical " Link "Assigns"} Assigns
@{" Devices " Link "Devices"} Devices
@{" DISKFONT " Link "Fonts"} Fonts
@{" Distribution " Link "Copyright"} Copyright
@{" Expansions " Link "Expansions"} Expansions
@{" Fonts " Link "Fonts"} Fonts
@{" FreeWare " Link "Copyright"} Copyright
@{" Handler, LowMemory " Link "LowMemory"} LowMemory
@{" Hardware " Link "Expansions"} Expansions
@{" Identify " Link "Identify"} Identify
@{" Input events " Link "InputHandlers"} InputHandlers
@{" InputHandlers " Link "InputHandlers"} InputHandlers
@{" Installation " Link "Installation"} Installation
@{" Interrupts " Link "Interrupts"} Interrupts
@{" Introduction " Link "Introduction"} Introduction
@{" Legalities " Link "Copyright"} Copyright
@{" Liability " Link "Copyright"} Copyright
@{" Libraries " Link "Libraries"} Libraries
@{" Limitation " Link "Copyright"} Copyright
@{" Locks " Link "Locks"} Locks
@{" Logical device names " Link "Assigns"} Assigns
@{" LowMemory " Link "LowMemory"} LowMemory
@{" MagicUserInterface " Link "MUI"} MUI
@{" Main Window " Link "Using Scout"} Using Scout
@{" Manufacturer " Link "Expansions"} Expansions
@{" Memory " Link "Memory"} Memory
@{" Mounted Devices " Link "Mounted Devs"} Mounted Devs
@{" MUI " Link "MUI"} MUI
@{" No Warranty " Link "Copyright"} Copyright
@{" Options " Link "Options"} Options
@{" Ports " Link "Ports"} Ports
@{" Processes " Link "Tasks"} Tasks
@{" RAM Pointer Count " Link "Devices"} Devices
@{" Resident Commands " Link "Resident Cmds"} Resident Cmds
@{" Residents " Link "Residents"} Residents
@{" Resource allocation " Link "Allocations"} Allocations
@{" Resources " Link "Resources"} Resources
@{" ROMFONT " Link "Fonts"} Fonts
@{" RPC " Link "Devices"} Devices
@{" ScreenMode " Link "ScreenMode"} ScreenMode
@{" Screens " Link "Windows"} Windows
@{" Semaphores " Link "Semaphores"} Semaphores
@{" System " Link "System"} System
@{" System Requirements " Link "System Requirements"} System Requirements
@{" Tasknames " Link "Commands"} Commands
@{" Tasks " Link "Tasks"} Tasks
@{" TCP/IP " Link "AmiTCP"} AmiTCP
@{" Timer " Link "Timer"} Timer
@{" Tool Types " Link "Options"} Options
@{" Trademarks " Link "Copyright"} Copyright
@{" Updates " Link "Updates"} Updates
@{" Using Scout " Link "Using Scout"} Using Scout
@{" VBR " Link "Vectors"} Vectors
@{" Vectors " Link "Vectors"} Vectors
@{" Vertical blank interrupt " Link "Interrupts"} Interrupts
@{" What is Scout? " Link "Introduction"} Introduction
@{" Windows " Link "Windows"} Windows
@EndNode