NFC: Reorder models
Return a slightly better error message.
Complete refactor to single process form wrapper

The first round of implementation was using ad-hoc $.post actions based
on as-I-went coding.  Due to my use of the jquery-editable plugin, this
included (effectively) an ad-hoc form for every edited element.  This
new implementation pre-wraps -- if the user is logged in -- every
process table in a form.  Thus, there is now a single function for
submitting new information, but the POST data changes for the current
parameter.  This is not a complete implementation because the interface
does not currently account for if a user changes fields, in which case
there would be multiple parameters sent to the update view.  It's a work
in progress.

Along the way, I also:

 * Made the 'showStatus' function slightly more flexible, allowing the
   caller to specify what kind of message it's displaying.  Currently
   have only implemented 'info' and 'error', with the 'error' being the
   default.

 * Have also implemented the ability to actually remove non-tabular
   parameters from the model: if the user completely empties the field
   before submitting, the UI will interpret that as "delete this
   parameter from this process."

 * For items that are deleted, The UI now reloads the process list.
   This is a Q&D method of putting the UI in a known state, allowing me
   to not have to worry about cascaded removals (e.g., removing an
   efficiency will also remove all associated emissions, removing a
   process discount rate replaces the '(GDR)' in the field).  It's not
   the most elegant or visually pleasing method, but it is simple.
Remove some debugging measures.

Forgot to remove these a couple of commits ago.  Sorry 'bout that.
Model copy/paste error.

Need to account for Tech _and_ Process Lifetime values.
Minor change in model appearance in admin.
Remove builtin image padding.

These icons had a builtin padding (forcing them to 48px by 48px:
apparently I'm misappropriating them!) that was making layout with CSS
difficult.  I've now cropped them so that they are now only as big as
the content.
Make inner table CSS slightly more compact.

With the previous commit's reduction of the icons built-in padding, we
now can have a more compact inner table layout.
Refactor update and delete view code.

I've now simplified some of the update and delete logic that I had
initially implemented.  It's still a work in progress, but hopefully
easier to follow along now, and with less overall code.  The change
boils down to distinction of parameter primary keys: if they share a
primary key (e.g., the process), they they can all share the same code.
Refactoring of JS code.

process_interface was a first attempt and it was showing.  I've
refactored a large part of the JS code and will, in the next few commits
include the requisite backend code.

The biggest pieces are that TemoaLib.js (formerly process_interface.js)
does a lot less DOM manipulation, leaving the building of Forms to
the webserver.  The original idea of passing data back and forth through
JSON wasn't wrong, but required some reinventing of the wheel.  Django
has a lot of niceties (like Form validation) that we can now take care
of on the server.

Also, for speed of development, have added a jQuery Hotkeys plugin and
subsequently added a shortcut "Ctrl+Space" which reloads the Javascript
and CSS in place.  It may seem small, but it reduces a common 2-3 second
operation to less than a quarter second.  Due the number of reloads
necessary for development, this adds up quickly.
Minor speed improvement

GZip content before sending over the wire.  This should mostly be a win,
but of course, we won't know until testing.
Major rework of model organization (schema)

 * Moved a number process-specific properties from their own tables to
   attributes on the Process model.

 * Added a new table 'Set_commodity_output'.  It's not 100% modeling
   perfect, but it makes many of the clean() and save() methods much
   easier.  The save() methods have gained a new "add me" to the _output
   set, and the clean() methods can be simplified because the FK
   relationships take care of the correctness.

 * Updated TechInputSplit and TechOutputSplit to only include the input
   and output commodity FKs.  This follows a recent change to the Temoa
   model that similarly removes knowledge from the *Split* constraints
   about the other side of the processes.  (The TechOutputSplit clean()
   implementation was made easier by the just-mentioned
   Set_commodity_output table.)
Major refactor: use Django Forms

I was running into difficulties with the dynamic nature of some of the
model parameters with the previous JSON and piecemeal AJAX approach.
I've now converted to using Django's Forms API for updating processes.
This puts more code server side rather than on the client, but also
enables hooking into Django's validation routines more cleanly.

I'm not altogether happy with this implementation, but TemoaDB is still
in flux it would seem.  Time will tell if using the Django Forms API
will prove a win for maintainability over time.

Along the way, I've refactored the model one more time.  This time, it's
more of a meta change than an actual change, taking advantage of
Django's Meta class "abstract = True" property to scale down some of the
repetition.

Some notable changes:

 * Rather than building the forms in the browser, forms are generated
   server side and sent as whole HTML chunks to the browser.  This
   currently means an intermittent use of JSON and HTML from the server.

 * The forms can correctly handle variable input (like new efficiency
   rows).

 * Minor modeling refactor in the DB code.  The instantiated tables and
   relationships should be the same in the DB.
Debugging help.

For debugging, it can be helpful (sometimes) to have normalized HTML
output.
NFC: String wrapping.
Major Refactor.

I bit the bullet and have implemented a form for every DB row.  This is
more in line with how Django "thinks" and has reduced the code bloat
tremendously.  The expense is slightly more complexity of the DOM, but
who cares.  We're starting to settle on an API, and I can document it at
some point in the hopefully near future.
Remove duplicated code.

I implemented those functions for a reason.  Utilize them!
EmissionActivity Forms.

The next iteration of variable length forms.

A "gotcha" for the time being is that if you remove an efficiency, you
have to reload the process, or else you'll have a stale EmissionActivity
on the screen.  I haven't decided the best method for dealing with this
yet.
Forgot to add these previous commits.

These are the piecemeal parts of the DOM that build each form.
Dynamically change form input type.

The choices input is nice because it means I don't have to write my own
validation routines.  Unfortunately, it is not a natural overlap with
the TextInput.  So, I've opted to split the difference by converting a
forced-choice option to a readonly text field.  Looks a lot nicer, and
still lets the user see the options.