pmacs3/IDEAS

2010/4/27:

It would be awesome to actually handle tabs correctly (e.g. how emacs or vim
does); that is, instead of substituting N whitespace characters for each tab
it would just handle seeing tabs correctly. There are some problems doing this:

  1. render objects store the X coordinate to write to; this needs to be
     calculated if characters are variable-width (easy to fix)
  2. buffer needs to stop munging/de-munging lines (easy to fix)
  3. draw_slot() needs to keep track of the X offset when drawing (easy)
  4. map_point() needs to be fixed so that logical cursor position gets
     translated correctly (e.g. for x=1, line="\tfoo\n", vx=4) (medium)
  5. fix all the navigation and cursor positioning code in window.py (hard)
  6. find all the other places where len(line) gets used for drawing (ugh)

Each time I embark on this I get a little farther before giving up. At this
point it's a race to see whether I fix indenting for "munged" lines (so that
"\t  \tfoo" and "    foo" indent the same) or actually fix all these problems.

2009/10/21:

More reasonable:
  * Check out integrating lxml and xml-mode (also html-mode).
  * Make spell-checking easier to add to modes (return of minor-modes?)
  * Figure out how to integrate bibtex to latex
  * Figure out nice/secure way to specify configurable command-lines
  * Add C-x DEL, M-t and C-t
  * Generic "selection buffer" for giving the user a list of choices
  * Make tab-completion more extensible/less hard-coded
  * make spell-checking/error-highlighting/etc. all easier to overlay

Less reasonable:
  * Maybe make highlighting and data storage synonymous (rather than two data
    structures kept in sync)?
  * Async events and handlers
  * 

2009/07/26:

Rather than using regions to try to capture delimiter matching (e.g. []) let's
create a option in grammar to keep a stack of delimiter tokens. That way,
rather than descending deeper and deeper into regions whenever things open or
close, we're just modifying a seperate stack. This might be equally bad
though... I'm not really sure. Maybe instead of a stack we could use a number?

2009/07/21:

There should be some sort of command-channel or RPC thing going on, so that
external programs can open files in pmacs, send commands to various pmacs
buffers, etc.

2009/07/11:

Redo mode detection so that it uses regexes not words. Then fix all the modes
that want #! detection.
(done)

2009/05/05:

Either give buffers direct access to the application object, or make the
application object global. Otherwise, you can't directly configure a buffer via
the application.config dictionary.

2009/04/09:

Fix the kludge that is completer initialization. Make application a global? Try
to make bufferlist nicer. Add support for vim/emacs mode-setting stuff. Fix
map_point, and refactor draw_cursor, draw_slot, etc. so that they all use it
(thus ending once and for all these goddamn cursor-sync bugs). ARGH!

Try to create a buffer abstraction so that things like BinaryBuffer, AESBuffer,
MboxBuffer, etc, etc don't need special open commands (e.g. you can open a
buffer, switch it into hex mode, then switch it into AES mode, and have what
you'd "want" to happen). Maybe this means BufferViews or something?  

2009/04/06:

Think about what to do with IPerl/IPython.

2009/04/04:

Rename tokens so that they follow the "c.identifier" "c.delimiter" etc.
convention. This will help nested grammars work properly, and will also allow
default coloring (with overrides) to work correctly.
(mostly done)

Once tokens are namespaced by mode, try to reduce the number of "leaf names"
(e.g. identifier, keyword, builtin, etc)

Think about replacing the 'context' module with something tied into the lexing
strategy. If not, then try to at least generalize it more.

Try to create some more toggles on the indentation package, to make it at least
a little bit configurable.

Move some "global methods" which use particular modes into those modes' files.
Also, try to combine some modes that are always intended to be used together
(for instace, python/ipython, perl/iperl, */*mini, etc)  

2009/03/27:

1. Create a Method attribute meaning should-appear-in-help-buffers. Use this to
hide actions that only make sense when the mini-buffer is open, as well as weird
actions like "text-insert-space"

2. Create a way to figure out what actions are legal in the various mini-buffer
modes (search, replace, whatever).

3. Maybe write a per-mode "how to use this mode" document that can be accessed
in a uniform way. This way, various non-discoverable features can be documented.

2009/02/15:

Remove $MODE.lib in favor of $MODE.libs[]

Also, try generalize things like documentation lookup, syntax highlighting, etc,
more than they are to reduce the size of modes (see python and perl for the most
obvious examples). Other modes will probably benefit from this.
(much of this is done)

Now that comment-region uses commentc, make it able to work with languages who
use /*...*/ type commenting, rather than just //...\n type commenting.

2009/02/05:

Create some more rules for lexing that will help things like XML be more
efficient.
(unclear if this is really possible)

2009/01/28:

Move modes into buffers and out of windows. This should reduce the memory
footprint a little bit, as well as fixing some weird bugs and making some
interfaces more consistent.

2008/09/21:

Tab completion, paren matching, and scope detection should be done by one module
(eventually, lexing should also, but for now having two isn't so bad).

Also, all modules need to parse whitespace out rather than just having the null
rule pick it up.  
(mostly done)

2008/05/23:

Buffers should run in their own threads and/or processes and communicate with
the main program through a series of locks and/or IPC calls. This will allow
two different useful features: (1) user navigation while reparsing, (2) buffers
representing pipes/sockets (e.g. shells, chat clients, tail -f, etc.)

solving (2) with asyncore or other non-blocking IO would work, but (1) almost
certainly requires seperate processes or threads.

2008/05/23:

Semantic tab-completion via iperl/ipython buffers... after syntax check, the
file will be read into an interactive buffer, which can then be hooked into in
order to support tab completion!
(mostly done!)

2008/05/11:

perl/python "open-module-by-name" command (auto-completing?).
python view help(time)-style documentation in buffer
convert console to user colorbuffer tech
step out of minibuffer support
click on completion support

2008/05/03:

use a error-buffer (pop up?) for reporting various errors.
(done)

2008/04/02:

fix read-only warnings to seem less junky (e.g. catch the buffer.ReadOnlyError
exception and write a graceful message everywhere applicable).

2008/03/18:

finish arg documentation and review method documentation

2008/03/16:

pdb/gdb/perldb buffer integration
error/stack-trace buffer

2007/10/20:

Tags for matching should be allowed to be multi-character, and should be
a list of data/type pairs (rather than several lists).

2007/08/11:

Instead of storing method state in the method objects (for mode callback stuff),
we should probably store it in the buffer.
AMENDED (2007/10/21): we should probably just store the entire mode in the
buffer, rather than storing all this junk piecemeal.

2007/07/17:

It would be nice to be able to toggle various lexing rules on/off, so that for
instance text mode could make spell checking optional, or optionally highlight
URLs/emails/etc.
AMENDED (2008/03/20): in the case of spell-checking and other non-standard
rules, we can do this with state variables in the mode. 

2007/07/15:

Vertical split would be awesome. Also, need more fine-grained controls for
even horizontally split windows.

2007/07/15:

Rename "lexing" to "parsing" since really we have moved way beyond a simple
lexing/tokenization strategy.
AMENDED (2009/04/02): since there is now a higher-level parser that can run,
this might not be as simple.