README for Agide - A-A-P GUI IDE

This is currently an experimental setup.

There is a separation between model and view nearly everywhere.  The model
defines the data structures (classes and objects).  The view how they are
presented on the screen.

The model should not depend on the kind of GUI used.  Later a console version
will be added.  

There are some leftovers from using code from Boa Constructor.  Mostly empty
directories (if you obtain Agide from CVS).


OBJECT STRUCTURE OF THE MODEL

At the toplevel:
1.  List of activities	The Activities the user is working on.
3.  List of nodes	Items inside an activity currently being worked on;
			often a file.  Could also be called "Windows",
			although several items may be handled by the same
			tool.
2.  List of tools	Tools currently being used; The same tool may appear
			several times, e.g. image viewers each displaying one
			image.

An Activity consists of:
- Navigators		different ways to navigate through the parts of an
			Activity.  Mostly a tree view on the items in an
			activity.  Can also be a class browser, grep output,
			etc.
   - toplevel item	properties of the activity (project name, grep
     			pattern used, etc.)
     - list of items    items contained in an item (recursively)
     - list of tools	tools being used for this item (editor, GUI
       			designer, etc.); mostly there is none.

An item in the list of items consists of:
     - link to the node
     - list of contained items

A Node contains:
     - list of tools	tools being used for this item (editor, GUI designer)

A Tool consists of:
- tool properties	e.g., whether it's open or not
- list of nodes		the Nodes being worked on in this tool.  Can be just
			one (new tool started for each node) or several (the
			tool can switch between items or display several at
			once).


IMPORTANT CLASSES OF THE MODEL

class name		file
		description
	- data
	> method
----------------------------------------------------------------------------
ActyList		Activity.py
		List of activities: The tasks a user is working on.  He can
		quickly switch between activities.  There is only one of
		these.
	- list of Activity objects
	> Open existing Activity (from file)
	> Create new Activity (from template)
	> Move Activity up/down in list
	> Remove Activity
	> close (close all activities)

Activity		Activity.py
		Something the user is working on.  Can be a single file, a
		project with multiple files, a shell window, browser, etc.
	- Type name (edit, project, shell, etc.)
	- Name
	- List of Navigators
	- Active Navigator
	> foreground, show current navigator and its selected item (restore
	  Activity)
	> save, close, delete, rename Activity.
	> new navigator (e.g., list of tags, grep for symbol)

Navigator		Navigator.py
		Organizes items of an Activity, a view on an Activity.
	- Name (of the view)
	- toplevel ActivityItem
	- active ActivityItem (in the tree)
	> foreground, show current ActivityItem
	> refresh (e.g., update class list)
	> close navigator

ActyItemList		Navigator.py
		list of ActivityItems, either for items of a project or items
		used in a tool
	- list of ActivityItems
	> Move ActivityItem up/down in list
	> add/delete ActivityItem

ActyItem		Navigator.py
		Link between an item in an Activity and a Node.
		Item that exists in an Activity; file, directory, class, file
		location, etc.
	- Node that this item refers to
	- ActyItemList, contained items
	- Activity that is for this specific item
	> list available tools for editing, viewing, etc.
	> open item in a specific tool
	> foreground, show tool editing this item
	> close all tools for this item
	> make an Activity out of this item

Node			Navigator.py
		The item that an ActyItem refers to: file, directory, class,
		etc.
	- list of Tools that this node is being used in.
	- data (depends on type of node)
	> list available tools for editing, viewing, etc.
	> open node in a specific tool
	> foreground, show tool editing this node
	> close all tools for this node