Overview

In my entire career here at Earlham, I've never written what you could call a "large" application; one where the entire program would not logically fit in a single source file. So, after talking to Charlie, I have decided to trash the Serial Communication thing, and go for building a WYSIWYG (What You See Is What You Get) HTML editor instead. I figured that I wanted to build something that would teach me about the issues involved, as well as being something useful. Since the web is becoming increasingly more important in our day to day lives, I figured that yet another HTML editor is something that we all needed (especially since I haven't found one that I REALLY like).

Requirements

When I first started thinking about this project, I knew I wanted to build something that had a similar functionality and interface to Microsoft's FrontPage Editor. I have used several other WYSIWYG editors before, and FrontPage was the most intuitive and had the cleanest interface of any of the other editors (unlike most of the rest of Microsoft's software). However, one of the biggest problems I've found with FrontPage is its intimate marriage with existing Microsoft software. For instance, the extensions that come with FrontPage (timestamps, page includes, etc) will only work with Microsoft's Personal Web Server or Information Server. My problem comes when I'm not using any of those web servers. Mozart will have very similar look and feel to FrontPage, but none of its proprietary nature. The user will be able to configure the editor to use any web server's capabilities (Apache's Server Side Includes, etc). In addition, I am going to be building Mozart in Java, making the program usable on many different platforms.

Functional Specification

It should be noted that these features are listed in order of implementation. That means that I will implement them in the order that they are listed here. I wanted to get the most important features added first, and work toward the "fluff" later.

WYSIGYG
Functionally, Mozart is going to be an HTML editor, with some significant improvements over earlier editors. The most important improvement is its interface. Mozart is an editor which will let the user edit his web page directly and not the source code. This will let the user see the formatting of images and paragraphs. However, if the user wants to, Mozart will also let the user view and edit HTML directly.

Popup Menus
One of the powerful features of the WYSIWYG interface is the "Popup Menu." This menu will give the user access to functions that have to do with what the mouse was clicked over. For instance, if the user clicked on an image that was in a table, the menu would contain "Page Properties," "Table Properties," "Cell Properties," "Image Properties." This context sensitive popup menu adds an important enhancement to the experience of using Mozart.

Web View Tool
Another of FrontPage's strengths are its web-management tools. FrontPage comes with FrontPage Explorer, a tool that lets users graphically view and manage their web site. Future releases of Mozart will also have such a tool, although it will not be as feature-packed. Mozart will have a tool that will read the structure of a web site and allow the user to select and edit pages from a tree view.

FTP Communication
One feature that I have not seen implemented in Web Page editors is the ability to open and save pages from remotely hosted sites. The TCP/IP protocols are a richly functional suite of programs, and it is a waste not to fully utilize them. And since many people today are using Internet Service Providers to host their pages, they are required to send their documents over FTP anyway using separate FTP client programs. Mozart will allow users to send and recieve documents through FTP without the "middle-man approach."

Design Specification

Architectural Style
Mozart is going to be written in the Java programming language to allow it to be as portable as possible. I felt that since the web is a collection of different platforms and operating systems, it is important that Mozart is available to them. In addition, Java seems to be gaining global acceptance within mainstream computer software manufacturers.

Sun, the developers of Java, have recently released the Java Foundation Classes, that they call the Swing Classes. These classes contain already implemented HTML parsers and viewers, and I will depend heavily on them. I think it is important to note that the Swing HTML parser is not fully correct yet, but it is replaceable. However, it is not my plan to re-implement a fully functional HTML 4.0 parser for this project. Instead, I will implement Mozart using Swing's HTML parser and viewer, and rely on forthcoming versions of Swing to correct any incorrect displaying of HTML in Mozart. This seems like a cheeky way to get around the problem, but my late start has left me a little short on alternatives.

Interface
Mozart will be based on a Multiple Document Interface, allowing the user to edit many documents at once. Each document will have its own resizeable window and have the ability to edit the HTML code directly. As explained above, the user will also have access to a context-sensitive popup menu allowing the user to modify any object shown in the document. There will also be a rich set of menus, allowing the user to manipulate the document in a reasonable way. A list of the menus and their choices is listed below.

File	Edit	Insert	Format	Table	Window	Help
New Open Close -------------- Save Save As... Save All -------------- Print Page Setup Print Preview -------------- <Old Documents> -------------- Exit	Undo Redo -------------- Cut Copy Paste -------------- Search Replace -------------- Preferences	Hyperlink Anchor Image Timestamp Horizontal Line Form File Comment Table Symbol	Page Properties Background Paragraph Image Font -------------- Remove Formatting	Insert Table... Insert Rows/Columns Insert Cell Insert Caption Delete Cells Merge Cells Split Cells -------------- Cell Properties... Table Properties...	Cascade Tile Arrange Icons -------------- <List Windows>	Help Topics Mozart Homepage -------------- About Mozart

In addition to the menu set, there will be a dockable toolbar with the most popular funtions, ie. new file, open file, cut, copy, paste, etc.

Modules
One of the reasons that I chose Java was its modularity. Java is a strictly object-oriented programming language, and, as such, requires the developer to create objects that are based on previously defined and implemented objects. The Mozart class will be derived from several smaller classes, each of which is derived from additional, smaller classes. The class structure is shown here:

<Insert graphic (I'll make it later)>