JDOM2

• java - Default XML namespace, JDOM, and XPath - Stack Overflow
• java - JDOM 2 and xpath - Stack Overflow
• Parsing an XML Document with XPath - O'Reilly Media
• XPathBuilder (JDOM v2.0.5)
• XPathFactory (JDOM v2.0.5)
• XPathExpression (JDOM v2.0.5)

What is DOM, DOM2, DOM3

• DOM
  • Document Object Model
• DOM 1
  • Document Object Model (DOM) Level1
  • http://www.w3.org/TR/REC-DOM-Level-1/
• DOM 2
  • Document Object Model (DOM) Level 2
  • http://www.w3.org/TR/DOM-Level-2-HTML/
• DOM 3
  • Document Object Model (DOM) Level 3
  • http://www.w3.org/TR/DOM-Level-3-Core/
• The Evolution of DOM
  • http://www.cafeconleche.org/books/xmljava/chapters/ch09.html#d0e13336

  • The first version of DOM wasn’t an official specification, just the object model that Netscape Navigator 3 and Internet Explorer 3 implemented in their browsers. (Really, these were two different object models since they were only marginally compatible with each other.) This is sometimes called DOM Level 0.

    DOM Level 0 only applied to HTML documents and only in the context of JavaScript. Nonetheless, both the usefulness of JavaScript and the growing incompatibility between the two browser object models made it obvious that something more standard was needed. Hence, the W3C launched the W3C DOM Activity and began working on DOM Level 1. DOM1 was an attempt to come out with a specification as quickly as possible that would codify existing practice while achieving some level of compatibility across browsers. Given the constraints the working group was laboring under, DOM1 is a surprisingly good spec. The naming conventions feel a little wrong to a Java programmer, but DOM1 does provides a solid core of functionality that covers maybe 75% of what programmers want to do when processing XML.

    DOM Level 2 cleaned up the DOM Level 1 interfaces. The big change was namespace support in the Element and Attr interfaces. In addition, DOM2 added a number of supplementary interfaces for events, traversal, ranges, views, and style sheets. I’ll address these in upcoming chapters. In 2002, all significant XML parsers that support DOM, support DOM Level 2. There’s not a lot of reason to worry about the difference between DOM1 and DOM2. From this point forward, I’m just going to teach DOM2. DOM Level 3 is visible not far up the road. Parts of it are just beginning to be supported by bleeding edge parsers, most especially Xerces 2. In the core, DOM3 just adds a few missing pieces needed to allow DOM to fully support all Infoset properties. This includes the original encoding and base URI of the document. However, DOM3 will also add some crucial functionality missing from DOM2. In particular, DOM2 doesn’t provide a parser-independent means to create a new Document object, either by parsing a file or by building one from scratch in memory. DOM3 will provide standard ways of doing both. DOM3 is also going to add a lot more support for DTDs and schemas. But despite all its new features and functionality, DOM3 will not replace DOM2. Everything that works today in DOM2 will continue to work the same way in DOM3. DOM3 extends the DOM into new territory, but it doesn’t change what has gone before.

NetBeans XML Editor Extension Module Tutorial

This tutorial demonstrates how to create a module that extends the functionality offered by one of the IDE's editors. The IDE has several editors—for example, the XML editor, the Java editor, the JSP editor, and the SQL editor. Normally all the IDE's editors are referred to collectively as the Source Editor. However, each of the editors is distinct—its functionality is targeted at the file type for which it exists. In this tutorial, you add an action to the XML editor. After you create and install the module, and you open an XML file, the editor's contextual menu will include a menu item that displays the XML file's tags in the Output Window.

Note: This is not the latest version of this document. It applies to NetBeans IDE 6.0/6.1 only. Click here to see the most up to date version.

Contents

Contents

• Setting Up the Module Project
  • Creating the Module Project the Sample
  • Specifying the Module's Dependencies
• Coding the Module
  • Creating the Action
  • Creating the Tag Handler
• Building and Installing the Module
  • Installing the Module
  • Using the Module
  • Creating a Shareable Module Binary

To follow this tutorial, you need the software and resources listed in the following table.

Software or Resource	Version Required
NetBeans IDE	version version 6.1 or version 6.0
Java Developer Kit (JDK)	version 6 or version 5

Optionally, for troubleshooting purposes, you can download the completed sample.

Setting up the Module Project

Before you start writing the module, you have to make sure you that your project is set up correctly. The IDE provides a wizard that sets up all the basic files needed for a module.

Creating the Module Project

1. Choose File > New Project (Ctrl-Shift-N). Under Categories, select NetBeans Modules. Under projects, select Module Project and click Next.
2. In the Name and Location panel, type ShowXMLStructure in Project Name. Change the Project Location to any directory on your computer, such as c:\mymodules. Leave the Standalone Module radiobutton selected. Select the Set as Main Project checkbox. Click Next.
3. In the Basic Module Configuration panel, replace yourorghere in Code Name Base with myorg and changeShowXMLStructure to xmltree, so that the whole code name base is org.netbeans.modules.showxmlstructure. Add spaces the the default Module Display Name to change it to Show XML Structure. Leave the location of the localizing bundle and XML layer, so that they will be stored in a package with the nameorg/netbeans/modules/showxmlstructure. Click Finish.

The IDE creates the Show XML Structure project. The project contains all of your sources and project metadata, such as the project's Ant build script. The project opens in the IDE. You can view its logical structure in the Projects window (Ctrl-1) and its file structure in the Files window (Ctrl-2). For example, the Projects window should now look as follows:

Specifying the Module's Dependencies

You will need to subclass several classes that belong to NetBeans APIs. Each has to be declared as a module dependency. Use the Project Properties dialog box for this purpose.

1. In the Projects window, right-click the Show XML Structure project and choose Properties.
2. For each of the following APIs, click "Add..." in the Libraries panel, select the name from the Module list, and then click OK to confirm it:
   • I/O APIs
   • Nodes API
   • Text API
   • Utilities API
   • Window System API

   Click OK to exit the Project Properties dialog box.

3. In the Projects window, double-click Project Metadata and note that the APIs you selected have been declared as module dependencies.

Coding the Module

Creating the Action

1. Right-click the project node and choose New > Other. Under Categories, select NetBeans Module Development. Under Projects, select Action. Click Next.
2. In the Action Type panel and click Conditionally Enabled. Select EditorCookie, which is the name of the class that lets the Source Editor access the action, as shown below:

   

   Click Next.

3. In the GUI Registration panel, select the 'Edit' category in the Category drop-down list. The Category drop-down list controls where an action is shown in the Keyboard Shortcuts editor in the IDE. Next, select Editor Contect Menu Item and then select the text/xml MIME type, as shown below:

   

   Notice that you can set the position of the menu item and that you can separate the menu item from the item before it and after it. Click Next.

4. In the Name and Location panel, type ShowXMLStructureAction as the Class Name and type Show XML Structureas the Display Name. Menu items provided by contextual menus do not display icons. Therefore, click Finish andShowXMLStructureAction.java is added to the package.
5. In the Source Editor, add the following code to the performAction method:

       public void performAction(Node[] activatedNodes) {
           EditorCookie editorCookie = activatedNodes[0].getCookie(EditorCookie.class); 
           String tabName = NbBundle.getMessage(ShowXMLStructureAction.class,"LBL_tabName");
           
           // "XML Tree" tab is created in output window for writing the list of tags
           InputOutput io = IOProvider.getDefault().getIO(tabName,false);
           io.select(); //XML Tree tab is selected
           OutputWriter writer = io.getOut();
           
           try {
               writer.reset(); //clean the output window
               java.io.InputStream is =  ((org.openide.text.CloneableEditorSupport)editorCookie).getInputStream();
               parse(new InputSource(is));
               is.close();
               for (int i=0;i<tags.length;i++) {
                   writer.println(tags[i]); //write tag to output window
               }
           } catch (IOException ex) {
           } catch (SAXException ex){
               writer.println("Parse Error: "+ex.getMessage());
           }
           writer.flush();
           writer.close();
       }

   
   
6. Add a new method:

       /** Parses XML document and creates the list of tags
       */
       private void parse(InputSource is) throws IOException, SAXException {
           XMLReader xmlReader = XMLUtil.createXMLReader();
           TagHandler handler = new TagHandler();
           xmlReader.setContentHandler(handler);
           xmlReader.parse(is);
           tags = handler.getTags(); 
       }

   
   
7. Declare the tags variable at the top of the source file:

       private String[] tags;

   
   
8. Add the display names to the Bundle.properties file:

   ACT_name=Show XML Structure
   LBL_tabName=XML Structure

Creating the Tag Handler

1. In the Projects window, expand the project node, expand the Source Packages node, and then right-click theorg.netbeans.modules.showxmlstructure node. Choose New > Other. Under Categories, choose Java Classes. Under File Types, choose Java Class. Click Next and type TagHandler in Class Name. Click Finish. The new Java class opens in the Source Editor.
   
2. Replace the default code with the code below:

   package org.netbeans.modules.showxmlstructure;
   
   import org.xml.sax.Attributes;
   import org.xml.sax.SAXException;
   
        /** Specific XML handler used for creating list of starting and ending tags, e.g. :
        * <AAA>
        *   <BBB>
        *     <CCC/>
        *   </BBB>
        * </AAA>
        */
   
       public class TagHandler extends org.xml.sax.helpers.DefaultHandler {
          
   	private final int indentLength=2;        
           private java.util.List tagList;
           private String indent;
           private String space;
           private String lastElement;
           
           TagHandler() {
               tagList = new java.util.ArrayList();
               StringBuffer indentBuf = new StringBuffer();
               for (int i=0;i<indentLength;i++) indentBuf.append(' ');
               space=indentBuf.toString();
               indent="";
           }
   
           public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
               tagList.add(indent+"<"+qName+">");
               indent+=space;
               lastElement=qName;
               
           }
   
           public void endElement(String uri, String localName, String qName) throws SAXException {
               indent=indent.substring(indentLength);
               if (qName.equals(lastElement)) {
                   int lastIndex = tagList.size()-1;
                   String lastInList = (String)tagList.get(lastIndex);
                   String replacedString = lastInList.replace(">","/>");
                   tagList.set(lastIndex,replacedString);
               } else {     
                   tagList.add(indent+"</"+qName+">");
               }
               lastElement=null;
           }
           
           String[] getTags() {
               String[] tags = new String[tagList.size()];
               tagList.toArray(tags);
               return tags;
           }
       }

Building and Installing the Module

The IDE uses an Ant build script to build and install your module. The build script is created for you when you create the module project.

Installing the Module

In the Projects window, right-click the Show XML Structure project and choose Install/Reload in Target Platform.

The module is built and installed in the target IDE or Platform. The target IDE or Platform opens so that you can try out your new module. The default target IDE or Platform is the installation used by the current instance of the development IDE. Note that when you run your module, you will be using a temporary test user directory, not the development IDE's user directory.

Using the Module

1. Choose File > New Project (Ctrl-Shift-N) and create a new project.
   
2. In the Files window (Ctrl-2), expand the project node and then expand the nbproject node. Double-click build-impl.xml so that it opens in the Source Editor.
   
3. Right-click anywhere in the Source Editor and notice the new popup menu item called "Show XML Structure": Choose the menu item and notice that the tag handler prints all the tags to the Output window, which is at at the bottom of the IDE, as shown below:
   

   

   
   
4. Open a different file type in the Source Editor. For example, open a Java class. Right-click anywhere in the Source Editor and notice that the new popup menu item is not included in the contextual menu.

Creating a Shareable Module Binary

1. In the Projects window, right-click the Show XML Structure project and choose Create NBM.
   

   The NBM file is created and you can view it in the Files window (Ctrl-2):
   

   

   
   
2. Make it available to others via, for example, e-mail.

Send Us Your Feedback

Next Steps

For more information about creating and developing NetBeans modules, see the following resources:

• Other Related Tutorials
  
• NetBeans API Javadoc

---

Versioning

Version

Date

Changes

1
11 July 2005
Initial version

2
27 September 2005

• Added Action wizard
  
• Renamed from "NetBeans Tag Handler Plug-in Tutorial" to "NetBeans Source Editor Extension Module Tutorial".
  
• Added issue 7 below.

3
28 September 2005

• Renamed the tutorial, because 'Source Editor' doesn't cover the SQL editor, which could also be extended using the steps in this tutorial.
  
• Rewrote the introductory paragraph.

4
11 June 2007
Worked through whole tutorial, and cleaned up, for 6.0, also changed screenshots.

5
17 November 2007
Fixed spacing between steps. Tried out the attached sample, and it works as described.

Issue Number
Description
Status

1
Code and tutorial itself need to be reviewed.
To be fixed.

2
Tutorial needs to be updated once Phase III and IV are complete.
Done.

3
Some APIs used in this tutorial have deprecated methods. This will produce errors in the Output window, but should not impact functioning of module.
To be fixed.

4
Clear explanations -- and links to Javadoc -- to be added for all APIs, classes, and methods. Also Javadoc links for each of the dependencies and why they are needed in this tutorial.
To be fixed.

5
Maybe other identifiers for JSP editor, HTML editor, etc. should be mentioned. For example, instead of "xml" (in layer.xml), use "html", "x-properties", "base" etc.
To be fixed.

6
Explain what a cookie is. Explain what a cookie action is.
To be fixed.

7
Need to change downloadable, because currently the tag handler and the show XML action are separate files while in the downloadable code, they're in the same file. For the same reason, must change screenshots where one file instead of two are shown.
To be fixed.

http://platform.netbeans.org/tutorials/60/nbm-xmleditor.html