yFiles AJAX Changelog
This file documents the feature enhancements and API changes to previous yFiles AJAX versions.
yFiles AJAX 2.2 changes since 2.1.1
General Changes
- yFiles AJAX is now bundled with yFiles for Java 2.12.0.1 and ySVG 2.5.
- yFiles AJAX is now based on Dojo 1.10.4
Bugfixes
- The edge realizer set with method
UpdateServlet#setDefaultEdgeRealizer(EdgeRealizer)
was not used inUpdateServlet#createEdge(Graph2D,Node,Node,int)
.
Changes in Technical Requirements
- The SVG functionality (SVG mode, rendering of SVG nodes, and SVG export) provided by the bundled ySVG libraries now requires at least Java 1.6, due to upgrading to ySVG 2.5. To enable SVG functionality with older Java releases, use a previous (2.4.x) ySVG release, or the ySVG JARs (
ysvg.jar
,batik.jar
) bundled with a previous yFiles AJAX release (ySVG 2.4 uses Batik 1.7, while ySVG 2.5 uses Batik 1.8).
yFiles AJAX 2.1.1 Changes Since 2.1
General Changes
- yFiles AJAX is now bundled with yFiles for Java 2.10.1.2
Improvements
- Added
onTileLoadingFailed
andonSVGLoadingFailed
callbacks to the client-sideGraphCanvas
. - Improved error handling for servlet requests: instead of just returning a 404 status code, the servlets will now return a status code adequate to the error condition (400 (bad request), 404 (not found), or 500 (internal server error)), and write an error message to the response stream.
Bugfixes
- Image tiles were requested even when the graph was not loaded yet, causing 404 errors and HTTP session problems.
- The client-side
GraphCanvas#paintDetailThreshold
property had no effect in bitmap mode. BaseServlet#getReadWriteLock()
threw aNullPointerException
when noHierarchyManager
was registered with the provided graph.- The group node open/close operation sometimes didn't work in Chrome.
yFiles AJAX 2.1 changes since 2.0.1
General Changes
- yFiles AJAX is now bundled with yFiles for Java 2.10
- yFiles AJAX is now based on Dojo 1.8.3
- All yFiles AJAX demo sources were adapted to HTML5 and Dojo 1.8.3. Most deprecated Dojo calls were replaced accordingly.
Improvements
- The client-side
MoveViewportInputMode
now uses a css class instead of a hardcoded css property in order to change the cursor icon. - The new
GenericGroupNodeStateLabelProvider
interface and the defaultStateLabelProviderPainter
implementation can be used to enable client-side expand/collapse functionality when usingGenericGroupNodeRealizer
s. - The new DynamicGraphDemo shows how to create a graph dynamically on the server, and how to use
GenericGroupNodeRealizers
in yFiles AJAX applications.
Bugfixes
- Fixed a concurrency issue that could lead to
IllegalPathStateException
s on the server. - Fixed the
setNodeURL(), setEdgeURL(), setNodeDescription() and setEdgeDescription()
convenience methods provided by thecom.yworks.yfiles.server.tiles.servlet.BaseServlet
to create the corresponding data provider if doesn't already exist. Also, the corresponding data provider keys are now public. - The client-side mouse position that can be accessed from the server-side
ActionContext
instance now uses correct world coordinates.
Incompatible Changes
- All JSON server responses now don't use "JSON prefixing" anymore, making it possible to parse the responses with JSON.parse(). This behavior can be reverted to use JSON prefixing using the
yfiles.ajax.config.json.prefixing
context parameter.
yFiles AJAX 2.0.1 changes since 2.0.0.1
Improvements
- Improved the server libraries thread safety handling in order to prevent deadlocks that could occur in combination with some servlet container implementations.
- Added a read/write lock API that is now used by the library and demo Servlets instead of simple synchronization in order to fix concurrent modification issues.
- Added
mouseClickSize
andmouseClickTime
properties on the client-sideGraphCanvas
to configure when mouse down and up events are considered mouse clicks for the graph canvas. - Improved the
setRenderMode()
implementation of the client-side graph canvas to switch modes without flickering.
Bugfixes
- Fixed the client-side
GraphCanvas#updateWorldBounds()
method to properly call theonWorldBoundsChanged()
callback when the world bounds changed. - Fixed a mouse event handling problem that prevented the
RectangularSelectionMode
from working in Internet Explorer. - Fixed a bug that could cause the svg element to be misplaced when switching from bitmap mode to svg mode.
- The
clear()
function of the graph canvas will now correctly clear cached image tiles in bitmap mode and remove the SVG graphic in SVG mode.
yFiles AJAX 2.0.0.1 changes since 2.0
General Changes
- yFiles AJAX is now bundled with yFiles for Java 2.8.0.4
Improvements
- The yFiles AJAX license data can now be specified programmatically using the static method
BaseServlet#registerLicense(String)
as an alternative to deployment of the license file to theWEB-INF
directory. - Removed library usages of
event.layerX
/event.layerY
(deprecated in WebKit browsers). Note that because the bundled Dojo version still references these properties, deprecated warnings can still appear when running yFiles AJAX applications in Chrome. - If the
LoaderServlet
fails to load the requested graph, an error message will now be logged in addition to returning a 404 status. - All Demos: The
RequestIndicator
("loading…" message) will now correctly disappear in Internet Explorer versions 7 and 8. - GraphEditor Demo: The graph is now correctly updated after a layout calculation in SVG mode.
- GraphEditor Demo: Removed scrollbars that appeared in some browsers in the overview window.
- Basic Demo: The SVG mode button now works correctly.
Bugfixes
- A bug in
GroupNavigationMode
was fixed that caused the expand/collapse operations for group nodes to be triggered during viewport drag gestures. - A bug in
MoveViewportInputMode
was fixed that caused mouse clicks to set the the move cursor, even when no drag gesture was started.
yFiles AJAX 2.0 changes since 1.4
Major New Features
- New SVG Render Mode: In addition to the existing bitmap tile mode, the graph visualization can now be rendered as a SVG document in supported browsers.
- Touch Support: The yFiles AJAX client now supports navigation gestures on touch devices (iOS, Android).
General Changes
- yFiles AJAX is now based on Dojo 1.6.1 and uses yFiles for Java 2.8.0.3 on the server.
- The SimpleAttributeDemo has been added to show how custom attributes associated with graph items can be retrieved and displayed on the client.
- The OrgChartEditorDemo has been added as a showcase application featuring both mouse and touch gesture support.
- All demos now provide a toggle button that can be used to switch between SVG Mode and Bitmap Mode.
- Some demo applications have been modified to provide a better user experience on touch devices.
Improvements
- The new class
ViewportLimiter
makes it possible to conveniently restrict the explorable region of aGraphCanvas
. TheGraphCanvas
now offers aviewportLimiter
property for this purpose, and all means of adjusting the viewport interactively were adapted to query the limiter. Also, methodsincreaseZoom(factor)
anddecreaseZoom(factor)
have been added to provide a means of zooming while respecting the viewport limits. - The new
zoomToPointRecognizer
callback onGraphCanvas
can be used to decide whether to zoom to the current mouse position or to the center of the canvas. - The new
NavigationInputMode
is now responsible for providing both mouse and touch navigation functionality. It uses the newMoveViewportInputMode
andPinchInputMode
classes to handle mouse and touch panning, and zooming on touch devices, respectively. - The new
paintDetailThreshold
property of classGraphCanvas
can be used to set the zoom value that triggers sloppy rendering on the client. - Various touch input related properties have been added to the
GraphCanvas
:doubleTapTime
,longPressTime
,touchDragSize
,minPinchDelta
,mainTouchId
. - Similar to the existing mouse events related to graph items, the
GraphCanvas
now provides corresponding events that are dispatched when a graph item is hit by a touch gesture (tap, long press, or double tap). - A number of low-level touch events have been added to the
GraphCanvas
:onTouchStart
,onTouchMove
,onTouchEnd
,onTouchLongPress
,onTouchTapped
,onPinchStart
,onPinch
,onPinchEnd
. - The
Rubberband
has been improved to support touch input. - The
ViewPortMarker
widget that can be used to create an interactive overview canvas has been improved to support theViewportLimiter
and touch input. - For convenience, the method
GraphCanvas#getMousePosition()
will now also consider touch events. - New
GraphCanvas
properties related to the added SVG support:svgBorder
,svgPrefix
. - New method
GraphCanvas#setRenderMode(mode)
can be used to switch the client-side render mode on the fly. The current render mode can be queried usingisSVGMode()
andisBitmapMode()
. - In SVG Mode, a new SVG image can be requested from the server using method
GraphCanvas#invalidateSVG()
. - Callbacks
onLoadSVG()
andonSVGLoaded()
have been added to notify clients when a SVG image request is started and finished by theGraphCanvas
. - The behavior of the
GraphCanvas#fitContent()
has been improved to reduce the amount of server requests in Bitmap Mode. - Various convenience methods for manipulating and querying the canvas viewport and the graph's world coordinates have been added to class
GraphCanvas
:getWorldBounds()
,getCenter()
,setCenter(center)
,zoomTo(worldRect)
,setViewPointWorld(worldX,worldY)
,zoomWithPoint(x,y,z)
,getViewport()
,toLocal()
Bugfixes
- A bug was fixed in method
GraphCanvas#getViewCoordinates(x,y)
that caused the method to treatx
ory
parameters of value0
as if the parameter was not defined.
Incompatible Changes
-
Configuring the interactive behavior of the
GraphCanvas
now behaves differently:In previous versions, panning was handled by the
GraphCanvas
itself. Now, the canvas uses the newNavigationInputMode
to handle panning (both mouse-based and touch-based).Whether or not the mouse wheel triggers zooming is now controlled by the additional
mouseWheelZoom
property. Hence, callingsetPanMode()
will now create and activate aNavigationInputMode
instance, whilesetNoInteractionMode()
will disable the navigation mode andmouseWheelZoom
.As the canvas now doesn't handle view point movement anymore, the callbacks
onMove(mover,leftTop)
andonFirstMove()
have been removed. -
As the behavior of
GraphCanvas#fitContent()
has changed to reduce the amount of server requests in Bitmap Mode, this may cause problems in rare cases where the world bounds actually changed during thefitContent()
call. For details on this incompatibility, please see the corresponding section in the README.
yFiles AJAX 1.4 changes since 1.3
New Features
- There is a new
ResizeNodesMode
for resizing a set of selected nodes. It is integrated as a child input mode into theEditMode
and featured in the Graph Editor demo. - yFiles AJAX now supports Undo/Redo. This is demonstrated in the Graph Editor demo.
General
- The directory layout of the yFiles AJAX distribution has been improved. The distribution no longer contains a prebuilt web application archive (war). Instead, an Ant script is included that allows to easily build the web application, and detailed documentation has been added for the configuration of yFiles AJAX projects in various IDEs. A detailed description of the new directory structure can be found in the README file.
- The yFiles for Java library, which is used for the server side of yFiles AJAX, is now part of the distribution.
- yFiles AJAX is now based on Dojo 1.5 and uses yFiles for Java 2.8 on the server.
- ySVG is no longer bundled with yFiles AJAX. Optionally, ySVG can be used to enable SVG support.
- To enable additional scalable graphics export functionality, yExport can be used together with yFiles AJAX 1.4.
- yFiles AJAX now supports Firefox 3.5 and 3.6 and Internet Explorer 6, 7 and 8. Firefox 3.0 is no longer supported, since Dojo does not support it any more.
- The layered Dojo build files
yfiles-ajax-prerequisites.js
andyfiles-ajax-base.js
have been merged into a single fileyfiles-ajax.js
. The layer fileyfiles-ajax-complete.js
previously used in some of the demos which additionally contained the yFiles AJAX client-side demo sources and resources has been removed. - Applications written for yFiles AJAX 1.3 should also run with yFiles AJAX 1.4 on the client side after adjusting the directives for including the yFiles AJAX client-side components as indicated above. On the server side some changes are needed, if the application uses some of the few APIs in yFiles for Java which were incompatibly changed. This applies mainly to label models. See the yFiles for Java Developer's Guide for details.
Improvements
- If ySVG is present, the graphs can be exported to SVG (using a "downloadGraph" request to the LoaderServlet).
- When a set of nodes is moved, the bends of edges connecting to moving nodes are moved, too.
- The new
onLoadTiles
andonTilesLoaded
callbacks of theGraphCanvas
widget can be used to monitor server requests that update the client-side graph visualization. The demoRequestIndicator
widget uses these callbacks in order to notify the user of running requests in most yFiles AJAX demo applications. - The handling of group nodes while editing the graph has been improved. Group nodes grow, if this is necessary to encompass all of our their child nodes as before. Group nodes do no longer shrink unless they are explicitly resized.
- The
GroupNavigationMode
's enter/exit functionality now also works on Mac. A custom function that identifies an enter/exit event can now be set.
Fixed Bugs
- The ports of edges at a group node sometimes lost contact to the group node, if a child node of the group node was deleted or resized.
- The Dojo build file
yfiles-ajax-complete.js
did not contain the new demo sources. - In the OrgChart demo disabling business units in global view mode did not work correctly, if there were collapsed business units.
yFiles AJAX 1.3 changes since 1.2
New Features
- A new demo has been added which displays the organization chart of a company. Several possible application features are demonstrated.
- Another new demo, the network monitoring demo, shows how live state of a network can be queried and displayed.
- The graph canvas shows a configurable loading image, if it is waiting for tiles from the server and no old scaled tiles are available.
- It is now possible to restrict the range of possible zoom values for the graph canvas.
- The new client-side class
GraphHighlighter
eases customized highlighting of nodes and/or edges. Its usage is demonstrated in the OrgChart demo.
General
- yFiles AJAX is now based on Dojo 1.4.0 and yFiles for Java 2.7. Older versions of yFiles for Java on the server are no longer possible.
- yFiles for Java 2.7 includes support for the GraphML file format. Thus, the separate graphml.jar in the yFiles AJAX distribution is no longer necessary and has been removed.
- yFiles AJAX ships with the ySVG extension package as before (with the new version 2.2), but does no longer rely on it. If your graphs do not use SVG nodes, you can now deploy your web application using yFiles AJAX without the
ysvg.jar
andbatik.jar
library files. - Applications written for yFiles AJAX 1.2 should also run with yFiles AJAX 1.3 on the client side. On the server side some changes may be needed, if the application uses GraphML directly. The GraphML API did not change much, but the classes reside in different packages. See the yFiles for Java Developer's Guide for details.
- yFiles AJAX now supports Firefox 3.0 and 3.5 and Internet Explorer 6, 7 and 8. Firefox 1.x and 2.x are no longer supported, since Dojo does not support them any more.
- Handling the requests for custom realizer images (as used by the palette in the Graph Editor demo) has been moved from the UpdateServlet to the new PaletteServlet.
Improvements
- The graph canvas uses scaled old tiles in fitContent while waiting for new tiles from the server. This technique already existed, but was only used for setZoom.
- If the canvas is dragged while the mouse is over a node an onMouseOutNode event is fired. An onMouseOverNode event is fired when the drag ends. This eases tooltip handling for example.
- The demos and demo graphs have been brushed up.
- Configuring the defaults and registering custom node realizers in the UpdateServlet has been improved.
Fixed Bugs
- A workaround for a bug in Internet Explorer now prevents that the overview marker becomes opaque. This happened, if the overview marker was once wider or higher than 4096 pixels. Even if it became smaller again it stayed opaque.
- View configurators with no other reference were garbage collected. This has been fixed.
- The pathSet function of the canvas was not called, if the new graph was empty.
yFiles AJAX 1.2 changes since 1.1.2
New Features
- The new action framework simplifies adding custom server side functionality to an application using yFiles AJAX.
- A new API was introduced for customizing the views (and the renderers) used for creating image tiles of a graph on the server.
- The new Treasure Hunt tutorial and the new Swimlanes demo application provide examples for using the action framework. Moreover, the Swimlanes demo also uses ViewConfigurators.
General
- yFiles AJAX is now based on Dojo 1.2.1.
- The demo applications for yFiles AJAX now depend yFiles for Java 2.6, while yFiles AJAX itself still works with yFiles for Java 2.5.
Improvements
- Some static support methods of the BaseServlet like newGraph and cacheGraph were protected. They are now public, so they can be used without inheriting from the BaseServlet.
- We added a workaround for an Internet Explorer bug which under certain circumstances resulted in an offset of the preview line for a customized CreateEdgeMode.
- The layout call in the LayoutServlet is also encapsulated in a protected method (doLayout) in order to provide better customization possibilities. Previously only the creation of the layouter (createLayouter) was customizable.
- There is a new optional parameter customData for the methods changing a graph in the client side Graph and HierarchyManager classes. These methods are asynchronous and use callbacks to notify the client side application when the requested operation succeeded or failed. The customData is not sent to the server, but it is passed to these callbacks. This enables associating extra data with specific calls which can then be used in client side post processing.
- The name of the license file is no longer fixed. It can be configured with a context parameter of the web application.
Fixed Bugs
- Fixed race conditions which sometimes created NullPointerExceptions in BaseServlet.writeWorldBounds.
- The pathSet function on the canvas was sometimes called, before the hit test data for the new graph was also loaded. Client code connected to pathSet, which depended on the hit test data for the new graph (e.g. highlighting a node in the new graph), was affected. Now pathSet is not called before the new hit test data is available.
- Exceptions occurred occasionally on the server, if the user ran two instances of the grouped graph demo. The UpdateServlet no longer tries to close already closed groups or to open already open groups, which lead to exceptions in yFiles for Java.
- Moving a group node to its own subgraph is now just ignored instead of creating an infinite recursion on the server.
yFiles AJAX 1.1.2 changes since 1.1.1
Improvements
- It is now possible to set a maximum zoom level for the
fitContent
function of aGraphCanvas
. This is demostrated in the demos (e.g. Graph Viewer demo). - The pre-compiled server side demo classes are now packaged in the separate
yfiles-ajax-demos.jar
instead of being part of theyfiles-ajax.jar
with the product classes. - yFiles AJAX now ships with GraphML 3.1.
- The
EditMode
is now configurable and customizable. Configuration includes for example enabling or disabling the creation of new nodes. Customization includes for example using your own function for creating nodes. - The
CreateEdgeMode
is now customizable. - The error handling of the build script was improved.
Fixed Bugs
- The Grouped Graph demo failed in a local installation, if the
y.jar
file from a yFiles for Java 2.6 distribution was used (instead of yFiles for Java 2.5). - The functions
getNodes
andisNormalNode
for the client sideHierarchyManager
were fixed. - Under some circumstances the
EditMode
produced "this._canvas.getHitTest().getElementType is not a function" errors. - The
MoveSelectionMode
sometimes produced errors when trying to move a node. - For failed edge creations
onNodeCreationFailed
was called instead ofonEdgeCreationFailed
. - For failed node creations
onNodeCreated
was called instead ofonNodeCreationFailed
. - The second tutorial did not work, if the sources were extracted using the
tutorials
target.
yFiles AJAX 1.1.1 changes since 1.1
Improvements
- The number of server requests made for resizing an overview GraphCanvas has been significantly reduced. As a result for example the new overview in the Graph Viewer demo is available much earlier after dragging one of the splitters.
- The
GroupNavigationMode
now keeps track of group nodes closed on switching the display to their subgraph and reopens them on returning from their inner graph. Previously, after entering an open group node and returning from it, the group node was closed. - A further customization hook has been added to the
LoaderServlet
, the methodcustomizeGraphMLIOHandler
, which can be used to add custom attributes to be read from a GraphML file or written to it. This is not possible with thegetIoHandler
method, since it has no access to the graph instance used for reading or writing.
Incompatible API Changes
- The client side function
HierarchyManager#getVisibleGraphParent()
does not take a parameter any more. It had an unnecessarynodeId
parameter, which did not have any influence on its result. Since this function is called from client side JavaScript code, which ignores unnecessary parameters, there is not really a need to change any code except for clarification.
yFiles AJAX 1.1 changes since 1.0.1
New Features
- If yExport is present on the server, the LoaderServlet automatically provides the download formats PDF, SWF, EMF and EPS which are supported by yExport.
- A new Grouped Graph Demo has been added.
General
- yFiles AJAX is now based on Dojo 1.0.
Improvements
- Support for grouping and folding of nodes has been added.
- yFiles AJAX is packaged with the new layered build system of Dojo. This enables using custom Dojo builds as a basis for yFiles AJAX instead of the Dojo release which ships with yFiles AJAX (Dojo 1.0.2).
- Styles for yFiles AJAX widgets have been separated into necessary style (e.g. positioning of tiles in the graph canvas) and optional style (e.g. color of selected graph elements in the graph canvas). The latter can be customized by changing the centralized yfiles AJAX style sheet.
- The Graph Editor demo now ships with client side source code.
- The visual effect for zooming with the mouse wheel has been improved.
- There is a new field
mouseWheelScrollFactor
on theGraphCanvas
widget, which can be used to control the amount of zoom change, - A new request for available download formats has been added to the LoaderServlet. An example for its usage can be found in the Graph Editor.
- For the highlight rectangle for a node, the additional width and height is now constant and does no longer depend on the size of the node and the zoom level. There is a new field
highlightNodeSurroundPixels
on theGraphCanvas
widget, which can be used to control the additional width and height. - The client API documentation has been completed. It is available in the
docs/client/api
directory of the deployed yFiles AJAX web application and there is a link to it from the developer's guide.
Fixed Bugs
- Selecting an edge inside an open group node is now possible.
- Fixed a bug which prevented proper deacivation of the rubberband. This bug showed up, when you canceled a zoom area operation in the Graph Viewer demo by deselecting the zoom area button. The rubberband showed up on the next mouse drag.
Incompatible API Changes
- The protected method
LoaderServlet#getFileForGraphName(String)
has been removed, since loading graphs from files might not be possible for some servlet containers and/or configurations. A new methodLoaderServlet#getGraphResourceStream(String)
has been introduced, which can now be used to customize the selection of graph resources in derived servlets instead of the removed method. It returns an input stream instead of a file. The default implementation usesServletContext#getResourceAsStream(String)
. - The protected method
LoaderServlet#loadableGraphs(HttpServletResponse)
still has the same signature, but does no longer return a list of all files in the subdirectoryresources/graphs/
of the web application. Instead it returns the contents of the resourceLoaderServlet#LOADABLE_GRAPHS_LIST
. This way the method can also work in an environment where all resources are fetched via the servlet container.
Porting to Dojo 1.0
If you already developed an application with yFiles AJAX 1.0, which you want to upgrade to take advantage of the new version 1.1 of yFiles AJAX, the main work is probably upgrading to Dojo 1.0. The client side API of yFiles AJAX did not change much, but the Dojo API did. There is a lot of documentation for porting applications to Dojo 1.0 on the Dojo website. At the time of this writing it can be found in "documentation" >> "Dojo Porting Guides".
Here is a list of some changes in Dojo, which were the most relevant for porting yFiles AJAX itself. This is not intended as a replacement for the information on the Dojo website, but as a sort of quick introduction to the topic from the yFiles AJAX perspective.
dojo.io.bind
no longer exists. Themethod
attribute has been removed from the arguments object of the successor functionsdojo.xhrGet
anddojo.xhrPost
. Instead of amimetype
attribute, there is now ahandleAs
attribute. Its values do no longer follow the mime conventions. An important new value isjson-comment-filtered
, the recommended way to transfer JSON data to the client, since it prevents some possible JavaScript cross site exploits, which were reported to be possible under certain circumstances for plain JSON responses. The signature of theload
anderror
callbacks has changed.- Most of the subpackages of Dojo such as
dojo.event
ordojo.html
no longer exist. Some functions moved to thedojo
namespace (e.g.dojo.event.connect
, see below), some do no longer exist. dojo.event.connect
becomesdojo.connect
. Remove thedojo.require("dojo.event.*")
statement and keep track of the handle which is returned by the connect call, if you want to disconnect again, because disconnect now needs the handle.dojo.event.connectOnce
no longer exists.- The wildcard notation as in
dojo.require("dojo.event.*")
is no longer supported. - Several widgets moved from
dojo.widget
todijit
,dojox
or one of their subpackages. dojo.widget.byId
becomesdijit.byId
.- The
dojoType
attribute for specifying a widget in the HTML markup now expects the fully qualified class name as its value, e.g. usedojoType="yfiles.client.tiles.widget.GraphCanvas"
instead ofdojoType="yfiles.client.tiles:GraphCanvas"
. dojo.html.getMarginBox
and similar functions no longer exist. You can now usedojo.marginBox
, but be aware that the returned object has a an attributew
instead of the formerwidth
andh
instead ofheight
.
yFiles AJAX 1.0.1 changes since 1.0
Improvement
- BaseServlet: Cached graphs can be removed from the cache. They could only be overwritten before.
- A newer version of GraphML is bundled with yFiles AJAX. Together with the new ySVG library mentioned above it is now possible to export a graph with SVG nodes from the yFiles AJAX editor demo as a GraphML file, which can be read by the current yEd graph editor without loosing the SVG data for the nodes.
- Graph Viewer Demo: Tooltips are now correctly displayed with Internet Explorer 7.
Fixed Bugs
- LoaderServlet: URL and Description of downloaded graphs were not written.
- LoaderServlet: An exception occurred, if the "bmp" format was not available.
- SVG: a new version of ySVG ships with yFiles AJAX. It contains a fix for a rare bug leading to an infinite loop while painting SVG nodes on the yFiles AJAX server.
- HitInfo: The end points of the path for an edge were the source and target ports of the edge instead the ends of the visible path of the edge (source and target intersection). This is relevant, if node events are disabled and edge events are enabled for a GraphCanvas.
- The web.xml template in the developers guide was missing in the binary distribution.
- InfoServlet: Labels transfered were not correctly escaped.