todo

jsXe 是java简单的XML编辑器。 它使用的Swing工具

TODO:

* General

    & Slowly document methods with javadoc.

    & Slowly prefix instance variables with m_ as a naming convention.

    & DOMSerializer should support the following parameters:
        well-formed
        - Is this necessary? The DOM representation can't really be
          non-well-formed can it? It provides error checking for invalid
          characters and such.
        xml-declaration
        check-character-normalization
        entities
        normalize-characters
            This maybe needs to be done after I better understand and have
            built methods for interacting with the DTD.
        ignore-unknown-character-denormalizations

    & Serialized XML should be 100% well-formed and parsable.
    
* Version 0.2 beta
    
    * Add the ability for XMLDocuments to have a structure for non-wellformed
      documents. Should I bother? Maybe not since some views will require
      documents to be well formed.
    
    * Create new packages for the XMLDocument and DocumentViews. Provide
      javadoc on the jsXe website. Rename AdapterNodes to something more
      meaningful and update it's API. Maybe make XMLDocument an interface
      so that XMLDocument classes can be created that use something other
      than Xerces.
    
    * Update javadoc for the DocumentViews and XMLDocument classes to be
      more descriptive and less specific to jsXe.
    
    * Change ant build file to build the DocumentViews and XMLDocuments into
      a different jar file. Also change the jsXe.bat and jsXe.sh to use the new
      jar file.
    
    * Make a test program that uses DocumentViews to prove that they don't
      need jsXe.
    
    * Change the way the TabbedView keeps track of the DocumentViews and
      DocumentBuffers so that it's easier to get the DocumentBuffer for a
      particular XMLDocument
    
    * Add a ghosted image of the node to drag and drop cursor. Hopefully the
      whole cursor can be replaced with the image since the default drag
      cursor is dumb in linux.
    
    * Create a way to show a no-drop cursor when the drop is rejected.
    
    * Create a dialog that displays all dirty DocumentBuffers and allows you to
      save the selected ones, like jEdit.
    
    * Add support for creating and editing Processing instructions. New
      tree cell renderer/editor for the different parts of the processing
      instruction?
    
    * Create some sort of interface to deal with editing of entity reference
      nodes. Can this be done before adding more support for DTDs?
    
    * Make the XML document declaration header non-editable in source-view
      mode. (how?) Update it when the user changes options in the options panel.
      Maybe make a non-editable text-panel or label above the source area and
      only show the part after the header?
    
    * Add option to use soft tabs in the source view. Override processKeyEvent
      in JEditorPane to accomplish this.
    
    * Add a feature that allows the cursor to be set to the location of a
      parse error in the source view.
    
    * Implement a find dialog (for the source view at least).
    
    * Fix the options dialog and make it look better. Maybe split into two
      dialogs, global options and view/document specific? Maybe even three
      dialogs, one for global options, one for view options, one for document
      options. Maybe make it like jEdit with a tree thing that displays
      option categories. So that way jsXe can have separate options for
      serialization and visualization and ...
    
    * Implement storing actions in an ActionSet or something so that actions
      can be retrieved easily.
    
    * Need some way of editing DOCTYPE nodes. DOM level 2 seems to not have
      support for this. jsXe needs to recognize when a document has a DTD and
      deal with serializing to it if necessary. Investigate XNI or whatever
      that is part of the xerces distribution as a way to do this.
    
    * Build an adapter for DocumentBuilder so that it implements the DOM3
      standard DOMBuilder interface? Maybe use it with DOMSerializer to created
      filtered documents? Or use a TreeWalker to serialize (how)?
    
    * Use the Nodefilter interface with the DefaultView to determine which types
      of nodes to show.
    
    * Add full support for namespaces. (adding, editing, serialization, etc.)
      New Cell Renderer for nodes that edits namespaces separately?
    
    * Redo the interface for XMLDocuments and AdapterNodes so that DOM
      implementation used in a more limited way? Implement Document editing
      methods? Can I eventually make my own DOM implementation? Look at
      extending the Xerces implementations of these interfaces. Maybe doing that
      is more feasable. However, that approach would make the application
      highly dependent on Xerces.
    
    * Implement undo for the DefaultView and SourceView.
    
* Version 0.3 beta
    
    * Implement cut, copy, paste in the DefaultView
    
    * Allow Views to be split so that one DocumentView can be displayed left/top
      and one on the right/bottom. Views should be able to update automatically
      using some sort of listener interface.
    
    * Implement BeanShell support. This is required for dynamic actions like
      those in jEdit. Create a way for actions to be created dynamically and
      then registered with jsXe. Much the same way that jEdit does.Is this
      really necessary? Can I achieve the same effect with actions that are not
      BeanShell actions?
    
    * Fully implement gui actions to include key mnemonics etc. so the actions
      act like you would expect. Allow users to define keys shortcuts to
      actions.
    
    * Create a toolbar that is customizable much the same way jEdit's is.
	    
	* Make a splash screen that displays on startup.

    * By this time, make sure all classes are documented with javadoc.
    
    * Make sure all instance variables are prefixed with m_ and are named in a
      consistent manner.
    
* Version 0.4 beta
    
    * Add threading support and allow multiple windows/Views to be open for one
      document at once. This can let you edit a document using one view and
      view it using another. Views should be able to update automatically using
      some sort of listener interface.  This will be another option to allow users
      to see more than one view of the document at the same time. How would you
      handle editing using a view that uses source and one that uses the tree
      structure at the same time?
    
    * Create a feature to edit source for 1 node only? (Not sure how to do this
      given current design. How would I allow the source view to do that?)
      Should I bother?
    
    * Create an interface for the main view in jsXe where the TabbedView
      implements it. Other views can then be created to allow a more
      customizable look.
    
    * Implement syntax highlighting for the SourceView.
    
    * Enhance the source view with element completion and other cool stuff. See
      the XML plugin for jEdit for ideas. How would I display well-formedness
      errors.
    
    * Add support for DTDs and Schema and add feedback about whether the
      current document can be validated by the DTD and what needs to be done to
      the document before it will comply with the DTD. Create interfaces to
      coincide with the XMLDocument interfaces that handles various Schema.
    
* Version 0.5 beta
    
    * Implement some version of the DOM Document interfaces and add features
      such as the registering of listeners that can tell when the structure
      has changed and a builder that can give the location of a parser error
      etc. Is this reasonable/possible?
    
    * Create an install program for jsXe.
    
    * Create a help system for jsXe.
    
* Version 0.6 beta
    
    * Finalize the class structure and public plugin interface as it will be
      harder to remove/deprecate methods after the introduction of plugins.
      Build into the interfaces support for printing.
    
    * Implement plugin support with BeanShell. Make DocumentViews into plugins
      that are loaded at runtime. DefaultView and SourceView will be distributed
      with jsXe as the default views.
    
    * Add a way for jsXe to try to open a document in any of the installed views
      before it shows errors saying it cannot open the document given that views
      are now plugins.
    
* Version 0.7 beta
    
    * Implement some form of internationalization support.
    
    * Implement printing support in the Default View and SourceView
    
    * Add a command line option so that a user can specify the view to open
      the document with. This will allow you to open large document in the
      source view without parsing it into the tree view using DOM.
    
    * Add an option when opening documents that lets users specify which
      installed view to open the document with.
    
    * Look for ways to improve efficiency with large XML documents
    
* Version 0.8 beta

    * Bug fixes?

* Version 0.9 beta

    * Bug fixes?

* Version 1.0

    * Bug fixes?

* Plugins
    
    * Implement the xsl transformation feature as a plugin.
    
    * Implement a plugin to view xsl:fo documents. Look at XSmiles for this.
      See www.x-smiles.org
    
    * Create a view that uses the view from pollo and implements the
      DocumentView interface. See pollo.sourceforge.net
    
    * Create a view that uses the view from Jaxe and implements the
      DocumentView interface. See jaxe.sourceforge.net
    
    * Create a view that is similar to the xeditor view if it's ok (it kind of
      has to be since jie bao used my GPL code his has to be open source too.)
    
    * Create a view for XHTML documents. This could probobly be an extension
      of the JEditorPane class that uses an adapter to attempt to transform
      XHTML into HTML 3.2 so that the canned JEditorPane can render it properly.
      Maybe XSmiles can do this too. See www.x-smiles.org
    
    * Implement a JasperReports plugin that helps users view report definitions
      for jasper reports. Eventually add support to edit visually like the
      JasperAssistant. See jasperreports.sourceforge.net
    
    * Implement a Schema Diagram plugin that can show Shema as a flow like
      diagram. Look at the JGraph components for this. www.jgraph.com.
      Eventually add support to allow editing of schemas