kate / part / TODO

Full commit

**** Bugs ****
* access of deleted cursors by the dynamic hl stuff
* cursor position after undo

**** Refactoring/Cleanups ****
* code cleanups wherever needed ;)

* KateViewInternal to be completely hidden from view for almost everything but
  the view itself.

  -> in progress, almost done for most parts, viewinternal only visible to friends of KateView

* Separate more functionality from KateDocument (selections moving to KateView,
  a plugin manager class, a config class, etc)

  -> in progress:
      * config classes already in place
      * selection moved to KateView

* Memory usage and leak auditing
  * KateHlContext::items needs to be implicitly shared + autodelete

**** new features ****

* Fix EOL whitespace cleaning finally by removing whitespace at load-time and
  keeping the document consistent all the time

  -> DONE ;) whitespaces are no cleaned at load time, the magic clean on save stuff is gone
  Ah, but there are bugs:
  * indenting a block of text will create whitespace on lines that were empty to start with
    -> could be fixed by adapting KateNormalIndent::indent()

* BiDi finally, using Scribe
  * just needs porting of deprecated calls, and testing
  * fix remaining redraw bugs while scrolling (grey, black areas)
    * haven't seen for a while, fixed?

* Finally implement arbitrary highlighting and arbitrary input filtering
  * Smart Cursors and Ranges todo list:
    * change edit notification to come as KTextEditor::EditInfo or similar
      * types: Insert, Remove, Change, Batch -> more EditInfos
      * Implement batching
        * multiple edits for one logical edit
        * multiple logical edits for one undo step
    * fix passive changes to cursors/ranges
      * extra regression testing needed to check that notifications work across SmartGroup boundaries
      * implement feedback requirement tree
    * consider a custom pointer type for Smart* objects
      * consider removing it now that the multiple watchers plan is probably better
    * dynamic highlighting
      * catch highlighting being created where the mouse or caret already occupies
        * probably already implemented, guess it just needs testing
    * add a QVariant as data store for 3rd party apps ?
    * D-pointer consideration
      * shouldn't get dptr imho
    * move back any excessively exposed parts of the smart ranges and cursors
    * testcases
    * performances testing suite
      * need to implement edit merging to reduce changes to cursors with large single edits
    * cachegrinding
    * make a translation snapshot feature where you can translate any cursor from a certain point in time - would be very cool :)
    * code cleanup
      * add advance{Pos|Line|Column} functions and replace the set*(*+x) calls

* Switch internal highlighting to use arbitrary highlighting api and thus be
  exposed (read-only)
  * only if the above cursors and ranges can be made to perform well enough

* Buffer reentrancy for multithreaded access
  * needed for potential:
    * separate threads for processing of bracket marks,
    * third party processing

* More robust history including cursor position history

* More featureful code completion including syntax highlighted entries
  * done:
    * model based completion
    * non-focused completion box (view passes on any interactions required)
    * native highlighting of completion entries
    * column resizing on scroll
    * highlighting
    * add a column to CodeCompletionModel to enable displaying an icon just before a completion's name
  * in progress:
    * implement sorting of items based on metadata, and sorted group headers
      * needs to react to model changes
  * todo
    * api improvement: generic way to detect when a completion could be offered, and possibly replaceable with a plugin, so that multiple model completion can be offered
      * multiple model merging
    * extend metadata to include inheritance depth of an item
    * implement column merging
    * implement click-execution of completion entries based on KDE click policy
    * implement filtering of items based on metadata
    * implement configurability
      * show/hide/reorder/merge columns
      * positioning retaining horizontal sync with text when it would mean the completion box going outside the screen or not (alternative: reorganise columns, hide column(s))
      * sorting list
      * filtering list
      * highlighting mode (native / custom / user / combination)
      * consider embedding 3rd party cc config with the above
    * make sure enough info is exported that the current completion's documentation can be retreived in a documentation browser;
      * place basic documentation in an extended popup... positioning / design still to be worked out
    * connect signals from source model to katecompletionmodel and vice-versa
    * configurability of keyboard commands for cc
    * refine keyboard control
  * performance testing and optimisation
    * test user-defined highlighting
    * test for thread safety
  * critical issues
    * crash from visual index == -1 (? still present)

* Custom widgets in between lines interface (eg. so kcachegrind could use
  katepart to display its cpu usage information etc)
  * Add an extraHeight() field to KateLineLayout
  * Change linesDisplayed() over to use these extra heights
  * Remove assumptions about the fixed height of lines (the difficult part? maybe not so hard seeing it supports dynamic wrapping)
  * Expose via an interface

* KateFoldingTree* to use smart*

* Splitting a view over multiple columns

* Modular input subsystem, to support emulation of other editors in a clean way
  -> see also scripting and idea with extending the command line

* Improved input modes especially in block selection

* Multiple selection support

* Better support for information overlay (eg. documentation of a function -
  switch between short / detailed descriptions)

* Whatever else is needed for multiuser editing (and perhaps put most of it
  inside the part, so eg. kate, kdevelop, quanta etc. could all use it)

* Scripting using kjs (in progress)

  * finish API
    * KateJSDocument: search, searchBackward, etc
    * add API so that scripts can save&load data (remember: we don't have persistent loaded scripts right now)
    * add mode to command line, where every keystroke executes a script (vim like command mode)
      * idea: F7 -> command mode, if you hit ':' you can use the cmd line just like now and type eg. set-highlight c++;

* Good interface for JavaScript indentation scripts
  It is a good idea to look how other editors deal with indentation, I think vim & emacs are good
  Here a list or URL's which describe how these editors handle indentation:
    * (bit about emacs stuff)
    * (bit about vim stuff)
    * (how to write a simple vim indenter)
  I think the vim way is a good idea to take, register keys which trigger the indent actions and such,
  look at the third link to have a reference.

* Cursor position restriction extension
  * export enough api to allow 3rd party apps to provide a cursor that
    * handles advancing/retreating
    * allows to query if a position is a valid cursor position, and to find the closest valid position
  * create a test version which does some basic restriction

* Input restriction extension
  * needed? probably not