Java Swing Graphical User Interface For XML Computer Science Essay

Published: Last Edited:

This essay has been submitted by a student. This is not an example of the work written by our professional essay writers.

The module handbook available for the students and faculty at the Middlesex University, London, comprising of details like the course syllabus, assessment information, references and general information is obtained by typing a word document and printing it. There was a need of developing software that enables the user to input the data through the Graphical User Interface (GUI) and generate a handbook in different formats like web based, Portable Document Format (PDF), or on any mobile device as it was very tedious job to type all the data in simple word document to get the handbook printout. Also if any information was to be added or changed, changes were done in the document. And in today's world of modern technology where laptops and mobile devices are commonly used it becomes easier to view the handbook content on such devices than carrying the hardcopy. Graphical User Interface is a type of user interface that allows the user to interact with the programs easily. GUI makes an application more user-friendly and easy to use. Computerizing the handbook printing system made easier for the users to have access and make changes/modifications to the handbook from any place, generate the output in different formats, and can also view it on a computer or mobile device or simply get a hardcopy printed.

Study Background/Problem:

The main aim of the proposed system is to design and develop a software tool that accepts data from the user through a GUI to convert all the information contained within a standard module handbook into three different formats viz. web based format i.e. Extensible Hyper Text Markup Language (XHTML), Portable Document Format (PDF) document or Wireless Markup Language (WML), unlike the existing system where the user needs to enter the data in word format to get a hardcopy of the handbook.

Aims and Objectives:

Goals to be accomplished by me to develop a module of the above mentioned project are as follows:

Define the Extensible Markup Language (XML) grammar using correct XML

validation schema so the XML document can be validated against this grammar.

Design and develop the Graphic User Interface to enable the user to enter the data of the module handbook. Development goal is achieved using Java Swing for the GUI display and java collections to store the data fed by the user. And the designing goal is attained using the Unified Modelling Language (UML).

Using the Java API for XML Processing (JAXP) APIs, create the Document

Object Model (DOM) based XML document tree and thus generate a XML document which are validated against the defined XML grammar, open an existing XML document, make changes to the opened XML document, save the changes.

1.3 Significance:

The significance of the proposed system is to enable the user to update the module information in one place and automate the generation of the module resource information for the three respective portals, hence not restricted only to a hard copy. It also enables the module leader to enter module information updates via an easy to use GUI instead of editing raw XML.

1.4 Dissertation Structure Overview:

The thesis contains various chapters portraying the research, findings, selection making, requirement specification, and evaluation, implementation, designing and testing for the developing of the proposed system.

Chapter 2 contains the description of various tools and technologies used, reviews the methods, approach, tools, programming language, schemas, etc. used to develop the software.

Chapter 3 discusses the user requirement specification of the proposed system.

Chapter 4 covers the analysis and the design techniques adopted to achieve the user requirements.

Chapter 5 shows the detail implementation of the design methods followed and testing of the software.

Chapter 6 contains the evaluation and demonstration of the functionality of the

application developed.

Chapter 7 gives an overview of the ethical issues taken into consideration.

Chapter 8 discusses the critical evaluation done during the software development process.

Chapter 9 gives a summary of the thesis i.e. the conclusion and future enhancements.


2.1 Background Reading:

This section presents a short Review of literature where in the different tools & technologies, approach and procedures adopted for developing such a project, and making proper choice of appropriate and useful technologies is discussed and reviewed. The main aim of this project is to develop a desktop based GUI interface that enables the user to enter the data, and to generate the DOM based XML document tree.

2.2 Tools and Technologies:

A GUI application offers graphical icons, visual indicators and technologies to provide a platform to the users to interact with, perform the task of gathering and producing information. (Lineback, Not Available) has discussed in his article how to make the GUI more user-friendly and interactive with more use of buttons, icons, tooltips, window management tips, and other designing tips. It not only becomes easier for the user to work with, but also for people with less computer knowledge to use the software.GUI enables the user to easily and quickly enter the data to generate the validated xml files from any remote place. Extensible Markup Language (XML) is required as an input to get the final output of the main project to generate three different formats of the handbook data.

2.2.1 Extensible Markup Language [XML]:

A markup language is a mechanism that identifies structures in a document. Hyper Text Markup Language (HTML) and XML are markup languages.(Walsh, 1998), states in his article, that XML specification defines a standard way to add markup to documents containing structured information. XML is designed to transport and store data where as html is designed only to format and display the data.XML makes the information easy to read and understand and hence easy to be processed by the computers. It is a meta-language for describing markup languages which provides the facility to define tags and the structural relationships between them. Since no predefined tag sets exists, XML does not specify any preconceived semantics. All the semantics of an XML document are either defined by the applications that process them or by style sheets. It is used to richly structure documents to be used over the internet that makes user to view them quickly and easily unlike HTML that has predefined tag sets and does not provide arbitrary structure. XML is amenable to modern compiler tools and techniques. Browsers with xml parsers are required to properly view the content of the xml document.

Some of the XML features are:

Data Sharing: As xml stores data in plain text format it provides a software and hardware independent way of storing data thus the data can be shared by different applications easily.

Data Transport: Complexity of exchanging data between incompatible systems over the internet is greatly reduced, as xml data can be read by different incompatible applications.

Platform changes simplified: XML data as stored in text format makes easier to expand or upgrade to new operating systems, new applications or new browsers, without losing data.

Data more available: XML data is available to not only html pages but also xml data sources, all kinds of reading machines (handheld computers, voice machines, news feeds) and for people with disabilities.

2.2.2 Document Object Model [DOM]:

(Refsnes, Not Available), defines the Document Object Model (DOM) as a cross-platform and language neutral programming convention for representing and interacting with objects in Hypertext Markup Language (HTML), Extended Hypertext Markup Language (XHTML) and XML documents. It provides a standard model of how the objects in an XML object are placed together. It is an interface for accessing and manipulating these objects and their relationships. DOM exposes an XML document as a tree structure comprised of nodes. Using DOM you can create a document, navigate the tree/its structure and add, change or delete any of its elements. DOM connects web pages to scripts or programming languages. Within the syntax of the programming language in use the DOM elements, nodes, etc. can be addressed and manipulated. DOM public interface is specified in its Application Programming Interface (API).

An overview of the DOM levels:

DOM Level 1: DOM Level 1 concentrates on HTML and XML document models. It contains functionality navigation and manipulation of document.

DOM Level 2: It adds a style object to the DOM, to manipulate the style information in a document.DOM Level 2 also defines an event model and provides support for XML namespaces.

DOM Level 3 specifies content models (Document Type Definition (DTD) and Schemas) and document validation. It also specifies document loading and saving, document views, document formatting, and key events.

(Peter-Paul Koch, May 2001) discusses about the XML DOM which provides access to all parts of an XML document, including the comments and processing instructions, and how it could parse and manipulate XML documents.(Armstrong, Dec 2005 ) have illustrated how DOM provides the API's that allow you to create, modify, delete, and rearrange nodes. Methods to structure DOM are also mentioned in the article.

2.2.3 Java Swing:

Softwares with command line interface are replaced with user friendly Graphical User Interface (GUI). Java provides Java support to design and develop Graphical User Interface (GUI).Java swing toolkit includes a rich set of components for building GUIs and adding interactivity to Java applications. Swing includes all the components you would expect from a modern toolkit: table controls, list controls, tree controls, buttons, and labels. Swing is part of the Java Foundation Classes (JFC). The JFC also include other features important to a GUI program, such as the ability to add rich graphics functionality and the ability to create a program that can work in different languages and by users with different input devices.

Java Swing has many features which makes it ideal for Graphical User Interface (GUI) development. Few of those are:


Built-in controls like image buttons, tabbed panes, sliders, toolbars, color

choosers, tables, text areas

Customizable (change border, text alignment, visual appearance of almost any

control and can change)

Pluggable look and feel

New features like tool tips, tool bars, keyboard accelerators, custom cursors, etc.

are also available

Has arbitrary keyboard event binding

Debugging support is also available

Java AWT and Java Swing are both part of a group of Java class libraries called the Java Foundation Classes (JFC). Java AWT is older than Java Swing. At first, Java provided Abstract Windowing Toolkit (AWT) for GUI interface designing. AWT is based on the underlying native

system components.

The Abstract Windowing Toolkit (AWT) is the original GUI toolkit shipped with the Java Development Kit (JDK) and Java Swing is built on Java AWT. Few benefits of choosing Java Swings compared to Java AWT are:

The look and feel and behavior of Java Swing components is consistent across platforms but

AWT components' provides different look and feel and behavior for different platform.

Event model is more efficient in Java Swing as compared to AWT which means Swing

components can run more quickly than their AWT counterparts.

A drawback of Java Swing as compared to Java AWT is that Java Swing components can take longer to load than AWT components. 

2.2.4 Java API for XML Processing [JAXP]:

JAXP is an API for accessing DOM providers for validating and parsing the XML documents.It enables applications to parse, transform, validate and query XML documents using an API that is independent of a particular XML processor implementation. It provides a pluggability layer to enable vendors to provide their own implementations without introducing dependencies in application code. Application and too developers can build fully functional XML-enabled java applications for e- e-commerce, application integration, and web publishing using this software. Evolution of JAXP, made it easier to obtain either a DOM Document or a SAX-compliant parser via a factory class. This reduced the dependence of Java developers over the numerous vendors supplying the parsers of either type. Additionally, JAXP made sure that an interchange between the parsers required minimal code changes.

JAXP has three main parsing interfaces:

1] Document Object Model (DOM) interface:

DOM parser parses an entire XML document and constructs a complete in-memory representation of the document using the classes modeling the concepts of DOM level 2.

Dom parser builds an in memory document representation so it is called as the DocumentBuilder. Using the DocumentBuilderFactory java class, a DocumentBuilder is created. DocumentBuilder creates a Document object of org.w3.dom.Document which is a tree structure containing nodes in the XML Document. Each tree node in the structure implements the org.w3c.dom.Node interface. There are different types of tree nodes, representing the type of data found in an XML document like the element nodes that have attributes, text nodes contained between the start and end tags of a document element. DOM provides a backward and forward search through the tree structure to retrieve evaluate the data held by the tags. As it stores entire XML document in memory before parsing, it occupies more memory and hence is suitable for small applications. Using Dom insertion or deletion of nodes is possible.

2] Simple API for XML SAX interface

SAX (Simple API for XML) is a sequential access parser API for XML is used to read data from an XML document. It is a popular alternative to the Document Object Model (DOM). It implements SAX (i.e., a SAX Parser) functions as a stream parser, with an event-driven API. SaxParser object is created by the SAXParserFactory java class. SAX parser is event driven, it does not create an in memory representation of the XML document and hence is faster and uses less memory. Sax parser informs clients of the XML document structure by invoking call back methods i.e. invoking methods on DefaultHandler instance provided to the parser. ContentHandler, ErrorHandler, DTDHAndler and EntityResolver interfaces of the DefaultHandler class are used by the client. The methods of the DefaultHandler are overridden and data is processed, in its subclass provided by the client. Data may be stored into a database or written out to a stream.

Call back methods defined by user are called events like XML text nodes, element nodes, comments occur during parsing. Events are fired when these XML features are encountered and ended. SAX parsing is unidirectional i.e. previously parsed data cannot be re-read without starting the parsing operation again. It parses node by node from top to bottom so can use for parsing data once.

3]  Streaming API for XML StAX interface

StAX is a median between the DOM and SAX interface. The programmatic entry point is a cursor that represents a point within the document. The application moves the cursor forward - 'pulling' the information from the parser as it needs. This is different from an event based API - such as SAX - which 'pushes' data to the application - requiring the application to maintain state between events as necessary to keep track of location within the document.

(Ed and Bhakti, 2003) have discussed the methods to access and use an XML through Java Programming. They have mentioned and compared the different parsers like the Simple API for XML (SAX) or the Document Object Model (DOM) parsers, how a SAX or DOM parser can be invoked in an application through the Java API for XML Processing (JAXP) API to parse the XML document, i.e. scan the document and logically break it up into discrete pieces is explained. The difference between the SAX and DOM parser is also discussed, and compared that how nothing is saved in the memory in case of the SAX parser and hence cannot do any in-memory manipulation where as in case of the DOM parser creates the tree of objects that represents the content and organization of the data in the document, and this tree exists in the memory so data can be retrieved and manipulated when required.

2.2.5 Java Document Object Model [JDOM]:

JDOM aims to build a complete Java platform-based solution for accessing, manipulating, and outputting XML data from Java code. JDOM is not concerned with parsing XML from text input, although it provides wrapper classes that take much of the work out of configuring and running a parser implementation. JAXP API is heavy in terms of memory use and interface size, also unwieldy. JDOM is a lightweight API which is Java-centric.

Even though JAXP reduced the need for caring about the different parser implementations, still it required the developers to use either the DOM or SAX for manipulating the XML data. JDOM evolved as the designers of Java APIs thought of moving more towards Java and Java-like constructs while processing XML documents and it supported moving away from non-Java constructs like Attributes (in SAX) and NamedNodeMap (in DOM). Now the Java developers can use the much more familiar Java Collection classes to manipulate XML data. Moving towards the customary Java constructs also helped making the processing faster - almost at par with SAX.

2.2.6 XML Schema:

XML schema also known as XML Schema Definition (XSD) describes the structure of an XML document. It is used to define the legal building blocks of an XML document. Schema defines elements and attributes that can appear in a document, which elements are child elements, order of the child elements, number of child elements, whether an element is empty or can include text, defines data types, default and fixed values for elements and attributes.

Schemas are extensible for future additions, richer and powerful than DTDs, written in XML, support data types, namespaces. Support for data types in schema make it easier to describe allowable document content, validate the correctness of data, work with data from a database, define data facets i.e. the restrictions on data, define data patterns(formats), and convert data between different data type.

Xml schemas are extensible as they are written in xml. Hence, use your schema in other schemas, create your own data types derived from standard data types. Reference multiple schemas in the same data type.XML editors, parsers can be used for the schema files, also new language not required to be studied.

2.2.7 Document Type Definition [DTD]:

A Document Type Definition (DTD) defines the document structure with a list of legal elements and attributes.DTD allows the XML to carry its own format description. Independent groups of people can agree to use a standard DTD for interchanging data. Application using standard DTD can verify the data received by you from outside is valid. A DTD can also be used to verify your own data.

2.2.8 Java Collections:

(Jenkov, Year Not Available) has mentioned the detailed information about the use of the java collection API (Application Programming Interface) which provides classes and interfaces. Java collections are used because of some other advanced behavior and its feature to change the size of the collections dynamically unlike arrays.

2.3 Conclusion:

Interactive and user friendly GUI guidelines; that enables the user to feed the data smoothly and quickly, XML, XSD-DTD, DOM, comparison of different parsers to generate the DOM tree, implementation of Java Collection APIs, Java APIs for XML Processing is been reviewed in this chapter.


This section specifies user requirements to be fulfilled by the developer to develop the intended software.

3.1 Functional Requirement:

Define XML grammar using correct XML validation Schema Definition (XSD).

Develop GUI using Java Swing.

Generate a XML file using the Java APIs.

Parse and validate the XML document.

Open the XML document, Update, Save.

Prepare a User Guide that describes the installation, execution steps and steps showing the flow and functionality of the application.

Create Javadoc API for the system developed


This section of the thesis consists of the analysis i.e. the UML diagrams, hierarchy or flow charts, what though process and approach is adopted, or iterative methods used to develop the application. Decision taking to make appropriate choice of methods, tools, and programming languages used are discussed in this chapter.

4.1 Analysis:

4.1 .1 XML Validations:

To accomplish the goal of defining grammar using correct XML validation for the XML to be validated, two options viz. Document Type Definition (DTD) and XML Schema Definition were available.

XML can be well formed and valid. A well formed XML document is the one that is correct syntactically which states that it should conform to all the syntax rules. It is concerned with the data structure of the document such as document must have unique root element , start tag must have matching end tag, having singleton tags using the format <LectureUnit/> , elements opened should be closed, should be properly nested, text content should be escaped, correct encoding done. A well formed document can be parsed using a parser. A valid document is the one that is correct semantically which means it must be validated against a known vocabulary or grammar. An XML document cannot be valid until it is well formed i.e. it should ne parsed before being validated. So all valid documents are well formed but all well formed documents are not valid. For a document to be valid it is required to be validated against the XML schema or DTD.

DTDs are easier to code and validate than schema but schemas are more powerful and richer than DTDs as everything defined by a DTD can be defined by a schema but the reverse is not true. DTDs are the only schema language that can be defined inline. Character Data (CDATA) and Parsed Character Data (PCDATA) are 2 types of data, we can use with DTD where as with XML schema all primitive datatypes used in programming language can be used and also can define your own datatypes based on the core datatypes and by using operators and modifiers. Supports object orientation concepts hence encapsulation and inheritance for elements, attributes, datatypes definition is supported. Elements include and import provides support for modularity and reusability. Schema supports web services, XSLT, and other XML based technologies. Datatype support feature of the schema allows yields efficiency in querying the data, as it allows specifying data type in attributes and elements. It supports regular expression to set constraints on cdata which is not possible with DTDs. Support for namespaces, enables to validate documents that use multiple namespaces, and reuse constructs from schemas already defined in different namespaces.

Hence, I selected schema over DTD to define the grammar for the XML document.

4.1.2 Programming Language:

Java is a platform independent object oriented programming language which supports concepts of encapsulation, inheritance, implementation, abstraction. Java swing is used to develop the GUI for the system as it is a desktop application. Buttons, labels, textboxes, textarea, tabular display, images, tabbed forms, input boxes, messages, tooltips, different font and color settings of the components of java swing are used to make the application more presentable and user friendly. Java swing class JFileChooser provides a GUI for navigating the file system, to select a file or directory from a list.

Java collection APIs provides set of interfaces and classes to store and manipulate groups of data as a single unit. Below shown diagram gives an overview of the set of interfaces:

Fig. Interfaces of Java Collections

ArrayList class implementing the List interface of the collection framework stores objects of any datatype, whereas arrays are the object of the class of Lang framework that stores similar datatype values and has limited size of storing values. ArrayLists are resizable and one dimensional array. One of its drawbacks is that it is not synchronized i.e. using it in more than one thread can cause problem. ArrayLists stores objects and allows inserting, deleting, appending, replacing, sorting and searching of data. Also if any data item is deleted the next item index is reset to the previous one thus keeping no null value in array lists. Vector also implements List interface and is growable as Arraylists. Vector is synchronized unlike Arraylists. But Arraylists give better performance compared to vector collection.

4.1.3 XML Parsers:

A XML document is parsed using a XML parser to load the document into the computer's memory, and the information of the document is accessed and manipulated using the programming interface DOM object. Most of the browsers have inbuilt XML parsers that loads the XML document, for Java applications to access a XML document various Java XML parsers are available which are used to parse the document and retrieve the data of the document i.e. load the file. Using these parsers XML documents can be created, root and child nodes, elements, can be added.

XML parsers are dynamic and they change with the changing standards, parsers must support the DOM level2, SAX level2, XSLT and namespaces. There are distinct differences in performance, reliability, and conformance to standards. Some Java XML parsers of different software foundation's available are shown and discussed below:

Java XML Parsers

Sun Parser

(Java APIs for XML Processing (JAXP))

Oracle Parser

(Beta Version)

Apache Parser

(Xerces Parser )

Supports DOM and SAX

Supports DOM and SAX

Supports DOM and SAX

org.w3c.DOM.* javax.xml.parsers.DocumentBuilderFactoryjavax.xml.parsers.DocumentBuilder




Fig. Java XML Parsers

Using factory classes, JAXP allows you to plug in any conforming XML or XSL parser, thus creating a standard mechanism for Java applications to interact with XML parsers. Parsers move towards full compliance with the standards, so changing parsers when using factory classes will be easier. Performance, reliability, familiarity with the JAXP APIs, and no requirement of downloading any jars in class path as with JDOM or unlike Apache's Xerces which has limited supported for XML schema, JAXP API was selected to develop or load the XML document.

4.2 FLOW Chart/Hierarchy Diagram:


Enter Data

Enter Data

Open XMLFile

Generate XMLFile

Edit and Save XMLFile

Open XMLFile

Generate XMLFile

Select LecturePlan


Select Coursework






Edit and Save XMLFile

View XML File

Iterate/Add more Lecture Units


5.1 Implementation:

This section describes the method in which the designing done is implemented to create the grammar, do the coding for the GUI and to convert the data into the XML format and vice-versa.

5.1.1 Resources Required:

To access the module handbook permission from Middlesex University is required. Volunteered module leaders and students are required to evaluate the project prototype. In case of failure to access to the module handbook test data can be used and for no availability of the participants, evaluation of the project can be conducted by the developers themselves.

5.1.2 Software Required:

Java Software Edition (JSE) version 1.6 for developing the java programs

TextPad editor to write the code

Browsers to view the xml files

5.1.3 Hardware Requirement:

A personal computer

Or a laptop is required

Module Handbook

5.1.4 Coding Implementation:

After doing thorough study of the markup language XML, schema languages like DTD, XSD to validate the XML document, using the XML schema definition,n defined the XML grammar.

To develop the GUI learnt Java swing, java collection APIs, JAXP, parsers etc and implemented the java code of swing for proper display.

Implemented the use of JButtons, JTextFields, JTextArea, JPanels, JTable, JLabel, etc for the display and presentation of the components.

Used the Java collections to store and retrieve the data.

Used the JAXP APIs to create the XML document based DOM tree mapping to the define grammar, and to open and view the XML documents created.

Put all Validations for the product to be robust.

Validate a SAXSource or DOMSource Using a Validator

Fig. 5.1.5 Using the XML schema validate the XML document

by implementing the validate method of the DOM parser

Software testing is the process of validating and verifying the software application developed meets the requirements specified for its development and design, and function as expected. Functionality testing, validation testing, etc. of the developed application was done during its development stage. Rest of the testing was done once the development process was finished.

The following tests were performed on the developed software:

5.2 XML was validated against the XML schema by writing the XML file and the XML schema, missing any tags in the xml file or not properly naming the elements or attributes in the schema also gives error.

5.2.1 With one of the end tags missing

5.2.2 Solving the problem by putting the end tag in the XML file.

5.2.3 Test all the tabs, buttons and functionalities on click of the tabs or buttons working or

not. Enter data into the text boxes on click of any of the sections. Functionality to Generate, open, edit/update and save the xml files, clear text boxes, exit, validate xml against schema, working or not are tested and its results are displayed below:




Expected Output



Data Values

Click on Generate button, enter file name

Generates Valid XML file



Data Values

Click on Generate button, enter no file name

Message Box displaying the message Empty Field.



Data Values

Click on Generate button, enter existing file name

Message Box displaying the message Name exists, enter valid name.



Data Values

Click on Clear button

Clears boxes the text



XML File

Click Open button

Text boxes/ Table populated with the data of the xml file



XML File

Click Open button , Edit the data in ext boxes and click save button

Message box with message of changes saved successfully.



XML File

Click Open button

Text boxes/ Table populated with the saved data of the xml file


Fig. Testing Report Table

Fig. Opened XML file for the coursework tab is validated

Fig. (a) Opened XML File for Lecture Plan tab is validated.

Fig. (b) Opened XML File for Lecture Plan tab is validated.

5.2.4 Validations are made if the null values for file names are entered and if same name

as of the existing file is given for the new file name.

Formative testing was conducted at each and every stage of development of the application and the errors, defects and bugs were corrected and retested. After the completion of the development of the application summative evaluation i.e. the testing of the final product was done. The project goals and aims were mapped to the outcome obtained, thus evaluating the project. The deliverables of the evaluation of the project are the reports generated, and the software developed.


6.1 ModuleHandBook is the main class that contains the Coursework class and the

LecturePlan class. ModuleHandBook contains the display of the tabs for the classes Coursework and LecturePlan. Coursework and LecturePlan class contains the presentation code, generating xml file validated against the XSD, validating the xml document code, code to open and save the modifications done to the xml document data, code to clear the text boxes, and exit the application for the Coursework and LecturePlan tabs respectively.

The following screen shots shows that the main page displays

tabbed panes containing the Coursework and LecturePlan tabs. On selection of the tabs respective display panels are opened. The LecturePlan tab has three fields to enter the data with the Generate, Iterate, Open, Save, Validate, Clear, and Exit buttons. As the LecturePlan tab creates an XML file validated against the LecturePlan XSD schema, which contains multiple elements in the XML document the Iterate button is used to add the data contents to the document, which will be generated on the click of the Generate button.

All necessary validations like null value not to be entered for the file name to be generated, existing file name not to be entered, adding fields with null values restricted, disable the functionalities when not to be used and enabled on its requirement, proper messages displayed on such validations, error message for the XML document validation check if not valid and proper message on being valid document are kept.

Enter the data to generate the XML document

Enter the XML file name to be generated

Not Null Validation for the Empty Fields entered

Open an existing XML File

Implementation of JFileChooser class of Java Swing enables the user to select and open existing files from the inbuilt Open dialog box, with the filtration of allowing only XML files to be selected, by implementing the FileFilter and FileNameExtensionFilter java class.

View the data of the XML file opened

As the LecturePlan functionality contains multiple elements JTable is used to

View all the data contents at the same time and in a proper format. Data can be edited/updated and saved the data contents of the XML document through the Table.

Edit the contents of the opened XML file and save the changes done


Ethical Aspects

The project requires volunteered module leaders and students as participants to evaluate the prototype. Their consent will be obtained through the consent forms after informing them about the research and what they are expected to do. Special care will be taken for the vulnerable participants like the disabled or the older people. Also take care that no mental or physical harm is done to the participants intentionally or unintentionally. Privacy of the participants will be maintained. No use of any unethical or offensive means during the development of the project. Ethical approval from our supervisor or the School Ethics Committee will be taken.


For development of the proposed system the XML grammar using validation schema was define at the primary stage. For this I initially used the XML converter tool to generate the XML document by giving a simple text file as input. But the output generated was not up to the mark for not so simple XML files, and was much more time consuming and tedious. So I defined the grammar for the XML documents using the XML schema validation manually.

Less Time: Due to more time spent on the findings and designing of the development could not meet the time line and hence some features like making the GUI more presentable using images for buttons, and including the Help option to navigate through the application was not incorporated.

Lack of expertise in transformation: Need to explore more XML, XSD and DTD, JAXP.


In the existing system the user enters module handbook data in word format and can get a hardcopy of the handbook, whereas the proposed system is to develop a GUI to enable the user to enter the module handbook information and generate a DOM based XML document tree to be used by another related project which will convert the XML into three different formats viz. XHTML, PDF document, and PDA. Proposed project results into a less time consuming and easy to access system, and outcome of this project is the module handbook in three different formats. The proposed system is a desktop application so need to have the source code or the class file in the desktop pc, future enhancements for this system is to make it web based so as to have good and more user friendly environment as compared to this desktop application which are restricted due to the limitations of Java Swing, or make it accessible from anywhere any time without having the source code on you system. Another enhancement to this system would be to have a help for the navigation of the system.

Hence, the outcome of the proposed system is the tool that would accept information from the user and generate the XML documents validated against defined grammar using XML schema validations.