Hey everyone,
The purpose of this e-mail is to propose a project which I am
tentatively naming "Viewpoint" in order to obtain feedback.
I shall start by presenting my two motivations for this project. First,
while I love Leo and use it for nearly all projects that I work on, I
have often felt frustrated by aspects of the user interface/editor that
aren't as polished as other text editors, which is basically just caused
by the fact that the Leo user/developer community is much smaller than
most of the other major text editors. Second, I would love to see the
core ideas of Leo --- that of structuring entire programming projects as
outlines with arbitrary levels of nestings and the possibility of
cloning nodes to create views --- be spread to a wider audience.
Thus I propose a project to build the following components:
(1) A Java interface that provides an abstraction of the Leo core data
model/controller, plus support for adding listeners that are notified
when the model is changed.
(2) A wrapper of the current code for Leo using Jython to implement (1),
plus support for adding listeners that are notified when the model is
changed.
(3) A Swing control based on JTree that provides a view of (1), designed
such that there can be multiple independent views of the same (which is
the reason for adding support for listeners).
(4) A plugin for jEdit that gives users the ability to
create/open/save/edit/etc. Leo outlines, based on the control
implemented in (3). In particular, I would like to see it have the
following features:
*) Ability to have multiple views of an outline, using tabs or windows.
*) Ability to open node bodies in separate windows. (Note that opening
the same node body in multiple windows is not a problem, since they can
all point to the same jEdit buffer.)
*) Ability to run Leo scripts, assuming that one knows that one is not
just using any implementation of (1) but the particular implementation
of (2).
The reason for having having (1) and (2) be separate is to give people
freedom to experiment with different back-ends. For example, someone
could experiment with a back-end that is written in Java/Scala/etc. to
see if it is faster. Or, someone could experiment with their own system
of Node heading sentinels. In fact, my original plan was to start by
writing my own back-end (that is, my own data
structure/tangler/untangler in Scala, which is actually almost
complete), but Edward managed to talk me out of having this be the main
implementation. :-)
Thoughts?
Cheers,
Greg
--
You received this message because you are subscribed to the Google Groups
"leo-editor" group.
To post to this group, send email to [email protected].
To unsubscribe from this group, send email to
[email protected].
For more options, visit this group at
http://groups.google.com/group/leo-editor?hl=en.
