JAVA SOURCE CODE EDITOR

A PROJECT REPORT

Submitted by

Chandra Shekhar Sharma

Sovit Tyagi

Abhinav Khandelwal

Anshul Goyal

in partial fulfillment for the award of the degree

of

BACHELOR OF ENGINEERING

IN

COMPUTER ENGINERING

VIVEKANANDA INSTITUTE OF TECHNOLOGY JAIPUR

RAJASTHAN TECHNICAL UNIVERSITY, KOTA

November - 2011

BONAFIED CERTIFICATE

Certified that this project report “JAVA SOURCE CODE EDITOR” is the bonafide work of “Chandra Shekhar Sharma, Abhinav Khandelwal, Sovit Tyagi, Anshul Goyal” who carried out the project work under my supervision.

SIGNATURE SIGNATURE

Dr. Baldev Singh Mr. Pawan Patidar

HEAD OF THE DEPARTMENT SUPERVISIOR

Computer Science Computer Science

VIT Campus VIT Campus

Sisyawas, NRI Road Sisyawas, NRI Road

Jagatpura Jagatpura

Jaipur Jaipur

TABLE OF CONTENTS

CHAPTER TITLE PAGE NO.

ABSTRACT

LIST OF FIGURE

LIST OF ABBREVATIONS

1. INTORDUCTION1.1 OBJECTIVE1.2 TOOLS AND TECHNOLOGY

1.2.1 JAVA STANDARD EDITION 1.7 1.2.2 JAVA SWING AND AWT PACAKGE

1.3 NEED OF SOURCE CODE EDITOR1.4 PROJECT REQUIREMENTS

2. SYSTEM DESIGN SPECIFICATION2.1 ENTITY RELATIONSHIP DIAGRAM2.2 DATA FLOW DIAGRAM2.3 USE CASE DIAGRAM2.4 CLASS DIAGRAM

3. PRODUCT SPECIFICATIONS3.1 BASIC FEATURES

3.1.1 FILE OPERATIONS3.1.2 EDIT OPERATIONS3.1.3 SEARCH OPERATIONS3.1.4 VIEW OPERATIONS

3.2 ADVANCE FEATURES4. SYNTAX COLORING AND HIGHLIGHTING

4.1 STRATEGIES4.1.1 CHANGE INSERTSTRING4.1.2 ADDING STRING SUPPORT4.1.3 ADDING NUMBER SUPPORT4.1.4 ADDING COMMENT SUPPORT4.1.5 PUTTING IT ALLTOGETHER

5. SNAPSHOTS OF PROJECT6. CONCLUSION7. BIBILIOGRAPHY

ABSTRACT

JFox (Java Source Code Editor) is a source code editor and notepad replacement. It

supports Java programming language and provides lot of exclusive features for

user convenience. JFox is a powerful editor targeted towards programmers and to

focus on dynamic implementation of a source code editor. JFox is completely

written in Java programming language so it provides better UI (User Interface) and

programming facilities.

JFox provides all basic editor features (i.e. cut, copy, paste, undo, redo) as well as

advanced features like syntax highlighting and line numbers while writing. It

successfully runs on any operating system with a Java 2 version 1.3 or higher

virtual machine - this includes MacOS X, OS/2, Unix, VMS and Windows. JFox

provides quite effective "Search and replace" method, which is capable of

searching both exact words and patterns. This is more than a editor as it provides

compile and run features for Java programmers.

LIST OF ABBREVATIONS

JDK = Java Development kit

GUI = Graphics user interface

JVM = JAVA VIRTUAL MACHINE

JFC = JAVA FOUNDATION CLASSES

AWT = ABSTRACT WINDOWS TOOLKIT

GPL = General public license

DFD = DATA FLOW DIAGRAM

ER = ENTITY RELATIONSHIP

JavaCC = Java Compiler Compiler

JIT = Just In Time

I/O = Input - output

INTRODUCTION

Objective : To design a powerful and user friendly source code editor for Java programmers

which will be capable of editing Java source code as well compile and run this code. Speed and robustness should be the key factors.

Tools and Technology:

J2SE (Java Standard Edition 1.7)

Java is a programming language originally developed by James Gosling at Sun Microsystems

(which has since merged into Oracle Corporation) and released in 1995 as a core component of

Sun Microsystems' Java platform. The language derives much of its syntax from C and C++ but

has a simpler object model and fewer low-level facilities. Java applications are typically

compiled to bytecode (class file) that can run on any Java Virtual Machine (JVM) regardless of

computer architecture. Java is a general-purpose, concurrent, class-based, object-oriented

language that is specifically designed to have as few implementation dependencies as possible. It

is intended to let application developers "write once, run anywhere." Java is currently one of the

most popular programming languages in use, particularly for client-server web applications. The

original and reference implementation Java compilers, virtual machines, and class libraries were

developed by Sun from 1995. As of May 2007, in compliance with the specifications of the Java

Community Process, Sun relicensed most of its Java technologies under the GNU General Public

License. Others have also developed alternative implementations of these Sun technologies, such

as the GNU Compiler for Java and GNU Classpath.

The syntax of Java is largely derived from C++. Unlike C++, which combines the syntax for

structured, generic, and object-oriented programming, Java was built almost exclusively as an

object-oriented language. All code is written inside a class, and everything is an object, with the

exception of the primitive data types (integers, floating-point numbers, boolean values, and

characters),wh classes for performance reasons. Unlike C++, Java does not support operator

overloading or multiple inheritance for classes. This simplifies the language and aids in

preventing potential errors and anti-pattern design. Java uses similar commenting methods to C+

+. There are three different styles of comments: a single line style marked with two slashes (//), a

multiple line style opened with /* and closed with */, and the Javadoc commenting style opened

with /** and closed with */. The Javadoc style of commenting allows the user to run the Javadoc

executable to compile documentation for the program.

Java Swing and AWT package:

Swing is the primary Java GUI widget toolkit. It is part of Oracle's Java Foundation Classes

(JFC) — an API for providing a graphical user interface (GUI) for Java programs.

Swing was developed to provide a more sophisticated set of GUI components than the earlier

Abstract Window Toolkit. Swing provides a native look and feel that emulates the look and feel

of several platforms, and also supports a pluggable look and feel that allows applications to have

a look and feel unrelated to the underlying platform. It has more powerful and flexible

components than AWT. In addition to familiar components such as buttons, check box and

labels, Swing provides several advanced components such as tabbed panel, scroll panes, trees,

tables and lists.Unlike AWT components, Swing components are not implemented by platform-

specific code. Instead they are written entirely in Java and therefore are platform-independent.

The term "lightweight" is used to describe such an element. Swing is a highly partitioned

architecture, which allows for the "plugging" of various custom implementations of specified

framework interfaces: Users can provide their own custom implementation(s) of these

components to override the default implementations.

The Abstract Window Toolkit (AWT) is Java's original platform-independent windowing,

graphics, and user-interface widget toolkit. The AWT is now part of the Java Foundation Classes

(JFC) — the standard API for providing a graphical user interface (GUI) for a Java

program.AWT is also the GUI toolkit for a number of Java ME profiles. For example, Connected

Device Configuration profiles require Java runtimes on mobile telephones to support AWT

Needs of Source Code Editor:

Apart of the ordinary notepad users, There is an another group of people who actually work with

other important side of notepad editor, they are computer programmers. Computer programmers

need to have a powerful programming interface where they should be capable of writing code

with ease of access and convenience. So there is always a requirement of good source code

editor which provide reliable, fast, powerful, and multi featured user interface i.e. syntax

coloring (highlighting), source code parsing, and line numbers of code searching. There is few

other thing which a programmer may want in source code editor, which is compiling and run

facility. So Jfox is a source code editor which is having all those requirements. JFox is basically

designed for those programmers which works on Java technology, as it provide syntax

highlighting for Java programming language.

Project Requirements:

Software Requirements

Hardware Requirements

SYSTEM DESIGN DIAGRAMS

Entity-Relationship (ER) Diagrams

In software engineering, an entity-relationship model (ERM) is an abstract and conceptual

representation of data. Entity-relationship modeling is a database modeling method, used to

produce a type of conceptual schema or semantic data model of a system, often a relational

database, and its requirements in a top-down fashion. Diagrams created by this process are

called entity-relationship diagrams, ER diagrams, or ERDs.

The building blocks: entities, relationships, and attributes:

An entity may be defined as a thing which is recognized as being capable of an independent existence

and which can be uniquely identified. An entity is an abstraction from the complexities of some

domain. When we speak of an entity we normally speak of some aspect of the real world which can

be distinguished from other aspects of the real world.

A relationship captures how two or more entities are related to one another. Relationships can be

thought of as verbs, linking two or more nouns. Examples: an owns relationship between a company

and a computer, a supervises relationship between an employee and a department, a performs

relationship between an artist and a song, a proved relationship between a mathematician and a

theorem. Entities and relationships can both have attributes.

Diagramming conventions:

Entity sets are drawn as rectangles, relationship sets as diamonds. If an entity set participates in a

relationship set, they are connected with a line.

Attributes are drawn as ovals and are connected with a line to exactly one entity or relationship set.

An entity may be a physical object such as a house or a car, an event such as a house sale or a car

service, or a concept such as a customer transaction or order. Although the term entity is the one most

commonly used, following Chen we should really distinguish between an entity and an entity-type.

An entity-type is a category. An entity, strictly speaking, is an instance of a given entity-type. There

are usually many instances of an entity-type. Because the term entity-type is somewhat cumbersome,

most people tend to use the term entity as a synonym for this term.

Entities can be thought of as nouns. Examples: a computer, an employee, a song, a mathematical

theorem. Entity-relationship diagrams don't show single entities or single instances of relations.

Rather, they show entity sets and relationship sets. Example: a particular song is an entity. The

collection of all songs in a database is an entity set. The eaten relationship between a child and her

lunch is a single relationship. The set of all such child-lunch relationships in a database is a

relationship set.

E R Diagram for JFox Editor

Figure 1

Data flow diagram:

A data-flow diagram (DFD) is a graphical representation of the "flow" of data through an

information system. DFDs can also be used for the visualization of data processing (structured

design).

On a DFD, data items flow from an external data source or an internal data store to an internal

data store or an external data sink, via an internal process.

A DFD provides no information about the timing of processes, or about whether processes will

operate in sequence or in parallel. It is therefore quite different from a flowchart, which shows

the flow of control through an algorithm, allowing a reader to determine what operations will be

performed, in what order, and under what circumstances, but not what kinds of data will be input

to and output from the system, nor where the data will come from and go to, nor where the data

will be stored (all of which are shown on a DFD).

The Level 1 DFD shows how the system is divided into sub-systems (processes), each of which

deals with one or more of the data flows to or from an external agent, and which together provide

all of the functionality of the system as a whole. It also identifies internal data stores that must be

present in order for the system to do its job, and shows the flow of data between the various parts

of the system.

Data-flow diagrams were invented by Larry Constantine, the original developer of structured

design, based on Martin and Estrin's "data-flow graph" model of computation.

Data-flow diagrams (DFDs) are one of the three essential perspectives of the structured-systems

analysis and design method SSADM. The sponsor of a project and the end users will need to be

briefed and consulted throughout all stages of a system's evolution. With a data-flow diagram,

users are able to visualize how the system will operate, what the system will accomplish, and

how the system will be implemented. The old system's dataflow diagrams can be drawn up and

compared with the new system's data-flow diagrams to draw comparisons to implement a more

efficient system. Data-flow diagrams can be used to provide the end user with a physical idea of

where the data they input ultimately has an effect upon the structure of the whole system from

order to dispatch to report. How any system is developed can be determined through a data-flow

diagram.

In the course of developing a set of leveled data-flow diagrams the analyst/designers is forced to

address how the system may be decomposed into component sub-systems, and to identify the

transaction data in the data model.

There are different notations to draw data-flow diagrams, defining different visual

representations for processes, data stores, data flow, and external entities.

Data flow diagram ("bubble charts") are directed graphs in which the nodes specify processing

activities and the arcs specify data items transmitted between processing nodes.

DFD is also a virtually designable diagram that technically or diagrammatically describes the

inflow and outflow of data or information that is provided by the external entity.

Level 0 DFD:

Level 0 and level 1 are probably the easiest for someone to create, because they are done

at such a high level view.

Shows the system’s major processes, data flows, and data stores at a high level of

abstraction.

Level 0 DFD shows how the system is divided into sub-systems(processes).

It also identifies internal data stores that must be present in order for the system to do its

job.

Shows the flow of data between the various parts of the system.

When the Context Diagram is expanded into DFDlevel-0, all the connections that flow

into and out of process 0 needs to be retained.

0 – Level DFD

Figure 2

Level 1 DFD:

The next stage is to create the Level 1 Data Flow Diagram. This highlights the main functions carried out by the system. As a rule, we try to describe the system using between two and seven functions - two being a simple system and seven being a complicated system. This enables us to keep the model manageable on screen or paper.

Level 1 DFD

Figure 3

Use Case:

A use case diagram in the Unified Modeling Language (UML) is a type of behavioral diagram defined by and created from a Use-case analysis. Its purpose is to present a graphical overview of the functionality provided by a system in terms of actors, their goals (represented as use cases), and any dependencies between those use cases.

Use cases are a software modeling technique that helps developers determine which features to implement and how to gracefully resolve errors.

Within systems engineering, use cases are used at a higher level than within software engineering, often representing missions or stakeholder goals. The detailed requirements may then be captured in SysML requirement diagrams or similar mechanisms.

The main purpose of a use case diagram is to show what system functions are performed for which actor.

Actors:

An actor is a person, organization, or external system that plays a role in one or more interactions

with the system. The same person using the system may be represented as different actors

because they are playing different roles. For example, user "Joe" could be playing the role of a

Customer when using an Automated Teller Machine to withdraw cash, or playing the role of a

Bank Teller when using the system to restock the cash drawer.

Types of Actors:

Primary Actor - Fulfills the user goals by using the services of the SuD (System Under Discussion). Ex: 'Cashier' in a Process Sale System.

Secondary Actor - Provides a service to the SuD. Ex: 'Automated payment authorization service'.

Offstage Actor - Has an interest in the behavior of the system but is not primary or secondary. Ex: A government tax agency.

Actor Generalization

One popular relationship between Actors is Generalization/Specialization. This is useful in

defining overlapping roles between actors. The notation is a solid line ending in a hollow triangle

drawn from the specialized to the more general actor.

Use Case Relationships

Four relationships among use cases are used often in practice.

Include

In one form of interaction, a given use case may include another. "Include is a Directed

Relationship between two use cases, implying that the behavior of the included use case is

inserted into the behavior of the including use case".

The first use case often depends on the outcome of the included use case. This is useful for

extracting truly common behaviors from multiple use cases into a single description. The

notation is a dashed arrow from the including to the included use case, with the label

"«include»". This usage resembles a macro expansion where the included use case behavior is

placed inline in the base use case behavior. There are no parameters or return values. To specify

the location in a flow of events in which the base use case includes the behavior of another, you

simply write include followed by the name of use case you want to include.

Extend

In another form of interaction, a given use case (the extension) may extend another. The

relationship indicates that the behavior of the extension use case may be inserted in the extended

use case under some conditions. The notation is a dashed arrow from the extension to the

extended use case, with the label "«extend»". The notes or constraints may be associated with

this relationship to illustrate the conditions under which this behavior will be executed.

Modelers use the «extend» relationship to indicate use cases that are "optional" to the base use

case. Depending on the modeler's approach "optional" may mean "potentially not executed with

the base use case" or it may mean "not required to achieve the base use case goal".

Generalization

In the third form of relationship among use cases, a generalization/specialization relationship

exists. A given use case may have common behaviors, requirements, constraints, and

assumptions with a more general use case. In this case, describe them once, and deal with it in

the same way, describing any differences in the specialized cases. The notation is a solid line

ending in a hollow triangle drawn from the specialized to the more general use case (following

the standard generalization notation).

Associations

Associations between actors and use cases are indicated in use case diagrams by solid lines. An

association exists whenever an actor is involved with an interaction described by a use case.

Associations are modeled as lines connecting use cases and actors to one another, with an

optional arrowhead on one end of the line. The arrowhead is often used to indicate the direction

of the initial invocation of the relationship or to indicate the primary actor within the use case.

The arrowheads imply control flow and should not be confused with data flow.

USE CASE DIAGRAM

Figure 4

Class Diagram:

The class diagram is the main building block of object oriented modeling. It is used both for

general conceptual modeling of the systematic of the application, and for detailed modeling

translating the models into programming code. Class diagrams can also be used for data

modeling. The classes in a class diagram represent both the main objects and or interactions in

the application and the objects to be programmed.

In the class diagram these classes are represented with boxes which contain three parts:

.

The upper part holds the name of the class

The middle part contains the attributes of the class

The bottom part gives the methods or operations the class can take or undertake

In the system design of a system, a number of classes are identified and grouped together in a

class diagram which helps to determine the static relations between those objects. With detailed

modeling, the classes of the conceptual design are often split into a number of subclasses.

In order to further describe the behavior of systems, these class diagrams can be complemented

by state diagram or UML state machine. Also instead of class diagrams Object role modeling can

be used if you just want to model the classes and their relationships.

Visibility:To specify the visibility of a class member (i.e., any attribute or method) there are the following

notations that must be placed before the member's name

+ Public - Private # Protected ~ Package/ DerivedUnderline Static

Some important concepts in class diagram are given below:

Association:An association represents a family of links. Binary associations (with two ends) are normally

represented as a line, with each end connected to a class box.

Aggregation:Aggregation is a variant of the "has a" or association relationship; aggregation is more specific than association. It is an association that represents a part-whole or part-of relationship.

Composition:Composition usually has a strong life cycle dependency between instances of the container class and instances of the contained class(es): If the container is destroyed, normally every instance that it contains is destroyed as well.

Generalization:The Generalization relationship ("is a") indicates that one of the two related classes (the subclass) is considered to be a specialized form of the other (the super type) and super class is considered as 'Generalization' of subclass.

Class Diagram

Figure 5

PRODUCT SPECIFICATIONS

JFox Source Code Editor is having number of interactive features which are mentioned

here respectively

Basic Features:

1. File Operations:

JFox Source Code Editor supports a number of file operations, which allows a user to write

code with convenience. Some of these operations are given here :

(a) Copy: Copying the content of document being written in the editor.

(b) Paste: Putting the content in text area which has been previously copied or cut by the

user.

(c) New: Opening a new file in text editor to edit or write code.

(d) Print: To print the document currently being edited in the source code editor.

(e) Rename: To rename the document currently being edited in the source code editor.

(f) Open: To Open any document for editing or as a new file.

(g)Close: To close the current document or all the document opened in source code

editor.

(h) Save: To Save the current file permanently into the disk (with a valid name as per the

operating system).

(i) Save As: To Save the current file with different file name or as a duplicate copy of

the current document.

2. Edit Operations:

(a) Undo: To revert the changes made just before last action (CTRL+Z)

(b) Redo: To get the previous state like it was before the UNDO operation (CTRL+Y)

(c) Convert Case: To convert the currently selected text in to UPPER Case or

LOWER case, as per the option being chosen

(d) Select All: To Select each and every character of the text area in that editor.

(e) Set Read Only: To convert the text area into a non editable canvas/text display,

where code will not be allowed to change or delete.

(f) Delete: To delete the selected text in that text area. this can be done via back space

key.

3. Search Operations:

(a)Search: To search any text or pattern in whole document this supports the exact key

value as well as text pattern.

(b)Replace: To replace any text or pattern in whole document this takes an input and

replace it by given string.

(c)Go to: This brings the focus/control on to any specific line number given as input to this.

4. View Operations:

(a) Themes: A number of themes are provided to user so he could change the User

Interface and color scheme as per his choice. Mainly 4 user themes are provided , i.e.

Classic, Advanced, Metal, Nimbus.

(b) Zoom: To change the font size and view of the editor. it either increase the text size or

decrease the text size in text editor. Zoom In is used to increase the text size and Zoom

Out is used to decrease the text Size.

(c) Word Wrap: It wraps the long lines into small ones.

(d) Change Background: To change the background color of the text editor area.

(e) Change Foreground: To change the Foreground color of the text editor area.

Advanced Features:

1. Execution of code: This consist of two major features which makes that editor

more useful. they are compiling, and run facilities.

Compile: In this state editor checks for the syntactical and Symantec of

the source code. It is connected to the Java Compiler which enables all the parsing

and optimization features.

2. Run: After successful compilation of the source code it's sent to the java run

time environment and this enables the execution of byte code created by JavaCC

(Java Compiler).

3. Line Number: When ever user is dealing with a huge file containing more than

1000 or more lines then seeking to desired line in editor is always very difficult.

so JFox source code editor provides line numbering to make thing easier for

programmer. These line numbers let the user know where exactly he is writing

right now.

4. Help: Help set is provided to user to understand the Java manual and JFox

manual. It has basically 3 major options which are given here -

(i) JDK help: takes the user to java development Kit user manual , where he can

find all the answer regarding java syntax and provided classes.

(ii) Tip of the day: Gives any random tips about JFox editor or Java

Development.

(iii) About: Gives information about JFox developer team and their contact ways.

Syntax Coloring and Highlighting

Syntax highlighting is a feature of some text editors that display text—especially source code—

in different colors and fonts according to the category of terms. This feature eases writing in a

structured language such as a programming language or a markup language as both structures

and syntax errors are visually distinct. Highlighting does not affect the meaning of the text itself;

it's made only for human readers/editors.

Syntax highlighting is a form of secondary notation, since the highlights are not part of the text

meaning, but serve to reinforce it. Some editors also integrate syntax highlighting with other

features, such as spell checking or code folding, as aids to editing which are external to the

language.

Syntax highlighting is one strategy to improve the readability and context of the text; especially

for code that spans several pages. The reader can easily ignore large sections of comments or

code, depending on what one desires.

Syntax highlighting also helps programmers find errors in their program. For example, most

editors highlight string literals in a different color. Consequently, spotting a missing delimiter is

much easier because of the contrasting color of the text. Brace matching is another important

feature with many popular editors. This makes it simple to see if a brace has been left out or

locate the match of the brace the cursor is on by highlighting the pair in a different color

Most editors with syntax highlighting allow different colors and text styles to be given to dozens

of different lexical sub-elements of syntax. These include keywords, comments, control-flow

statements, variables, and other elements. Programmers often heavily customize their settings in

an attempt to show as much useful information as possible without making the code difficult to

read.

Strategies for Syntax highlighting in text Area:

To start things out let's try and use what we have so far. If we look at the code below we can see

that plugging the Document we've created into a JTextPane component is quite easy. Defining

the keywords is also very easy.

JTextPane editor = new JTextPane();

CodeDocument doc = new CodeDocument();

Vector keywords = new Vector();

keywords.addElement("abstract");

keywords.addElement("boolean");

...

doc.setKeywords(keywords);

editor.setDocument(doc);

We could have just created the CodeDocument on the fly and passed it in as an argument to the

constructor of the JTextPane class, but then the keywords for the Document wouldn't have been

set and we'd have had to retrieve the Document and then add them.

Changing the insertString Method

Some of you may have noticed that the Document Model code we developed in the previous

article worked only if you actually typed in the text manually. If we had called the insertString

method and passed in a string with a length longer than one character, the syntax highlighting

wouldn't have worked. To fix that we'll make a simple change, moving the code that actually did

the comparing to another method, and changing the insertString method to support any size

string. We'll create a method called processChar that will actually do the work of checking the

kind of character we're dealing with and, in turn, call the correct method to handle that character.

To make the whole thing work, we can then just loop through each of the characters in the string

that's passed into the insertString method, starting at the offset position (the offs variable passed

into the insertString method) and ending at the offset plus the length of the string passed in. For

each character we find we can call the processChar method, and voila! We can now handle any

size string. To get an idea of the code, take a look below.

public void insertString(int offs,

String str,

AttributeSet a) throws BadLocationException{

super.insertString(offs, str, normal);

int strLen = str.length();

int endpos = offs + strLen;

int strpos;

for (int i=offs;i<endpos;i++){

currentPos = i;

strpos = i - offs;

processChar(str.charAt(strpos));

}

currentPos = offs;

}

The only problem with the solution above is that when reading large chunks of text you may

notice a slowdown in JTextPane's performance while it loads and parses all the text. A possible

solution would be to use a thread to handle any text not immediately visible to the user, parse it

in the background and then...well, that'll be the subject of a future article!

Adding String Support

Now that we can support entered text of any size, let's add highlighting support for strings.

Adding string support isn't too hard now that we have the basic pieces in place. We'll add a

variable that we'll use to keep track of whether we're entering a string. If this flag is turned on,

any text we enter following the double quote ("") will be colored in a different foreground color.

Also, if this flag is turned on, no keyword processing will occur. A carriage return will

automatically shut the flag off. We'll need to keep track of the start position where the flag was

first turned on. This will allow us to type in some text representing a string, hit the carriage

return and type other stuff, and then put the caret back on the line where the string was and

resume entering the string text all the while keeping the formats correct. We'll also need a

variable that represents the style attribute we want for strings.

In addition to variables we'll need some new methods. For strings we'll create a checkForString()

method that will determine whether we're inside a string. If it finds that we are, the mode

variable will be set appropriately (this will be explained in more detail a few paragraphs down).

We'll also need a method called insertTextString() that will actually reinsert the properly

formatted string.

Adding Number Support

Adding support for numbers is similar to adding support for strings. We'll add a variable to hold

the style attribute for numbers, and also add two more methods: checkForNumber() and

insertNumberString(). Like strings, the checkForNumber() method determines whether we're

actually entering valid digits. If we are, it sets the CodeDocument's mode accordingly. Like

insertTextString, insertNumberString inserts the properly formatted text as a number.

Adding Comment Support

Comments are handled in a similar manner. Two new methods are needed, checkForComment()

and insertCommentString(). Like numbers and text, the checkForComments method determines

if a comment block has been started (it checks for the "/*" combination to start a comment and

the "*/" to end a comment block). If it has, it changes the attributes of the entered text by calling

the insertCommentString() method. Again, like numbers and strings, the insertCommentString()

changes the formatting attri-butes of the string accordingly, and then inserts into the document.

Another private variable is needed to hold the formatting attributes for comments.

Putting It All Together

Now it's time to get down and dirty. We're finally going to look at the whole process, first in

general terms and then in more detail using code examples. As we mentioned earlier, the original

insertString method of the CodeDocument class was changed, and much of the logic was moved

to a new method called processChar(), thus allowing us to handle not only single keystrokes, but

also to programmatically insert multiple character strings. ProcessChar() works by making

certain assumptions about what characters will follow other characters. Based on this, it sets the

insert mode for the current position of incoming text. Based on this mode (which is simply a

private integer variable), it can then determine which insertXXXString() method to call.

For example, when it encounters the character '9', it figures there's a very good chance that this is

the start of a number or that a number is currently in the process of being entered. To verify this

it calls the checkForNumber() method. If checkForNumber() determines that we're still entering

a number, it sets the mode to the number entry mode. If it discovers any other character present,

however, such as a space, a parenthesis or a letter, it sets the mode to the default text entry mode

(the number entry mode is represented by the static constant NUMBER_MODE, while the text

entry mode is represented by the static constant TEXT_MODE). The other checkForXXX()

methods work in a similar fashion. After the checkForXXX() method has returned, the mode will

have been set correctly and, based on this, the proper insertXXXString() method can be called. If

the mode is in TEXT_MODE, the formatting is left alone.

Now look at the code in Listing 1 for method processChar. The first thing the method does is to

check if we're in COMMENT_MODE. Because comments can include anything (aside from the

comment-terminating characters), we'll let the mode default to COMMENT_MODE; otherwise

we'll change it to default to TEXT_MODE, which is the standard text entry mode (no

formatting). Next, a switch statement is created based on the character passed to the processChar

method. As mentioned before, the method works on the assumption that the character being

entered belongs to one of five groups (generic text, keywords, strings, numbers or comments),

and that the case statements are grouped accordingly. Characters equaling the numbers '1'

through '9' cause a check for numbers; characters equaling '*' or '/' suggest the possible start or

end of a comment block, and a check is made; and so on. Once the switch statement is finished

executing, a final check is made for quoted strings if we're still in TEXT_MODE. Finally,

depending on which mode we're in, a call is made to the appropriate insertXXXString method.

There are four check methods: checkForComment(), checkForKeyword(), checkForNumber()

and checkForString(). While there are some differences from the original checkForKeywords()

method, the basic idea, as discussed last month, is the same. We retrieve the current element, get

the text from it, find our position in the element and then, starting at the end, we walk backward

until a delimiter of some sort is found and then set the mode accordingly. Let's look at some of

the checkForString() method's code to examine this more closely. We'll assume we already have

the correct offset from the Document's element.

int quoteCount = 0;

if ((offs >= 0) && (offs <= strLen-1)){

i = offs;

while (i >0){

//the while loop walks back until we hit a delimiter

char charAt = elementText.charAt(i);

if ((charAt == '"')){

quoteCount ++;

}

i--;

}

int rem = quoteCount % 2;

mode = (rem == 0) ? TEXT_MODE: STRING_MODE;

}

The code is fairly simple: we loop backward until we run out of characters to process, each time

comparing a character from the element text. If the character is a double quote (" "), we add one

to the local variable called quoteCount. Once we're done with the loop, we check the remainder

of the quoteCount divided by two and assign the results to another local variable called rem.

Why do this? Again, this is another assumption about the way words are put together. Since

quotes always come in pairs, if our remainder isn't equal to zero, we know we're "inside" a string

quotation. Otherwise we can safely assume that we're "outside" and are just entering normal text.

And Finally... I think at this point I've probably run out of column space. We now have a syntax-

highlighting Document class that supports any user-defined set keywords, plus string, number

and comment highlighting (see Listings 2 and 3). We've also seen how easy it is to incorporate

our Document class into the JTextPane control to test our results as we go along. In the next

article we'll add some more user-definable properties so you can change the color of highlighted

string, comments, keywords and so on. We'll also look at adding support for a kind of "smart

editor" à la Borland's Code Insight features in their IDE editors.

SNAPSHOTS OF PROJECT

HOME SCREEN

OPEN A FILE

PRINT THE DOCUMENT

SELECTALL

FIND AND REPLACE

ABOUT JFOX

THEME DISPLAY – NIMBUS

CHANGING BACKGORUND COLOR

CONCLUSION

The primary goal of this report is to identify action initiatives that make up the

information details regarding JFox - java source code editor. The application is

made in all possible way to meet the user requirements using latest version of

available software and hardware. But as user requirements and operating

environment keep changing further extensions can be made on this. The project

that has been developed is a part of programmer's developing tool , so it can be

used and extended the scope and domain of project.

BIBLOGRAPHY

Java the Complete Reference, Seventh Edition(Herbert Scheldt)

http://java.sys-con.com/node/36509

http://www.oracle.com/technetwork/java/index.html

http://www.java.com