Moved debuging commands from hooke_cli and plugin.system to plugin.debug.

Moved system commands from hooke_cli to plugin.system.

Added Argument.count handling to hooke.ui.commandline.

Rework hooke.command.Command.handle_arguments (again :p).

Previous implementation didn't set params[name] when
  num_provided == 0 and argument.callback != None

Adjust hooke.command.UncaughtException to properly handle pickle reconstruction.

multiprocessing.Queue pickles objects to send through its pipe, so our
objects must be capable of surving the pickling process unscathed.

Added interaction to hooke.ui.commandline.LocalCommandExit.

Also broke out commandline's exit and help commands.  They were
getting complicated enough to deserve their own classes.

Better solution to internal/external names via `name_fn`.

Use ._cl_name and ._cl_aliases instead of overwriting .name and .aliases.

We don't change the keys hardcoded into the Command._run methods, so
we need to keep the original names.  Hmm, I'll have to adjust
Command.help and Argument.help to use the external names...

Add hooke.playlist.NoteIndexList and refactor exception handling in commandline.

Highlights:
  * hooke.playlist classes now subclass the new hooke.playlist.NoteIndexList
  * hooke.plugin.cut.CurveArgument replaces previous _run hacking with
    a callback to initialize the default curve.x
  * hooke.ui.commandline.command_parser -> CommandLineParser.  The new
    class is cleaner, and raises exceptions rather than exiting.  We
    don't want Hooke dying until the user has time to clean up.

Pass Hooke instance to CommandEngine.run(), not UserInterface.run().

User interface just needs its configuration (already setup in
  Hooke.load_ui() -> ui.load_ui(self.config)
) and a read-only list of commands.  Giving the Hooke instance to
CommandEngine allows the commands to work on the Hooke instance
directly.  This makes user interfaces less intelligent (i.e. easier to
write), and more consistent (because they all depend on the same
commands engine.)

Don't crash when Command._run() raises an uncaught Exception.

Just print the traceback and move on.  This gives the user time to
exit gracefully (saving playlists etc.).

Argument parser now works for command execution as well (vs. just for help).

Added command parser to hooke.ui.commandline for argument listing.

help_* working in commandline UI.

Still to go:
  * DoCommand._parse_args
  * DoHelp._usage_string
  * CompleteCommand
  * Interactive communication between user and command

Added basic commandline framework to ui.commandline (using cmd.Cmd)

Finished off hooke.hooke and fleshed out hooke.ui.

Highlights:
  * New hooke.command for CommandExit (and subclasses), Command, and
    Argument.  For the same reason as hooke.playlist: keep core
    functionality out of hooke.plugin, which is only for the pluggable
    interface to that functionality.
  * New hooke.engine containing CommandEngine.  Not much going on
    here.  Perhaps I will merge it into hooke.command later...
  * New hooke.ui.commandline stub for 'command line' UI.
  * Filled in hooke.ui stub.
  * Added UI and CommandEngine handling to hooke.hooke.Hooke.
  * Added a new super-local '.hooke.cfg' to hooke.config.DEFAULT_PATHS.
    For project-specific hooke configuration?  Mostly to avoid suprising
    the user by clobbering ~/.hooke.cfg.
  * Fix expanduser bug in hooke.config.HookeConfigParser.write.
  * Fix super(AddCommand, self) -> super(AddGlobCommand, self) bug in
    hooke.plugin.playlist.AddGlobCommand.__init__.

Added hooke.plugin.playlist.AddGlobCommand.

This completes the rewrite of individual playlist handling.

Also:
  * Added hooke.plugin.playlist.FilePlaylist.set_path() to reduce
    duplicate code.

Oops, I'd forgotten to version the restored hooke.playlist module.

A number of minor documentation cleanups.

Updated to doc building framework.  Added Sphinx extensions and fixed genrst dependency

Minor fix to hooke.plugin.playlist.__doc__

Moved Playlist and FilePlaylist definitions back to hooke.playlist

We shouldn't define core classes in plugins.  This will make the
plugin clearer, separating the core functionality from the silly
plugin interface to that core functionality.  Such Builtins are useful
for the Hooke command line and GUIs, but not for people using Python
to import hooke directly.

Cleaned up Builtin handling and reduced driver/plugin duplication.

Moved hooke.playlist -> hooke.plugin.playlist and added hooke.plugin.Builtin.

Highlights:
  * Cleaner Playlist, with more consistent file format.
  * New "Builtin" class for required (core) commands.
  * Moved NotRecognized from hooke.driver -> hooke.curve to avoid
    import-order issues.  Now hooke.curve can be fully loaded before
    hooke.driver.
  * Moved hooke.curve.Data.notes -> hooke.curve.Data.info['note']
    for better consistency with Curve and Playlist.
  * Started cleaning up plugin loading into flexible functions.

Add Hooke.commands, a list of available commands

Ironed out kinks in plugin/driver loading and configuring.

Highlights:

  * Plugin/Driver.setting_section attribute so subclasses don't need
    to construct it on their own (duplicate effort, and so, error
    prone).
  * Fixed self.wrap = True -> self.wrap = wrap bug in
    hooke.config.Setting
  * No longer alter hooke.config.DEFAULT_SETTINGS in
    hooke.hooke.Hooke.__init__()
  * Filled in Hooke.load_plugins()/.load_drivers() stubs.
  * Removed deprecated Hooke.driver_default_settings().
  * Commented out a lot of the old HookeFrame code.  I'll delete
    it as I go through and implement its functionality.

Rework hooke.driver and hooke.driver.tutorial along the lines of hooke.plugin.

Many more drivers to refactor, but this is good enough to get me going
again with the core code.

Assorted changes so import hooke.plugin works ;).

Uncommenting the cut entry in PLUGIN_MODULES exposed a number of bugs
which I fixed:
  * def Plugin (object): -> class Plugin (object):
  * plugin initialization must occur *after* Command/Argument definition.
    That way the neccessary classes are defined when we go to load the
    plugin modules.
  * Broken default_settings() fixed.

Also did some docstring cleanup.

Moved hooke.libhookecurve -> hooke.curve and rewrote HookeCurve -> Curve class.

New class Data subclasses numpy.ndarray for faster data handling.

Changes:
  * hooke.libhookecurve.PlotObject -> hooke.ui.gui.plot.PlotObject
  * hooke.libhookecurve.Driver -> hooke.driver.Driver
  * Raise new exception hooke.driver.NotRecognized if no driver
    matches (vs. old print message and return false).
  * Curve stores data in a list (vs. old dict).  Often data order
    is important.  The names that used to key the data dict can
    now go into Data.info['name'].
  * HookeCurve.fits -> Curve.info['fits']
  * HookeCurve.plots is GUI data, but if the UI needs it, it should be
    stored in Curve.info['plots']
  * Since Curve.data is an array,
    HookeCurve.add_data() -> Curve.data.append(),
    HookeCurve.delete_data() -> Curve.data.remove(), and
    HookeCurve.set_data() -> Curve.data[i] = data

Converted hooke.plugin.cut to new Plugin architecture.

Use .type.upper() (vs. old .name.upper()) for Argument.metavar.

This conveys more information to the user
     output FILE
compared to the same word twice:
     output OUTPUT

Also rearranged some options.

Moved Argument and other class definitions after Command

Added Command and related classes to hooke.plugin

Based on my libbe.commands.base work for Bugs Everywhere.

Added hooke.plugin.Plugin.name attribute.

Also:
  * Reordered Plugin methods from first called -> last called.
  * Removed old Commands class.

Added tip-to-root/root-to-tip flexibility to hooke.util.graph

The old implementation only did tip-to-root.  The new default is
root-to-tip.

Added inclusion logic to hooke.plugin

Added the graph module I'd developed for Bugs-Everywhere

Beginning to rewrite Hooke to decouple from GUI.

This commit:
  * Started documenting with reStructuredText (for later use by Sphinx)
  * Added hooke.config module to handle configure files (via ConfigParser)
  * Added hooke.compat module to hold compatibility code
    (e.g. workarounds to allow Hooke to work on older Python versions).
  * Added config input/output to hooke.hooke.Hooke.
  * Stubbed out driver/plugin initialization in Hooke

Added Sphinx documentation framework

Convert from DOS to UNIX line endings.

This keeps the project consistent, since all my new files will have
UNIX line endings.  If people use tools that can't handle UNIX line
endings, we can always convert back later:

  for f in $(find . | grep -v '\.git'); do unix2dos "$f"; done

Really hideous merge of Rolf Schmidt's code.

It's hard to merge code when you're not sure which version is more
recent, what the rationale behind the changes are, or very much about
how the code is supposed to work at all ;).  I think I caught most of
the important ideas from both sides, and now I'm going to go back
through and clean things up.

Oops, fix libinput import in hooke.plugin.review.  Missed it in the merge

Removed busy loop from hooke/plugin/flatfilts.py.

Perhaps it was an attempt to pause briefly?  If so, time.sleep() would
be better.  It wasn't much of a pause though:
  $ time python -c ''
  real    0m0.111s
  user    0m0.089s
  sys     0m0.020s
  $ time python -c 'for i in range(1000): k=0'
  real    0m0.115s
  user    0m0.090s
  sys     0m0.024s

Merged with trunk

WLC and FJC output are now with 2 decimal precision.  Added a comment on autopeak on how to use the 'manual' option

Added the possibility to manually choose the peaks in 'autopeak' with the option 'manual'.

Correct number of digits of many output, improvement in the utility 'cut' and 'txt'.

Fixes bad call to wlc/fjc fit

Added modular directory structure.

Also some import and other cleanups to convince myself that the
reorganization was mostly working.

fit.py : extended FJC fit (models water bridges of PEG in water solutions)
fit quality parameter, ratio distance(fit-data)/std(flat_area)

multifit.py : WLC and eFJC as default fits
saves quality of fits

multifit.py : slope can be measured from data or form manual points
tried to scale better the YNarrow

multifit.py : slope can be measured manually
generalvclamp.py : change color of slope line to black

mfp3d.py : the retraction speed is extracted from Velocity, not RetractVelocity

multifit.py : some graphical niceties

multifit.py : proper formatting of help section

multifit.py : Fixed a wrong named var
libhook.py  : Deleted deprecated message (irritates me :D)

multifit.py :    new plugin, mouse input based
generalvclamp.py : separated code from do_slope into _slope allowing use in other funtions
hooke.conf:        activate multifit plugin by default

review.py: fixed crash when a file is not valid

review.py: avoided crash when displaying final stats
hooke.conf:  deactivate hdf5 by default, activate native mfp3d
mfp3d.py:  adapted driver from Hooke GUI to work in this version
procplots.py: centerzero only uses last chunk of retract

FMjoin.py: utility script to put together all files from IgorPro force maps

Corrected a bug for the command txt when it is invoked with an unvalid plot to export.

A correction on autopeak.py due to the add of curvetools.py (a self. was missing)

Corrected some bugs in the scale of graphs.

Fixed some bugs

Scale of axis are now in engineering format.

(generalvclamp.py) Error checking in flatten plot manipulator - fixes issue 31

review.py plugin allows to review curves in groups of ten (à la Igor Pro), select some of them and save to a separate directory

Added two plugin: jumpstat.py and multidistance.py. Change to the function has_peaks. Moved some basics routines in the new file curvetools.py.

Command 'note' saves notes into 'hookedir/output' directory (a bit cleaner) and if the note file exists adds instead of overwriting the file.

New plotmanip 'centerzero' shifts the curves to 0 force

Support for HDF5 files created with Igor Pro (see wiki for how to create the HDF5 file)

Fix: genlist can now import files without extension

Added Alberto's mailing list comments about lib*.py to their docstrings.

From the thread:
  http://groups.google.com/group/hookesoftware/browse_thread/thread/7b893284cc317ea6#

Added config_dir to libhooke.HookeConfig to match new dir structure

Added USAGE file based on code.google.com/p/hooke/wiki/BasicAnalysis

All classes should at least subclass 'object' to avoid being old-style classes.

See, for example
  http://www.python.org/doc/newstyle/
  http://www.python.org/doc/2.5.2/ref/node33.html

Removed sha-bang from non-executable python files + whitespace cleanups.

Whitespace cleanups mostly involved removing trailing whitespace.

Added README and reorganized directory structure (breaks code)

(fit.py) Quick kludgy patch for crash of issue 0028

(fit.py) Fixed -maybe- FJC plotting

(autopeak.py) Corrected a bug introduced in r208

(autopeak.py) Repeatedly asks for correct input.

Added multidistance plugin.

(autopeak.py) fixed autopeak documentation

(autopeak.py) autopeak can now use FJC or WLC

(fit.py) wording output is consistent with fit function used

(fit.py) WLC and FJC now aliases of fit command

Got FJC drawing right.

Better plotting of FJC but not there yet

First steps towards FJC support. New variable fit_function for flexible switching, still errors in drawing, inconsistencies etc. but the numbers in output seem sensible

Hopefully reverted to r193 after mbrucale's incident

using numpy.mean to avoid warnings; still not perfect though

correct parsing of args of peaks command; Fixes issue 0017

added cut.py plugin (by Fabrizio Benedetti, EPFL, Lausanne)

deleted spurious empty dir from tree

fixed: plot does not display on Windows at program launch (troubleshooting issue 1)
fixed: driver tries to open a directory (issue 15)

fixed counter issue

Fixed MFP1D export from Igor 4 (wavenote was not complete)