Date post: | 29-Nov-2014 |
Category: |
Documents |
Upload: | kush-bhargava |
View: | 78 times |
Download: | 2 times |
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