Development system with application browser user interface

Abstract

A component-based, rapid application development (RAD) Java environment providing an improved user interface is described. The interface includes a single Application Browser or "AppBrowser" that is used to perform all the usual development functions. The AppBrowser lets the user explore, edit, design, and debug all in one unified window. Serving as a mechanism for hosting arbitrary documents or other objects related to development, the AppBrowser presents the documents or other objects for manipulation in a window that consists of three panes: Navigation pane, Content pane, and Structure pane. In general, the Navigation pane displays a list of documents, the Content pane displays the document itself, and the Structure pane displays the structure of the document if available. The grouping of the three panes exists on a browser "context" or mode. Multiple contexts can appear on an AppBrowser represented by a tab in a tab set at the lower left of the window. These contexts add a 3D feel to AppBrowser by layering its functionality in one window rather than spread across multiple windows. Switching between completely different contexts is then as easy as selecting a tab. The AppBrowser may have different logic for any given context that is global across the three panes; the logic is provided by implementing a standard browser context interface.

Claims

What is claimed is:

1. In a development system for creating computer programs, a method for assisting a user with development of a program, said program being developed from a project comprising at least a plurality of files employed for developing the program, the method comprising:

displaying a graphical user interface window having a navigation pane, said navigation pane for displaying a hierarchical view of said project comprising a tree having a plurality of nodes of files employed for developing said program of said project, said nodes being displayed in collapsible outline format, so that the user can navigate to a particular file of the project by selecting one of the nodes;

simultaneously displaying in said graphical user interface window a content pane, said content pane for displaying contents of the particular file selected at the navigation pane; and

simultaneously displaying in said graphical user interface window a structure pane, said structure pane for displaying a hierarchical view of said particular file comprising a tree having a plurality of nodes, so that the user can navigate to a particular object of the particular file by selecting one of the nodes;

wherein all said panes remain automatically synchronized by the system during system operation.

2. The method of claim 1, further comprising:

maintaining a history list for tracking which nodes the user has selected in the navigation pane.

3. The method of claim 1, further comprising:

providing navigation buttons allowing the user to navigate forward and backward through the history list, for re-selecting nodes of the navigation pane.

4. The method of claim 1, wherein said content pane provides at least one viewer for viewing contents of a particular selected file within said content pane.

5. The method of claim 4, wherein the particular selected file is a source code file and wherein said at least one viewer comprises a source code viewer.

6. The method of claim 4, wherein the particular selected file is a hypertext markup language (HTML) file and wherein said at least one viewer comprises an HTML viewer and an HTML code editor.

7. The method of claim 4, wherein each at least one viewer is associated with a particular tab which can be selected by the user for displaying the viewer as the current viewer in the content pane.

8. The method of claim 1, wherein said plurality of files includes source code files.

9. The method of claim 8, wherein interdependencies exist between various files of the project.

10. The method of claim 9, wherein a file which is dependent on another file is represented as a child of that other file in the navigation pane.

11. The method of claim 1, further comprising:

upon user selection of a particular node in the navigation pane, synchronizing the content pane and the structure pane for the selected node.

12. The method of claim 1, wherein said structure pane displays designable objects for said particular file, said structure pane indicating how the objects are interrelated to one another.

13. The method of claim 12, wherein said particular file comprises a Java file and wherein the structure pane displays structural information about Java code in the particular file.

14. The method of claim 13, wherein said structural information about Java code comprises information about Java classes and class relationships.

15. In a development system, a method for assisting a user with development of a program, said program being developed from a project comprising at least a plurality of files, the method comprising:

displaying a graphical user interface window having a navigation pane, said navigation pane for displaying a hierarchical view of said project comprising a tree having a plurality of nodes, so that the user can navigate to a particular file of the project by selecting one of the nodes;

displaying in said graphical user interface window a content pane, said content pane for displaying contents of the particular file selected at the navigation pane;

displaying in said graphical user interface window a structure pane, said structure pane for displaying a hierarchical view of said particular file comprising a tree having a plurality of nodes, so that the user can navigate to a particular object of the particular file by selecting one of the nodes;

upon user selection of a particular node in the navigation pane, synchronizing the content pane and the structure pane for the selected node;

wherein said structure pane displays designable objects for said particular file, said structure pane indicating how the objects are interrelated to one another;

wherein said particular file comprises a Java file and wherein the structure pane displays structural information about Java code in the particular file;

wherein said structural information about Java code comprises information about Java classes and class relationships; and further comprising:

receiving a request for drilling down into an ancestor class; and

in response to said request, displaying information for the ancestor class.

16. The method of claim 15 wherein said displaying information for the ancestor class comprises displaying Java code for the ancestor class in the content pane.

17. The method of claim 16, wherein said displaying information for the ancestor class further comprises displaying structural information about the Java code for the ancestor class in the structure pane.

18. The method of claim 15, wherein said request comprises user selection of a node in the structure pane which is an ancestor of a node currently selected in the structure pane.

19. In a development system, a method for assisting a user with development of a program, said program being developed from a project comprising at least a plurality of files, the method comprising:

displaying a graphical user interface window having a navigation pane, said navigation pane for displaying a hierarchical view of said project comprising a tree having a plurality of nodes, so that the user can navigate to a particular file of the project by selecting one of the nodes;

displaying in said graphical user interface window a content pane, said content pane for displaying contents of the particular file selected at the navigation pane; and

displaying in said graphical user interface window a structure pane, said structure pane for displaying a hierarchical view of said particular file comprising a tree having a plurality of nodes, so that the user can navigate to a particular object of the particular file by selecting one of the nodes, wherein said particular object comprises a user interface object;

wherein the graphical user interface maintains synchronization among all panes of the graphical user interface.

20. A development system for developing software programs comprising:

a compiler for compiling files into a program; and

an integrated development environment providing a user interface comprising:

a first display region for representing said files as a hierarchical tree comprising a plurality of nodes, wherein each node corresponds to a particular file, and wherein said nodes are arranged in the tree to represent interdependencies among said files;

a second display region for viewing contents of a particular file whose node is selected in the first display region; and

a third display region for representing the particular file as a hierarchical tree comprising a plurality of nodes, wherein each node corresponds to a distinguishable element of the file, and wherein said nodes are arranged in the tree to represent interdependencies among said elements;

wherein said first, second, and third display regions are simultaneously displayed in the user interface of said integrated development environment, and wherein the user interface maintains synchronization among all display regions of the user interface.

21. The system of claim 20, further comprising navigation buttons allowing a user to navigate among nodes in the first display region.

22. The system of claim 20, wherein said second display region includes at least one viewer for viewing contents of a particular file whose node is selected in the first display region.

23. The system of claim 22, wherein said particular file comprises a source code file and wherein said at least one viewer comprises a source code editor allowing a user to modify source code contained therein.

24. The system of claim 22, wherein the particular selected file is a hypertext markup language (HTML) file and wherein said at least one viewer comprises an HTML viewer and an HTML code editor.

25. The system of claim 20, wherein a file which is dependent on another file is represented as a child of that other file in the tree of the first display region.

26. The system of claim 20, wherein said synchronization includes synchronizing the second and third panes upon user selection of a particular node in the first pane.

27. The system of claim 20, wherein said synchronization includes synchronizing the second pane to be positioned at a particular line of source code upon user selection of a particular node in the third pane representing an object which is declared in the source code at said particular line.

28. The system of claim 20, wherein the distinguishable elements in the file include user interface elements.

29. In a development system, a method for assisting a user with management of a development project comprising at least a plurality of files, at least some of the files including a plurality of objects, the method comprising:

displaying an integrated user interface having a first region for displaying a hierarchical view of said project, the hierarchical view comprising a tree having a plurality of nodes, so that the user can navigate to a particular file of the project by selecting one of the nodes;

displaying in said integrated user interface a second region for viewing contents of the particular file selected at the first region; and

displaying in said integrated user interface a third region for displaying a hierarchical view of said particular file, the hierarchical view comprising a tree having a plurality of nodes, so that the user can navigate to a particular object of the particular file by selecting one of the nodes;

wherein said first, second, and third display regions are simultaneously displayed in the integrated user interface of said development system, and wherein the integrated user interface maintains synchronization among all display regions of the integrated user interface.

30. The method of claim 29, wherein said particular file comprises a Java file and wherein the third region displays structural information about Java code in the particular file.

31. The method of claim 30, wherein said structural information about Java code comprises information about Java classes and class relationships.

32. The method of claim 29, wherein said second region displays source code for an ancestor class in response to selection of a node which is an ancestor of a node previously selected in the third region.

33. The method of claim 29, wherein said third region displays children nodes for representing methods for a particular object whose node has been selected.

Description

COPYRIGHT NOTICE

A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure as it appears in the Patent and Trademark Office patent file or records, but otherwise reserves all copyright rights whatsoever.

BACKGROUND OF THE INVENTION

The present invention relates generally to a development environment for creating application programs and other software and, particularly, to system and methods providing an improved interface for such an environment.

With the explosive growth of the Internet and the World Wide Web, an ever-increasing number of computers of disparate platforms are being connected together. As a result, there is renewed interest in distributing software in binary format which operates in this ever-increasing heterogeneous environment. In the early 1990s, a team at Sun Microsystems developed a new language, "Java," to address the issues of software distribution on the Internet. Java is a simple, object-oriented language which supports multi-thread processing and garbage collection. Although the language is based on C++, a superset of C, it is much simpler. More importantly, Java programs are "compiled" into a binary format that can be executed on many different platforms without recompilation. The language includes built-in mechanisms for verifying and executing Java "binaries" in a controlled environment, protecting the user's computer from potential viruses and security violations.

A typical Java system comprises the following set of interrelated technologies: a language specification; a compiler for the Java language that produces bytecodes from an abstract, stack-oriented machine; a virtual machine (VM) program that interprets the bytecodes at runtime; a set of class libraries; a runtime environment that includes bytecode verification, multi-threading, and garbage collection; supporting development tools, such as a bytecode disassembler; and a browser (e.g., Sun's "Hot Java" browser).

Java is designed for creating applications that will be deployed in heterogeneous networked environments. Such environments are characterized by a variety of hardware architectures. Further, applications in such environments execute atop a variety of different operating systems and interoperate with a multitude of different programming language interfaces. To accommodate such diversity, the Java compiler generates platform-neutral "bytecodes"--an architecturally neutral, intermediate format designed for deploying application code efficiently to multiple platforms.

Java bytecodes are designed to be easy to interpret on any machine. Bytecodes are essentially high-level, machine-independent instructions for a hypothetical or "virtual" machine that is implemented by the Java interpreter and runtime system. The virtual machine, which is actually a specification of an abstract machine for which a Java language compiler generates bytecode, must be available for the various hardware/software platforms which an application is to run. The Java interpreter executes Java bytecode directly on any machine for which the interpreter and runtime system of Java have been ported. In this manner, the same Java language bytecode runs on any platform supported by Java.

Compiling Java into platform-neutral bytecodes is advantageous. Once the Java language interpreter and runtime support are available on a given hardware and operating system platform, any Java language application can be executed. The bytecodes are portable since they do not require a particular processor, architecture, or other proprietary hardware support. Further, the bytecodes are byte-order independent, so that programs can be executed on both big-endian machines (e.g., Intel architecture) and little-endian machines (e.g., Motorola architecture). Since Java bytecodes are typed, each specifies the exact type of its operands, thereby allowing verification that the bytecodes obey language constraints. All told, the interpreted bytecode approach of compiled Java language programs provides portability of programs to any system on which the Java interpreter and runtime system have been implemented.

The bytecodes are actually stored in "class" files. Each class file stores all the information for a particular Java class. A "class" in Java is a software construct which defines instance variables and methods, in effect, serving as a template for creating objects of a particular type. In this regard, a Java class is akin to a C++class. A very simple "Point" class, for instance, may be declared as follows.

class Point {

public double x; /* instance variable */

public double y; /* instance variable */

}

This declaration serves as a template from which "Point" objects can be instantiated.

Actual instantiation of an object occurs in a manner similar to that found in the C++programming language. For example, a variable which refers to a "Point" object can be declared as follows:

Point myPoint;

An instance of a point object is allocated as follows.

myPoint=new Point( );

Here, one can now access variables of the "Point" object, using familiar "dot" notation for referring to the names of the variables.

myPoint.x=10;

myPoint.y=20;

Objects communicate by sending messages to each other. A recipient object responds to a message by selecting a particular method to execute. If one object wants another object to do some work on its behalf, for instance, the first object sends a message to the second object. The second object, in response, invokes the method which is appropriate for processing the message. The methods themselves, therefore, define the behavior of objects instantiated from a class. In particular, it is an object's methods which manipulate the object's data--its instance variables.

Further description of the Java Language environment can be found in Gosling, J. et al., The Java Language Environment. A White Paper, Sun Microsystems Computer Company, October 1995, the disclosure of which is hereby incorporated by reference.

"Visual" development environments, such as Borland's Delphi.TM., Microsoft.RTM. Visual Basic, Microsoft.RTM.J++, and Powersoft's PowerBuilder.TM., are rapidly becoming preferred development tools for quickly creating production applications, including those created with the Java programming language. Such environments are characterized by an integrated development environment (IDE) providing a form painter, a property getter/setter manager ("inspector"), a project manager, a tool palette (with objects which the user can drag and drop on forms), an editor, a compiler, and a linker. In general operation, the user "paints" objects on one or more forms, using the form painter. Attributes and properties of the objects on the forms can be modified using the property manager or inspector. In conjunction with this operation, the user attaches or associates program code with particular objects on screen (e.g., button object); the editor is used to edit program code which has been attached to particular objects.

Because development projects--particularly Java projects--use many files, and because the various development tasks (such as editing, debugging, and browsing for information) have traditionally used multiple windows, it can be difficult to find the window one needs. What is needed is a system with an improved user interface which simplifies the job. In particular, what is needed is a simplified application browser that is used to perform all the usual development functions. The present invention fulfills this and other needs.

SUMMARY OF THE INVENTION

The present invention is embodied in a component-based, rapid application development (RAD) Java environment. The system's user interface is structured to increase one's productivity, particularly when developing in Java. Because Java projects use many files, and because the various development tasks (such as editing, debugging, and browsing for information) have traditionally used multiple windows, it can be difficult to find the window one needs. To simplify one's job, therefore, the present invention introduces a new concept in user interfaces for development environments: a single Application Browser or "AppBrowser" that is used to perform all the usual development functions.

The AppBrowser lets the user explore, edit, design, and debug all in one unified window. Serving as a mechanism for hosting arbitrary documents related to development, the AppBrowser presents the documents (or other objects) for manipulation in a window that consists of three panes: Navigation pane, Content pane, and Structure pane. In general, the Navigation pane displays a list of documents, the Content pane displays the document itself, and the Structure pane displays the structure of the document if available.

The grouping of the three panes exists on a browser "context". Multiple contexts can appear on an AppBrowser represented by a tab in a tab set at the lower left of the window. These contexts add a 3D feel to AppBrowser by layering its functionality in one window rather than spread across multiple windows. Switching between completely different contexts is then as easy as selecting a tab. The AppBrowser may have different logic for any given context that is global across the three panes; this logic is provided by implementing a standard browser context interface.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1A is a block diagram of a computer system in which the present invention may be embodied.

FIG. 1B is a block diagram of a software system for controlling the operation of the system of FIG. 1A.

FIG. 2A is a block diagram of a Java development system.

FIG. 2B is a block diagram showing further detail of the virtual machine of the Java development system of FIG. 2A.

FIG. 3 is a bitmap screen shot illustrating a preferred interface of a Java-based visual development system of the present invention.

FIG. 4A is a bitmap screen shot illustrating an application browser interface of the present invention.

FIG. 4B is a bitmap screen shot illustrating synchronization among the different panes of the browser.

FIG. 5A is a bitmap screen shot illustrating a "project" context of the application browser.

FIG. 5B is a bitmap screen shot illustrating an "opened files" context of the application browser.

FIG. 5C is a bitmap screen shot illustrating a "directory" context of the application browser.

FIG. 6A is a bitmap screen shot illustrating a "hierarchy" context of the application browser.

FIGS. 6B-C are bitmap screen shots illustrating operation of the "hierarchy" context of the application browser.

FIGS. 7A-C are bitmap screen shots illustrating operation of "drill down" operation of the application browser.

FIG. 8A is a flow chart illustrating general methodology of the present invention.

FIG. 8B is a block diagram illustrating synchronization of the user interface panes.

DETAILED DESCRIPTION OF A PREFERRED EMBODIMENT

The following description will focus on a preferred embodiment of the present invention (and certain alternatives) embodied in a visual development environment running on an Intel 80.times.86-compatible computer operating under an event-driven operating system, such as the Microsoft.RTM. Windows environment. The present invention, however, is not limited to any particular application or any particular environment. Instead, those skilled in the art will find that the system and methods of the present invention may be advantageously applied to a variety of platforms and environments, whether command-line or GUI based, including MS-DOS, Macintosh, UNIX, NextStep, and the like. Therefore, the description of the exemplary embodiments which follows is for purposes of illustration and not limitation.

General Architecture

A. System Hardware

The present invention may be embodied on a computer system such as the system 100 of FIG. 1A, which includes a central processor 101, a main memory 102, an input/output controller 103, a keyboard 104, a pointing device 105 (e.g., mouse, track ball, pen device, or the like), a display device 106, and a mass storage 107 (e.g., removable disk, floppy disk, fixed disk, optical disk (including CD-ROM), and the like). Additional input/output devices, such as a printing device 108, may be provided with the system 100 as desired. As shown, the various components of the system 100 communicate through a system bus 110 or similar architecture. In a preferred embodiment, the system 100 includes an IBM-compatible personal computer, available from a variety of vendors (including IBM of Armonk, N.Y.).

B. System Software

Illustrated in FIG. 1B, a computer software system 150 is provided for directing the operation of the computer system 100. Software system 150, which is stored in system memory 102 and/or on disk storage 107, includes a kernel or operating system (OS) 160 and a windows shell or interface 180. One or more application programs, such as application programs 170 or windows applications programs 190, may be "loaded" (i.e., transferred from storage 107 into memory 102) for execution by the system 100. OS 160 and shell 180, as well as application software 170, 190, include an interface for receiving user commands and data and displaying results and other useful information. Software system 150 also includes a visual development system 200 of the present invention for developing system and application programs. As shown, the development system 200 includes components which interface with the system 100 through windows shell 180, as well as components which interface directly through OS 160.

In a preferred embodiment, operating system 160 and windows shell 180 are provided by Microsoft.RTM. Windows 95/Windows NT, available from Microsoft Corporation of Redmond, Wash. Those skilled in the art will appreciate that the system may be implemented in other platforms, including Macintosh, UNIX, and the like. Development system 200, on the other hand, includes JBuilder.TM., available from Borland International of Scotts Valley, Calif. Application software 170, 190 can be any one of a variety of software applications, such as word processing, database, spreadsheet, text editors, and the like, including those created by the development system 200.

C. Development System

Shown in further detail in FIG. 2A, a Java development system 200 of the present invention includes a client 210 which employs a virtual machine 220 for executing programs. In particular, the client 210 executes a "compiled" (i.e., bytecode or pseudo-compiled) Java program 240, which has been created by compiling a Java source code program or script 205 with a Java compiler 230. Here, the Java source code program 205 is an application program written in the Java programming language; the pseudo-compiled program 240, on the other hand, comprises the bytecode emitted by the compiler 230. The virtual machine 220 includes a runtime interpreter for interpreting the Java bytecode program 240. During operation, the client 210 simply requests the virtual machine 220 to execute a particular Java compiled program.

As shown in FIG. 2B, the virtual machine 220 comprises a class loader 221, a bytecode verifier 222, a bytecode interpreter 223, and runtime support libraries 224. The class loader 221 is responsible for unpacking the class file which has been requested by a client. Specifically, the loader will unpack different sections of a file and instantiate in-memory corresponding data structures. The class loader will invoke itself recursively for loading any superclasses of the current class which is being unpacked.

The bytecode verifier 222 verifies the bytecode as follows. First, it checks whether the class has the correct access level. Since the class will access other classes for invoking their methods, the bytecode verifier must confirm that appropriate access is in place. Additionally, the bytecode verifier confirms that the bytecode which comprises the methods is not itself corrupt. In this regard, the bytecode verifier confirms that the bytecode does not change the state of the virtual machine (e.g., by manipulating pointers).

Once the bytecode has been verified, a "class initializer" method is executed. It serves, in effect, as a constructor for the class. The initializer is not a constructor in the sense that it is used to construct an instance of a class--an object. The class initializer, in contrast, initializes the static variables of the class. These comprise the variables which are present only once (i.e., only one instance), for all objects of the class.

Runtime support libraries 224 comprise functions which provide runtime support to the virtual machine, including memory management, synchronization, type checking, and interface invocation. At the client, runtime support libraries 224 are included as part of the virtual machine; the libraries are not downloaded with the Java application. The bytecode which is executed repeatedly calls into the runtime support libraries 224, for invoking various Java runtime functions.

D. General Development Interface

The present invention is embodied in a component-based, rapid application development (RAD) Java environment (commercially embodied as Borland JBuilder.TM.). Many of the traditional requirements of programming, particularly for GUI applications, are handled for the programmer automatically by the system.

FIG. 3 illustrates a preferred interface of the Java-based visual development or programming environment 360 provided by the system. As shown, the programming environment 360 comprises a main window 361. The main window 361 itself comprises main menu bar 362, tool bar (buttons) 363, and component palette 364.

Main menu bar 362 lists user-selectable commands, in a conventional manner. The menu bar 362 is where the user selects menu commands. The following provides brief descriptions of menu commands.

    Menu          Commands for
    File menu     Creating, opening, closing, renaming and saving files and
     projects;
                  removing files from projects; configuring printers; printing
     files.
    Edit menu     Copying, pasting, deleting and selecting text; undoing and
     redoing
                  actions.
    Search menu   Finding and replacing text; searching for text incrementally
     and by line
                  number; searching for text across a source path; searching
     for a
                  symbol.
    View menu     Viewing Debugger windows, a new AppBrowser, the next or
     previous
                  error message, the tool bar or the Component Palette.
    Build menu    Making or building the selected node.
    Run menu      Running the application or applet; stepping over or tracing
     into code;
                  running to the end of a selected method; pausing the program;
     setting
                  watches or breakpoints; inspecting, evaluating and modifying.
    Wizards menu  Running utility wizards for tasks such as implementing an
     interface,
                  overriding a method, bundling resources, and wrapping an
     applet.
    Tools menu    Displaying the Environment Options dialog; invoking the
     Windows
                  Notepad and Calculator and other internal tools.
    Help menu     Displaying documentation, such as the Help system, a
     BeansExpress
                  tutorial for creating Java Bean components, the JDK API
     Reference,
                  and the JBCL API Reference. Also for viewing Online web site
     in the
                  user's default web browser, loading the Welcome project for
                  experimenting, and seeing information about this release of
     product.

    Button          Commands for
    File.vertline.Open Opens a project, file, or package.
    File.vertline.Close Closes the active window.
    File.vertline.Save File Saves the active file.
    File.vertline.Save Project Saves the current project and all changed files
     that are shown in the
                    system's project tree.
    Edit.vertline.Undo Reinserts any characters deleted, deletes any characters
     inserted,
                    replaces any characters the user overwrites, or moves the
     cursor back
                    to its prior position.
    Edit.vertline.Redo Reverses the effects of an Undo.
    Search.vertline.Find Searches for text within the active file.
    Search.vertline.Replace Replaces specified text with other specified text
     in the current file.
    Search.vertline.Search Again Finds the next occurrence of a search string
     in the current file.
    Search.vertline.Browse Loads the specified class into the AppBrowser. The
     class must be on
                    the imports path of the current file.
    Run.vertline.Run Compiles and runs the application using the startup
     parameters in the
                    Parameters dialog box.
    Run.vertline.Debug Compiles the program and runs it in the Debugger using
     the startup
                    parameters in the Parameters dialog box.
    Build.vertline.Make Compiles any .java files within the selected node that
     have outdated or
                    nonexistent .class files. Also compiles any of the node's
     imported files
                    that the node depends on which have outdated or nonexistent
     .class
                    files.
    Build.vertline.Rebuild Compiles all .java files within the selected node,
     regardless of whether
                    their .class files are outdated. Also compiles the imported
     files upon
                    which the node depends, regardless of whether their .class
     files are
                    outdated.

    File Type   Editor(s) or Viewer(s) available in the Content pane
    Text files  If the user selects a text file in the Navigation pane (a file
     with an extension such as .txt or
                .bat), a single editor, identified by the Source tab, is
     available in the Content pane. This is a
                simple text editor that lets one see and modify the text file.
     JBuilder recognizes certain file
                extensions (such as .txt and .bat) as text files. However, the
     user can extend this list.
    Image files If the user selects a .GIF, .JPG, or .BMP image file in the
     Navigation pane, an image
                viewer, identified by the View tab, is available in the Content
     pane.
    HTML files  If the user selects an HTML file in the Navigation pane, two
     tabs are displayed at the
                bottom of the Content pane, labeled View and Source.
                View tab
                         The View tab selects an HTML viewer. This viewer lets
     the user see the
                         rendered HTML flle, as the user would see it in a web
     browser.
                Source tab
                         The Source tab selects an Editor that lets the user
     see and edit the file as raw
                         HTML source.
    .java files If the user selects a .java file in the Navigation pane, the
     system displays three tabs labeled
                Source, Doc, and Design.
                Source tab
                         If the user selects the Source tab when viewing a
     .java file, the system will
                         display the JBuilder Java Source Code Editor. This is
     a full-featured,
                         syntax-highlighted programming editor, with several
     popular key mappings.
                Doc tab
                         If the user selects the Doc tab when viewing a .java
     file, the system will display
                         the corresponding reference doc for that .java file,
     if there is one. Java supports
                         a documentation standard called JavaDoc that
     automatically generates HTML
                         documentation pages from .java source code and
     comments.
                         JBuilder has produced an enhanced version of JavaDoc,
     called JBDoc. JBDoc
                         produces HTML files that show additional information
     about JavaBeans
                         properties, methods and events. JBuilder comes with
     JavaDoc or JBDoc HTML
                         pages installed for the following:
                         JavaSoft packages (JavaDoc)
                         Borland JBuilder (borland.jbcl) packages (JBDoc)
                         Selected third-party packages
                         If the user clicks on the Doc tab for any of these
     provided java files, will view
                         the HTML documentation page for the class.
                Design tab
                         If the user selects the Design tab when viewing a java
     file, the system will
                         display the JBuilder visual design tools for that
     class. For example, if the user
                         selects the WelcomeFrame.java class in the Welcome
     project (or a Frame class
                         in the user's own project), the system will display
     the JBuilder UI Designer in
                         the Content pane. This designer will show the user
     what the UI appearance of
                         this class will be at run-time, and lets the user
     visually construct and develop
                         the user's UI.

• Inventors
  Minard, Jayson R.;
• Assignee
  Borland Software Corporation (Scotts Valley, CA)
• Published
  Jun-12-2001
• Current US Classes:
  345/629
  345/854
  707/104.1
  709/206
  715/501.1
  715/513
  717/100
  717/107
  717/118
• Application #
  992434
• International Classes
  G06F 017/30; G06F 017/00; G06F 013/00
• Field of Search
  707/501 707/513 707/206 707/1 707/101 707/104 709/203 709/206 709/224 709/229 345/357 345/435 395/500.13 717/1 717/4
• Examiner
  Vu; Kim
• Agent
  Smart; John A.
• US Patent References:
  5734882
  5740444
  5768510
  5794259
  5801689
  5802334
  5815154
  5815415
  5826254
  5835712
  5838906
  5842020
  5845298
  5848424
  5852439
  5864676
  5870559
  5877766
  5917498
  5953525
  6026362
  6078327