Rogue Wave JViews Maps
Don't miss these features!
Getting assistance
Contacting Rogue Wave support
Electronic Services
Online documentation help
How to use this documentation
Browser compatibility
General information
Before you start
Applications
SDKs
Components for Java and Web deployment
Running the samples
Compiling a Rogue Wave JViews program
Distribution structures
JViews Maps distribution structure
Rogue Wave JViews Maps jar files
Additional directories
JViews Diagrammer distribution structure
Rogue Wave JViews Diagrammer jar files
Additional directories
JViews Framework distribution structure
JViews Framework jar files
Additional jar files
Additional directories
Open source software in JViews
Deployment licenses
About deployment licenses
Declaring the use of Rogue Wave JViews services
Monitoring the use of Rogue Wave JViews services
Release notes
Requirements for Rogue Wave JViews Maps
Rogue Wave JViews Maps 9.0 release notes
JViews Maps API in Eclipse
API changes
Previous release notes
About this documentation set
What you need to know
Notation conventions
Data used in this documentation
Samples and code examples
Starting the samples
Running application and applet samples
Copying a sample
Running the server-side samples on Apache Tomcat
Building the samples for the Apache Tomcat Web server supplied with the product
Building the samples for another Apache Tomcat Web server
Running the server-side samples on the Apache Tomcat server supplied with the product
Running the samples for WebSphere Application Server (WAS)
Installing and starting the samples for WAS
Running the server-side samples on WAS
Running the server-side samples in a headless environment
Design tools
Map Builder
Running the Map Builder
The Symbol Editor
Running the Symbol Editor
On Windows
On UNIX
Designer for Rogue Wave JViews Diagrammer
Running the Designer
On Windows
On UNIX
The Dashboard Editor
Running the Dashboard Editor
On Windows
On Unix
JViews Maps samples
Importing map data with the JViews Maps SDK
Symbols and overlaid graphics in JViews Maps
Building a user application
JSF samples
Integration
Installing and using Eclipse samples
Installation of a new local site
Plug-in descriptions
Setting up a workspace for browsing source files
JViews Diagrammer samples
Diagram samples
Dashboard samples
Graph layout samples (SDK)
Advanced samples
JSF samples
JavaScript samples
Integration
Installing and using Eclipse samples
Installation of a new local site
Plug-in descriptions
Setting up a workspace for browsing source files
JViews Framework samples
Basic samples (SDK)
Grapher samples
Accessibility samples
Performance
Integration
JSF samples
JavaScript samples
JViews Maps code examples
Importing map data
Projections
Advanced techniques
JSF Web applications
JViews Diagrammer code examples
Basic code examples
Animation and complexity
Graph layout
Label layout
JSF Web applications
JViews Framework code examples
Graphic objects
Interactors
Advanced features
Getting started
Introducing JViews Maps
About JViews Maps
Overview
Cartography
What is a map?
Spatial reference systems
Coordinate systems
Map projections
Map data formats
The added value of JViews Maps
Overview
Display of complex maps
Performance
Component libraries
Map Builder
Map preparation
Advanced map animation
Typical uses of JViews Maps
Overview
General use
Typical actions
Developing with the SDKs
Basic concepts
Usage and design concepts
Usage concepts
Design concepts
Development approach
Map preparation
Overview
Importing map data
Merging
Contextual information display
Coordinate system
Grids, units, and measures
Export
Map animation
Overview
Performance
Map manipulation components
Symbology
Architecture
Overview
Populating the map
Map data sources
Diagram data sources
The SDM engine
Styling
Overview
The map theme
JViews Diagrammer style sheets
Symbols
Graphics SDK for experts
Developing a dynamic map
Overview
The process flow
Overview
Defining a set of background maps
Toolchain for an application without predefined background maps
Creating a map with the Map Builder
Overview
Importing map data sources
Styling properties
Setting preferences
Saving the map
Handling symbols
Prototyping the application with the designer
Introducing JViews Diagrammer
About JViews Diagrammer
Overview
Types of displays covered by JViews Diagrammer
Diagrams
Dashboards
Map-based displays
Types of deployment platforms
Key aspects of a JViews Diagrammer user interface
Symbols
Model-driven diagrams
Dashboards and monitoring panels
The JViews Diagrammer tool chain
Basic concepts
General architecture
Views
Data
Styling
Symbology
User interactions
Graph layout
Refreshing the display in real time
Creating diagramming applications
Managing the views
The SDM engine
The data model interface
The renderers
The grapher
The interactors
Populating a diagram
The data sources
The style sheets
The project
Graph layout
Backgrounds and maps
Using Designer projects
How the Designer helps the developer
Filling the data model
Viewing the data model as a diagram
Viewing style rules
Creating style rules
Configuring the layout
Defining a background
Saving the project
Controlling the diagram in an application
Actions
Toolbars and menus
Overview
Tree and table
Property sheets
Application
Advanced configuration
Customizing the application
The Rogue Wave JViews Framework path
Managing dashboards
Overview
Direct data feeding
Dashboard introspection
Integration and deployment
Developing with design tools
Using the Map Builder
Getting Started
Running the Map Builder
An example map
Overview
Creating a map
Setting map properties
Adding data to a particular state
Saving the current map
Adding data to a particular city
Saving the final map
Getting to know the Map Builder
Maps
Overview
Map layers
Map themes and zoom levels
Saving a map theme with or without map data
Map layer hierarchy
Viewing hidden map layers
Map Dynamic Styles
Split or filtered map layers
Coordinate systems supported
Map data supported
Exporting map data
Map Builder features
Overview pane
Symbols
Using JViews Diagrammer Designer to design symbols
Properties
Sublayer properties
Areas of Interest
Map scale pane
Preferences
Coordinate systems
Labels
Annotations
Grid Settings
Map magnification
Map rotation
Compass
Advanced Settings
Legend
Additional views
Data sources
Printing Features
Multithread monitor
Orthodromy Measures
Tiled Images for a Thin Client
Zoom Configuration
Using more Map Builder features
Map Builder main window
Overview
Map Builder toolbar
Menus
The pop-up menu
Opening a Map
Importing data sources
Importing a simple data source
The Select Data Sources pane
Importing an ESRI/Shape file
Importing nongeoreferenced image files
Importing a TIGER/Line file
Importing a DXF file
Importing a Web Map Server Image
Importing layers from a DB2 spatial database
Importing layers from an Informix spatial database
Importing layers from an Oracle spatial database
Importing an SVG file
Importing any file type using menus
Using drag-and-drop
Exporting data sources
Map Layers
Managing map layers
Setting dynamic styles
Using the map style property sheet
Setting sublayer properties
Creating a map layer hierarchy
Populating a new layer or sublayer
Deleting a map layer
Hiding and showing a map layer in the tree
Displaying and concealing a map layer
Positioning layers in the map hierarchy
Renaming a map layer
Splitting or filtering a map layer
Simplifying the polygons in a layer
Adding layer styling based on metadata
Managing annotations
Annotations
Creating annotations
Making annotations visible or invisible
Editing annotation labels
Repositioning annotations
Changing the shape of an annotation
Adding and removing points to/from an annotation
Changing the style of an annotation
Deleting annotations
Managing Symbols
Overview
Adding a new group
Adding a new symbol from a palette
Editing a symbol from a palette
Symbol operations
Setting symbol layer properties
Managing areas of interest
Overview
Creating a new area of interest
Renaming an area of interest
Deleting an area of interest
Refreshing an area of interest
Moving an area of interest up or down
Zooming In on an area of interest
Setting the map scale
Setting preferences
Setting coordinate systems
Overview
Coordinate system tab
Predefined coordinate systems
Displaying labels
Displaying a grid
Creating an orthodromy measure
Deleting an orthodromy measure
Overview
Deleting all orthodromy measures in a layer
Deleting a single orthodromy measure
Magnifying part of a map
Rotating a map
Using the Compass
Using the Data Sources pane
Using Advanced Settings
Setting base text direction
Bidirectional text support
Setting base text direction in map components
Using the Multithread Monitor
Setting thin client parameters
Printing a map
Saving a map
Writing an application
Preparing to deploy a map component
Creating a read-only map application
Creating a Simple Map Application
Using the Symbol Editor
Getting started with the Symbol Editor
About the Symbol Editor
Running the Symbol Editor
Default palettes of symbols
Understanding symbols
Planning a project for the Symbol Editor
Working with symbols
Making a new symbol
Understanding the Styling Customizer
Adding an object
Selecting an object
Performing basic object customization
Deleting an object
The Undo and Redo facilities
Using palettes and categories
Creating a new palette
Creating a new category
Saving a symbol
Understanding the Symbol Palettes pane
Closing and opening symbols and palettes
Transforming symbols using parameters
Creating a new parameter
Transforming an object
Adding flexibility using parameters
Working in different modes
Testing your symbol
Transforming symbols using conditions
Using link-in and link-out ports
The BAM Dashboard example
About Business Activity Monitoring
Definition of the dashboard
Definition of the dashboard symbols
Creating the dashboard symbols
Creating the dashboard
Generating and using symbol reports
Generating a report for all symbols
Filtering a report to show specific symbols
Navigating through different palettes in a report
Searching for a symbol in the open palettes
Refreshing a palette report
Saving a report
Reorganizing palettes
Using more features of the Symbol Editor
Exploiting advanced graphics features
Supported graphic formats
Importing a vector graphic
Converting SVG images to symbols
Control of group layout
Adding intelligence to an advanced graphic
Additional transformation techniques
Transforming object position
Rotating an object
Customizing text style and contents
Setting base text direction for symbols
Bidirectional text support
Setting base text direction for the Text element of a Symbol
Revisiting the BAM dashboard
Making a simple status indicator
Creating the SVG region symbol
Understanding interactors
Working with interactors
Creating a rotation interactor
Creating a push interactor
Creating a horizontal interactor
Applying interactors to multiple objects
Using expressions
Designing for performance
Performance guidelines
Creating a light alarm symbol using the image list creation wizard
Next steps after the Symbol Editor
Integrating a symbol into JViews Dashboard Editor
Changing base text direction dynamically at run time
Base text direction: same value for all text elements of a symbol
Assigning one specific value to a specific text element of a symbol
Integrating a symbol into Designer for JViews Diagrammer
Generating symbols as Java source code
Using the Designer
Getting started
Running the Designer
Creating a diagram
Launching the New Diagram Wizard
Choosing the format of data to import
Importing your JViews Diagrammer XML data
Editing the data model
Selecting the type of diagram
Choosing a graph layout theme
Saving the diagram
Adding to the style sheet
Selecting the rule on all nodes
Selecting the rule on all links
Customizing genealogy nodes by type
Creating a person rule
Renaming a rule
Assigning a specific symbol to the person nodes
Setting properties in the Styling Customizer for person nodes
Setting properties for females
Adding a death fact to person nodes
Customizing the death date
Creating a couple rule
Assigning a specific symbol to the couple nodes
Setting properties in the Styling Customizer for couple nodes
Rule-select and blue icons
Status icons and local properties
Customizing genealogy links by type
Creating a couplelink rule
Setting couplelink properties
Testing application behavior
Adding and customizing a legend
Integrating your development into an application
Reusing a project in the Designer
Getting to know the Designer
Style rules
Style Rules pane
Options
Node and link rules
Level of detail
Styling customizers
Styling properties
Priority
Style sheet debugging
Resetting of default property values
Graph and link layouts
Layout selection
Layout customization
Label layout
Label layout customization
Symbols
About symbols
Styling Customizer
Assigning a symbol
Editing a symbol
Refreshing symbols
Palette management
General links
Link connections
Interactors
About interactors
Predefined interactors
Customizing interactors
Working in different modes
The three modes
Working in Style Editing mode
Working in Preview mode
Working in Diagram Editing mode
Using wizards
New Diagram wizard
Create Style Rule wizard
Change Style Rule wizard
Graph Layout wizard
Data wizard
The Rule menu
Cutting
Copying
Pasting
Pasting styling properties
Deleting
Renaming
Viewing as CSS
Moving up or down
Enabling or disabling
The Undo and Redo facilities
The Check Rules facility
Messages for troubleshooting
Printing the diagram
Print operations
Page Setup
Print Preview
Comparing the Designer and the API
Using more Designer features
Changing Layout Parameters
Customizing graph layout algorithms
Using the genealogy diagram
Changing a basic parameter
Changing a link style parameter
Setting a link style with mixed links
Using the Graph Layout Wizard
Loading a different style sheet
Resetting a default value after a state change
Importing data from a flat file
Loading the file
Importing node data
Importing link data
Mapping node data
Mapping link data
Editing the data model
Selecting the diagram type
Inserting an icon
Image file formats
Setting a special symbol
Creating rules for population ranges
Rule priority
Creating a user-defined data model
Creating the data model
Editing the data model
Changing the graphic representation of the nodes
Adding decorations for alarm severities
Adding a node to a diagram
Using subgraphs
Creating subgraphs by grouping objects
Styling subgraphs
Displaying different levels of detail
Using background maps
Importing data from a database
Loading the database
Connecting to the database
Mapping the database
Editing the data model
Selecting the diagram type
Choosing a Graph Layout Theme
Using data model expressions
About references and expressions
Using expressions in text properties
Using expressions in numeric or fixed-value properties
Using Expression Assist
Using variables
Using custom functions
Displaying help on expressions
Importing data from a JViews TGO data file
Loading the file
Importing node and link data
Selecting the diagram type
Setting base text direction
Bidirectional text support
Setting base text direction in a diagram
Setting base text direction for nodes
Setting base text direction for links
Writing an application
Deployment considerations
Deployment paths
Functional application types
JViews Diagrammer classes available as beans
Creating a JViews Diagrammer application
Creating an application instance
Customizing the predefined application
Creating a basic application from JViews Diagrammer beans
Adding further components
An editing application created from JViews Diagrammer beans
Printing the diagram from an IlvDiagrammerApplication instance
Data formats
About supported formats
Application data in XML files for JViews Diagrammer
Diagram format in XML
Metadata in the XML data file
Application data in flat files for JViews Diagrammer
Application data in databases for JViews Diagrammer
Project files
Style sheet files
Next steps after the Designer
Specifying a different data source
Using the Dashboard Editor
What is a dashboard
Using the Dashboard Editor
Running the Dashboard Editor
Creating a dashboard
Adding a symbol to a dashboard
Linking symbols
Adding links
Link-in and link-out ports
Enabling link layout
Editing the dashboard background
Adding shape background objects
Adding and editing polyline objects
Adding a point to a polyline object
Editing background object properties
Using layers in a dashboard diagram
Understanding layers
Setting the default insertion layer
Raising and lowering a background object between layers
Raising and lowering a layer
Setting layer visibility
Setting layer transparency
Saving a dashboard
Changing symbol parameters
Aligning and grouping objects
Testing your dashboard
Dashboard XML files
Loading a palette
Adding charts
Opening a dashboard
Editing multiple documents
Opening a dashboard from within a dashboard
Setting base text direction
Bidirectional text support
Setting base text direction at the dashboard level
Setting base text direction at the background text elements level
Setting base text direction at the symbol level
Setting base text direction at the symbol text element level
Programming the Dashboard Editor
A basic Dashboard Editor
The Dashboard Editor sample
IlvDashboardDiagram and IlvDashboardEditor
Dashboard GUI components
Adding menus
Adding toolbars
Adding the Tree pane
Adding a Property pane
Using the Overview pane
Using the Palettes pane
Dashboard actions
Retrieving the link layout of a dashboard
Reading and writing dashboards
Using the compiled symbol Dashboard Reader
Changing the value of dashboard symbol parameters dynamically
Base text direction
Elements eligible for base text direction
Setting base text direction programmatically
Enabling dynamic change at run time
Using the Symbol Compiler
Introducing the Symbol Compiler
Getting started with the Symbol Compiler
Running the Symbol Compiler
Compiling symbols
Testing compiled symbols
Getting to know the Symbol Compiler
What you can do with the Symbol Compiler
Loading symbol palettes
Displaying the Java source code
Working with project symbols
Output directories
Generating source files
Compiling Java classes
Testing the compiled symbol classes
Compound symbols and subsymbols
Symbol compiler project file
Basic settings and predefined CSS functions
Using compiled symbols in applications
What is a compiled symbol?
Generated class of a compiled symbol
Using compiled symbols in an IlvDiagrammer
Using compiled symbols in a runtime dashboard
Reading a dashboard binary file in a grapher
Parameter accessors and mappings
Using compiled symbols at the Graphic Framework level
Programmer's documentation
Programming with JViews Maps
Introducing the main classes
Reader framework
Class diagram
The IlvMapFeature class
The IlvMapFeatureIterator interface
The IlvFeatureRenderer interface
The IlvMapStyle class
The IlvMapGraphic interface
The IlvMapDynamicStyle class
Map layers and map styles
Introduction to layers and styles
Map layers for graphic objects
Composite layers
Label layer
Grid layers
Map scales and layer styles
Map attribute filters
Map-specific manager properties
Altitude management
The display preferences property
The data source property
Map layer tree
Thread monitoring
Map labeling
Areas of interest
Coordinate system
Persistent symbol model
Readers and writers
Overview of readers and writers
The pivot format reader and writer
Saved files
Saving and reloading a map
Map Export API
The shapefile reader and writer
The MID/MIF reader and writer
The DTED file reader
The image file reader
The IBM spatial database readers
The Oracle spatial reader and writer
The GeoTIFF reader
The TIGER/Line reader
The DXF reader
The KML reader and writer
The DEM/GTOPO30 reader
The Web Map Server reader
The SVG reader
Raster image management
Raster image management classes
The IlvRasterAbstractReader class
Image tiling and subsampling
Persistence of images
The IlvRasterMappedBuffer class
The IlvRasterProperties class
Graphical User Interface beans and interactors
Geodetic computation and date line wrapping
Utilities
Ellipsoid and geodetic datums
Modeling the earth
Ellipsoids
Overview of ellipsoids
Defining new ellipsoids
Defining a spherical ellipsoid
Predefined ellipsoids
Geodetic datums
Datums
Defining a new horizontal datum
Predefined datums
Map projections
Introducing map projections
Predefined projections
Projection methods and parameters
Creating a new projection
Spatial reference system
Coordinate system base class
Geocentric Coordinate System
Geographic Coordinate System
Projected Coordinate System
Creating a map application using the API
Overview
Creating data source objects
Data source
Vector data sources
Raster data sources
Using data sources
Overview
Integrating the data source
Layer styling considerations
Clearing map data
Developing a new data source
Understanding the data source backup paradigm
Renderer management
Layer management
Data tiling
Feature management
Printing
Overview of multithreading
Use of threads in the Map Builder
Use of threads in map labelling
Using threads in tile loaders
Using threads in data sources
Using the IlvThreadMonitor
Generic code sample for creating a map
Using readers
Code examples for using readers
The map loader
Developing a new reader
Optimizing the reader
Map GUI interactors
Pan
Zoom rectangle
Continuous zoom
Rotate
Distance measuring
The See-Through interactor
Using the GUI beans
Map Overview
Area of Interest panel
Scale Bar
Scale Control Bar
Zoom Control panel
Legend panel
Coordinate System Editor
Display Preferences Editor
The Coordinate Viewer
The Map Layer Tree
The Toolbar
Multithread Monitor
Coordinate Panel Factory
Compass
Using annotations
The Symbology Tree View bean
Handling map features
Map Feature Geometry
Map Feature Attributes
Using load-on-demand
Load-on-demand
Structure of the tiling grid (indexed mode only)
Size of the tiling grid in indexed mode
Structure and size of the tiled layer (free mode only)
Displaying the state of tiles
Controlling load-on-demand
Managing errors and load-on-demand events
Caching tiles
Saving a tiled layer
Writing a new cache algorithm
Writing a tile loader for a custom data source
Load-on-demand for hierarchical data sources
Manipulating renderers
Overview
Overview of renderers
Creating a colored line renderer
Making a renderer persistent
Extending an existing renderer
Using CSS to customize the rendering process
Renderers and styling
Rendering with a geodetic computation
Handling spatial reference systems
Converting between two spatial reference systems
Converting coordinates between coordinate systems
Predefined math transformations
Transforming data
Adding Graphic Objects on Top of an Imported Map
Managing units
Pregenerating tiled images for a thin client
Integration
Overview of integration
Integrating with JViews Diagrammer
Overview
Using symbols and maps in the Designer for JViews Diagrammer
Integrating a JViews Diagrammer project into an application
Using symbols through the API
Overview of symbols
Storing symbols
Integrating symbols into an application
Populating the SDM model
Creating symbol groups
Using JViews Maps in SWT applications
Installing the JViews runtime plug-in
Map data
DTED0
ESRI shape
ESRI shape or TIGER/Line
GeoTIFF, JPG or PNG
GTOPO30
VMAP0
Other data sources
Accessible Maps
Accessibility: the definition and the disabilities it covers
Keyboard Navigation
Use of colors in accessible applications
Developing with the JViews Diagrammer SDK
Introducing the SDK
The diagram component
What is a diagram component
The Diagrammer class
The data source
The style sheets
The project
Managing the diagram
Styling and Data Mapping (SDM)
Overview
The SDM engine
The SDM data model
Renderers
The grapher
Interactors
Composite graphics and symbols
Maps
Developing applications
User interface components
Customizing the user interface components
Deploying applications
Overview
Java AWT/Swing application
Java applets
Java Web Start
Web deployment
Eclipse/RCP
Using the Graphics Framework directly
Overview
Accessing and creating basic graphic objects
Storing graphic objects in layers
Organizing graphic objects into graphs
Composite graphics in Java code
Using and writing data models
Overview
Deciding your data model strategy
Implementing the behavior of data model objects
Methods for navigating among nodes and links
Methods for retrieving ID, tag, and properties
Methods for implementing listeners
Methods for editable models
Connecting data sources to the diagram component
XML data source
JDBC data source
Flat file data source
In-memory data source
Custom data model
JavaBeans example
The Molecule example
The Atom, Bond, and Molecule classes
The Molecule model
The Phenol Molecule data source
Loading the Molecule into the diagram component
NonJavaBeans example: abstract model variant
The Tree Model example
The Swing JTree
The TreeSDMModel class
The TreeSDMNode class
The TreeSDMLink class
Loading the data model and style sheet into the diagram component
NonJavaBeans example: basic model variant
The second Tree Model example
The TreeSDMModel2 class
The TreeLink class
Loading the data model
Using a custom data model in the Designer
Exporting your data model
Loading the XML file
Writing your application
Handling XML data files in Java
Reading data
Writing data
Reading and writing custom XML formats
Content on demand
About content on demand
Concepts
Classes involved
Using content on demand
Content on demand and tiling systems
Using CSS syntax in the style sheet
Overview
The origins of CSS
The CSS syntax
Style rule
Selector
Declaration
Priority
Cascading
Inheritance
Applying CSS to Java objects
Overview
The CSS engine
The data model
CSS recursion
Expressions
Divergences from CSS2
Customizing general nodes in the style sheet
Overview
Controlling the node’s shape
Controlling the node’s skin
Controlling the node’s border
Controlling the node’s label
Controlling the node’s icon
Automatic resizing
Decorations
Customizing general links in the style sheet
Controlling the link’s look
Obtaining color effects
Controlling link decorations
Controlling arrows
Controlling extra effects
Summary of link properties
Using and adding renderers
About renderers
Using renderers in the style sheet
Enabling a renderer
Customizing a renderer
Using rendering properties on objects
Predefined renderers
Class summary
The Coloring renderer
The Decoration renderer
The Blinking renderer
The GrapherPin renderer
The DrillDown renderer
The HalfZooming renderer
The InfoBalloon renderer
The Composite renderer
The Interactor renderer
The LabelLayout renderer
The Legend renderer
The Map renderer
The StyleSheet renderer
The Map StyleSheet renderer
The SubGraph renderer
The SwimLanes renderer
Adding your own renderer
Writing a renderer class
Registering a renderer
Loading and customizing a renderer
The Flag renderer example
Overview
Header part
Bean properties
Private methods
Overloading methods of the Filter class
Integrating the Flag renderer
Possible enhancements
Configuring renderers in Java code
Overview
Accessing a renderer
Modifying a renderer
Setting new renderers
Support for renderers in the Designer
Using and writing interactors
Predefined interactors
View interactors
Object interactors
Declaring a default interactor
Subclassing view interactors
Writing an object interactor
Writing a subclass of IlvObjectInteractor
Enabling a custom interactor
Connecting interactors to diagrams using listeners
Managing dynamic symbols
Introducing symbols
What is a symbol?
The advantages of symbols
Using symbols
Basic concepts
Loading palettes
Saving palettes
Advanced management of symbols and palettes
Palettes
Categories
Palette symbols
Palette parameters
Palette events
Palette manager
Palette manager events
Organizing symbols in categories
How to use a symbol in CSS
Using composite graphics
What is a composite graphic object?
Building composite nodes in CSS
Building composite graphics in Java
Printing
Using JViews products in Eclipse RCP applications
Installing the JViews runtime plug-in
Providing access to class loaders
The bridge between AWT/Swing and SWT
Threading modes
Performance enhancements
Global performance improvements
Optimizing the performance of JViews Framework
Introduction
Configuring the Java Virtual Machine
Minimizing JAR files
Choosing the best graphic object
Drawing performance in the view
Events and listeners
Interactors
Anti-aliasing
Transparency
Printing
Optimizing the performance of symbols
Optimizing the performance of diagrams
The Overview pane
Grids in a diagram
Rendering Done mode
Composite renderer
Load on demand
Content on demand
Adjusting modes
Detail level
Better SDM/Java transition
Optimizing the performance of dashboards
The Overview pane
Binary dashboard format
Rogue Wave JViews Framework Essential Features
Introducing Rogue Wave JViews Framework
Overview
The Framework package
JavaBeans(TM)
API
JViews Framework as Rogue Wave JViews foundation
A basic graphics application model
The Framework object model
The graphic object: IlvGraphic
The data structure: IlvManager
The viewport: IlvManagerView
Getting started with JViews Framework
Overview of tutorial
Running the example
Stage 1 - The manager
Overview of stage 1
Importing the library and packages
Creating the frame class
Creating the manager
Loading/reading a file
Creating the view
Testing the application
Stage 2 - View interaction
Overview of stage 2
Adding the selectInteractor field
Creating the Select button
Stage 3 - Using events
Overview of stage 3
Adding new interactor fields
Creating the interactor buttons
Listening for a change of interactors
Registering the listener
Stage 4 - Manipulating graphic objects
Adding graphic objects
Moving graphic objects
Framework JavaBeans
Installing Rogue Wave JViews beans in an IDE
Framework classes available as JavaBeans
Rogue Wave JViews main data structure beans
Rogue Wave JViews main GUI components
Predefined interactors
GUI convenience components
Creating a simple applet using Rogue Wave JViews beans
Create the manager view
Set the properties of the manager view
Create a manager and display its content in a view
Load an .ivl file into the manager
Add a control toolbar bean
Configure the toolbar
Test the result
Graphic objects
A graphic object
The class IlvGraphic
Hierarchy of predefined graphic objects
Geometric properties
The boundingBox method
The draw method
Zoomable and nonzoomable objects
Testing whether a point is part of an object shape
Moving and resizing a graphic object
User properties of graphic objects
Globalization support
Locale and component orientation
Base text direction in JViews Framework
Input/output operations
The graphic bag
Predefined graphic objects
Arcs
Ellipses
Lines
Rectangles
IlvReliefRectangle
Polygons and polylines
Labels and text
In-place text editing
Markers
Groups
Scales
Icons
Paths
IlvGraphicPath
Component graphics
The ShadowEllipse class
Creating a new graphic object class
Stage 1 - Creating the class
Stage 2 - Defining the Constructors
Stage 3 - Overriding the draw Method
Stage 4 - Overriding the boundingBox method
Stage 5 - Overriding the applyTransform method
Stage 6 - Overriding the copy method
Stage 7 - Defining accessors
Testing for a point inside an object
Saving and loading the object description
The write method
The read constructor
Named properties
Managers
A manager
A manager view
Layers
Handling input events: interactors and accelerators
Interactors
Accelerators
Input/output
Class diagram for IlvManager
Multiple manager views
Binding views to a manager
Creating a manager and a view
Listener for the views of a manager
View transformation
Scrolled manager view
Managing double buffering
The manager view grid
Class diagram for IlvManagerView
Manager view repaint skipper
Managing layers
Layers in a manager
Setting up layers
Layers and their graphic objects
Listener for layer changes in a manager
Triple buffering layers
Caching layers
Manipulating the drawing order
Managing graphic objects
Adding objects to a manager and removing them
Modifying geometric properties of objects
Applying functions
Editing and selecting properties
Optimizing drawing tasks
Listener for the content of the manager
Selection in a manager
Selection objects
Managing selected objects
Creating your own selection object
Listener for the selections in a manager
Hover highlighting in a manager
Managing hover highlighting
Creating your own highlighting effect
Blinking of graphic objects
Introduction
Managing input events
Handling input events
Object interactors
Example: Extending the IlvObjectInteractor class
Customizing the interactor of selected graphic objects
View interactors
Class diagrams for interactors and selection classes
Interactor listeners
The selection interactor
Tooltips and pop-up menus on graphic objects
Saving and reading
File formats
Drawing Exchange Format (DXF)
Using the DXF reader
Customizing the DXF reader
Limitations
Graphers
The grapher
Managing nodes and links
Nodes
Links
Predefined link classes
Managing link visibility
Showing and hiding grapher branches
Contact points
Default contact points
Using link connectors
Using pins
Other link connectors
Class diagram for graphers
Grapher interactor class
Creating a new class of link
The IlvPolylineLinkImage class
getLinkPoints
getPointCardinal, getPointAt
allowsPointInsertion, allowsPointRemoval
applyTransform
Input/Output
Link shapes and crossing
Shape policies
Orthogonal links
Crossing modes
Composite Graphics
Introducing composite graphics
Creating a composite graphic
Stage 1 - Starting the composite graphic
Stage 2 - Creating an attachment layout
Stage 3 - Creating the first child graphic
Stage 4 - Attaching a child graphic
Stage 5 - Using a stacker layout
Stage 6 - Using a centered layout
Rogue Wave JViews Framework Advanced Features
Nested managers and nested graphers
Submanagers
Using nested managers
Adding a nested manager
Optimizing the addition of nested managers
Traversing nested managers
Coordinate system in nested managers
Working with graphic objects in nested managers
Views on a nested manager
Adding a manager frame
Defining and drawing a default frame and its margins
Using the default frame
Using the constant mode frame
Expanding and collapsing
Defining the collapsed representation
Expand/collapse events
Using nested graphers
Nested graphers
Intergraph links
Creating and accessing an intergraph link
Coordinate system of Intergraph Links
Collapsed grapher and intergraph links
Creating a link using IlvMakeLinkInteractor
Selection in nested managers
Selection method for a nested manager
Selection methods for a hierarchy of nested managers
Selection Events
Selection interactor in nested managers
Selecting multiple objects
Moving a nested manager
Content-change events in nested managers
Hierarchy events in nested managers
Graphic bag hierarchy events
Manager views changed events
Interactors for nested managers and graphers
Creation interactors
Object interactors
Class diagram for nested managers
Link shape policies
Overview of link shape policies
Orthogonal link shape policy
Setting the Link Shape Policy
Chaining of link shape policies
Crossing link shape policy
Setting the link shape policy
Crossing graphics
Example
Parameters of the link shape policy
Gaps at crossings
Obtaining the link shape policy of IlvEnhancedPolylineLinkImage instances
Defining your own link shape policy
Callback methods of IlvLinkShapePolicy
Creating a link shape policy with up to two bends
Class diagram for link shape policies
Advanced globalization
Software globalization in JViews
Use of ICU
Locale and Ulocale classes
ULocale in Swing and Eclipse RCP applications
ULocale in web applications
ICU services: implicit use
ICU services: explicit use
Bidirectional text
Base text direction: concepts
Base text direction: supported values
Base text direction: interactive change at run time
Bidirectional text: disable bidi support
Controlling base text direction of JViews graphic objects
Controlling base text direction in a custom component
Base text direction: in the JViews Maps SDK
Base text direction: in the JViews Diagrammer SDK
JViews web framework for bidirectional text (bidi)
Web components that support control of base text direction
jvf:tooltipInteractor
jv:imageButton
jv:messageBox
jv:menuItem
jvf:contextualMenu
jvmf:layerTool
The generic printing framework
Overview of the support for printing
Java print package and printing API
Overview
The printable interface
Using the PrinterJob class to print a component
The printing framework
Features of the printing framework
The Document Model classes
The PrintableDocument class
The Page class
The Printable class
The header and footer classes
The IlvFlow class for creating a document with styled text
Printing user interface components
The PrintingController class
Creating an IlvDocument with printable objects
Creating an IlvDocument with a flow of text
Printing framework for manager content
Overview of the printing framework for managers
Printing the contents of a manager on multiple pages
The IlvManagerPrintableDocument class
The IlvManagerDocumentSetupDialog class
The IlvManagerPrintingController class
The IlvPrintAreaInteractor class
A Swing application that prints the contents of a manager
Printing a manager as a flow of text
Printing a manager in a custom document
Class diagram for printing the contents of managers
Scalable Vector Graphics
Overview of SVG support
SVG support in the JViews Framework class library
Uses of SVG Files
The contents of an SVG File
SVG file example
Loading and saving SVG files with Rogue Wave JViews
SVG advanced personalization
Overview of conversion to SVG
Customizing the conversion of a graphic object
SVG features supported when reading an SVG file
Accessible graph displays
Accessibility: the definition and the disabilities it covers
Keyboard navigation
Keyboard operation modes
Zoomed display
High contrast mode
Use of colors in accessible applications
Building Web Applications
Introduction to JViews Maps Web applications
JViews Web technologies
Overview of JViews Maps Web features
JViews Maps Web applications
JViews JSF Web applications at a glance
The tag libraries
The server-side Java API
The JavaScript library
JViews JavaScript Web applications at a glance
The server-side Java API
The JavaScript library
Getting started with JViews JSF applications
Getting started with a basic JViews JSF application
Software required for developing JViews Web applications
Setting up the workspace
Creating the JViews “Hello World” JSF application project
Preparing the data used in this example JViews JSF application
Implementing and configuring the managed bean
Configuring the JViews servlet
Creating the main JSP page
Creating a JSF manager view
Deploying a JViews JSF application
Testing a JViews JSF application
Getting started with JViews Diagrammer JSF applications
Configuring the JViews Diagrammer JSF library
Creating the JViews Diagrammer JSF application project
Preparing the data for a JViews Diagrammer JSF application
Configuring the JViews servlet
Creating the main JSP page
Creating a JSF diagram view
Deploying the JViews Diagrammer JSF application
Testing a JViews DiagrammerJSF application
Getting started with a JViews Maps JSF application
Configuring the JViews Maps JSF library
Creating the JViews Maps JSF application project
Preparing the data for a JViews Maps JSF application
Configuring the JViews servlet
Creating the main JSP page
Creating a JSF map view
Deploying the JViews Maps JSF application
Testing a JViews Maps JSF application
JViews Web technology architecture
Overview
Client-server architecture
JViews Web application client
JViews servlet implementation
Using Ajax for better responsiveness
JViews JSF components for RAD
JViews JSF component tag library
JViews JSF component renderers
JViews JSF applications versus JViews JavaScript applications
JViews desktop applications versus JViews Web applications
Summary
Developing JViews Maps JSF applications
Overview
The architecture of JViews Maps JSF technology
About support for JViews JSF technology
Servlet and component classes
The JViews Maps JSF component set
Overview
Creating simple views
Creating a Google Maps view
Google Maps JavaScript API V3 support
Controlling the display of the view
Zoom constraints
Zoom levels and dynamic layers
Progressive zoom
Tiling the view
Visible layers
Image maps
Adding a pop-up menu
Styling the pop-up menu
Adding a legend
Adding a Message Box
Adding an overview
Adding a Pan Tool and a Zoom Tool
Multipurpose interactors
Server-side caching
Managing server action listeners
Intercept interactors
Managing the session expiration
The map view as a JViews Diagrammer view
JViews Maps project
JViews Diagrammer Designer Project
Data Source Binding
Styling with CSS
Installing Interactors
Select Interactor
Using Hitmap technology
Creating nodes and links
Deleting selected nodes and links
Resize interactor
Link interactor
Dashboard diagram
JavaScript objects
Contexts for actions on the view
Overview
JavaServer Faces lifecycle context
Image servlet context
Developing basic JViews JavaScript Web applications
Overview of JavaScript Web application support
Rogue Wave JViews JavaScript Web application architecture
Getting started with the Rogue Wave JViews JavaScript Web application
Installing and running the XML Grapher example
Running on Tomcat
Running on WebSphere Application Server (WAS)
Developing the server
The XML Grapher server
The XmlGrapher class
The servlet
The init method
The getManagerView method
The getMaxZoomLevel method
Developing the client
Overview of client-side development
The IlvView JavaScript component
The IlvOverview JavaScript component
The IlvLegend JavaScript component
The IlvButton JavaScript component
The IlvZoomTool JavaScript component
The IlvZoomInteractor JavaScript component
IlvPanInteractor
The IlvPanTool JavaScript component
The IlvMapInteractor and IlvMapRectInteractor JavaScript components
The pop-up menu in JavaScript
Adding client/server interactions
Overview of actions on the server and client sides
Actions on the client side
Actions on the server side
Predefined interactors
Generating a client-side image map
Define the image map on the server side
Use the image map on the client side
The IlvManagerServlet class
Overview of the predefined servlet
The servlet requests and parameters
Multiple sessions
Multithreading issues
The IlvManagerServletSupport class
Web application support in the XML Grapher example
Specifying fixed zoom levels on the client side
Controlling tiling
Tiling
Tile size
Cache mechanisms
Developing client-side tiling
Developing server-side tiling
Client-side caching
Server-side caching and the tile manager
Developing JViews Maps JavaScript Web applications
JavaServer Faces components as opposed to JavaScript components
Servlet classes
Overview
The IlvMapServlet class
The IlvMapServletSupport class
Developing JViews Diagrammer JavaScript Web applications
JavaServer Faces components as opposed to JavaScript components
Low level servlet and JavaScript libraries
Creating a JavaScript Web application
Servlet classes
Writing the JViews Diagrammer JavaScript client
Managing selection
Creating nodes and links
Deleting selected nodes and links
JViews web applications globalization and multicultural support
Overview
Introducing globalization technologies used in JViews web applications
Background
JViews JSF applications
JViews JavaScript applications
JViews JSF applications globalization and multicultural support
Determine the active locale
Create and register locale-specific data
Retrieve locale-specific data
Specify the preferred locale in languages option of the browser
Referenced example
JViews JavaScript applications globalization and multicultural support
Determine the active locale
Create locale-specific JavaScript message data
Retrieve locale-specific data
Specify the preferred locale in the languages option of the browser
Referenced example
Tips for multicultural support JViews web applications
JSF locale-determination process
JSF locale-identification priority
Retrieve the ResourceBundle in JViews web applications
How to change your browser language settings
Accessible displays in web applications
Accessibility: the definition and the disabilities it covers
Enabling keyboard navigation
Keyboard accessibility for JViews JSF and JavaScript applications
Changing the focus
Interacting with image buttons
Navigating graphic elements inside the view
Using the default navigation
Defining your own navigation style
Selecting and moving graphic elements in the view
Selecting graphic elements
Moving graphic elements
Interacting with the view
Zooming the view
Panning the view
Resizing the view
Scrolling the view
Configuring the hotkeys
JViews Web applications client/server exchange protocols and securities
Introducing JViews Web application exchange protocols and securities
JViews Web application client/server exchange protocols
JViews requests
Common requests
Available requests for JViews Diagrammer, JViews Maps and JViews TGO
JViews Web application security
Introducing JViews Web application security
Enabling the security mechanism in JViews Web applications
Customizing the security mechanism in JViews Web applications
Interoperability with third party Web technologies
JViews JSF application configuration
Required settings
Optional settings
Session persistence
Multiple-page browser support
Multiple-page support architecture
Designing web applications for multiple browser pages
Running JViews JSF applications in JSR 168 portlets
Scripts prefixed by a namespace
JavaScript variables prefixed by a namespace
Declaring the image servlet
Integrating JSF components into the portal
Supporting Facelets and Trinidad
Compatibility with Facelets and Trinidad
Code examples
Contextual menus
Static menu
Supporting JSF 2
Overview
Prerequisites for using JSF 2
Using JViews JSF components to trigger the partial page rendering feature of JSF 2
Using JSF 2 components to render JViews JSF components
Web Application Server support
JBoss Application Server 5.1.0.GA
IBM WebSphere Application Server Network Deployment 7.0
Oracle WebLogic Server 10.3
Web Application Server Community Edition 2.1.1.3
Reference documentation
Glossaries
JViews Maps Glossary
A
B
C
D
F
G
I
J
K
L
M
N
O
P
R
S
T
U
V
W
JViews Diagrammer Glossary
A
B
C
D
E
G
I
J
L
M
N
P
R
S
T
U
V
Z
Graph layout glossary
Numerics
A
B
C
D
E
F
G
I
L
M
N
O
P
R
S
T
U
V
JViews Framework Glossary
A
B
C
D
G
H
I
J
L
M
N
O
P
Q
R
S
T
V
JViews Web Applications Glossary
C
G
H
J
M
P
R
V
Rogue Wave JViews Maps
V