* bugs

- There is a pretty strange bug in kig when you use the accel keys.
   Open Kig, type p to start constructing a point.  Click somewhere to
   construct one.  Now click p again, and press escape to cancel the
   construction.  It will not work, and you will have to construct as
   many points as times you pressed escape ( or perhaps the times you
   pressed esc square or sth like that ).  Anyway, this is due to how
   Kig works with some strange Qt event loop stuff to make its modes
   work, along with a strange way in kaccel of working.  I have a
   patch against kdecore/kaccel.cpp that should fix it, but the real
   fix is to get rid of the entire event loop stuff and think of a
   better way to manage all this. pino: seems pressing the stop button
   n times, where n are the times you pressed escape, cancel all the
   constructions, so the problem is the behaviour of escape.

- The polar coordinate system blocks Kig when zooming. Select the
  polar coordinate system, use the Select shown area tool ( or your
  favorite zooming tool ) and select a specific part of the document.
  Smaller parts of the document cause bigger problems. pino: this is
  due to the polar grid: try to make zoom if there is no grid.

* more or less urgently necessary

- document mathematical i18n strings, so that the translators have a
   clue about how to translate them !

* not too hard:

- add other command line options, like:<br />
  -e, --export-to FORMAT file.kig => Kig will export file.kig ( or any
  other supported format ) into file.ext ( even more than one file ).
  The output format depends on the FORMAT string. domi: this is more
  difficult, because the export plugins require extra parameters.
  E.g. the ImageExporter needs an image size etc.

- make stuff from RMB menu's accessible from other places as well.

- write *-filter-status.txt's for the kseg and cabri filters.

- Two new transformations: projection on a line, orthogonally and
  according to a given direction.  As a mathematician, I'm supposed to
  have a grudge against these, as they don't fit the definition for
  affine transformations ( the matrix has to be regular ) ;), but I
  suppose high-school students may find them useful.  However,they
  would give rather useless results for e.g. lines ( all curves are
  almost always projected on a line, segment or ray that you wouldn't
  see because it's equal to the line we project upon ).  It would be
  useful for points though.

- When selecting an argument of a certain type, maybe we should check
   whether the required arguments are really there, before telling the
   user to select them.  Then we could give an error telling the user
   to first construct the other objects.  An exception should be made
   for points of course.

- Add the possibility to attach text label also to angles.

- add the possibility to transform more than one object at one time,
  using the popup menu. For example, I select two circles, I choose
  Transform->Translate form the RMB menu and then Kig should ask me for
  a vector to use to translate all the selected objects.

- Add the possibility to select, via new dialog, one or more types of
  object.

- add "Tools": easy tools designed for geometry, like Angle converter and
  so on...

- add a magnifying glass to magnify "on-the-fly" a part of the document.

- Python scripting: export cubics for real, improve existing API.

- add support for work with other measure units (cm, inches, etc...)
  than just pixels...

- add the possibility to modify a type in the "manage types" dialog.
  (pino: partially done)

- add an option to the objects popup to start a script object with the
  selected object as arguments...

- implement cut, copy and paste for objects...

- extend ObjectFactory::sensiblePointCalcer to also construct
   intersection points of stuff... (pino: done for lines)

- add the possibiity to construct the tangent to a cubic.

* harder:

- use the KTextEditor interface ( with highlisght style, tools and more )
  for the script code editor.

- make DoubleImp a "visible" object with uses like Dr. Geo numeric
  values.

- Provide some nice stuff for differential geometry: velocity vector
   of a curve, curvature vector, osculating parabole, osculating
   circle, evolute.  Most of this is not too difficult to implement, but
   very cool :)

- when moving an object that wants to move its parents, try to check if
   it is itself not an indirect child of one of the parents it is
   trying to move, and forbid the move in that case, as it will lead
   to chaotic behaviour.  I am not sure if this is really well
   possible, but I have to look at it.

- allow editing of python scripts

- add intersection types: arc-arc; arc-conic; arc-cubic; conic-cubic;
  cubic-cubic; locus-other object.

- allow for using kformula w/o OOFormula w/o MathML formulas in the
  document.

- rework the ObjectConstructor and GUIAction stuff into something more
   general, and more clean.  See the comment for
   ObjectConstructor::constructMode().

- make the dialogs not pop up over the main window..

- make the scripting system work more like the macro system. Make it
  a way to define new object types that can be reused more than once,
  instead of making it just a way to add *one* object..

- support for more scripting languages than just python..

- fillable polygons/shapes..

- filters: more input filters, improve Cabri filter and Dr. Geo filter
  ( see filters/drgeo-filter-status.txt ), add the possibility to ignore
  errors on loading

* hard :

- save a "session", i.e.: record how a document is moved, and save it to
  e.g. a flash file or something like that.

- figure out a way to allow the user to enable and disable certain
  features.  E.g. I have been asked to allow the user to limit himself
  to compass-ruler constructions..

- "export to *": add stuff like java applets, SVG documents, latex, etc...

- add support for saving/opening native compressed files like
  'myfile.kig.gz' or 'myfile.kig.bz2'.

- koffice support ?

- add another viewmode ( which would be completely orthogonal to the
  KigMode concept ), where you can more clearly see the dependencies
  in a figure.  Something with colours, numberings, and/or a tree-like
  text representation of the dependencies..

- defined integrals, as a particular case of filled shapes...

* future ?
- there should be a way to link a figure to a (html?) file containing
   exercises.  Teachers would be able to create exercises for Kig.
   I'm thinking of doing this with HTML (& KHTML) + scripting ( but
   this is _distant_ future.. )
