Post on 20-Jan-2023
COURSE CONTENT AUTHORING AND
SEQUENCING USING XML
by
BILLY BROOKS YORK, B.S.
A THESIS
IN
COMPUTER SCIENCE
Submitted to the Graduate Faculty of Texas Tech University in
Partial Fulfillment of the Requirements for
the Degree of
MASTER OF SCIENCE
Approved
/
August, 1999
l^ ^ ACKNOWLEDGEMENTS
m /lO' /^^ I would like to thank each of my committee members: Dr. Bharti Temkin and Dr.
^ ^ ' Terence Ahem. Their help was invaluable in this research. I would like to extend my
deepest gratitude to my chairperson. Dr. Nancy Van Cleave. Her help and support has
taught me many things and made me a better person.
I would also like to thank my family and my fiance for all of their love and
support. Without their help, none of this would have been possible. Lastly, I would like
to thank God, without whom none of this would have been possible.
11
TABLE OF CONTENTS
ACKNOWLEDGEMENTS ii
ABSTRACT vii
LIST OF FIGURES vih
CHAPTER
L INTRODUCTION 1
1.1 Overview 1
1.2 Introduction to Educational Issues 2
1.3 Educational Resources 3
1.3.1 Money 3
1.3.2 Computers 4
1.4 Classroom Software 5
1.4.1 Creating Educational Software 5
1.4.2 Classroom Software is Static 5
1.5 The Internet 6
1.5.1 Open Systems 6
1.5.2 Proprietary Systems 6
1.5.3 Pros and Cons of Open and Proprietary Systems 7
1.5.4 The Internet is an Open System 8
1.5.5 The Internet as an Educational Tool 8
1.5.6 Internet Instructional Standards 9
1.6 Summary of Educational Issues 10
iii
II. CURRENT RESEARCH 12
2.1 An Overview of Commercial Authoring Tools 12
2.2WebCT 13
2.3 Non-Commercial Authoring Tools 14
2.4 Significance of this Work 15
m. COMPUTER ASPECTS 17
3.1 Introduction 17
3.2 Requirements Definition 18
3.3 Overview of Solution 19
3.4 Document Type Definition 20
3.4.1 What is a Document Type Definition? 20
3.4.2 Prototype of "Syllabus.dtd" 21
3.5 Extensible Markup Language (XML) 22
3.6 Java 24
3.7 Justification for Using Java 24
3.8 Statement of Work to Accomplish 24
IV. ALGORITHMS 26
4.1 Introduction 26
4.2 General Algorithms 26
4.3 Refined Algorithms 28
4.3.1 Create Lesson 28
4.3.2 Edit Lesson 32
4.3.3 Merge Lesson 34
IV
4.3.4 View Lesson 35
V. IMPLEMENTATION ISSUES 38
5.1 Introduction 38
5.2 Java Related Issues 38
5.2.1 The Authoring Tool as a Java Application or Applet 38
5.2.2 File Filters 38
5.2.3 Data Structure 39
5.2.4 Initializing the Current Node 40
5.3 Java Applet Issues 41
5.3.1 Loading Files 41
5.3.2 Internet Explorer and Netscape 42
VL CONCLUSIONS 43
6.1 Showing Feasibility 43
VII. FUTURE WORK 45
7.1 Introduction 45
7.2 Usability Study 45
7.3 User Interface Improvement 46
7.4 Creating a Student View Lesson 46
7.5 A Possible Alternative to the View Lesson 46
7.6 Scheme for Delivery of Material 49
7.7 Dynamic Structures 49
BIBLIOGRAPHY 51
ABSTRACT
For a variety of reasons, classroom computers in our public schools are not being
utilized to the fullest extent possible. In an effort to provide more accessible software, in
this work we explore the feasibility of using an open systems model to develop course
authoring applications. These programs may be used by educators to produce tutorials
quickly and simply at little or no cost. As educator gathers all files and URLs which are
to be part of the tutorials, and organizes them using the authoring software. This is
accomplished using a Document Type Definition (DTD) to define a series of rules for a
direct instructional model based on Gagne's Nine Events of Instruction. We then
developed a Java application which may be used to produce tutorial files based on the
DTD in Extensible Markup Language (XML) format. We then produced a Java applet
which may be used to view the tutorial files.
We met our goal of showing the feasibility of using an open system model with a
protocol for course authoring software. In addition, our programs form a complete
system for creating, editing, and storing tutorials. Beyond this, they are also inexpensive,
produce cross-platform tutorials, and provide a GUI to aid in ease of use.
vu
LIST OF FIGURES
3.1 "Syllabus.dtd" 22
3.2 A tree showing a possible file using "Syllabus.dtd" 23
4.1 Main Menu 27
4.2 Creating a Lesson with Add Enabled 29
4.3 Creating a Lesson with Presentation, Practice, and Performance Enabled 30
4.4 Allowing the User to Enter a URL or Filename 31
4.5 Allowing the User to Select a Local File 31
4.6 Saving a File 32
4.7 Opening a File 33
4.8 Editing a File 33
4.9 Merge Menu 34
4.10 Viewing a Local File 36
4.11 Viewing a URL 37
7.1 An XML File 48
7.2 XML File in IE 5.0 48
VlU
CHAPTER I
INTRODUCTION
1.1 Overview
Using Computers for the delivery of instructional material should be an excellent
match of technology to education. There are countless products currently on the market
that deliver instructional material via computers, yet little of it is being utilized in
America's classrooms. Several factors may account for this including cost, lack of
flexibility in the software, start up learning curves, and limited classroom usefulness.
Using the Internet to deliver instructional material is becoming increasingly
popular. The Internet provides access to vast amounts of information, however Internet-
based instructional tools must still direct the learner through the material to some extent
or the acquisition of content suffers.
There are two possible designs for any computer-based instructional tool; they
may be either proprietary or open. The first is based on a proprietary or closed system
software approach. Using this design, only the group implementing the product,
application, or system has total knowledge of the inner workings of the software and
generally does not release these to the public at large. This generally prevents third party
vendors from developing add-ons or extensions to the system.
The other approach to the development of instructional tools is based on an open
system model. The exciting aspect of using this model is that the protocols and data
representations used are publicly published and are thus available to all parties. This
allows anyone to develop a tool that can utilize a specific protocol, which in turn may
extend the usefulness of the system.
This research investigates the feasibility of developing a protocol for course
authoring tools using Extensible Markup Language (XML). We first developed a general
and flexible protocol, then produced a course authoring application utilizing it.
We have shown using an open system for the development of authoring tools is
feasible and very promising. We have also shown that it is feasible to develop such tools
based on an open system model. It is our hope that such an open systems idea will grow,
begin to enrich education, and help educators everywhere.
1.2 Introduction to Educational Issues
The technological revolution in education began in the early eighties with the
advent of the Apple computer by Steve Jobs and Steve Wozniak. Since then, technology
has gained momentum and led to changes in almost every aspect of our daily lives.
Computers are an integral part of this revolution and have been a dominant factor
in the spread of technology. Owing to their potential as learning tools, computers have
been proclaimed the next cure-all for most of the problems confronting K-12 educators
today. However, with all of the time and money spent on technology in our schools,
should not the majority of eighth graders do more than just write papers on computers
[DE 97]?
In spite of all the funds that have been and will be spent on educational
technology there does not appear to be many effective software applications targeted for
classrooms that utilize the Internet. With the currently evolving Internet instructional
standards for education moving toward an extremely complex model, it does not appear
there will be many in the future either. To fill the gap caused by this lack of educational
software and standards, we have written a curriculum and course authoring application
geared toward K-12 educators which allows them to author their own computer based
lessons and distribute them to other educators. This application is based upon the
concept that such an authoring tool should be inexpensive, simple to use, allow
modification of lesson content, and produce lessons which can be presented across
various computer platforms. Most importantly, it is based upon an open systems model.
1.3 Educational Resources
1.3.1 Money
As every taxpayer knows, the United States earmarks a vast amount of money for
education every year. This money includes funds from federal, state, and local agencies
as well as the private sector. Much of this money is used for the everyday functions of a
school, but politicians and others are pushing for the use of technology in the classroom.
For example, the Telecommunications Act of 1996 provided deep discounts to make
Internet access affordable to schools and libraries. "The [Clinton] Administration also
increased its investment in educational technology (computers, software, teacher training)
from $23 million in 1993 to over $700 million in 1998" [Wh99, p. 3]. With this much
money at stake, it becomes very important to find the best ways to utilize the technology
being acquired in our classrooms.
1.3.2 Computers
There exists an underlying framework of hodgepodge and legacy computers that
have already been purchased. "In 1995, the average public school contained 72
computers" [DE 98, p. 2]. Obviously a significant amount of money has already been
spent on existing computer systems. The number of computers in our schools continues
to increase. "The number of U.S. students for every instructional multimedia computer
dropped from 21 in 1997 to 13 in 1998" [Je 98, p. 1]. Considering the large number of
computers already in the classroom as well as computers to be added in the future, it is
important to understand the variety of platforms used in schools.
Common sense and casual observation leads to the conclusion that the current
makeup of technology in the classroom is a hodgepodge at best. "Ann Arbor's recent
Technology Bond ($10 milhon) paid entirely for Macs. Many U.S. schools are now
purchasing Wintel [PC based] machines, making schools probably the largest truly multi-
platform, Mac and Wintel, market" [So 98, p. 12]. To further illustrate the non-uniform
nature of classroom computers, in 1998, 45 percent of all computers in public schools
were classified as a multimedia computer [Je 98]. This implies the otner 55 percent of
the computers currently in school classrooms and labs cannot play a CD-ROM. However,
even though some of these systems are older, they still function and thus should be
utilized, if possible.
1.4 Classroom Software
1.4.1 Creating Classroom Software
Properly utilized, computers and other technologies inherently improve learning,
[CI 85] but no one is making money in educational software. It is basic economirs:
prices are high because they must reflect the costs for developing good educational
software [So 98]. One reason why educational software costs so much is a development
issue. Such software basically contains two parts: the content and the delivery system or
engine. Most commercial software, games for example, are built upon a preexisting
engine. The content is designed, then added to the presentation engine which may be
tweaked to allow for new advances in technology. This separation of content from
delivery system is an important concept because the reuse of code decreases development
time. With decreased development time comes a decrease in cost of the finished software
product. However, with educational software the content and the engine must be written
nearly from scratch every time. This is due to the fact that currently there is no
educational engine. And since educational software does not generate a profit, no one is
bothering to develop such an engine.
1.4.2 Classroom Software is Static
Demand for educational software is low because schools are choosing not to
spend their funds on software [So 98]. This is because the content of most courses is
always evolving, but software packages are currently static and usually focus only on one
subject area. This means current instructional software's content cannot be changed as
the course changes. Soloway states that due to the unmodifiable nature of the software,
an educator might spend their entire budget for a CD which then may be used
infrequently, or they can choose to spend the money on a book which can be used all
year. To quote Soloway, educators are forced to ask, "How does that snazzy CD tie to
the curriculum, which ties to the state standards, which ties to the state tests, which ties to
the textbook?" [So 98, p. 13].
1.5 The Internet
1.5.1 Open Systems
An open system is one in which it is possible for various types of computers to
exchange information due to public standardized interfaces. "Open systems are
characterized by the fact that their key interfaces are published" [CoDoKi 94, p. 16]. An
interface can simply be thought of as a definition of certain data types and how they are
stored. A standard is a commonly accepted way of doing a particular task. The process
by which an interface becomes a public standard is through the request for comment
process (RFC). Using this process a new standard is proposed and after lengthy
discussion by the computing community, it is either formally accepted or rejected. If it is
accepted, developers can be assured systems will support it, thus making communication
easier between disparate systems.
1.5.2 Proprietarv Svstems
The opposite of an open system is a proprietary system. This is a system that is
completely self contained, and all the interfaces work only on the specific machines for
which they were designed. It is difficult to develop third party software for proprietary
systems since the inner workings of proprietary systems are not generally shared with the
public.
1.5.3 Pros and Cons of Open and Proprietary Svstems
Both open systems and proprietary systems have advantages and disadvantages,
and some of the main ones are highhghted in Table 1.1 [KaGil^Se 98]. Each has
something to offer but for education, scalability, cost, and simpler functionality are very
important. Scalability allows a system to grow as needed without much change to the
overall system design. The simpler functionality of open systems allows more people to
have access to the system due to its uncomplicated nature.
Table 1.1: Advantages and Disadvantages of Open and Proprietary Systems
Functionality
Administration tools
Scalability
Cost
Open Systems
Current standards push interoperability and simplicity, not features. Typically done by editing configuration files.
The Internet was designed from the beginning to be large and scalable.
Generally requires less server and system administration support.
Proprietary System '
Typically offer a much richer feature set.
Typically offer nice graphic tools.
Generally not very scalable.
Typically requires a lot of server and system administration support.
Note: Advantage (^)
Source: IBM Systems Journal, J. Von Kanel
1.5.4 The Internet is an Open System
The framers of the Internet originally intended for the Internet to remain open so
information can be relayed between hosts on different transport systems by a host on both
transport systems [Po82]. The "Internet was based on the idea that there would be
multiple independent networks of rather arbitrary design, beginning w ith the
ARPANET..." [ISOC 98, p. 4]. It is this open system concept of a variety of computers
interconnected on a variety of networks that gives the Internet many of its inherent
strengths, especially since the interfaces are published. Public interfaces are crucial
because computer systems are all very different: computers are not created equal. A Cray
supercomputer is different in both hardware and the software which runs on it from a
Wintel machine. And both of these machines are different from a Macintosh.
Fortunately, due to well established protocols and standards, they have the ability to
communicate with each other. This ability is facilitated by the Internet's openness
through each machine's published interface.
1.5.5 The Internet as an Educational Tool
Used correctly the Internet can provide a great medium for delivering information
to students. Eighty-five percent of K-12 schools are connected to the Internet and the
majority of educators are more likely to use the Internet as a source of information than
as a tool for communication [DE 98]. This shows educators are willing to use the
Internet as a powerful resource for collection of information.
The fact the Internet allows access to vast quantities of information cannot be
questioned. However, this deluge of information may overwhelm a user, especially if
that user is a student attempting to learn specific material. According to Edwards and
Hardman, the Internet can provide a means for sending information to potential students,
but the Internet is too broad and inhibits the user from learning [EdHa 89]. This is
because the Internet does not restrict students to the content material. They are able to
follow links in a dynamic rather than linear fashion, allowing students to get lost or
sidetracked. This is not a negative aspect from a recreational viewpoint, but it is
detrimental when trying to focus on specific facts or concepts in a limited amount of
time.
1.5.6 Internet Instructional Standards
Many people are currently working to set standards for educational instruction
over the Internet, since such standards are essential for further development of Internet-
based instruction. The standards currently proposed involve how learning materials
should be developed, with key emphasis on the Internet as the delivery medium. A major
problem with all of these proposed standards is they violate the underlying principle of
openness in the Internet. One very good example is the set of standards proposed by
EDUCOM/NLII [EDU 98]. These standards consist of 295 pages in an early release
version that is complicated and dependent upon proprietary technology. Other
organizations besides EDUCOM, for example IEEE, are considering standards based on
proprietary technology as well. Should any of these proprietary standards be adopted, it
will make it more difficult for developers to create products which conform to the
standards. This is partially due to the nature of proprietary systems and also due to the
complexity of the standards.
1.6 Summary of Educational Issues
Educational issues are very important to many people. These issues are not only
concerned with the future of the nation; they also involve the way tax money is spent. A
problem surrounding technology is that currently it is viewed as requiring replacement
every few years to keep it useful. This planned obsolescence makes countless systems
that have already been purchased outdated, while in reality these systems are still useful
for a wide variety of educational tasks.
Another problem with educational software is no one is making money writing it,
so the impetus for innovation from developers is lacking. This is because most
educational software packages must be developed from scratch. Further, the demand for
educational software is low since it is not modified easily to adapt to individual
classrooms.
The open system of the Internet is an alternative to commercial proprietary
systems for instructional delivery. The Internet is preferable over proprietary systems
which require a specific set of hardware to make them useful. An open system by
definition has public interfaces which allows greater diversity in hardware. Both of these
systems have advantages and disadvantages, but the advantages of scalability, cost, and
simpler functionality that open systems provide are very important in education.
The Internet owes much of its inherent strength to its open system design. It is a
great medium for finding information, but one problem from an instructional view is the
10
Internet is so broad it tends to inhibit users from learning due to the hypertext
environment. Some people are working to set standards for the delivery of educational
information, but most of these standards are very complicated and violate the underlying
principles of the Internet.
Educational issues are very complex and extremely important because the future
of a nation depends on the education of its citizens.
11
CHAPTER n
CURRENT RESEARCH
2.1 An Overview of Commercial Authoring Tools
Various conmiercial authoring tools are available, but as Soloway pointed out
there is very little profit in educational software. In fact, many authoring tools are no
longer supported by the companies that created them. Macromedia's Authorware once
retailed for several thousand dollars in the mid 1990's, but now the company no longer
supports this software. Claris Corporation's HyperCard once retailed for several hundred
dollars in the mid 1990's, but it too is no longer supported.
Why are these once successful products no longer supported? A key problem is
these authoring tools were unable to incorporate and adapt to rapid technological change.
Authorware did not have support for the Internet, while HyperCard did not even support
color when it was dropped from the products supported by Claris Corporation.
Another authoring environment, HyperStudio, was first marketed by Roger
Wagner Publishing in 1978. As of 1999, HyperStudio retailed for $199.95 for a single
user license. HyperStudio was designed by a teacher and uses constructivist design
methodologies. Constructivism is the idea that students learn best by doing. HyperStudio
revolves around allowing the student to create and present instructional material.
HyperStudio supports most of the current technological innovations including
video and digital cameras. It also provides a means of publishing finished lessons to the
Internet through the use of plug-ins for web browsers.
12
Personal observation in the classroom confirms that Microsoft's PowerPoint is
extremely popular for the delivery of instructional material. One reason for this is
PowerPoint allows for rapid development of material. PowerPoint also supports many of
the same components and has the same look and feel other Microsoft products have,
allowing for a short learning curve and ensuring PowerPoint always supports the newest
technology. While PowerPoint is popular, it should be noted that it was not designed to
be a course authoring environment. PowerPoint does not require or force any structure in
a presentation, neither does it allow any other educational activities such as online testing
or discussions.
2.2 WebCT
WebCT, currently the official tool used by Texas Tech University, is an extremely
popular Internet authoring tool. The Computer Science department at the University of
British Columbia developed WebCT, headed by faculty member Murray W. Goldberg.
WebCT allows course designers to include components such as online discussion
groups and online testing, as well as many other features found in education using a
direct instructional model. In this model instructional design is linear in nature.
Components for the lesson are placed in order of the expected use, and there is no
branching allowed in the lesson.
All of the material from WebCT is accessed from any web browser. WebCT is
free for use in development, but a user license must be purchased for course delivery.
The fee for this license is based on the number of student accounts on a single se^/er for a
particular course. The current price for an unlimited number of students on WebCT is
13
$1,200 for four months, $1,680 for six months, $2,160 for eight months, and $3,000 for
twelve months. A private company recently purchased WebCT and they have stated
current license holders will not face more than a 5% per year increase in the license fees.
2.3 Non-Commercial Authoring Tools
There are two interesting tools currently under development in academia. The
first, presented in an article in Computers & Education by Nkambou, Frasson, and
Gauthier [NkFrGa 98], highlights the design and implementation of a curriculum and
course authoring tool developed in Canada. According to the authors, they created "[a]n
authoring environment dedicated to the development of curriculum and course material
that can be handled by an Intelligent Tutoring System (ITS)" (p. 105). The ITS is a
proprietary system that runs separately from the authoring environment. This authoring
environment is concerned with instructional design and uses a subject-matter model
called CREAM (Curriculum REpresentation and Acquisition Model). "In this model, a
curriculum is represented and organized according to three points of view: the domain
knowledge, the pedagogical aspect, and the didactic point of view" (p. 108). The domain
knowledge is implemented as a multi-graph where nodes represent capabilities, or
knowledge, stored in a person's long term memory. The pedagogical aspect consists of
instructional objectives represented and organized together, while the didactic point of
view consists of a network of relations for the resources used. The authors force the user
to adhere to the CREAM model by using an expert system to validate the curriculum.
The second authoring tool was found in an abstract entitled "Using a High-Level
Language to Describe and Create Web-Based Learning Scenarios" by Miguel Rodriguez-
14
Artacho. The full paper for this work is currently unavailable, but it will be presented in
the 1999 Frontiers in Education (FIE 99) conference in November. This abstract
describes the author's work as an SGML-based language called PALO. The purpose of
PALO is to provide educators with no knowledge of HTML a tool for preparing
documents for the Internet.
2.4 Significance of this Work
Although there are many similarities between this work and the programs
discussed above there are also several key differences. The first distinction is we are
looking at the feasibility of using an open system for the development of authoring tools.
With the exception of the Rodriguez-Artacho work, every product described above is
based on a proprietary system. The Rodriguez-Artacho work uses an open system for
delivery, but users are restricted to the author's SGML-based language instead of XML,
which the World Wide Web Consortium is working to standardize.
This work uses a cross-platform application for creating and editing courseware,
and a web-based Java applet for viewing the resulting lessons. Both were created to
utilize the Internet, partially due to representing the syllabus protocol in XML and using a
web browser in the applet inherently includes support for the Internet. Several of the
products described above include support for the Internet. These products tend to be fair
in price, but if this work were ever to become a protocol the price would be free. It
should also be noted products such as WebCT also have high overhead costs since they
require a system administrator to ensure the server is running correctly.
15
Another difference is this work does not force the user to adhere strictly to a
specific design methodology as some of the products described above. This work is
loosely based on Gagne's Nine Events of Instruction which is a commonly accepted
instructional design methodology for direct instruction. Gagne's Nine Events of
Instruction is seen below [GaBrWa 88, p. 196]:
1. Gaining attention,
2. Informing the learner of the objective,
3. Stimulating recall of prerequisite material,
4. Presenting the stimulus material,
5. Providing learning guidance,
6. Eliciting the performance,
7. Providing feedback about performance correctness,
8. Assessing the performance,
9. Enhancing retention and transfer.
The only items which are specified in the authoring application are items four, six, and
eight. These items are available to the designer using the protocol which we developed.
16
CHAPTER m
COMPUTER ASPECTS
3.1 Introduction
As discussed in Chapter I, many issues which impact educational software
development. The first relevant problem is schools have invested in and continue to
acquire a wide range of computer systems which are mutually incompatible and/oi have
differing capabilities. The second issue of interest to us is currently tLere is a lack of
motivation to develop educational software because it has not been profitable for
commercial developers to invest resources in producing a reusable delivery system. This
is partially due to software development issues stemming from the creation of an engine
separate from the content in educational software. Also, current software is not very
profitable since most educational software is static or not easily modifiable to evolve as
class content changes, thus discouraging educators from incorporating it into their
classrooms. Another problem is most of the available packages run on proprietary
(closed) systems which require specific machine configurations and usually disallow
third party developers.
The use of open systems like the Internet is an option since the interfaces are
standardized, making them available to all that need them. The Internet can also serve as
a very effective means of delivering information when used correctly, but proposed
Internet instructional standards threaten the openness of the Internet.
K-12 teachers want to utilize technology in their classrooms, but have been
frustrated by both the expense and difficulty of using available software.
17
3.1 Requirements Definition
As a result of above considerations, our proposed authoring package must meet
the following criteria:
1. Take advantage of the variety of platforms and functionality of current
computer systems in public schools, i.e., both the authoring tool and the
delivery system should be cross-platform.
2. A delivery system or engine, separate from the changeable educational
content, should be developed to enable faster, cheaper production of software
for classrooms. This system should also allow simple modification of content
for more extensive educational utilization.
3. Creation and editing must be simple and rapid to be useful to teachers.
4. Both the authoring/editing tool and the engine should adhere to open
standards, encouraging third party add-ons.
Thus our requirements definition for our solution includes:
• The protocol should be based on open standards -
In order to make it possible for the protocol to become a standard, it must be
open so that many people will be able to develop applications that can utilize
the product.
• Separate the content from the delivery system or engine -
The development of a separate re-usable engine will make the production of
educational software easier and more cost effective.
• Make our solution cross-platform -
18
>'i'P%V
Because of the non-uniform nature of computer systems, the product should
run on as many platforms as possible.
The product should be inexpensive -
Since educational money is taxpayer money, the product should be as
inexpensive as possible. Which also makes the product available to more
people.
The product should have a short, flat learning curve -
Because teachers are always busy, the proposed product must be easily
learned and simple to use.
The product should allow modifiable lessons -
As a teacher finds or creates more material, it should be simple for him/her to
incorporate this material into an existing lesson.
The product should allow lessons to be shared -
Once the effort has been expended to create a lesson, it would be desirable to
make it accessible to other teachers.
3.2 Overview of Solution
The authoring system is software that will be used to produce tutorials,
instructional material, etc., which in turn will be data processed by another application.
How we propose to meet these requirements to produce an authoring system bas^d on an
open systems model involves several important items.
First, we developed an appropriate protocol to represent our instructional model
using a Document Type Definition (DTD). Next we developed a two-part engine
19
consisting of a Java application for editing and a Java applet for viewing the lessons
created. This engine utilizes the protocol developed using the DTD and produces an
Extensible Markup Language (XML) file representing a lesson or content. The engine is
kept separate from the content, since the content for a lesson is created elsewhere and the
Java application is used to sequence the material into lessons.
The product should be cross platform, utilizing the Internet. Therefore, Java and
XML were used to develop the authoring system. In addition, this product should be
simple, fast, and include a nice graphical user interface (GUI) for the user.
3.4 Document Type Definition
3.4.1 What is a Document Type Definition?
A document type definition (DTD) can be thought of as a layout standard or
template for an Internet document that is published and available for all users. For
example, the standards that hypertext markup language (HTML) uses can be considered a
DTD. Once a DTD is downloaded, through an Internet browser for example, an
extensible markup language (XML) capable program can interpret the formatting of
documents based on that particular DTD. These documents are usually contained on the
same web page. Technically, a DTD is a set of specifications that completely define
what elements and attributes data may have in a user defined markup language. A user-
defined markup language is simply a set of instructions for manipulating data that any
user can modify or create.
20
We developed a DTD named "Syllabus.dtd" which incorporates the rules for a
lesson based on a direct instruction model developed from Gagne's Nine Events of
Instruction. Users of the authoring software are restricted to these rules which specify all
of the legal elements which may be produced.
3.4.2 Prototype of "Syllabus.dtd"
The "Syllabus.dtd" may be considered a general set of rules or grammar for a
lesson created using this software. The term syllabus was selected after much
consideration because the final product could be a single lesson or it could be a series of
lessons for the entire course.
As can be seen in Figure 3.1, the Syllabus.dtd consists of three main parts. The
first part is a course which consists of a name (a text identifier), and zero or more courses
or units. A unit also consists of a name, zero or more units or lessons, and a performance
section (an exam) that may occur only once. The next piece is a lesson which also has a
name, and zero or more presentations, practices, performances, or Lessons. A
presentation is considered to be any material that contains information of relevance, such
as an article or a web site. A practice could be a practice test or it could be something
similar to a discussion board. A performance is some type of exam or quiz to evaluate or
assess the student.
After much thought, we decided the general design of "Syllabus.dtd" shown in
Figure 3.1 would be the best approach. The first reason is the goal of this project is to
give the educator the power to create what they need while imposing the fewest possible
restrictions. The second reason is that with a general design, it will be more intuitive to
21
make modifications by hand to the files which a user may have previously created using
the authoring tool. This is a possible alternative to using the authoring tool once the
structure of the DTD is known, a user simply needs to modify tags much like those in
HTML. Lastly, the DTD created echoes tables of contents with which most teachers are
familiar. This helps organize the information that teachers have.
A DTD and XML are inherently tree structures. The tree showing a possible file
using "Syllabus.dtd" is shown in Figure 3.2.
<
<
<
<
<
<
<
<
<
<
-Syllabus DTD Version 1.0~> —Brooks York—> ELEMENT Syllabus (Course)> ELEMENT Course (name,(Course|Units)*)> ELEMENT Units (name,(Units|Lesson)*,performance?)> ELEMENT Lesson (name,(presentation|practice|performance|Lesson)*)> ELEMENT name (#pcdata)> ELEMENT presentation (#pcdata)> ELEMENT practice (#pcdata)> ELEMENT performance (#pcdata)>
Figure 3.1: "Syllabus.dtd"
3.5 Extensible Markup Language (XML)
Extensible Markup Language (XML) has been developed by a group of the Worid
Wide Web Consortium (W3C) with the goal of bringing the advantages of the already
standardized SGML (Standard Generalized Markup Language) to the Internet. The
reason XML was needed is because SGML is very complicated and not easy for
designers to utilize. The first working draft of XML was published in 1996, and since
then it has gained considerable favor with developers due to some of the strengths of the
design. 22
XML is considered a markup language. Another example of a markup language is
hypertext markup language (HTML). Due to the use of DTDs, XML is not limited to a
fixed set of element types as HTML is. Instead, elements are defined in the DTD with
the attributes or plug-ins the user wishes to utilize in the document. XML is designed to
fit into areas for which HTML was never intended. The advantages of XML include a
tightly controlled document display, flexibility to describe different and specific types of
information, and the ability to convey information in a variety of media formats [TiMiCh
98].
Civil War (Course)
n Reconstruction
(Course)
The South (Unit)
Figure 3.2: A tree showing a possible file using "Syllabus.dtd"
23
3.6 Java
Java was developed at Sun Microsystems by James Gosling. The basic idea
behind Java is that it should be a small language, but not as small or hard as machme
language, and it should run on any kind of computer chip [DeHi 98]. The ability of Java
to run on many different types of machines is one reason why IBM and Sun
Microsystems have switched to Java for their development languages. Java is a modem
object-oriented programming language that bears a resemblance to C++. Java programs
are secure, robust, and portable [LaOs 99].
3.7 Justification for Using Java
Java was our language of choice because of the nature of school systems with
their many different types of computer systems. In order to provide access to as many
users as possible, a program must be cross-platform and Java allows for this.
We used J Builder 2.0 Professional to implement our project. J Builder was
chosen simply because of its interface, but any environment that uses Java 1.1 would
have been feasible.
3.8 Statement of Work
The key features of this project include:
• The development of a protocol using an appropriate DTD for representation of
a "Syllabus."
24
The implementation of "Create Lesson" functionality —
This allows the user to input data (filenames or URLs) and to create the
corresponding XML structure (highlighted in Figure 3.1), which
represents a standardized lesson.
The implementation of "Edit Lesson" functionality —
This function allows an author to open an already existing file, edit the
data associated with it, and choose to replace or rename the new file.
The implementation of "Merge Lessons" functionality —
This function makes it possible for users to take multiple existing files and
create a single file from them. This is important if an entire section,
chapter, or semester's worth of work is to be included in one large
"lesson."
The implementation of "View Lesson" functionality —
This is a Java Applet that will be launched from a web browser. This
applet was used to test the files created in "Create Lesson," "Edit Lesson,"
and "Merge Lessons" by displaying the files and connecting them to the
URLs specified in them when needed.
25
CHAPTER rV
ALGORITHMS
4.1 Introduction
The logic for this program utilized several built-in features of the source language
discussed in CHAPTER III and an associated library (Swing 1.1) of routines. These will
be identified as they are encountered in this discussion. Since one goal of this research
was to create a graphical user interface (GUI) for educators, the overall design revolves
around the GUI components that Java provides. Many of the code segments use listeners
and events to trigger a section of code to execute, but the overall discussion of the
algorithms will not show this.
4.2 General Algorithms
The Main_Menu of the program is based on the general algorithm given below.
A screenshot of the highest level menu is shown in Figure 4.1. The Main_Menu provides
the user with the option of creating a lesson (the Create object), editing a lesson (the Edit
object), merging several lesson (the Merge object), and exiting the program. The general
algorithm of the main program is as follows:
Start Main_ Menu
Loop
Case user selects
Create : Create_Lesson
Edit: Edit_Lesson
26
Merge: Merge_Lesson
Exit: System_Exit
Until (System Exit invoked by user)
End Main_Menu
This menu works in a manner similar to most other menus. When the user selects
the CREATE A LESSON button by clicking on it with a mouse, an instance of the Create
object is created and displayed on the screen. This is also true of the EDIT A LESSON
and MERGE LESSONS. When these buttons are selected (or clicked) an instance of the
Edit and Merge objects are, respectively, created and displayed. The pull-down menu
under File has the same functionality as the buttons of Main_Menu.
^ C o u i s e Content Sequencing Using XML
Fie Help
CREATE A LESSON
EDIT A LESSON
MERGE LESSONS
EXIT
Figure 4.1: Main Menu
27
4.3 Refined Algorithms
4.3.1 Create Lesson
The interface to a Create object is a dialog box as shown in Figure 4.2. This
object allows the user to create a file which adheres to the Syllabus.dtd protocol
discussed earlier. Once the file is created to the user's satisfaction, the file is saved when
the Finish button is pressed and the user is taken back to the Main_Menu discussed in the
previous section. The algorithm for Create is as follows:
Start Create
Loop
Case user selects:
A: Add
R : Remove
Pr: Presentation
Pa: Practice
Pf: Performance
F : Finish
Until (Exit invoked by user)
End Create
As can be seen from Figure 4.2 and Figure 4.3, the Create object has different
functionality based on where the user is in the creation process. The Add and Remove
buttons respectively insert or delete children from the parent in the tree, where parent
refers to the tree node which is currently selected. It should be noted that the Remove
button removes the currently selected node and all of the selected node's children. This
28
can have a very dramatic and highly agitating effect if the user does not understand the
remove process.
If the user is on the appropriate level of the tree (depth three, or at a Lesson level
for Presentation and Practice, Lesson or Unit for Performance) then the Presentation,
Practice, and Performance buttons become active and the Add button is no longer
selectable (Figure 4.3). This forces the user to insert children with the names
presentation, practice, and performance, as dictated by the Syllabus.dtd file.
^& Cieating a Lesson
Please Enter a Unit Name
•^d\^.~ V,
/• ^/' Add
Presentation s -artice
Item Selected
Selected: Dinosaurs
Remove
PaiformancS
9 [13 Syllabus __ [^ iDinosaurs
Figure 4.2: Creating a Lesson with Add Enabled
29
Once a presentation, practice, or performance node has been inserted, the user
may provide a URL or filename as a legal presentation, practice, and performance item
(Figure 4.4). If no item is entered in the text box, then the Open dialog window appears
and allows the user to select a local file (Figure 4.5). Once the Finish button is selected,
the Save dialog window opens, and the user is allowed to save the file (Figure 4.6).
^ Creating a Lesson
Please Make a Selection
idd-
Presentation Practice
Item Selected Selected: Tt ieeratops
Remove
Performance
9 [l3 Syllabus 9 C3 Dinosaurs
9 CH Plant Eatery Dpceratups;
Figure 4.3: Creating a Lesson with Presentation, Practice, and Performance Enabled
30
^ d e a l i n g a Lesson
. . _.-.,r. -'.' -.• - , t -•' ^i- *.-.-, - . „», .y ,
lease Make a Selection -; -; JftK-
' . . " - ' : r t . . ^ , . J . / .
mil till I
I Presimtafion •l*HIMMM
Item SeCectetf Sleeted: MevaNodel
Remove
. ^ •". * V
Practice -I PiTrtoffhahce
V f E!3 Syllabus
9 (SI Dinosaurs ^ S Plant Eaters
''•- D Presentation
2 j«
."V
Figure 4.4: Allowing the User to Enter a URL or Filename
M^d
D SampleWav.wav
Q Twenty.bmp
D congressg.jpg
Q triceratops_-_wireframe.large
Figure 4.5: Allowing the User to Select a Local File
31
4.3.2 Edit Lesson
The Edit object is very similar to the Create object. The key difference between
them is the user is first asked for an XML file to open (Figure 4.7), and then the file is
read and parsed and an instantiation of a tree is initialized using the syllabus stored in the
file (Figure 4.8). Once this occurs, the functionality available is exactly the same as the
Create object.
j Look H i :Mi ,
u:± ^LT>^. y y->
l l ! ] Java
javax
sun
^ untitled2 Q DJno.xmI..;.;f; . T."!i V -t^^, ^ ^ ; ^ ^ y^^j''^:^r''/: '4" .^ ^ ^
9 / y^ 'A / , / ^ y ' ^ / K - S - * ' "
^K,..rrt,...f,ri.<..<f«<»yMoi ..w
Q Money.xml
D readmaxml
Q trlaLxml
File name:
FOes or^e:
Dino-xml ''/'^fM{^{^^0^/^9f^^f^/0y^P^i^p^^^^^^^ '.•/' ,^-
%y/4iS.//<^.-M/x:y^~'. ^'.. \f}^sm£!k?^/.Sm'Z iAbortflle chooser diafei%it+3
Figure 4.6: Saving a file
32
Figure 4.7: Opening a file
^ ^ E d i t i n g a Lesson
Please Entera Lesson Name era UiittTest
Add Remove
Pr^semst.r- Pr- :»-? I Perfomriance
Item Selected Setectad: Platrt Eateis
9 1:3 Syllabus 9 (I3 Dinosaurs
9 aifkjPf\B9ieri
' , f ; ffiVM'i
9 (I3 Triceratops 9 C3 Presentation
|~" D C:\downloads\tncer; ^ n www.zoomschool c<
',-> ,*-'', * .. *
Hi >.
Figure 4.8: Editing a File
33
4.3.3 Merge Lessons
The Merge object begins by requiring the user to specify the filename under
which they wish to save the new merged file. The Save dialog window shown in Figure
4.6 opens and allows the user to enter an existing filename or select a new filename.
Once a filename has been chosen, a new Merge object is created (Figure 4.9). The
interface for this object is a dialog box with two simple functions. The first function is
the Add a File button which causes the Open dialog window shown in Figure 4.7 to
appear, allowing the user to select a file to add. The user may select the Add a File
button repeatedly to add any number of files. Once the Finish button is pressed, the
object is closed, the new file is saved as an XML file, and the user is returned to the
Main Menu.
^ M e r g i n g Lessons
Add a File
>.'^-
Finish (Save> • • ; . ' ; •
- A -"•*
Figure 4.9: Merge Menu 34
4.3.4 View Lesson
Once a lesson has been created and stored as an XML file, the View object, a Java
applet, allows a user to see the components of the lesson by processing the XML file.
This file may have been created using the previously described Java application or
possibly by hand, but it must conform to the Syllabus.dtd specifications previously
outlined in CHAPTER in. The algorithm for View Lesson is as follows:
Start View
Loop
Case user selects:
L : Load (string Filename)
0 : 0 K
H: Home
V : View (string Item)
N : Next (string Item)
B : Back (string Item)
Until (Exit invoked by user)
End View
The user begins by loading an HTML file which contains the applet, into a v/cb
browser, which will automatically start the applet. The user must firs* enter into the text
box the filename of the XML file they wish to view. Once the Load button is selected,
the file contents are parsed and used to create a tree, much like what was done with the
Edit object. The user must then make selections using the pull-down menus for Coarse,
Unit, Lesson, and Available Files. Once viewable material is specified by selecting a
35
path through the tree to a viewable leaf (presentations, practices, and performances) the
user is then able to select the View button, causing the item to be displayed in the lower
frame. Viewable items include local files, as shown in Figure 4.10, or URLs as shown in
Figure 4.11.
Navigation through the viewable material is simple. The user can use the Next
and Back buttons to load the material pertaining to the next and previous items,
respectively. The user may move directly to a desired leaf by selecting different material
using the pull-down menus and pressing the View button to load the selected item.
' 3 picluie - Miciosolt Internet Exploiei UMM P » gdt ifiev* Fjjyofies look tielp
Stop Rehesh Home i Seach Favoiitet Hotory Mail ftmt EcSl
i <#4
j ^j(fa»« | @ C \jbulde(2\inyclanes\picluie.htin " 3 «^8o li'-***'*!
Enter afite to toad.
c ^ibulder2\iriyclasses\dino.ianl Load
Matte 9 seteetion and Pren OtC
Cou«8 ^ Lfr»t /JJ/J^ l e t w n AvalafcfeRkstoView
I j _ ] | ~i. _ I t jtjp. _J IC \downloads\lriceratops__w«diai_;J
OK
VIEW NEXT
«]£><»» T i " i j } My'Computer
Figure 4.10: Viewing a local file
36
£i« t A ) ^ FaMMkat lock M«t>
l m?" |A(|ita»*J^ D\)>uidei2\iiiyclattes\picluta hlin
flaitV I - KM W «
^ttttflbtlaiMd
jc \|biJdei2\ir)yda»es\dno lonl load
"4
M«lu»aMl«eiian«nilRw>aK
3 1 1 vwm zooimchool com/siiiieclt/'dr^
u
ZOOM
lablcj i i Coatcnts
iDinnsaurs
DinD iNcws
Plmse visit ouf sponsor.
ZoomPittosaur i. com
j
Figure 4.11: Viewing a URL
37
CHAPTER V
IMPLEMENTATION ISSUES
5.1 Introduction
Several implementation issues arose during development. Some of these issues
stemmed from learning Java during development, while others were problems with the
Java interpreter itself (including a few documented bugs). Due to these issues, several
choices had to be made and these are highlighted below.
5.2 Java Related Issues
5.2.1 The Authoring Tool as a Java Application or Applet
The first important decision encountered was whether the authoring tool, which
implements the "Create", "Edit", and "Merge" objects, should be created as a Java
application or a Java applet. A Java application is a traditional program which requires a
Java interpreter. A Java applet is a segment of code that is downloaded and run locally
through a web browser.
We were forced to choose an application since applets are heavily restricted in
opening, creating, and saving files due to Internet security concerns.
5.2.2 File Filters
The next problem that arose with the authoring software was how to implement a
file filter. A file filter is an object that only allows files of a selected type, in this case
XML files, to be shown in Open File and Save File dialog windows.
38
The problem stenmied from the JDK Chooser class. This class implements Open
and Save dialog windows and if a duplicated filename is specified it asks the user if they
wish to replace the file that already exists. This particular class does not property
implement file filters, which is a bug documented on many Java discussion groups. A
possible solution to this was to use the new Swing 1.1 classes. Swing is a new set of
classes Sun Microsystems has released to allow easier GUI implementation. The Swing
version of the file filters work, but the object does not notify the user when a file already
exists when saving. This means a user must be careful about what filename they select
when saving since they can easily overwrite existing files without warning.
The solution chosen was to use the Swing 1.1 classes. It was decided it would be
more important to show a user which file type was needed (i.e., XML files), than to allow
the user to attempt to load any type of file into the authoring software for editing. The
trade-off to this choice is the user is not notified that a selected file is about to be replaced
by a new file if the filenames are the same.
5.2.3 Data Structure
Because XML is inherently a tree structure, it was determined the best approach
for reading, storing, and manipulating data would be to implement a tree data structure to
contain the data in a user created XML file.
Originally, a custom tree structure was considered. The decision to use Swing
classes for the file filters led to the decision to use a preexisting data structure. Th^
Swing classes have a tree structure already implemented in the JTree -:lass. Images of the
JTree can be seen on the right hand side of the windows in Figure 4.2 and Figure 4.8.
39
The decision to use the JTree was made because we determined writing a custom
tree data structure would be redundant. The JTree has a steep learning curve, but the use
of the tree made the implementation of the "Create", "Edit", and "View Lesson" object
quite easy. The JTree also has many nice extra features, for example, allowing selected
items to have their names directly edited, automatically expanding/collapsing the tree
when invoked by the user, and it has the look and fell of a typical Microsoft Windows
File Manager with which many users are already familiar.
5.2.4 Initiahzing the Current Node
This problem involved selecting the root, which is always Syllabus, as can be
seen in Figure 4.2 and Figure 4.3. Actions in Create and Edit depend on which node is
current or selected, i.e., highlighted (Figure 4.2). Thus, in Create and Edit, it would be
desirable to have the root initially selected so the user can begin entering data with out
being forced to first select the root node.
Unfortunately, the tree uses a listener to respond to selections a user may make
with the mouse. The listener is simply an object which determines when an element in
the tree is clicked and then invokes an appropriate action. A problem arises in the case of
the Create object when the only activated node in the tree is the root. If the root is
already selected, the listener will never be activated regardless of how many times the
root is clicked.
Since this problem is inherent in the design of the listener the Create and Edit
objects require the user to first select an item to begin. Obviously, in the case of editing
40
any element may be selected. However, when creating a new syllabus, the root must be
selected by the user to begin.
5.3 Java Applet Issues
5.3.1 Loading Files
Applets were designed to be pieces of code downloaded by a web browser from
the Internet and executed locally. Owing to this, many restrictions were placed on
applets for the sake of security. One of these restrictions pertains to the circumstances
under which an applet can open a file. The reason a user would not want software of
dubious origin downloaded from the Internet to have access to their local files is obvious,
but in our case we developed the software ourselves and needed the ability to access local
files referenced in the XML tutorial files. To get an applet to read a file requires a small
compromise.
The only files an applet is allowed to access are those which reside in the same
directory as the HTML file that launched the applet. This condition can be met locally if
the HTML file is local, or it can be accomplished by running the applet on a server and
bundling the necessary files in the same directory. If neither of these options is used, the
applet gives a Java security exception and the file will not load. A possible solution to
this is discussed in CHAPTER VII: Future Work.
However, it was beyond the scope of this work to write a server to control the
input file of the applet. We instead require the user to execute the "View Lesson" applet
locally and to place all necessary input files in the same directory as the applet's HTML
file.
41
5.3.2 Internet Explorer and Netscape
There are two inconsistencies with running the "View Lesson" applet in Internet
Explorer or Netscape. The first is that the applet does not repaint properly when another
window is opened over it and then closed. The buttons are still present on the applet, but
they will not be visible. Numerous repaint fixes were tried, but the applet will not refresh
properly.
The second problem with these two browsers is that Internet Explorer loads the
item the user wishes to view as expected and into the desired frame, which is located in
the bottom half of the window below the horizontal line shown in Figure 4.10 and Figure
4.11. Netscape, on the other hand, loads the item into an entirely new and different
browser window. Since this inconsistency only occurs in Netscape, it has been attributed
to the Netscape browser and we recommend using Internet Explorer until Netscape fixes
this bug.
42
CHAPTER VI
CONCLUSIONS
6.1 Showing Feasibihtv
The purpose of this work was to show the feasibility of using an open system
model in the development of course authoring tools. Since an open system is based on
protocols, we first developed an XML-based protocol as a template for a Syllabus. This
Syllabus is expressed as a Document Type Definition, or DTD, and tutorials adhering to
this protocol should also be created as XML documents.
We then showed the feasibility of such a protocol by developing a Java
application which allows the user to create, edit, merge, and store tutorials according to
the Syllabus format. A separate applet allows the user to view the finished tutorial using
a web browser.
The authoring application and the viewing applet both separate the engine* from
the content. The separation of the content from the engine allows our programs to adhere
to the open system model (as previously discussed). This idea is significant since anyone
can develop authoring or viewing tools for these tutorials as long as they have the DTD.
Our solution is also cross-platform because we used both Java and XML in the
development of our authoring application and viewing applet. This is extremely
important since as long as a potential user has one machine which runs the authoring
software and has a web browser, then they can create and view a tutorial.
43
Our solution is also cost effective since it uses an open system model. This can
be seen in many of the applications that have been developed for UNIX and the
availability of the source code which was used to create those applications.
As we have stated above, we met our goal of showing the feasibility of using an
open system model with a protocol for course authoring software. In addition, our
programs form a complete system for creating, editing, and storing tutorials. Beyond
this, they are also inexpensive, cross-platform, and provide a GUI to aid in ease of use.
44
CHAPTER Vn
FUTURE WORK
7.1 Introduction
Even though this work fulfills all of the requirements set forth in the Thesis
proposal, a few issues arose which should be given consideration in any future work
relating to this study. By considering the items addressed below, this work could be
extended to become a more complete study in the development of an open protocol
model for the delivery of educational material.
The items listed below are of interest for several reasons. The completion of the
usability study mentioned in section 7.2, would be required to verify the appropriateness
of this work in an actual educational setting. The completion of sections 7.3 through 7.7
is necessary in order for this work to be considered a production-quality model with
production quality features and reliability rather than simply a prototype.
7.2 Usability Study
A usability study aids in determining the actual effectiveness of a work in a real
setting. A study featuring educators using the tool we developed based on the open
protocols proposed in this work should be completed. In-service and pre-service tearher
feedback from such a study would provide valuable insights to improve the tool created
for this work.
45
7.3 User Interface Improvement
After the usability study mentioned above is completed, it would be advantageous
to look at ways to improve the user interface based on the input provided by the test
subjects. Many issues are involved in the development of a user interface: designs that
prohibit/promote learning and special considerations for education which help to improve
the overall effectiveness of an educational tool.
7.4 Creating a Student View Lesson
There are several aspects requiring further study in order to improve the View
Lesson object created as part of this work. The first item includes determining the best
approach to designing a View Lesson component for a student. The View Lesson object
we created is for use by an author to see how the components of the tutorial file they
created appear. However, it would be extremely easy to modify the existing source code
to allow the applet to read a data file containing the name of the lesson to open. It would
then be possible to limit the access provided to a student to the lesson named in the data
file, and Umit them to only the Back, View, and Next buttons provided in the applet
(Figure 4.10 and Figure 4.11). These restrictions would force a student to access the
tutorial sequentially as the instructor intended, rather than randomly as the curreii
software allows.
7.5 A Possible Alternative to the View Lesson
The second item relevant to the View Lesson object involves a possible
alternative to using Java applets that may cure some of the problems mentioned in section
46
5.3, which describes problems with loading data files and problems encountered with
Netscape. A programmer could use Common Gateway Interface (CGI) scripting and
XML style sheets to create a seamless view, one in which there would be no frames and
no obvious Java applet. This method would involve using CGI for the buttons to
navigate the course material. CGI should be investigated because the tool's buttons
would actually be embedded in the web page that is loaded, unlike a Java applet which
requires a frame context in which to run.
The XML stylesheet tells the web browser how to display a certain file, in this
case an XML file that conforms to the Syllabus.dtd document type definition. As of this
writing, the only web browser recognizing XML is Internet Explorer 5.0. The file listing
seen in Figure 7.1 is loaded into a text editor, this file represents the XML file created for
Figure 4.8, Figure 4.10, and Figure 4.11. The same file is shown in Figure 7.2 using the
default XML style sheet in Internet Explorer (IE). If the stylesheet were modified, it
would be possible to alter the look of the XML file, perhaps into a more useful
representation for the presentation, practice, and performance items a user may wish to
view, as opposed to loading them into a separate frame as they are currently done.
This method could help with the idea of using an open protocol, since the style
sheet could be changed to reflect any new items whenever changes to the document type
definition changed to accommodate new technological innovations.
47
M Dino - Notepad
lEte £ « "Search i i l p
<!DOCTVPE Syllabus SYSTEM "Syllabus.dtd"> <Syllabus> <Course> <nanie>Dlnosaurs</naine> <Unit> <naine>Plant Eaters</nanie> <Lesson> <nane>Triceratops</naiiie> <presentation>C:\downloads\triceratops_-_wirefi-ane.large</presentation> <presentation>www.zoomschool.con/subjects/dinosaurs/</presentation> </Lesson> </Unit> </Course> </Syllabus>
iammmm\mmtmmuutmui W!k ^ ^^ /^
"3
? n . •^/•' t
Figure 7.1: An XML file
3 C Aibuildei2\mycIasses\Dmo
g i p / * : ^ i> i3 IS ^ Jii # : > ^ % ^ ^ ^C'^^f Step Reiinh Horn Ssaich FavortM
ia?^
-««UA)MM^ • » * < MJ^-'^^xl
^ C \jbuldei2\mycldsse$\Dro xml ^ 6 o ' U * i * • . ^ < ^ f
<!DOCTYPE Syllabus fWew Source for fiilldoctYpe...)> • <Syllabus>
- <Course> <name>Dinosaurs</name>
- <Unit> <name>Plant Eaters</name>
- <Lesson> <name>Triceratops</name> <presentat ion>C: \downloads\ t r iceratops_-_wlrBframe. large</pre5entat ion> <prBsentat ion>v«iww.zoomschool .com/subjects /d inosaurs/< /presentat ion>
</Lesson> </Unit>
</Course> </'Syllabus>
"i r ,'3TSyC<wput«
S
^ i I
i *
^
Figure 7.2: XML file in IE 5.0 48
7.6 Scheme for Delivery of Material
Further investigation into the delivery of the content material is needed to allow
centralized distribution and easy access by educators. The idea of a centralized location
is important because it would create a known distribution center that could be accessed
by educators for help, content ideas, and possibly bundled content packages.
The first issue concerns the delivery of the material needed for execution. The
applet, application, and content material could be delivered via a server that is set up to
handle this kind of material. Such a server would solve some of the applet issues
discussed above, but would make distribution more complicated beca ise it necessitates a
system administrator.
The second consideration is the bundling of content material, the DTD used to
create the tutorial, and the XML file created for distribution. Possible methods include
using an index to keep track of the files or creating a database with the files inside.
Although the current project keeps track of where the presentation, practice, and
performance files are, it does not force the educator to use some predefined scheme for
itemizing files used in the lessons created. This implies that the tutorial creator has some
knowledge of where all the files are located.
7.7 Dynamic Structures
The last item suggested for future consideration is the addition of the ability of the
Java application and applet to dynamically read the document type definition. This
would allow the modification of the Syllabus.dtd file for future enhancements without
loss of functionality to the authoring tools. It may be this could be done rather easily
49
using a class similar to the IBM class for parsing XML files and incorporating the style
sheets mentioned above.
50
BIBLIOGRAPHY
[CI 85] Clark, R. E., (1985). Confounding in Educational Computing Research. Journal of Educational Computing Research. 1. 2. 137-147.
[CoDoKi 94] Coulouris, G., Dollimore, J., & Kindberg, T. (1994). Characterization of Distributed Systems. In A. D. McGettrick (Ed.), Distributed Systems Concepts and Design (pp. 1-28). Hariow, England: Addison-Wesley Publishing Company.
[DE 97] Department of Education National Center for Educational Statistics. (1997). National Assessment of Educational Progress. Washington, D.C.: Author.
[DE 98] Department of Education National Center for Educational Statistics. (1998). National Assessment of Educational Progress. Washington, D.C.: Author.
[DeHi 98] Decker, R., & Hirshfield, S. (1998). An Introduction to Programming Using Java. Boston, MA: PWS Publishing Company.
[EdHa 89] Edwards, D. M., & Hardman, L. (1989). 'Lost in Hyperspace': Cognitive Mapping and Navigation in a Hypertext Environment. Hypertext: theory into practice, 105-125.
[EDU 98] EDUCOM/NLII (1998) Instructional Management Systems Specifications Document [online] Available: http://www.imsproject.org.
[GaBrWa 88] Gagne, R., Briggs, L., & Wager, W. (1988). Principles of Instructional Design. Orlando, Florida: Holt, Rinehart, and Winston, Inc.
[ISOC 98] Leiner, B., Cerf, C , Clark, D., Kahn, R., Kleinrock, L., Lynch, D., Postel, J., Roberts, L., & Wolff, S., (1998) A Brief History of the Internet, [online] Available: http://www.isoc.org/intemet/history/brief.htm.
[Je 98] Jerald, C. D., (1998). By the Numbers. Education Week on the Web [On-Line]. Available: http://www.edweek.org/sreports/tc98/data/exsum.htm.
[KaGiLeSe 98] Kanel, J., Givler, J. S., Leiba, B., & Segmuller, W. (1998). Internet Messaging Frameworks. IBM Systems Journal 37,1, 4-18.
[LaOs 99] Lambert, K. A., & Osborne, M. (1999). Java: A Framework for Programming and Problem Solving. Pacific Grove, CA: Brooks/Cole Publishing Company.
51
[NkFrGa 98] Nkambou, R., Frasson, C , & Gauthier, G. (1998). A new approach to ITS-curriculum and course authoring: the authoring environment. Computers & Education, 31, 105-130.
[Po 82] Postel, J. (1982). Simple Mail Transport Protocol. (No. RFC 821). Information Sciences Institute, University of Southern California.
[So 98] Soloway, E. (1998). No One Is Making Money In Educational Software. Communications of the ACM, 41,2, 11-15.
[TiMiCh 98] Tittel, E., Mikula, N., & Chandak, R. (1998). XML for Dummies. Foster City, CA: IDG Books.
[Wh 99] The White House, Office of the Vice President. (1998). Information Technology for the Twenty-first Century: A Bold Investment in America's Future [online] Available: http://www.pub.whitehouse.gov/uri-res/I2R?um:pdi://oma.eop.gov.us/1999/l/25/12.text.l
52
APPENDDC A
GLOSSARY
1. Computer Aided Instruction (CAI) - the use of (personal) computers in education and
training.
2. Curriculum REpresentation and Acquisition Model (CREAM) - an instructional
design model based on creating instructional material for intelligent tutoring systems and
discussed in detail in Chapter II.
3. Engine - a program which performs a core or essential function for other programs.
An engine can be a central or focal program in an operating system, subsytem, or
application that coordinates the overall operation of a related set of programs. It is also
used to describe a special-purpose program containing an algorithm that can sometimes
be changed.
4. Event - an action which occurs in a program, in this work particularly mouse clicks.
5. Lesson - a series of sequential steps used to instruct a user.
6. Listener - an object which responds to certain events.
7. Markup - refers to the sequence of characters or other symbols inserted at certain
places in a text or word processing file to indicate how the file should look when it is
printed or displayed, or to describe the document's logical structure. The markup
indicators are often called "tags."
8. Multimedia - media which utilizes more than one concurrent presentation medium
(for example, on CD-ROM or a Web site). Although still images are a different medium
than text, multimedia is typically used to mean the combination of text, sound, and/or
motion video. 53
9. Nine Events of Instruction - Robert Gagne made a significant contribution when he
examined the internal learning processes proposed by cognitive learning theory and
developed a set of "external events" designers might incorporate in lessons to stimulate
the corresponding internal processes. This set of nine "Events of Instruction" aie:
motivation, objectives, prior knowledge, teach, guide, practice, feedback, test, and
transfer.
10. Open System - a system which adheres to a publicly-known and sometimes standard
set of interfaces so anyone using it can also use any other system that adheres to the
standard.
11. Package - a method of formally storing data in order to distribute it.
12. Proprietary System - a completely self contained system, in which all interfaces
work only on the specific machines for which the system was designed to run.
13. Protocol - a set of standardized rules to follow.
14. Syllabus - Used in this discussion, any single lesson or series of lessons that have an
instructional objective.
15. World Wide Web Consortium (W3C) - an industry consortium which seeks to
promote standards for the evolution of the Web and interoperability between WWW
products by producing specifications and reference software. Although W3C is funded by
industrial members, it is vendor-neutral and its products are freely available to all.
16. Wintel - a computer trade industry term for personal computers based on the Intel
microprocessor and one of the Windows operating systems from Microsoft. The term
"PC" has often been used for this purpose.
54
APPENDDC B
SAMPLE SOURCE CODE
//Title: Edit.java //Version: 1.0 //Created On: 06/08/99 //Copyright: Copyright (c) 1998 //Author: Billy Brooks York //Company: Texas Tech University //Description: This section of code allows for the editing of "Syllabus" // files that meet the specifications set in Syllabus.dtd
//package Thesis 1;
import java.awt.Color; import java.awt.Frame; import borland.jbcl.layout.XYLayout; import borland.jbcl.layout.XYConstraints; import j avax. swing. tree.DefaultMutableTreeNode; import javax.swing.tree.TreePath; import j avax. swing, tree .DefaultTreeModel; import javax.swing.tree.TreeSelectionModel; import javax.swing.tree.TreeNode; import j avax. swing. tree. MutableTreeNode; import javax.swing.event.TreeSelecfionListener; import javax.swing.event.TreeSelectionEvent; import java.awt.event.ActionEvent; import j ava. io. lOException; import java.io.OutputStream; import java.io.FileOutputStream; import java.io.PrintWriter; import java.io.FileReader; import java.io.BufferedReader; import javax.swing.JDialog; import javax.swing.JPanel; import javax.swing.JLabel; import javax.swing.JFileChooser; import com. inprise.jbcl.control.ButtonControl; import com.inprise.jbcl.control.LabelControl; import com.inprise.jbcl.control.TextFieldControl;
public class Edit extends JDialog { JPanel panel 1 = new JPanel(); XYLayout xYLayoutl = new XYLayout(); //This is the tree stuff. //"root" is the root of the tree and it is always "Syllabus" //the "treeModel" is default because that is all that is needed. protected DefaultMutableTreeNode root = new DefaultMutableTreeNode("Syllabus"); protected DefauItTreeModel treeModel = new DefaultTreeModel(root); protected javax.swing.JTree tree = new javax.swing.JTree(treeModel); javax.swing.JScroUPane jScroUPanel = new j avax. s wing. JScrollPane(tree); javax.swing.JPanel jPanell = new javax.swing.JPanelQ; XYLayout xYLayout2 = new XYLayout();
//Design Items
55
// XYLayout xYLayoutl = new XYLayout(); public ButtonControl bttnChild = new ButtonControl(); public ButtonControl present = new ButtonControl(); public ButtonControl pract = new ButtonControl(); public ButtonControl perform = new ButtonControl(); public ButtonControl bttnFinish = new ButtonControl(); public ButtonControl bttnRemove = new ButtonControl(); public LabelControl label 1 = new LabelControl(); public LabelControl labelControU = new LabelControl(); public LabelControl Ibll = new LabelControl(); public JLabel j Label 1 = new JLabel(); public TextFieldControl textl = new TextFieldControl();
//These are variables //"Current_State" is used to determine where the user is. //"newNodeSuffix" is used when no name is provided for a node. //"remove" is used when a node is removed to ensure that the // Listener does not crash. //"UnitTest" is used when a user enters a Unit Test (there can only be one). public String Current_State="start"; public String Selection; public int newNodeSuffix =1; public boolean remove=false; public boolean UnitTest=false;
//The Swing choosers (for files) JFileChooser jchooser = new JFileChooser(); JFileChooser selector = new JFileChooser();
//The Selection Listener that has given me so much trouble. TreeSelectionListener Listener2;
public Edit(Frame frame, String title, boolean modal) { super(frame, title, modal); try { jblnitQ; MakeltO; DoListenerO;
}//end try
catch (Exception ex) { ex.printStackTraceO;
}//end catch packO;
}//end public edit
public Edit() { this(null,"", false);
}
void jblnitO throws Exception {
panel 1. setLayout(x YLayout 1); X YLayout 1. setHeight(480); xYLayoutl .setWidth(640); getContentPaneO. add(panel 1);
56
//getContentPane().setLayout(xYLayoutl); // getContentPane().setSize(new Dimension(640,480)); panell.add(bttnRemove, new XYConstraints(155, 102, 149, 46)); panel l.add(bttnChild, new XYConstraints(8, 102, 149,46)); panell.add(labell, new XYConsti-aints(39, 14, 281, 30)); panell.add(textl, new XYConstraints(44,43, 204, 43)); panell.add(lbll, new XYConstraints(44,9, 203, 32)); panell.add(jLabell, new XYConstraints(17, 252, 221, 24)); panell.add(pract, new XYConstraints(107, 192, 93, 34)); panell.add(present, new XYConstraints(15, 192, 93, 34)); panell.add(perform, new XYConstraints(200, 192, 93, 34)); panell.add(i5ttnFinish, new XYConstraints(20, 350, 257,43)); panell.add(labelControll, new XYConstraints(17, 234, -1, -1));
jLabell.setText("NO ITEM SELECTED"); labelControll .setText("Item Selected"); lbll.setText("labelContioll");
//Set the Buttons to work present. setEnabled(false); present. setLabel (" Presentation"); present.setToolTipText("Insert a presentation section"); present.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) { present_actionPerformed(e);
} });
pract. setEnabled( false); pract.setLabel("Practice"); pract.setToolTipText("Insert a practice section"); pract.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) { pract_actionPerformed(e);
} });
bttnRemove.setLabel("Remove"); bttnRemove.setToolTipText("Remove selected node and all children."); bttnRemove.addActionListener(newjava.awt.event.ActionListener() {
public void actionPerfonned(ActionEvent e) { bttnRemove_actionPerformed(e);
} });
bttnFinish.setBackground(new Color(0, 0,205)); bttnFinish.setForeground(Color.white); bttnFinish.setLabel("Finish"); bttnFinish.setToolTipText("Save the file and reUim to the main screen"); bttnFinish.addActionListener(newjava.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) { bttnFinish_actionPerformed(e);
} });
perform. setEnabled(false); perform. setLabel(" Performance"); perform.setToolTipText("Insert a performance section"); perform.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
57
perform_actionPerformed(e); }
});
bttnChild.setLabel("Add"); bttnChild.setToolTipText("Add a child item to the selected item"); bttnChild.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) { bttnChild_actionPerformed(e);
} });
//Set the tree up. tree. setShowsRootHandles(true); tree. setEditable(tiiie); ti-ee. setForeground(Color.black); tree.getSelectionModel().setSelectionMode
(TreeSelectionModel.SINGLE_TREE_SELECTION); tree.putClientProperty("JTree.lineStyle","Angled"); jPanel 1 .setLayout(xYLayout2); panell.add(jPanell, new XYConstraints(357, 8, 254, 426)); jPanell.add(jScrollPanel, new XYConstraints(0, 1, 253,423)); jScrollPanel .getViewport().add(tree, null);
}// end JBINIT
//Makelt takes in a file and parses it. It then takes all of the nodes and //places them into the tree, public void Makelt() { JFileChooser jchooser = new JFileChooser(); jchooser.setMultiSelectionEnabled(false); Stiing[] files = new String[] {"xml"}; jchooser.addChoosableFileFilter(newSimpleFileFilter(files,"XMLFiles(*.xml)")); String filename=null;
FileReader theFile; BufferedReader fileln=null; String oneLine; String Currentltem=null;
String Item=null; int Stringl^ngth=0;
//Need to keep track of these items int NumofPresentations=0; int NumofPractices=0; int NumofPerformances=0;
//These nodes are used to determine where to insert nodes DefaultMutableTreeNode currentParent=root; DefaultMutableTreeNode UnitParent=root; DefaultMutableTreeNode LessonParent=root; DefaultMutableTreeNode presentationParent=null; DefaultMutableTreeNode practiceParent=null; DefaultMutableTreeNode performanceParent=null; DefaultMutableTreeNode InsertMe=null;
int option =jchooser.showOpenDialog(this);
58
if(option==JFileChooser.APPROVE_OPTION) { if(jchooser.getSelectedFile()!=null) { filename=jchooser.getSelectedFile().getAbsolutePath(); if (!filename.endsWith(".xml"))
filename=filename + ".xml"; //System.out.println(filename); }//end jchooser.getSelectedFileO !=null try { theFile=new FileReader(filename); fileln= new BufferedReader(theFile);
while ((oneLine = fileIn.readLine())!=null) { if(oneLine.equals("<Course>"))
Currentltem=" Course"; else if (oneLine.startsWith("<Unit>"))
CurrentItem="Unit"; else if (oneLine.startsWith("<Lesson>"))
CurrentItem="Lesson"; else if (oneLine.startsWith("<presentation>")) { NumofPractices=0; NumofPerformances=0; if (NumofPresentations==0) { InsertMe = new DefaultMutableTreeNode("Presentation"); treeModel.insertNodeInto(InsertMe, presentationParent,presentationParent.getChildCount()); presentationParent = (DefaultMutableTreeNode) (InsertMe); tree.scrollPathToVisible(newTreePath(InsertMe.getPath()));
}//end if NumofPresentations==0 S tringLength=oneLine. length(); Item=oneLine. substring( 14,StringLength-15); //System.out.print("Found a name "); //System.out.printin(Item); InsertMe = new DefaultMutableTreeNode(Item); treeModel.insertNodeInto(InsertMe, presentationParent,presentationParent.getChildCount()); tree.scrollPathToVisible(newTreePath(InsertMe.getPath())); NumofPresentations++;
}//end else if presentation
else if (oneLine.startsWith("<practice>")) { NumofPresentations=0; NumofPerformances=0; if (NumofPractices==0) { InsertMe = new DefaultMutableTreeNode("Practice"); treeModel.insertNodeInto(InsertMe, practiceParent,practiceParent.getChildCount()); practiceParent = (DefaultMutableTreeNode) (InsertMe); tree.scrollPathToVisible(newTreePath(InsertMe.getPath()));
}//end if NumofPractices==0 S tiingLength=oneLine. length(); Item=oneLine. substring( 10, S tringLength- II); //System.out.print("Found a name"); //System.out.printin(Item); InsertMe = new DefaultMutableTreeNode(Item); treeModeI.insertNodeInto(InsertMe, practiceParent,practiceParent.getChildCount()); tree.scrollPathToVisible(newTreePath(InsertMe.getPath()));
59
NumofPractices++; }//end else if practice
else if (oneLine.startsWith("<performance>")) { NumofPresentations=0; NumofPractices=0; if (NumofPerformances==0) { InsertMe = new DefaultMutableTreeNode("Performance"); treeModel.insertNodeInto(InsertMe, performanceParent,performanceParent.getChildCount()); performanceParent = (DefaultMutableTreeNode) (InsertMe); tree.scrollPathToVisible(newTreePath(InsertMe.getPath()));
}//end if NumofPerformances==0 StringLength=oneLine .lengthO; Item=oneLine.substring(13,StringLength-14); //System.out.print("Found a name "); //System.out.println(Item); InsertMe = new DefaultMutableTreeNode(Item); treeModel.insertNodeInto(InsertMe, performanceParent,performanceParent.getChildCount()); tree.scrollPathToVisible(newTreePath(InsertMe.getPath())); NumofPerformances++;
}//end else if performance
else if (oneLine.startsWith("<name>")) { StringLength=oneLine.length(); Item=oneLine.substring(6,StringLength-7); //System.out.print("Found a name "); //System.out.println(Item);
if (CurrentItem=="Course") { tree. setSelectionRow(O); TreePath parentPath = tree.getSelectionPath(); currentParent = (DefaultMutableTreeNode)(parentPath.getLastPathComponent()); InsertMe = new DefaultMutableTreeNode(Item); treeModel.insertNodeInto(InsertMe, currentParent,currentParent.getChildCount()); UnitParent = (DefaultMutableTreeNode) (InsertMe); treeModel.reloadO;
}//end if CurrentItem==Course
else if (CurrentItem=="Unit")
{ InsertMe = new DefaultMutableTreeNode(Item); treeModel.insertNodeInto(InsertMe, UnitParent,UnitParent.getChildCount()); tree.scrollPathToVisible(newTreePath(InsertMe.getPath())); LessonParent = (DefaultMutableTreeNode) (InsertMe); performanceParent = (DefaultMutableTreeNode) (InsertMe); treeModel.reloadO;
}//end else if CurrentItem==Unit
else if (CurrentItem=="Lesson")
{ InsertMe = new DefaultMutableTreeNode(Item); treeModel.insertNodeInto(InsertMe, LessonParent,LessonParent.getChildCount()); tree.scroIlPathToVisible(newTreePath(InsertMe.getPath())); NumofPresentations=0; NumofPractices=0; NumofPerformances=0; presentationParent = (DefaultMutableTreeNode) (InsertMe);
60
practiceParent = (DefaultMutableTreeNode) (InsertMe); performanceParent = (DefaultMutableTreeNode) (InsertMe); treeModel.reloadO;
}//end else if CurrentItem==Unit }// end oneline Starts with name System.out.printin(oneLine);
}//end while((oneLine = fileIn.readLine())!=null) theFile.closeO;
}//end try catch (lOException x) { System.out.println("Error Opening!!");
} }// end if(option==JFileChooser.APPROVE_OPTION) else
this.disposeO; }//end MakelT
private void DoListenerO { tree.addTreeSelectionListener(newListener2());
}//end DoListener
void bttnChild_actionPerformed(ActionEvent e) { if (Current_State=="start") { labell.setText("Please make a selection from the tree.");
}//end if Current_State=="start"
else if (Current_State=="root") { DefaultMutableTreeNode parentNode=null; TreePath parentPath = tree.getSelectionPath(); Object child=null; Object compare=""; String text=null; text=text 1. getTextO;
if (text.equals(compare)) addObject("New Node" + newNodeSuffix++);
else addObject(textI .getTextO);
textI.setText(""); }//end else if Current_State=="root"
else if (Current_State=="Course") { DefaultMutableTreeNode parentNode=null; TreePath parentPath = tree.getSelectionPath(); Object child=null; Object compare=""; String text=null; text=textl .getTextO;
if (text.equals(compare)) addObject("New Node" + newNodeSuffix++);
else addObject(textl .getTextO);
61
textl.setText(""); } //end else if Current_State=="Course"
else if (Current_State=="Unit") { DefaultMutableTreeNode parentNode=null; TreePath parentPath = tree.getSelectionPath(); Object child=null; Object compare=""; String text=null; text=textl.getTextO;
if (text.equals(compare)) addObject("New Node" + newNodeSuffix++);
else addObject(textI .getTextO);
textl.setText(""); } //end else if Current_State=="Unit"
else if (Current_State=="ThreeP") { boolean childExists = CheckPerformanceChild();
if (childExists==true) { labell.setText("There can only be ONE Unit Test!");
} else { DefaultMutableTreeNode parentNode=null; TreePath parentPath = tree.getSelectionPath(); Object child=null; Object compare=""; String text=null; selector.setMultiSelectionEnabled(false); text=text 1. getTextO;
if (text.equals(compare)) { int option = selector.showDialog(this,"Add"); if(option==JFileChooser.APPROVE_OPTION) { if(selector.getSelectedFile()!=null)
{ child=selector.getSelectedFile().getAbsolutePath(); addObject(child);
}//end if !=null }//end if APPROVE
}//end equals compare else { addObject(textl .getTextO); textl.setText("");
}//end else }//end else ChildExists
}//end else if Current_State=="ThreeP" }//end bttnChild
void bttnRemove_actionPerformed(ActionEvent e)
{
62
remo veCurrentNodeO; }// end bttnRemove
void present_actionPerformed(ActionEvent e) { DefaultMutableTreeNode parentNode=null; TreePath pai-entPath = tree.getSelectionPath();
if (parentPath==null) { parentNode=root;
} else { parentNode = (DefaultMutableTreeNode)(parentPath.getLastPathComponent());
}
Object child; child="Presentation"; DefaultMutableTreeNode childNode = new DefaultMutableTreeNode(child);
//insert the node treeModel.insertNodeInto(childNode,parentNode,parentNode.getChildCount()); //set the new node to be visible tree.scrollPathToVisible(newTreePath(childNode.getPath())); textl.setText("");
}//end present_actionPerformed
void pract_actionPerformed(ActionEvent e) { DefaultMutableTreeNode parentNode=null; TreePath parentPath = tree.getSelectionPath();
if (parentPath==null) { parentNode=root;
} else { parentNode = (DefaultMutableTreeNode)(parentPath.getLastPathComponent());
} Object child; child="Practice"; DefaultMutableTreeNode childNode = new DefaultMutableTreeNode(child);
//insert the node treeModel.insertNodeInto(childNode,parentNode,parentNode.getChildCount()); //set the new node to be visible tree.scrollPathToVisible(new TreePath(childNode.getPath())); textl.setText("");
}//end pract_actionPerformed
void perform_actionPerformed(ActionEvent e)
{ //System.out.printin(Current_State); boolean check=CheckThis(); int SelectedChildren=0; TreePath parentPath = tree.getSelectionPath(); DefaultMutableTreeNode SelectedParent=null; SelectedParent = (DefaultMutableTreeNode)(parentPath.getLastPathComponent()); SelectedChildren=SelectedParent.getChildCount();
63
//System.out.printin(check);
if (check==true) { labell.setText("Performance can only be added once here!");
}//end if check==true else { DefaultMutableTreeNode parentNode=null; if (parentPath==null) { parentNode=root;
} else { parentNode = (DefaultMutableTreeNode)(parentPath.getLastPathComponent());
} Object child; child="Performance"; DefaultMutableTreeNode childNode = new DefaultMutableTreeNode(child);
//insert the node treeModel.insertNodeInto(childNode,parentNode,parentNode.getChildCount()); //set the new node to be visible tree.scrollPathToVisible(newTreePath(childNode.getPath())); textl.setText(""); check=true;
}//end else check==true }//end perform action_Performed
void bttnFinish_actionPerformed(ActionEvent e) { //This is essentially a big for loop, which fraveses the tree //and outputs the correct information to the file.
int a=0; int b=0; int c=0; int d=0; int f=0;
int rootNumChildren=0; int courseNumChildren=0; int unitNumChildren=0; int lessonNumChildren=0; int presNumChildren=0;
String rootChild=null; String text=null; String filename=null;
TreeNode courseNode=null; TreeNode unitNode=null; TreeNode lessonNode=null; TreeNode presentationNode=null;
String[] files = new String[]{"xml"}; jchooser.setMultiSelectionEnabled(false); jchooser.addChoosableFileFilter(newSimpleFileFilter(files,"XMLFiles(*.xml)"));
64
String CheckForTest=null; boolean finishedTest=false;
int option =jchooser.showSaveDialog(this);
if(option==JFileChooser.APPROVE_OPTION) { if(jchooser.getSelectedFile()!=null) { filename=jchooser.getSelectedFile().getAbsolutePath(); if (!filename.endsWith(".xml"))
filename=filename + ".xml";
fry { OutputStream fileout = new FileOutputStream(filename); Print Writer output = new PrintWriter(fileout);
rootNumChildren=root.getChildCount(); System.out.println("<!DOCTYPE Syllabus SYSTEM \"Syllabus.dtd\">"); output.prinan("<!DOCTYPE Syllabus SYSTEM \"Syllabus.dtd\">"); output.flushO; System.out.println("<Syllabus>"); output.println("<Syllabus>"); output.flushO;
for(a=0;a<rootNumChildren;a++) { System.out.println("<Course>"); output.println(" <Course>"); output.flushO;
System.out.print("<name>"); output.print(" <name>"); output.flushO; System.out.print(root.getChildAt(a).toString()); output.print(root.getChildAt(a).toString()); output.flushO; System.out.println("</name>"); output.printin("</name>"); output.flushO;
courseNode=root.getChildAt(a); courseNumChildren=courseNode.getChildCount(); if (courseNumChildren==0)
{ System.out.printin("</Course>"); output.printin("</Course>"); output.flushO;
}//end if courseNumChildren==0
for (b=0;b<courseNumChildren;b++)
{ System.out.printin("<Unit>"); output.println("<Unit>"); output.flushO; System.out.print("<name>"); output.print("<name>"); output.flushO; System.out.print(courseNode.getChildAt(b).toString()); output.print(courseNode.getChildAt(b).toString());
65
output.flushO; System.out.println("</name>"); output.println("</name>"); output.flushO;
unitNode=courseNode.getChildAt(b); unitNumChildren=unitNode.getChildCount(); if (unitNumChildren==0) { System.out.println("</Unit>"); output.println("</Unit>"); output.flushO;
}//end if unitNumChildren==0
for (c=0;c<unitNumChildren;c++) { CheckForTest=unitNode.getChildAt(c).toString();
if (CheckForTest=="Performance") { System.out.print("<performance>"); output.print("<performance>"); output.flushO; lessonNode=unitNode.getChildAt(c); System.out.print(lessonNode.getChildAt(0).toString()); output.print(lessonNode.getChildAt(0).toString()); output.flushO; System.out.println("</performance>"); output.println("</performance>"); output.flushO; finishedTest=true;
}//end if CheckForTest=="Performance" else { System.out.println("<Lesson>"); output.println("<Lesson>"); output.flushO; System, out. print(" <name>"); output.print(" <name>"); output.flushO; System.out.print(unitNode.getChildAt(c).toString()); output.print(unitNode.getChildAt(c).toString()); output.flushO; System.out.println("</name>"); output.println("</name>"); output.flushO;
}//end else if CheckForTest=="Performance"
lessonNode=unitNode.getChildAt(c); lessonNumChildren=lessonNode.getChildCount(); if ((lessonNumChildren==0) && (finishedTest==false)) { System.out.println("</Lesson>"); output.println("</Lesson>"); output.flushO;
} //end if ((lessonNumChildren==0) && (finishedTest==false))
for(d=0;d<lessonNumChildren;d++) { if(lessonNode.getChildAt(d).toStiing()=="Presentation") {
66
presentationNode=lessonNode.getChildAt(d); presNumChildren=presentationNode.getChildCount();
for (f=0;f<presNumChildren;f++) { System.out.print("<presentation>"); output.print(" <presentation>"); output.flushO; System.out.print(presentationNode.getChildAt(f).toString()); output.print(presentationNode.getChildAt(f).toString()); output.flushO; System.out.println("</presentation>"); output.printin("</presentation>"); output.flushO;
}//end f=0
if (presNumChildren==0) { System.out.println("</Lesson>"); output.printin("</Lesson>"); output.flushO; System.out.println("</Unit>"); output.println("</Unit>"); output.flushO; System.out.printin("</Course>"); output.println("</Course>"); output.flushO;
}//end if presNumChildren==0 }//end if Presentation
else if (lessonNode.getChildAt(d).toStringO=="Practice") { presentationNode=lessonNode.getChildAt(d); presNumChildren=presentationNode.getChildCount();
for (f=0;f<presNumChildren;f++) { System, out .print(" <practice>"); output.print( "<practice>"); output.flushO; System.out.print(presentationNode.getChildAt(f).toString()); output.print(presentationNode.getChildAt(f)toString()); output.flushO; System.out.printin("</practice>"); output.println("</practice>"); output.flushO;
}//end f=0
if (presNumChildren==0) { System.out.println("</Lesson>"); output.println("</Lesson>"); output.flushO; System.out.printin("</Unit>"); output.printin("</Unit>"); output.flushO; System.out.printin("</Course>"); output.println("</Course>"); output.flushO;
}//end if presNumChildren==0 }//end else if Practice
67
elseif(lessonNode.getChildAt(d).toString()=="Performance") { presentationNode=lessonNode.getChildAt(d); presNumChildren=presentationNode.getChildCount();
for (f=0;f<presNumChildren;f++) { System.out.print("<performance>"); output.print("<performance>"); output.flushO; System.out.print(presentationNode.getChildAt(f)toString()); output.print(presentationNode.getChildAt(f)toString()); output.flushO; System.out.println("</performance>"); output.println("</performance>"); output.flushO;
}//end f=0
if (presNumChildren-=0) { System.out.println("</Lesson>"); output.println("</Lesson>"); output.flushO; System.out.println("</Unit>"); output.println("</Unit>"); output.flushO; System.out.println("</Course>"); output.println("</Course>"); output.flushO;
}//end if presNumChildren==0 }//end else if performance
if ((d==lessonNumChildren-1 )&&(finishedTest==false))
{ System.out.println("</I^sson>"); output.println("</Lesson>"); outputflushO;
}//end if ((d==lessonNumChildren-l)&&(finishedTest==false)) }//end for d=0
if (c==unitNumChildren-1)
{ System.out.println("</Unit>"); output.println("</Unit>"); output.flushO;
}//end if (c==unitNumChildren-l) finishedTest=false;
}//end for c=0 if (b==courseNumChildren-l) { System.out.println("</Course>"); output.println("</Course>"); output.flushO;
}//end if (b==courseNumChildren-l) }// end for b=0
}//end for a=0 System.out.println("</Syllabus>"); output.println("</Syllabus>"); output.flushO; output.closeO;
68
}//end try
catch (lOException x) { System.out.printin("Error Saving!!");
} }//end if !null else { labelI.setText("PLEASE ENTER A FILENAME!!"); jLabell.setText("PLEASE ENTER A FILENAME!!");
} }//end if APPROVE OPTION
}// end bttnFinish
//This code is currently NOT used, but clears all nodes public void clear() { root.removeAUChildrenO; treeModel.reloadO;
}// end clear
/** Remove the currently selected node. */ public void removeCurrentNode() { TreePath currentSelection = tree.getSelectionPadi(); String blah=null; if (currentSelection != null) { DefaultMutableTreeNode currentNode = (DefaultMutableTreeNode)(currentSelection.getLastPathComponent()); MutableTreeNode parent = (MutableTreeNode)(currentNode.getParent()); //System.out.println(parent); if (parent != null) { fry
{ //System, out. println(parent); //System. out.println(currentNode); currentNode. setParent(parent); remove=true; treeModel.removeNodeFromParent(currentNode); remove=false; tree.addSelectionRow(O);
}//end try
catch(NullPointerException exc) { System.out.printin("ERROR!");
}//end catch return;
}//end if parent !=null }//end if currentSelection !=null
}//end removeCurrentNode
/** Add child to the currentiy selected node. */ public DefaultMutableTreeNode addObject(Object child) { DefaultMutableTreeNode parentNode = null; TreePath parentPath = tree.getSelectionPath();
if (parentPath == null)
69
parentNode = root; else
parentNode = (DefaultMutableTreeNode)(parentPath.getLastPathComponent());
return addObject(parentNode, child, true); }//end addObject
public DefaultMutableTreeNode addObject(DefaultMutableTreeNode parent,Object child) { return addObject(parent, child, false);
}// end addObject
public DefaultMutableTreeNode addObject(DefaultMutableTreeNode parent,Object child,boolean shouldBeVisible) { DefaultMutableTreeNode childNode = new DefaultMutableTreeNode(child); if (parent == null)
parent = root;
treeModel.insertNodeInto(childNode, parent,parent.getChildCount());
// Make sure the user can see the new node, if (shouldBeVisible)
tree.scrollPathToVisible(newTreePath(childNode.getPath()));
return childNode; }//end addObject
class Listener2 implements TreeSelectionListener! public void valueChanged(TreeSelectionEvent tse){
if (remove==true)
{ remove=false; //System.out.println("Hey I am removing!");
} else
//System.out.println("Hey I am NOT removing!"); TreePath tp= tse.getNewLeadSelectionPath(); int count=tp.getPathCount(); boolean LessonPresentation; boolean AddedUnitTest=CheckThis(); boolean AddedTestinfo=CheckForTest(); LessonPresentation=CheckLesson(tp); int SelectedChildren=0; //System.out.printin(AddedUnitTest); if (LessonPresentation==true)
{ count=5;
// CreateLesson.UnitTest=true; UnitTest=true;
} else
UnitTest=true; //CreateLesson.UnitTest=false;
switch(count) { case 1:
textl .setEnabled(true); UnitTest=false;
70
tree.setEditable(false); Current_State="root"; textl.setText(""); labelI.setText("Please Enter a Course Name"); present. setEnabled(false); pract. setEnabled(false); perform.setEnabled(false); bttnChild. setEnabled(true); break;
case 2: textl .setEnabled(true); UnitTest=false; tree. setEditable(true); Current_State="Course"; textl.setText(""); labell.setText("Please Enter a Unit Name"); present. setEnabled(false); pract. setEnabled( false); perform. setEnabled(false); bttiiChild. setEnabled(true); break;
case 3: text 1. setEnabled(true); UnitTest=false; tree. setEditable(true); Current_State="Unit"; textl.setText(""); labell.setText("Please Enter a Lesson Name or a Unit Test"); present.setEnabled(false); pract. setEnabled(false); DefaultMutableTreeNode SelectedParent=null; SelectedParent = (DefaultMutableTreeNode)(tp.getLastPathComponent()); SelectedChildren=SelectedParent.getChildCount();
if (SelectedChildren==0) perform. setEnabled(true);
int i = 0; for(i=0;i<SelectedChildren;i++)
{ if(SelectedParent.getChildAt(i).toString()=="Performance")
{ perform.setEnabled(false); tree.setEditable(false); break;
} else perform. setEnabled(true);
}//end for bttnChild. setEnabled(true); break;
case 4: textl .setEnabled( true); UnitTest=false; tree. setEditable(true); Current_State="Lesson"; textl.setText(""); labell.setText("Please Make a Selection");
71
present.setEnabled(true); pract. setEnabled(true); perform. setEnabled(true); bttnChild. setEnabled(false); break;
case 5: UnitTest=false; Current_State="ThreeP"; textl.setText(""); Iabell.setText("Please Enter a Complete File Name or URL"); if (AddedTestinfo!=true) { textl .setEnabled(tiaie); free.setEditable(false); present. setEnabled(false); pract. setEnabled(false); perform. setEnabled(false); bttaChild.setEnabled(true);
} else { text 1. setEnabled(false); tree. setEditable(true); present. setEnabled(false); pract. setEnabled(false); perform. setEnabled(false); btmChild. setEnabled(false);
} break;
case 6: text 1. setEnabled(tme); UnitTest=false; tree. setEditable(true); Current_State="END"; textI.setText(""); labell.setText("You Cannot Add Anything Here!"); present. setEnabled(false); pract. setEnabled(false); perform. setEnabled(false); bttnChild.setEnabled(false); break;
default: System.out.println("IN DEFUALT"); break;
}// end switch
//System.out.printin(count); jLabell.setText("Selected: " + tp.getLastPathComponentO); //Selection=tp. toS tringO; //System.out.printin(Selection); remove=false;
}//end else remove==true }//end valueChanged(TreeSelectionEvent tse)
}//end class Listener2 implements TreeSelectionListener!
public boolean CheckThis() { int SelectedChildren=0;
72
TreePath parentPath = tree.getSelectionPath(); DefaultMutableTreeNode SelectedParent=null; SelectedParent = (DefaultMutableTreeNode)(parentPath.getLastPathComponent()); SelectedChildren=SelectedParent.getChildCount(); int level=0; level=parentPath.getPathCount(); if ((level==3) && (SelectedChildren>0)) { //System.out.println(Current_State); int i = 0; for(i=0;i<SelectedChildren;i++) { if(SelectedParent.getChildAt(i).toString()=="Performance")
return true; }//end for
}//end if return false;
}//end checkthis
public boolean CheckPerformanceChild()
{ int SelectedChildren=0; TreePath parentPath = tree.getSelectionPath(); DefaultMutableTreeNode SelectedParent=null; SelectedParent = (DefaultMutableTreeNode)(parentPath.getLastPathComponent()); SelectedChildren=SelectedParent.getChildCount(); int level=0; level=parentPath.getPathCount(); if ((level==4) && (SelectedCliildren>0))
return true; return false;
} //end CheckPerformanceChild
public boolean CheckForTest()
I int SelectedChildren=0; TreePath parentPath = tree.getSelectionPath(); DefaultMutableTreeNode SelectedParent=null; TreeNode parent=null; SelectedParent = (DefaultMutableTreeNode)(parentPath.getLastPathComponent()); String info=null; int level=0; level=parentPath.getPathCount(); //System.out.print("Level is"); //System.out.prinfln(level); if(level==l)
info=SelectedParent.toString();
else
parent=SelectedParent.getParent(); info=parent.toString();
} //System.out.printin(info); if ((level==5) && (info=="Performance"))
return true; return false;
}//end CheckForTest
public boolean CheckLesson(TreePath tp)
{ int SelectedChildren=0;
73
//System.out.prinfln(Current_State); DefaultMutableTreeNode currentNode = (DefaultMutableTreeNode)(tp.getLastPathComponent()); int level=0; level=tp.getPathCount(); String stringOne=currentNode.toString(); if ((level==4) && (stringOne=="Performance")) return true;
return false; }//end CheckLesson
}//end EDIT
74
PERMISSION TO COPY
In presenting this thesis in partial fulfillment of the requirements for a
master's degree at Texas Tech University or Texas Tech University Health Sciences
Center, I agree that the Library and my major department shall make it freely
available for research purposes. Permission to copy this thesis for scholarly
purposes may be granted by the Director of the Library or my major professor.
It is understood that any copying or publication of this thesis for financial gain
shall not be allowed without my further written permission and that any user
may be liable for copyright infringement.
Agree (Permission is granted.)
Sttident's Signature (/ Date
Disagree (Permission is not granted.)
Student's Signature Date