JGraph Swing组件详解：作者解析与改进历程

需积分: 9 62 浏览量更新于2024-08-02 收藏 908KB PDF 举报

《JGraph Swing组件的深入探讨》这篇由Gaudenz Alder在2001年11月至2002年3月期间完成的硕士论文，着重于JGraph组件的设计与实现，它是在Java Swing框架下的一款图形绘制和可视化工具。JGraph是瑞士联邦理工学院（ETH Zurich）计算机科学系全球信息系统组的研究成果，其作者在该学期项目中开发了初始版本，并将其作为开源项目发布在网上。论文的目的是为了解决早期JGraph组件存在的问题，特别是文档缺乏以及与Swing兼容性不足的问题。作者在收集了来自Java社区的大量反馈，包括功能需求、错误报告、评论和建议后，对组件进行了改进。这些反馈帮助识别了JGraph包中的其他弱点，比如可能存在的API不清晰、用户体验不佳或性能瓶颈等问题。 JGraph Swing Component的核心内容包括： 1. **设计与实现**：论文详细介绍了JGraph组件如何利用Java Swing API进行图形用户界面（GUI）的构建，如图形节点、边、布局算法等。这部分内容对于理解Swing组件在图形绘制中的应用非常有价值。 2. **文档完善**：鉴于早期版本的文档不完整，论文强调了对组件的详细文档编写，包括使用指南、API参考和示例代码，以提高开发者的学习曲线和工作效率。 3. **Swing兼容性**：作者着重解决了JGraph与Swing框架的集成问题，确保了组件与其他Swing组件的无缝交互，使得用户可以更方便地将JGraph嵌入到Swing应用程序中。 4. **问题修复与优化**：通过处理社区提交的bug报告和建议，论文揭示了在开发过程中遇到的技术挑战，以及如何通过代码重构和性能优化来解决这些问题。 5. **开源项目发展**：作为开源项目的后续，论文反映了JGraph组件的发展历程，包括如何吸收用户反馈，以及如何通过社区合作推动软件的持续改进。 6. **版权与致谢**：论文强调了版权归属和保留，同时也表达了作者对Ana的感谢，她被认为是作者工作的重要支持。《JGraph Swing Component》不仅是一份技术论文，更是关于如何在开源环境中开发和维护高质量组件的一次实践研究，为开发者提供了宝贵的经验教训。阅读此论文有助于深入理解Java Swing框架下的图形组件开发策略和最佳实践。

Design and Implementation of the JGraph Swing Component

1 Introduction

After a brief overview of the fundamentals of graph theory and Swing, this

introduction outlines the structure of the document, and the literature that was

used. For additional information, updates, binaries and source code see the

Home Page of JGraph at http://www.jgraph.com.

1.1 Overview

Fig. 1: The Peterson graph

The intention of this project is to provide a freely available and fully Swing

compliant implementation of a graph component. As a Swing component for

graphs, JGraph is based on the mathematical theory of networks, called graph

theory, and the Swing user interface library, which defines the architecture. By

combining these two, a Swing user interface component to visualize graphs

will be obtained. (The term graph is used in the sense of graph theory

throughout this document, not to be confused with function plots.)

The following principles guided the implementation of JGraph:

• Full Swing Compatibility

• Clear & Efficient Design

•

Short Download Time

• 100 % Pure Java

The idea behind these principles is based on the experience with other

graph libraries, which typically come as large and complex frameworks that

are not standards compliant.

In JGraph instead, the basic architecture is the same as for standard Swing

components, and the method and variable naming complies with Java code

conventions. This has the advantage of reduced learning costs, and existing

source code can be reused, resulting in shorter development time.

Design and Implementation of the JGraph Swing Component

1.1.1 Graph Theory

The concept of a graph is based on a well-founded mathematical theory,

called graph theory, which is rigorously defined in [1], [2] and [3]. A graph

consists of vertices and of edges connecting certain pairs of vertices. The

exact geometric pattern is not specified.

As a mathematical generalization of lists and trees, graphs come into play

where lists and trees are not sufficient to model the relations. For example, in

a tree each node has at most one parent, and zero or more children, whereas

in a graph, each vertex simply has zero or more neighbors. (In the case of the

list, each node has at most two neighbors.)

The single term neighbor to emphasize the more general setup replaces the

terms parent and child used in the context of trees. The term cell is used in

place of node throughout this document to distinguish between the elements

of graphs, and those of lists and trees.

Formally, a graph G consists of a non-empty set of elements

V(G)

and a

subset E(G) of the set of unordered pairs of distinct elements of V(G). The

elements of V(G), called vertices of G, may be represented by points. If (x, y)

∈ E(G), then the edge (x, y) may be represented by an arc joining x and y.

Then x and y are said to be adjacent, and the edge (x, y) is incident with x and

y. If (x, y) is not an edge, then the vertices x and y are said to be

nonadjacent

Graph theory also offers standard algorithms to solve common graph

problems. For example, the Dijkstra algorithm can be used to find the shortest

path between two vertices of a graph. The Dijkstra algorithm, and many other

standard algorithms are explained in [4], [5] and [6]. (An implementation of the

Dijkstra algorithm ships with the JGraphpad example application.)

To summarize, graphs are used as a paradigm in JGraph to display any

network of related objects. A road or computer network, a molecule, software

architecture, or database schemas are examples of graphs. Since graphs are

a mathematical generalization of lists and trees, JGraph may also be used to

display simpler structures, as for example a file system tree.

1.1.2 Swing

Swing is the user interface library that ships with Java, and provides the

elements that can be placed on an application’s windows. Such elements are

called user interface components, or simply components. Common

components are buttons, lists, trees and tables.

Swing is based on AWT, which stands for Abstract Windowing Toolkit. AWT

is another user interface library that ships with Java and may be used

independently of Swing. In contrast to AWT, Swing is more sophisticated, and

provides many built-in features.

Design and Implementation of the JGraph Swing Component

A good introduction to Java and AWT is given in [7] and [8]. [9] and [10] are

for the more experienced programmers. In contrast to AWT, Swing is only

explained in [11] and [12], and there is a good web-based Swing Tutorial [13].

The documents mentioned before discuss existing components in great

detail, but do not explain how to create new components. (Not to think of an

in-depth study of Swing MVC, which is the basic architecture that all Swing

components have in common [17].) Swing’s source code must be used to

elaborate the required information.

graph: JGraph

GraphView

graph: JGraph

GraphView

graph: JGraphgraph: JGraph

GraphModel

graph: JGraph

GraphView

Fig. 2: Model-View-Control (MVC)

In a nutshell, the model provides the data, which is a graph – in the sense

used in graph theory – and the JGraph object provides a view of the data, in

platform specific manner. The Swing MVC design pattern is used to separate

the model from the view and establish a relation between them, such that

more than one view can be attached to the same model, and all views are

automatically updated when the model changes.

JGraph is largely based on Swing’s component for trees, called JTree,

which is explained in [14]. Some ideas were adopted from Swing’s text

components, namely the Element interface, which is discussed in [15], and

the views [16]. The JGraph class itself is an extension of

JComponent

, which

is Swing’s base class for all components.

JGraph complies with all of Swing’s standards, such as pluggable look &

feel, datatransfer, accessibility, internationalization, and serialization. Also, all

concepts used in JGraph are common, well-known concepts from Swing. For

the more sophisticated features such as undo/redo, printing, and XML

support, additional Swing standards were used. Aside from Swing’s

standards, JGraph also complies with the Java conventions for method and

variable naming, source code layout, and javadoc comments.

Design and Implementation of the JGraph Swing Component

2 The JGraph Component

The implementation of JGraph is entirely based on the source code of the

JTree [14] class, which is Swing’s component for displaying trees. Rather than

explaining JGraph from scratch, this description focuses on the differences

between the two classes. Swing features such as serialization, datatransfer,

and the Swing MVC pattern are explained in the appendix.

2.1 Foundation

JGraph is not an extension of JTree; it is a modification of JTree’s source

code. In the following, the changes are briefly outlined, pointing to the classes

and methods that were modified or introduced. The modifications are grouped

into:

1. Differences between trees and graphs

2. JGraph requirements (features)

The following important differences between trees and graphs lay the

foundation of the JGraph component:

2.1.1 Overlapping Cells

In a tree, the position and visibility of a cell depends on the expansion state.

In a graph, instead, the position and size of a cell is user-defined, possibly

overlapping other cells. Consequently, a way to enumerate the cells that

intersect the same position, and to change the order in which they are

returned is provided.

2.1.2 Multiple Cell Types

A tree consists of nodes, whereas a graph possibly consists of multiple cell

types. Consequently, JGraph provides a view for each cell, which specifies

the renderer, editor and cell handle. Additionally, a graph view is provided,

which has its own internal representation of the graph. The idea of views has

been adopted from Swing’s text components [16].

2.1.3 Separate Geometry

The mathematical definition of a graph does not include the geometric

pattern or layout. Consequently this pattern is not stored in the model, it is

stored in the view. The view provides a notification mechanism, and undo-

support, which allows changing the geometric pattern independently of the

model, and of other views. Since Swing’s undo manager is not suitable for this

setup, JGraph provides an extension of this Swing’s default undo mechanism

in the form of the

GraphUndoManager

class.

剩余110页未读，继续阅读

flyingEric

粉丝: 0
资源: 2

JGraph Swing组件详解：作者解析与改进历程

深入解析Java图形组件JGraph源码结构

JGraph入门教程：从Manual到实践

Java图形组件JGraph的压缩包解析

JGraph 手册+The JGraph Tutorial

Swing 实现 JGraph

jgraph

JGRAPH

JGraph

jGraph简介

jgraph包

最新资源