The backend has been started.
Added a rudimentary menu system.  Did some reorganization.  Removed the 'refs' object, because I can't forsee ever needing it.
Added rudamentary menuing support, and started the module loading code.
Submenus don't work yet, and only the root menu works as of right now.
Fixed up the menu-ing system to support sub menus.  Menus are now correctly
object oriented.

Modules were fleshed out a bit and organized better.

TODO:

There's a bug where onmouseout on the rootmenu kills the submenu, even if
you are mousing into the submenu.
Changed the look of the menus, and completed the menu code for the most
part.

Commented the code thoroughly and added header comments to every file.
Added a darkener object which 'darkens' the screen for modal dialogs and
such.

Added a dialog class with a lot of flexibility.

Added the mechanisms for logging in using a dialog object (as well as changing of the root menu if you are logged in or not).  No user verification has been implemented yet, but a very very early implementation of the user table has been created along with the database.  This app is going to use the SecDB class.
Added a bit more documentation to the dialog class.
Added the time box (clock) that keeps track of the time.  Has code that is
the equivalent of PHP's date() function (http://php.net/date), and is
tracked through 'settings.timeFormat'.

Added a new property to the dialog box, firstFocus.  This specifies which
element within the form for the dialog box gets the focus on first load.

Fixed a few visual bugs.
Modified the core object to keep track of the root_button, local_button,
strip_bar, cmdline, and time_box objects within itself so code doesn't have
to use code.gebi() to find those block objects.

Added "addText()" to the dialog class, which adds plain text to a dialog
box in both columns of the dialog table.

Added a loading tracker, which keeps track of loading processes.  It knows
how many processes are loading, so someone calling "core.done()" doesn't
cause the loading notifier to go away if other processes are currently
loading as well.

Added rudimentary server object support.  This object keeps track of and
creates XMLHttpRequest objects and executes commands when everything is
done.  This code is completely theoretical at this point since there is no
server/database code up yet, so it hasn't been tested in any way yet.
Added complete command support.  The command class has one main instance,
cmd, which keeps track of the toplevel commands.  From there, functions and
other command objects are registered with that in trees which can be
infinitely long.  Multiple commands can be stated by separating them with
semi-colons, and each argument is split up by space.  Arguments can be
quoted, and quotes can be used by escaping with a '\'.  Semi-colons can be
escaped as well.  Basically, it works the same way as most UNIX command
prompts work (Bourne Shells, at least).
Fixed a bug in the command parsing that caused an infinite loop if a
"shift()" call was returning nothing (IE: The person who entered the
command forgot a trailing quote or there was no trailing semi-colon when a
semi-colon was quoted).
Fixed a bug with the menus where the Timeout wasn't cleared in certain
situations, leading to an error.  Now, the Timeout is cleared and even if
it does manage to not get cleared some other way, it doesn't trigger a
Javascript error.

Cleaned up some of the code to eliminate the reliance on the env object.  I
think this time through I'm going to try to do without it, since everything
is properly object oriented as it is.
Fixed a problem where you couldn't register a command if it didn't have
some sort of arguments passed to it.

Added support for "default" handlers.  Registered by '', these handle
"everything else" or situations where there are no arguments passed to the
command object.

Added support for aliasing.
Started work on the backend stuff.  The idea is for each module to have an
object which is an interface, and have each method inside of it be callable
by the client.

Also started work on the install scripts, which will create databases
required for each module and such.
Pushed a few things around, and it seems the requests work.  The command
"a" is a PoC for this.
Fleshed out the server communication stuff.  Sending and parsing requests
is easy, just send an object with the attributes, and out comes an object
for the responses.

Simple user verification is in play, as well, but it's not very secure
because the encryption and security algorithms aren't created yet..
Added easy to create error dialogs that act similar to alert(), but are in
the dialog class.  Called through dialog.error().

Added error support for dialogs, so that if an error occurs in the
submission of a form, the form can be redisplayed and an error spit out
that says what happened.  Currently being used to verify the user is in
existence or not.
Added an encryption algorithm that hopefully doesn't suck.  Seems to work
pretty well, though.  Changed the users table to take out encryption
boolean, and added a credentials text field for storing hashes generated by
the script.
Added the winbar, and started work on creating actual windows for modules
and such.  When the width gets too big, the scroll bars pop up, and they
work as well.

Moved the currently logged in user from the time box to the root window
title.

Started work on adding a body and a root window.  Technically it's there,
although not visible.
Fixed up the code so that the body block elements are removed when a new
window is selected, and the new window is added.

Fixed the height of the encasing body element 'body_scroll'.

Made the note command set the retrieved data of the note to the value of
the textarea.