> <\body> <\description> Mechanism to recover all C++ and scheme error messages in a dedicated buffer, together with foldable backtraces. Provide correct locations for the primitive. Also provide line numbers in C++ crash reports. Provide a clean exception semantics for all routines in the basic APIs. Try hard to recover from errors and segmentation faults, except when configuring using . Test-suite of documents for different features and automated checks for certain types of correctness. Perform extensive (automated) checks for memory leaks using and implement a marking algorithm. More and more unit tests should be written under the GTest framework. <\description> Encode the system environment variables; this will globally accelerate the program. Also, intermediate data during the typesetting process might be encoded in a more binary way. Systematically use \Pconst ref\Q style parameter passing should both decrease the size of the binary and accelerate the global efficiency. Optimize performance as a function of cost of recomputation and storage requirement The typesetter should be made lazy in a more fundamental way (see ). <\description> Transform a tree into a correct tree for the current style. This routine should in particular be called before or after any conversion to an external format. documents> Downgrade documents to those of a previous version. This should be used in particular in combination with plug-ins: after communication of the version of for which the plug-in was designed, should emulate the behaviour of this, potentially older, version. <\description> Systematically use . Some changes have still to be made in the way font encodings are handled. This should make it easier to maintain fonts with characters from several physical fonts, virtual fonts, special characters, etc. Currently, the current logical font is determined from a fixed set of environment variables only. The current typesetting font should rather be a tree (instead of a string), which is evaluated (so that environment variables are replaced) and then passed to . The current font can then be a joined font and future fonts might depend on user environment variables (i.e. colored fonts, using more than one color). Implement large brackets and wide delimiters for fonts. Provide standard implementations using vector graphics, which do not depend on fonts, with many parameters for customizing width, shape, etc. interface> <\description> plug-in> Internally present as a plug-in, which could later be replaced by another implementation. content interface> A clean interface for manipulating content (a unified interface for both internal trees and the associated representation). Better documentation on how to use the extensions. Implement a proper parser and autocompletion mechanism. Add standard code browsing tools and visual aids. <\description> Replace dispatch tables by contextual overloading where possible (i.e. export). Systematic use of closures throughout the code. In particular, we should base our implementation of dialogs on closures instead of continuations. Rename > for routines from kernel/drd. Appropriate naming convention for routines which operate on markup: when to use , , , , etc., especially for tags like "" which are also used as data types. <\description> > In , the always equals 0.75em. It should be possible to modify this. For symmetry, we might also introduce a \Pbottom sep\Q. When attempting to resize a macro application to become smaller than the \P\Q, the invisible markers may have undesirable side-effects. Separate environment variables for \Ptypewriter\Q, \Psans serif\Q, \Psmall caps\Q, \Pslant\Q, etc. Find rendering font as a function of selected font and language? Should we still reorganize? It should be easy to access to the page width and height and some other parameters. Boxes should not have origins; its children should have positions instead. Example: when pressing inside a tag, we first remove the two first children of the surround tag (so that it obtains arity 1) and next remove the tag itself. The temporarily incorrect tag of arity 1 may cause to crash. Temporary fix: add extra nodes in the bridge. Better fix: implement an elementary modification , which allows to change the surround tag into another tag like tuple before performing incorrect operations. In general: the typesetter should not crash in the case of incorrect edit trees. <\description> Distinguish between paragraphs and paragraph units. Should the corresponding environment variables become macros? Also make the contents editable whenever possible. Associate baseline skip (or ascent and descent) to each individual box in concatenation. Next compute maximum over each line. Take maximum of maximum after first line and maximum before second line in order to obtain final value. Also for other parameters such as baselineskip? The scopes of several such variables is currently a bit ill-defined, especially when they are modified several times by macros. Cursor movement is extremely slow for oriental languages. Line breaking could also be further improved. <\description> Macro for continued fractions, such that right hand sides of fractions are aligned. Less vertical spacing in text style between numerator/denominator and bar. Left-numbering of equation arrays. Should be possible now using the extern primitive. Regard , , and as operator decorations, both for typesetting purposes and for the standard mathematical grammar. See . Mode for showing invisible symbols and distinguishing between other homoglyps. Also show alternatives for homoglyphs in the menu. Forall and exists as big operators. Upright and sans serif mathematical symbols. <\description> Introduce a mechanism for style options. For instance, style packages in a given directory might be executed before the actual document style and document packages. Grey menu entries for parameters which cannot be changed in the style. For instance, astyle might provide a limited number of font base sizes. > Replace primitive by a primitive inside the macro, e.g.: macro\|a\|b\|\drd-props\|\drd-prop\|a\|accessible\\|...\|body\\> and/or tag for associating drd-properties without actual assignment. Implement a variant of use-package, which does not (re)load. Or simply let use-package never reload the same package twice. Implement forms by letting field tags link to the main form tag. > Declaration of key-bindings and more complex scheme code in style packages. Declaration of style packages and macros from within a module. <\description> Should we provide icons for certain presentation tags and other environment variables, such as font type and size? The interface for editing document titles is buggy. In particular, we cannot remove authors or transform selections into titles. Also selecting part of the title information is buggy. Finally, the macros for rendering titles are overly complex. Automatically turn block content into inline content when appropriate. Maybe use shift-mouse-click for outward selection (besides pointing inside a hyperlink). <\description> User-defined macros can be turned into a compound using the backspace key, builtin macros can't. Why is that? How do I change the name of the call to a buildin macro? Can I avoid removing it and creating a new one? If the first argument of a call to a user defined macro contains a tag, I cannot turn it into a compound any more. Why that? By the way, there seems to be no way to manually create or remove tags. Edit the "init" part of a file in source code form. Make the presentation of source code more customizable by user macros. Done for syntactic highlighting, but should also be done for special rendering of certain primitives and the rendering of tags. Currently, we may stretch tags. We also need a primitive for stretching tag arguments. Tags for short commands inside the program. Display informative flags at places where tags have been stretched or a modification to the source style has been applied. <\description> A facility to convert a selection into any other format and put the result in an tag for manual editing. When pressing return, reconvert back into . Assistant for creating your own styles. Widget for editing simple macros in the preamble without entering preamble mode. and conversions> When tags for the history management get large, then the and conversions may fail. > Relaunch after change of look and feel. <\description> Implement different routines for quoting and quote/unquote using the appropriate routine. > <\description-dash> Importation of macros whose names coincide with built-in commands may lead to incorrect documents (e.g. the point macro in ). We should probably imported documents. Some commands, like , , take verbatim arguments, which should not be parsed in the generic way. The function is a temporary remedy. Use watermarks for generation with hyperlinks and tables of contents. <\description> <\itemize> <\with|par-par-sep|0fn> Explanatory messages on the status bar. Better \Pmouse button layout\Q: do as much as possible with left mouse button only and reserve right button for contextual menu. Fine-grained resizing using keyboard (also allow modification of grain?). Resizing using mouse. Automatic detection of simple types of curves when dragging in drawing mode. Automatic detection of simple ornaments (arrows, dots). Cairo plug-in for nicer looking graphics. Graphical macros and constraint-based drawings. Documentation, reference guide (markup specification) and tutorial. code> <\description> <\itemize> <\with|par-par-sep|0fn> Remove/restore one object (while preserving -order). Remove/restore a selection of objects (while preserving -order). Specify decorations for current graphical object. Undo and cancel. Possible attributes: color, line width, line style, fill color, etc. <\itemize> <\with|par-par-sep|0fn> Selecting the value of a given attribute. Retrieving the value of a given attribute. Apply attributes to one or more objects. Retrieve attributes from one (or more) objects. <\itemize> <\with|par-par-sep|0fn> Set an attribute. Retrieve an attribute. <\itemize> <\with|par-par-sep|0fn> Different types of arguments: point, length, content, etc. Adding an argument to the current object. Removing an argument from a current object. Event handlers and how to map mouse buttons to different actions. Computation of decorations. <\itemize> <\with|par-par-sep|0fn> Adding an object / region. Removing an object / region. Geometric transformations. Changing -order. Group / ungroup. Copy and paste. Computation of decorations. <\description> <\itemize> <\with|par-par-sep|0fn> Implement grammar rules with productions. Implement content output. When making semantic selections, don't select ignored markup at the border of selections (or only if explicitly selected). For instance, inside maxima sessions, the )>> output prefix is current included when selecting a complete output semantically. <\itemize> <\with|par-par-sep|0fn> Automatic correction of formulas > editing mode based on \Pslots\Q. Explicit prefix-postfix, prefix-infix and symbol-prefix operator types for operators such as , >. Better scheme for entering big operators and large delimiters as symbols and not binary/ternary constructs. Above, below, wide and wide* as operator decorations. Upgrade wide spaces (e.g. > ) as separating spaces. <\itemize> <\with|par-par-sep|0fn> Overload and > as data access operators. Symbols for and with the appropriate precedence. Notations X> and ,n>. Several precedences for separators in >. <\itemize> <\with|par-par-sep|0fn> Add facility to automatically close partial environments, e.g. with missing or missing statement after . Applications: highlighting imcomplete input, automatic indentation. <\itemize> <\with|par-par-sep|0fn> Generalize use of mathematical focus instead of usual focus. For instance, the focus bar, tooltips on math symbols, using instead of , etc. Easy way to switch between semantic and non-semantic selections. Shortcut for circulating among homoglyphs. We started to incorporate a \Puniversal spreadsheet\Q facility into . The idea is that all dependencies between the cells in the sheet are analyzed by , but all actual computations are delegated to an extern system of your choice, like one of the currently supported computer algebra systems. Also, the data of the spreadsheet will not necessarily be formatted in a rectangular table; one can also imagine dependencies between nodes of a tree, elements of a graph, or anything else. <\description> <\itemize> It would be better to use links for dependencies between cells instead of going through the entire document at each re-evaluation, as well as links to auxiliary cache for storing the last computed values. This can for instance be done by defining an environment variable with the ID of the current cell and adding a link to this ID for any or inside the cell. Implementation of the possibility to associate an alternative name to a cell. Possibility to send all inputs at once to the plug-in instead of evaluating them one by one, so as to speed up computations. How to deal with errors? <\itemize> The focus bar should be adapted. Inside a spreadsheet, the facilities for editing tables should still be available and we should be able to edit the input fields for tags (at least when the input is a string). Possibilitity to apply operations to subtable selections. For instance, when selecting part of a column and applying \Psum\Q, the sum of the column should be computed at the bottom of the selection. Similarly, applying a unary operation such as \Psin\Q might apply the operation to each cell in the selection and put the result right next to it. <\description> <\itemize> <\with|par-par-sep|0fn> Attention to implicitly changed variables, such as , , etc., which may cause the entire document to be retypeset. Attention to , , . Also put these variables in . Replace primitive by quasi-quoting mechanism. This seems to be quite necessary: consider assign\|foo\|\macro\|body\|...\\> and a document piece \\foo\ ... \/foo\> with a large body. When making changes to the body; the environment for typesetting the body also changes, because we need to store the body in the environment argument variable. For this reason, we implemented an alternative mechanism, which is enabled using . More systematic usage of symbols instead of strings. Should labels really be prefixed by ? Links and multiple views: which view should be selected when following a hyperlink. More generally: refine criteria for automatically preferring one locus over another one in presence of ambiguities. There is a problem with auxiliary data in hidden markup (eg. labels, loci, links, indexes). Analogy: hidden markup > loaded file which is not in a buffer. We might want to associate auxiliary data to tree nodes instead of files. Notice that there are different types of hidden structures: <\itemize> <\with|par-par-sep|0fn> Contents should be evaluated when hidden, but we need to keep track of auxiliary data. Example: a hidden chapter. Contents are evaluated but not typeset: auxiliary data may be kept in macro expander. Example: fold. Contents are not evaluated, not typeset and no auxiliary data are attached to the contents. Example: a comment or any piece of markup which has to be completely ignored. <\description> <\itemize> <\with|par-par-sep|0fn> Attach the action to be applied after popup input to a specific buffer. Cleaner implementation of read-only parts in documents. Cleaner implementation of size computation of widget. Also: notebooks and folding constructs, which may require to update the size later on. Cleaner implementation of widget fields (i.e. the way we associate data to names). Don't require the specification of a body for hidden input fields. Argument history and browsing suggestions using keyboard. Destroy call backs associated to a widget when the corresponding window is closed using another method than . Idea: potentially associate a dismiss routine to each buffer. <\description> <\itemize> <\with|par-par-sep|0fn> List actions to be undertaken. <\itemize> <\with|par-par-sep|0fn> CVS mirror at Savannah and automatic update scheme. Also search for other mirror sites (increases availability and visibility on the web). \; <\description> <\itemize> <\with|par-par-sep|0fn> Different purposes of . Writing a simple text. Style-sheets and writing a simple macro. Running a computer algebra system. Inserting an action tag which launches an . <\itemize> <\with|par-par-sep|0fn> Why are structured documents useful? How to enter structure into , redundancy of the interface. Understanding the visual indications, cursor movement. Editing the structure (removing structure, improper nesting, variants, numbering). Exploiting structure: spell checking, searching. Reminders about correct typography. <\itemize> <\with|par-par-sep|0fn> Entering math mode, equations, equation arrays. Simple mathematical formulas, recall cursor movement. Mathematical symbols, variants. Semantics of multiplication, function application and other implicit semantics. Simple matrices and other tabular environments. <\itemize> <\with|par-par-sep|0fn> Rendering of source code, what is source code? A simple macro. A simple style package. Customization of some existing macros. >