Version 136 (modified by jri, 8 years ago) (diff)

4.8 release notes, pt. 2

Release Notes

2016-04-15: DeepaMehta 4.8

4.8 release notes not yet complete

New features:

  • Collaborative authoring in private views: private topicmaps can be created within shared workspaces (#927).
  • Association Auto-Typing (#931).
  • 2 new standard modules:
    • DM4 Events: provides topic type "Event" as the basis for calendaring applaications (#902).
    • DM4 Date/Time?: provides topic types "Date", "Time", "DateTime?" (#901).
  • Extended hot deployment for both,
    • The standard distribution (#846).
    • The development environment (#847).


  • Renaming/deleting/inspecting properties of a topicmap or workspace is simplified (#852, #427).
  • Meta model extension: more than one assoc def with the same child type are allowed (#903).
  • Streamlined text editor with a hand-picked feature set (#700).
  • Auto-scale images and videos displayed in the detail panel (#876).
  • Contacts model: Person has a Date of Birth (#916).
  • Contacts model: new type "Organizational Role" to describe a Person-Institution relationship (#916).
  • The disk quota can be disabled at both levels, globally, or per-user (#812).
  • Fine granular request filter (#946).

Bug fixes:

  • Deleting a workspace doesn't corrupt DB (#898).
  • When switching to a geomap the canvas element keeps its event handlers (#896).
  • Numbers are sorted numerically (#928).
  • On small displays the Webclient toolbar does not line wrap (#926).
  • When changing the assoc def order in the type editor the assoc defs does not loose their renderers (#909).
  • Changing the label configuration has an effect in every situation (#910).
  • For a private installation the browser's own login dialog appears. Was broken in DM 4.7 (#892).
  • The Geomaps module doesn't issue the failing /theme/default/style.css request anymore (#894).


  • A disk quota is disabled by default (#812).
  • CKEditor updated 4.3.2 -> 4.5.6 (#700).
  • Extensive Core refactoring (#935).

Plugin Development Framework:

  • Semantic markup in the detail panel (#929).
  • Composite renderers (#908).
  • Directives can be attached to any response (#932).
  • Add property indexes afterwards (#897).
  • New ModelFactory is in charge for creating Model objects (#933).
  • Revised Core API (#941).
  • Core API: ChildTopics? accessors which don't throw (#923).
  • by-URI deletion references (#631).
  • Files API: user support for constructing repository paths (#884).
  • Bug fixes:
    • The "URI uniqueness" check is also performed when updating a topic/association (#891).

2015-10-23: DeepaMehta 4.7

DeepaMehta 4.7 is a maintenance release that focuses on both, multi-user server installations, and touch devices. For plugin developers new features include a configuration facility, and webclient support for hierarchical menus.

You can update any DeepaMehta 4 installation which is not older than DeepaMehta 4.1. For installation and update instructions see the README.

3rd-party plugins compatible with DeepaMehta 4.6.x might be required to be adapted by the respective developers in order to work with DeepaMehta 4.7. See the BREAKING CHANGES in the tickets marked in #bold.

New features:

  • Access controlled file repositories. In particular private and collaborative file repositories are now supported (#815).
  • Administrators can interactively configure a Disk Quota (for file uploads) on a per-user basis (#812).
  • Administrators can interactively enable/disable user accounts (#842).
  • The Webclient is usable also on Touch Devices (still experimental) (#803).


  • Webclient: the detail panel's resize-handle is more wide and appears visually distinct when grasped. This is beneficial in particular on touch devices (#803).
  • Webclient: failed uploads are reported to the user (#815).

Bug fixes:

  • Anonymous can browse public file repositories (#573).
  • A file whose path contains a "+" character is properly rendered in the detail panel (#819).
  • A folder created by the File Browser's "Create Folder" command show's up in the detail panel immediately (#820).
  • Creating a file browser when one already exists doesn't throw an error (#826).


  • We switched back from Pax Web to Felix HTTP. This is because the way Pax Web handles the relationship between an OSGi HttpContext and a web session manager. As a consequence private and collaborative DM file repositories do not work with Pax Web (see ticket:815#comment:13).
  • The dm4.webservice.path config property allows switching between Pax Web and Felix HTTP without recompiling the Core (#448).
  • The default value for the dm4.filerepo.path config property is / instead of empty. / regards the entire file system as the DM file repo (#832).
  • A file repository path contained in a /files/ or /filerepo/ request must be encoded as a URI component (#819).
  • The WebPublishingService is an internal Core facility. It is deliberately not consumable as an OSGi service (#834).

Plugin Development Framework:

  • Config module (new):
    • A Configuration Facility supports the plugin developer with attaching configuration information to arbitrary topics. Support includes creation, interactive editing, querying, and controlling the access to configuration information (#830).
  • Core module:
    • The @Inject annotation allows a plugin the injection of arbitrary OSGi services, not only services provided by other DM plugins (#835).
    • Changed service interface pickup mechanism: A service interface must no longer extend PluginService and must no longer be located in the plugin's service package. Instead the service interface name must end with Service (#836).
    • The standard workspace assignment can be suppressed on a per-code block basis (instead of per-request) (#752).
    • New preInstall() hook (#843).
    • DM Core Service API: get associations by key/value (#807).
    • The DM Core Service can be statically accessed from everywhere. This is useful e.g. in JAX-RS provider classes (#812).
    • Changes in 2 JSON utility methods (ticket:832#comment:3).
    • Bug fixes:
      • If an error occurs in a plugin's shutdown() hook the error is logged and stopping the plugin proceeds (#831).
      • Core AccessControl's assignToWorkspace() method works also for associations (#827).
  • Webservice module:
    • Exception handling is unified for static and dynamic resources, in particular: 1) Logging the exception, and 2) Enriching the response with an error entity (#484).
  • Webclient module:
    • The Webclient supports Hierarchical Menus (#758).
    • Redesigned search mode extension mechanism (#839).
    • dm4c.open_error_dialog() opens an error dialog and renders a server response (ticket:815#comment:16).

2015-07-15: DeepaMehta 4.6.1

DeepaMehta 4.6.1 fixes serious User Account related bugs introduced in DM 4.6.

You can upgrade any DeepaMehta 4 installation which is not older than DeepaMehta 4.1. For installation and update instructions see the README.

All DeepaMehta 4.6 plugins are guaranteed to run also in DeepaMehta 4.6.1.

Bug fixes:

  • Changing passwords work again (#795).
  • There can't be 2 user accounts with the same username (#799).
  • Usernames can't be changed (#799).
  • When processing form input fails due to invalid user input the user can correct the input and submit the form again (#799).

Plugin Development Framework:

  • More robust Topicmaps API (#800).

2015-05-31: DeepaMehta 4.6

DeepaMehta 4.6 is a maintenance release that comes with an extended DM meta-model, a lot of small improvements, and (partly overdue) bug fixes. As a first application of the extended meta-model the DM Contacts model is revised. For an explanation of the new meta-model and Contacts model see this posting:

You can upgrade any DeepaMehta 4 installation which is not older than DeepaMehta 4.1. For installation and update instructions see the README.

3rd-party plugins compatible with DeepaMehta 4.5 might be required to be adapted by the respective developers in order to work with DeepaMehta 4.6.

New features:

  • Extended meta-model: association definitions can have custom association types (#341).
  • Error reporting: errors occurring at server-side are reported to the Webclient user (#790).


  • Refined Contacts model: the intermediate Address Entry and Phone Entry topic types/instances are gone. A person/institution is connected directly to its Address and Phone topics via a custom association. This renders the topic network more intuitive (#779).
  • Webclient usability:
    • The detail panel remembers a topic/association's vertical scrollbar position. When the user revisits the topic/association the remembered scrollbar position is restored (#783).
    • When a topic appears in several topicmaps, in each map it can have an individual color and expansion flag (the Note topic's triangle) (#761).
    • When clicking a topic in the detail panel which has more than one association to the selected topic only one association is revealed (instead of all), nameley the one that corresponds to the clicked list entry. This reduces the chance for selecting the wrong association on the canvas afterwards (#460).
    • The sensitive area of the detail panel's resize-handle is increased from 2 pixel width to 7 pixel width (#676).
    • In the New Workspace dialog the radio buttons to select the Workspace Sharing Mode feature a tooltip which explains the respective option (#784).
  • In the detail panel's "related topics" list besides the association type the association value is displayed (#793).
  • DM never creates empty simple child topics. In particular a combobox menu is not extended by an empty item when the user lefts the field (e.g. "Phone Label", "City") empty (#171).
  • In Number fields the Webclient does not fill in 0 automatically as 0 and "not set" are semantically different (#171).
  • DeepaMehta can be installed again in an existing Karaf environment by Karaf feature install. 2 features are provided: dm4-platform and dm4-standard-distribution (#711).

Bug fixes:

  • The user can't select disabled menu items. In particular a user can't create a Membership if she is not authorized (#774).
  • The detail panel's form rendering works properly for child topics of data type "HTML" and cardinality "Many" (#792).
  • When a Note topic's triangle is clicked the Note content does appear in the topicmap in any situation (#762).
  • A type can't be deleted if instances still exist. If tried the Webclient displays an error message (#789).
  • The DB is not corrupted when an association definition is retyped into a non-association definition type and then retyped back into an association definition (#773).
  • The standard type's (Note, Person, ...) Association Definitions (and their View Configurations) are editable by logged in users (#771).
  • Interactively created types get creator info and creation timestamp (#772).


  • Webclient: the standard topicmap view properties (x, y, and visibility) are stored as node properties (instead as child topics) (#761).

Plugin Development Framework:

  • Core module:
    • Error handling: when an error occurs at server-side the exception (including all cause exceptions) is transmitted to the client. The Webclient reports the error to the user. Server-side plugin developers can supply custom error objects. Client-side plugin developers (that is users of the RESTClient) can supply custom error handlers (#790).
    • The model object used to create/update a composite topic/association can contain the values (simple or composite) to be used to update the relating associations as well (#785).
    • The JSON format for a declarative migration is extended in order to create the entities in a specific order (#778).
    • REST APIs: the include_assoc_childs query parameter controls weather the child topics of the requested object's Relating Associations are included in the response (#659).
    • REST API and declarative migrations: simplified format for create/update requests. The child topic's type_uri must no longer be specified (#636).
    • Core API: an Association Definition can be added in the middle of the sequence (#770).
    • Core API orthogonality: in a create/update operation Topic References and Topic Deletion References are supported for all the 4 cases, that is Composition/Aggregation, One/Many.
      • Topic References are supported for Composition as well (#786).
      • Topic Deletion References are supported for Composition-One and Aggregation-One childs as well (#171).
    • Bug fixes:
      • Objects don't loose their label when updating their child topics (#766, #791).
      • ChildTopics manipulator methods work for child topics defined with cardinality many (#788).
      • When a type is deleted and the (then deleted) type is requested subsequently (via API) a proper "Type not found in DB" exception is raised (#765).
  • Access Control module:
    • New "System" authority: Code that is invoked by the system itself -- as opposed to be invoked by a user -- runs under the System authority. The System authority has unrestricted access to the database (#764).
    • REST API: the getPrivateWorkspace() service call is RESTful (#768).

2015-02-04: DeepaMehta 4.5

4.5 is a major release that brings DeepaMehta's basis for Collaboration to the next level. For the first time the user can control the access to shared workspaces purposefully. For shared workspaces several access levels are supported, ranging from "completely closed" to "completely open". The access levels are enforced by the DeepaMehta backend, so that confidential content is never exposed to unauthorized users. For the first time DeepaMehta supports Privacy.

The Access Control system of DeepaMehta 4.5 is completely redesigned. The basic points are described in this posting:
Further details are described here:

For plugin developers the highlight feature of DeepaMehta 4.5 is Service injection for migrations. This supports the development of upgradable plugins.

You can upgrade any DeepaMehta 4 standard installation which is not older than DeepaMehta 4.1. For installation and update instructions see the README.

3rd-party plugins compatible with DeepaMehta 4.4.x might be required to be adapted by the respective developers in order to work with DeepaMehta 4.5.

New features:

  • Completely redesigned Access Control system (#592):
    • User configurable access levels by the means of Workspace Sharing Modes. A Workspace Sharing Mode lets the user control how (if at all) the workspace content is accessible by other users. To accommodate typical sharing scenarios 5 sharing modes are pre-defined: "Private", "Confidential", "Collaborative", "Public", and "Common". A matrix explaining the 5 sharing modes is available in ticket:592#comment:1
    • The Webclient GUI presents workspaces as well-defined content spaces between the user can switch. The Workspaces menu lists only the workspaces the user has access to. The Topicmaps menu lists only the topicmaps that belong to the selected workspace. Topicmaps can still contain (interrelated) contents belonging to different workspaces. Which parts of the topicmap are visible/accessible to the user depends on the user's authority.
  • 2 new commands in the topic/association context menu:
    • "Assign to Workspace": let the user assign a topic/association to another workspace and thus changing its accessibility (#592).
    • "Get Info": shows creator/modifier/owner info and timestamps for a topic/association (#747, #749).

Plugin Development Framework:

  • Service injection for migrations: in your plugin's migrations you have access to the services provided by other plugins, including your own (#324).
  • Core module:
    • The postInstall() hook is dropped. You can do the same with a migration now (#324).
    • The Core API provides a generic getObject(id) method (#760).
  • Workspaces module:
    • The automatic workspace assignment can be switched off on a per-request basis (#752).
    • The Workspaces API is RESTful (#592).
  • Access Control module: changes in client-side events (#592):
    • The logged_in and logged_out events are replaced by authority_increased and authority_decreased with extended semantics.
    • 2 logout levels (in shape of the authority_decreased and authority_decreased_2 events) allow plugin's to orchestrate their logout actions.
  • Webclient module: certain items rendered by GUIToolkit's topic_menu() can be disabled by the means of an indicator function (#755).


  • Caching module optimization: GET topic/association requests perform faster (#685).
  • The dm4-assemblies module (DeepaMehta Karaf Distribution) is dropped from the git repository (#711). A Karaf based DeepaMehta distro is maintained here:

Bug fixes:

  • The "Create Association" operation is only available if the user has the corresponding permission (#592).

2015-01-25: DeepaMehta 4.4.3

DeepaMehta 4.4.3 is a maintenance release.

Bug fixes:

  • Webclient module:
    • Fix display of workspace details (#739) and user account details (#742). Was broken in DeepaMehta 4.4
    • The max_result_size=100 query parameter is dropped from requests (#741).

You can update any DeepaMehta 4 installation which is not older than DeepaMehta 4.1. For installation and update instructions see the README. All DeepaMehta 4.4 plugins are guaranteed to run also in DeepaMehta 4.4.3.

2015-01-20: DeepaMehta 4.4.2

DeepaMehta 4.4.2 is a maintenance release.

Bug fixes:

  • The Webclient properly handles form fields of type "Number" (#750).

You can update any DeepaMehta 4 installation which is not older than DeepaMehta 4.1. For installation and update instructions see the README. All DeepaMehta 4.4 plugins are guaranteed to run also in DeepaMehta 4.4.2.

2014-11-22: DeepaMehta 4.4.1

DeepaMehta 4.4.1 is a maintenance release.

You can update any DeepaMehta 4 installation which is not older than DeepaMehta 4.1. For installation and update instructions see the README. All DeepaMehta 4.4 plugins are guaranteed to run also in DeepaMehta 4.4.1.


  • DeepaMehta can be easily deployed in an existing Karaf installation (#734).
  • All DeepaMehta Standard Distribution artifacts are deployed at Maven Central (#713).

Bug fixes:

  • Webclient module:
    • The values of a composite association appear in the detail panel. Was broken in DeepaMehta 4.4 (#714).
  • Core module:
    • The label of a composite topic/association is properly calculated in a certain case (#715).
    • The POST_UPDATE_TOPIC_REQUEST core event is fired in a certain case. As a consequence the Time module's modification date bubbling works as expected (#510).

2014-10-15: DeepaMehta 4.4

4.4 release notes not yet complete

DeepaMehta 4.4 is a maintenance release.

You can update any DeepaMehta 4 installation which is not older than DeepaMehta 4.1. For installation and update instructions see the README. For plugin developers: see the BREAKING CHANGES in the tickets marked in #bold.

New features:

Plugin Development Framework:

  • Core API Spring Cleaning:
    • Service Injection. New @Inject annotation (#695).
    • Declarative Transactions. New @Transactional annotation (#698).
    • directives parameter removed from all APIs (#697).
    • clientState parameter removed from all APIs (#696).
    • fetchComposite parameter removed from most APIs (#699).
    • Orthogonal traversal methods (#707).
    • Wording: the concept of a Composite Value is now named Child Topics (#702).
  • Additional Core module changes:
    • PluginActivator has a convenience method to access a static plugin resource (#692).
    • DeepaMehtaObject has a method to access the underlying Neo4j Node object. This allows plugins to utilize Neo4j specific extensions (#634).
  • Webservice module:
    • A number returned by a resource method is serialized automatically (#682).
  • Geomaps module:
    • The Geomaps service has a method to calculate the distance between 2 geo coordinates in kilometer (#681).
    • The Geomaps service has a convenience method for accessing the geo coordinate encoded in a Geo Coordinate topic (#633).

Bug fixes:

  • Topics going over the wire include all their child topics only if requested. The former bug (existing since DM 4.1) resulted in crucial network overhead as more data than requested was sent on a regular basis (#684).
  • Class CompositeValue (now named ChildTopics): on-demand child topics loading works also with the convenience accessors (#683).
  • Unregistering plugin listeners throws no exception in case of plugin activation failed before (#686).
  • Root resource and provider classes which Jersey could not successfully hot deploy due to JAX-RS related errors are properly hot deployed once the errors are corrected (#650).
  • Plugins start:
    • When an error occurs very early in the plugin's starting phase that error is logged and the plugin is not retried to start endlessly (#693).
    • Errors like NoClassDefFoundError are not thrown through the OSGi container. The phenomenon of "swallowed" exceptions and endlessly retried plugin starts is eliminated once and for all (#693).
  • Error logging:
    • When an error occurs while event handling (e.g. NoSuchMethodError or AbstractMethodError) the log is more informative (#693).
    • If file logging is active all errors are logged into file (#694).

Further changes:

  • Felix HTTP is replaced by OPS4J Pax Web (#448).
  • Non-DM data stored by 3rd-party Neo4j applications can coexist with DM data in the same Neo4j instance, even when this data is connected to DM data (#687).
  • 3rd-party software is upgraded:
    • Jetty 7.6.13 -> Jetty 8.x.x (Servlet API 2.5 -> Servlet API 3.0) (#703).
    • Felix 3.2.2 -> Felix 4.4.1 (OSGi 4.2 -> OSGi 5) (#703).

2014-05-22: DeepaMehta 4.3

DeepaMehta 4.3 is a maintenance release that brings crucial bug fixes and enhancements in the Plugin Development Framework. The enhancements are mainly driven by the recent development of various DeepaMehta 3rd-party projects like the Kiezatlas application, its Familienportal subproject, the Wikidata plugin, and the Import/Export plugin.

The most notable changes in the Plugin Development Framework include a More flexible file upload: uploaded files can be processed by arbitrary plugins; processing can be on-the-fly (not writing the file to disk), Adding index modes afterwards: a plugin can add new index modes to types already installed at a production instance; existing content is reindexed automatically, and a RESTful Facets service: 3rd-party applications can access the DeepaMehta Facets service via HTTP.

You can update any DeepaMehta 4 installation which is not older than DeepaMehta 4.1. For installation and update instructions see the README. For plugin developers: see the COMPATIBILITY NOTES below.

Plugin Development Framework:

  • Core module:
    • Add index modes to types afterwards and reindexing existing content (#649).
    • Core Service method getTopics(key, value, fetchComposite) is RESTful (#637).
    • Core API's CompositeValueModel is extended (#632):
      • has a method to add a multiple-value child.
      • has a method to add a deletion reference to a multiple-value child.
      • CompositeValueModel is an Iterable over the child type URIs.
    • Core API: RoleModel has a method to set the player ID (#654).
    • Core API: fail-fast ClientState accessors let the developer detect errors more early (#639).
    • Core API: an exposed DB vendor object allows plugins to utilize vendor specific DB extensions (#634).
  • Files module:
    • More flexible file upload:
      • An uploaded file can be processed by any plugin (not just the Files plugin).
      • The plugin can process the file on-the-fly (not necessarily writing it to disk). Arbitrary (JSON) data can be send back to the client (#655).
      • The file chooser dialog can upload files to an arbitrary plugin service (not just the Files service) (#655).
    • The Files service has a method to create new files in the file repository programmatically (#506).
  • Facets module:
    • The Facets service is now RESTful (#629).
    • The Facets service has a method to fetch a topic along with selected facets (#652).
  • Geomaps module:
    • The geocoder can be switched off on a per-request basis (#641).
    • The Geomaps service has a method to access the geo coordinate of a geo-facetted topic (#645).
    • The Geomaps service methods are renamed to be more clear (#645).
  • Topicmaps module:
    • The Topicmaps service has a method to load a topicmap while including the topic's child topics (#653).
    • New client-side event post_refresh_topicmap_menu allows plugins to customize the Topicmap menu (#646).
    • The client-side Topicmaps API has a method to add a newly (server-side) created topicmap to the Topicmap menu, and display it in the Webclient (#656).
    • Core API:
      • CompositeValueModel has incompatible changes (#632).
      • Type interface and TypeModel class have incompatible changes related to index modes (#649).
    • Topicmaps module:
      • Server-side API has incompatible changes related to topicmap loading (#653).
      • Client-side API has incompatible changes related to selecting and creating a topicmap programmatically (#656).
    • The Facets API has incompatible changes (#629).
    • The Geomaps API has incompatible changes (client-side and server-side) (#645).
    • The Files API (client-side) has incompatible changes related to file uploading (#655).

Bug fixes:

  • Core module:
    • Deleting an association definition programatically does not corrupt the DB (#640).
    • A plugin whose initialization fails is not tried to restart endlessly (#635).
    • The server is robust against empty-valued (non-DM) cookies (#625).
  • Workspaces module:
    • Editing a newly created Workspace in the Webclient does not run into an endless recursion (#627).

2014-02-18: DeepaMehta 4.2

DeepaMehta 4.2 is a maintenance release that brings bug fixes and additions to the Plugin Development Framework. New is a facility for Custom Events: plugins can define its own specific event types. Furthermore this release is compatible with 2 new plugins (optional install): WebSockets provide plugin developers the basis for server push, and the experimental D3.js Renderer plugin demonstrates how the D3.js library can be utilized for rendering topicmaps. It features a SVG-based animated force layout for automatic topic positioning. D3.js is a JavaScript library for manipulating documents based on data (

You can update any DeepaMehta 4.1.x installation (including 4.1). For installation and update instructions see the README. For plugin developers: see the COMPATIBILITY NOTES below.

About the 4.2 version number: starting with this release we use a new versioning scheme in order to make more transparent to users and developers which plugins are compatible with a particular DM release. A plugin which is compatible with e.g. DM 4.2 is guaranteed to run at least in all DM 4.2.x releases without changes. We also use a fixed naming scheme for the plugin binary (.jar) files (see #603).

2 new plugins (optional install):

GUI improvements:

  • A topic/association type's Data Type is not displayed twice in the detail panel (#606).
  • The user can select/enter an aggregated number via a combo box (#240). Aggregated number instances are created only once (#588).

Bug fixes:

  • Webclient:
    • Pressing the "Create a Note instantly" button (Alt-N) while another topic is being edited causes no lost edits (#595).
    • Deleted types disappear from type menus (#246).
    • A Folder topic's content listing is sorted on all platforms (#605).
    • On a Mac: ctrl-clicking a topic's type icon does not initiate association drawing (#604).
    • Clicking on a long menu's scrollbar does not close the menu prematurely on mouseup (Firefox, Chrome) (#609).
    • Closed dialogs do not pollute the DOM (#583).
  • Server-side:
    • Deleting an Association Definition does not corrupt the DB (#615).
    • Topic create/update logic: resolved topic references have a composite value (#614).
    • Time plugin: when a child topic is updated the modification timestamp bubbles up to all composite parent objects. Thus the browser cache is invalidated and the up-to-date parent topic/association is retrieved (#510).
    • When updating a topic/association its URI is not lost (#311).

Plugin Development Framework:

  • Server-side:
    • New feature: Custom Events. A plugin can define and fire its own specific events. Other plugins can implement listeners for these events (analogous to Core Event listeners) (#290).
    • Core API: a DeepaMehtaObject provides a loadChildTopics() method to fetch all its child topics afterwards (#522).
    • 2 new RESTful Core Service methods (#607):
      • deleteTopicType()
      • deleteAssociationType()
    • The Core Service provides a deliverEvent() method for delivering an event to a particular plugin (#597).
    • 3 new Core Events:
      • PRE_DELETE_TOPIC (#616).
      • POST_DELETE_TOPIC (#616).
    • A plugin can react on Login and Logout events as fired by the Access Control module (#538).
    • A plugin can react on being stopped by the means of a shutdown() hook (#594).
    • A plugin can determine its own URI (#598).
  • Client-side:
    • 2 new Webclient events (#608):
      • post_delete_topic_type
      • post_delete_association_type
    • GUIToolkit's Dialog class supports auto-closing and Return key handling (#610).
    • Callers of dm4c.on_return_key() can stop event propagation (#610).
    • The Webclient's context menus are reusable by 3rd-party Topicmap Renderers (#602).
    • The Topicmap plugin's TopicmapViewmodel class is reusable by 3rd-party webclients (#612).
    • There are breaking API changes in the Webclient's GUIToolkit: if your plugin displays dialog boxes (dm4c.ui.dialog()) it must be adapted. See comments in #583 and #610.

Further changes:

  • Deleting topics perform faster (#617).
  • 3rd-party components are updated:
    • Jetty 6.1.2 -> 7.6.13 (#584).
    • CKEditor 3.6.2 -> 4.3.2 (#585).

2013-12-10: DeepaMehta 4.1.3

DeepaMehta 4.1.3 brings a lot of crucial GUI improvements and a View Customization Framework (for developers).

You can update any DeepaMehta 4.1.x installation (including 4.1) or perform a clean installation. For installation and update instructions see the README.

New features:

  • The Topicmap Panel has a new look & feel (provided by the Box Renderer plugin) (#577, #505):
    • Topics are rendered as solid boxes with a reduced-size type icon in the corner. This way the topic content takes center stage (instead of the icon).
    • The content of Note topics is displayable right on the topicmap. Note topics have an expand/collapse handle. The goal is to increase the topicmap's information density. Don't show a proxy, but the real thing.
    • Each topic box can have an individual color (independent of topic type). The color is set via context menu. The goal is to provide the user increased means of expression as known from graphics applications.
    • Associations can be drawn by pulling the topic's type icon. No context menu and no Shift key is involved (although these gestures still work.)
  • View Customization Framework: enables a plugin developer to customize the topicmap look & feel without the need of implementing an entire Topicmap Renderer. Instead she selectively hooks in drawing and event handling behavior and model extensions (#505):
    • Two topic rendering flavors: a) draw on Canvas, b) render as DOM (stylable via CSS).
    • Intercept event handling and provide custom interactions/gestures.
    • Extend the topicmap view model with per-topic custom properties (e.g. color, shape).
    • While loading a topicmap from DB: selectively load topic content to be rendered in the topicmap.
  • The Webclient supports complex data models, namely "Aggregated Composites". Such complex topic/association instances can be edited via Detail Panel (#337, #30).
  • The Apache Felix Gogo Shell is included. That enables you to e.g. start and stop DeepaMehta plugins, and even install new plugins without restarting DeepaMehta.

GUI improvements:

  • Topicmap Panel:
    • Create topics directly on the topicmap: right-click and choose a type from the list. The topic is created on-the-spot (#529).
    • Associations are displayed along with their values (as entered in the detail panel) (#34).
    • Shortcut: double clicking a topic/association enters edit mode (#526).
    • Clearing the Detail Panel: clicking on the topicmap removes current topic/association selection (#523).
    • Mouse cursor shapes: while something is moved a grabbing hand is shown, while an association is drawn a crosshair is shown (#552).
    • The topicmap uses full window height. No dead space at the bottom (#543).
  • Detail Panel:
    • "Related Topics" list:
      • Redundant topics are suppressed. A topic is regarded redundant if it is already represented in the detail panel's upper area (the "model-driven nested boxes") (#315). Suppressed topics can still be revealed in the topicmap, namely via the page panel's upper area: when hovered the corresponding box is highlighted. A click reveals the underlying topic.
      • The topics are grouped by Topic Type (instead of Association Type). The respective association type is now shown beneath each topic. The Related Topics list is much more readable this way (#315).
      • Revised icon vs topic label click behavior: the icons of the topics which are contained in the current topicmap are now surrounded by a thin red line (instead of appearing dimmed). Clicking such an icon a) reveals the respective association (in case it was hidden), and b) translates the topicmap to bring the topic into the viewport (in case it was outside the viewport) (#579).
      • Long topic labels are not truncated (instead of applying a limit of 50 characters) (#315).
      • The topics are sorted case-insensitively (#521).
    • Long words (like file names) are line-breaked. No horizontal scrollbar appears in the detail panel (#537, #575).
  • Menus:
    • Long menus (exceeding the screen) have a scrollbar. The former upper/lower "scrolling areas" are gone. You can use the mouse wheel or whatever gesture for scrolling (#534).
    • Menu items can be selected via 1-click gesture (mousedown-select-mouseup) or 2-click gesture (click-to-open, click-to-select) (#534).
    • All menus can be controlled via keyboard (#534).
  • Toolbar:
    • In the toolbar, beside the Create menu, there is a "Create Note instantly" button. It can be triggered via Alt-n. The button creates a Note topic instantly (#529).
    • When clicking the logged in username (upper/right corner) and the respective User Account topic is already contained in the topicmap but outside the viewport, the topicmap is translated to bring the revealed User Account into view (#570).

Plugin Development Framework:

  • More data binding (automatic sync'ing of DB and topicmap view):
    • The RESTful plugin methods can return Directives now. They are automatically processed by the Webclient (#556).
    • The CompositeValue's manipulator methods (set(), setRef(), remove()) extend the passed Directives (by a UPDATE_TOPIC resp. UPDATE_ASSOCIATION directive) (#576).
    • Core API Type interface: setDataTypeUri() and setLabelConfig() take a directives parameter (#576).
  • Core API:
    • The DeepaMehta Core thoroughly uses Lists instead of Sets. One advantage is better performance (#559).
    • New model class: de.deepamehta.core.model.TopicReferenceModel: A reference to a topic, either by ID, or by URI (#574).
    • DeepaMehtaObject has a method to fetch child topics selectively: loadChildTopics() (#522). This is particularly useful in conjunction with a Viewmodel Customizer (#505).
  • Extended server-side Topicmaps API (#544).
  • Client-side:
    • Plugins can add icons and disabled items to the topic/association/canvas context menus (#529).
    • DeepaMehta GUI Toolkit:
      • Support for context menus (#532).
      • Disabled items can be added to menus (#529).
    • 2 new client-side events:
      • pre_submit_form (#547).
      • association_doubleclicked (#530).
    • Support for more complex Detail Panel renderers: a Simple Renderer or Multi Renderer can navigate to the parent page model (#567).
    • Interwoven plugin initialization: 2 new init events init_2 and init_3 (#518).
  • The JAX-RS Exception Mapper also maps checked exceptions and errors (#484).
  • 3rd-party plugins must no longer declare a deepamehta-core dependency [0546cfef].

Bug fixes:

  • Webclient:
    • The toolbar menus show all their items without scrolling (#534).
    • The canvas context menu do scroll when invoked near screen bottom (#534).
    • No accidental scrollbars appear around the browser window (#543).
    • Various display bugs are fixed:
      • The new icon appears on the topicmap once a topic is retyped and the topicmap is switched (#508).
      • An association definition's value displayed on the topicmap is updated once the "Include in Label" setting is changed in the type form (#564, #576).
      • A type's data type assignment (an association) disappears once the data type is changed in the type form (#576).
      • An uploaded file immediately appears in the Detail Panel (#563).
    • On a Mac where ctrl-click emulates the right mouse button: when invoking the association context menu via ctrl-click the topic cluster does not stick to the mouse cursor (#517).
    • Various topicmap management bugs are fixed, e.g. after deleting a topicmap the menu does not show 2 "untitled" topicmaps (#520).
    • The file content renderer works also if embedded in a parent topic (#566).
  • Changed Person data is saved also if the Address can't be resolved (via Google Geocoder) (#565).
  • When updating an aggregated composite no error occurs (#574).
  • The Caching plugin does not prevent updating topics/associations which are not selected (#547).
  • Association values are included in the serialized topicmap representation (#531).
  • Topicmaps keep their URI when translated (#311).

Further changes:

  • The overall Webclient style is flat. There are no gradients in buttons, menu items, dialog titles etc. (#532).
  • The "success" alertbox after a file upload is gone (#563).
  • The markup generated by dm4c.render.topic_list() contains no <table> anymore (#575).
  • The RESTClient no longer depends on the Webclient (#557).
  • The GUIToolkit menus and context menus rely on the jQuery UI Menu widget (#532).
  • 3rd party components are updated (#507):
    • jQuery 1.7.2 -> 2.0.3
    • jQuery UI 1.8.21 -> 1.10.3

2013-09-07: DeepaMehta 4.1.2

DeepaMehta 4.1.2 fixes just one geo-map related bug that was introduced in the previous release.

You can update an existing DeepaMehta 4.1.x installation while keeping your content or you can perform a DeepaMehta 4.1.2 clean installation. See the README for installation and update instructions.


Bug fix:

  • Editing a topic displayed in a geomap throws no error (#503). The error was introduced in DeepaMehta 4.1.1 in conjunction with caching/conditional requests.

2013-09-01: DeepaMehta 4.1.1

While DeepaMehta 4.1.1 has not much to offer for the end user it brings crucial bug fixes and various enhancements in the Plugin Development Framework. Main features of this release comprise Timestamps (not yet user perceivable) and a new Time API, better performance through exploitation of the browser cache, and Edit Conflict Detection for supporting collaborative work. Furthermore, plugin developers can attach arbitrary metadata to topics and associations. Numeric metadata is trie-indexed which make it suitable for time- and and geo-based range queries.

You can update an existing DeepaMehta 4.1 installation while keeping your content or you can perform a DeepaMehta 4.1.1 clean installation. See the README for installation and update instructions.


New features:

  • Timestamps (#386). Each topic/association have creation and modification timestamps. Timestamps are delivered along with topics/associations retrieved via the REST API. The new Time API allows programmatic timestamp access and topic/association retrieval based on time ranges. Timestamps are also the basis for validating the browser cache and for Edit Conflict Detection. The entire time aspect is realized as a separate module (dm4-time).
  • Exploiting the browser cache (#478). Consequent usage of intrinsic HTTP features (Last-Modified and Cache-Control response headers and If-Modified-Since request header) results in lesser network traffic and better perceived performance. The caching aspect is realized as a separate module (dm4-caching).
  • Edit Conflict Detection (#479). The server rejects a PUT request when the resource has changed meanwhile. The check is based on the resource's modification timestamp. This fights the "lost update" problem when working collaboratively. Edit conflict detection is realized at HTTP level, that is a conditional PUT request (involving an If-Unmodified-Since request header). Conflict resolution is not yet realized.

Plugin Development Framework:

  • The new Property API allows plugins to attach Node Properties to topics and associations. Node properties are metadata like timestamps, ACL information, or geo coordinates. Topics/associations can be retrieved based on property value or value range (#472). Node properties can be indexed. Numeric properties are trie-indexed which allows for performant range queries (#490). Property keys are namespaced (#491).
  • HTTP response generation:
    • A plugin can produce specific HTTP (error) responses by throwing a WebApplicationException from its resource methods or event handlers (#484, #481).
    • Exceptions thrown from resource methods or event handlers must no longer be wrapped in a WebApplicationException if a 500 response is intended (#484).
  • The entity parameter (represented in the message body) of a REST resource method can use an arbitrary class as long as the representation is JSON and the class has a public JSON constructor. Implementing a custom JAX-RS provider class (a message body reader) is no longer required (#277).
  • 3 new Core Events:
    • SERVICE_REQUEST_FILTER allows plugins to manipulate or interrupt REST service requests (#480).
    • RESOURCE_REQUEST_FILTER allows plugins to manipulate or interrupt static resource requests (#480).
    • SERVICE_RESPONSE_FILTER allows plugins to manipulate REST service responses, e.g. by setting certain response headers (#477).
  • Webclient:
    • (Client-side) plugins can send REST service requests asynchronously (#476).
    • New Webclient event (client-side): pre_send_request allows plugins to investigate and manipulate a request before it is send to the server (#486).
    • The default topicmap view model is renderer agnostic. It is reusable by custom topicmap renderer implementations (#443).
  • Access Control API: there are methods for retrieving topics/associations based on creator or owner (#458).
  • Core Service: there are methods for retrieving all topics/associations from the DB. These are useful for migrations which transform the entire database (#495).
  • Core API and standard plugin APIs: the clientState parameter is no longer required in get/retrieve/delete service methods (#496).

Bug fixes:

  • Login/Logout:
    • Logout works for private DM installations as well. (A private installation is one with read_requires_login=true.) Missing HTTP Logout is worked around by bringing up a bogus browser login dialog (#423).
    • Login works for open DM installations as well. (An open installation is one with write_requires_login=false.) (#475).
    • When the user enters wrong credentials in DM's login dialog the browser's login dialog does not appear. The user stays in DM's login dialog (#471).
    • When the user enters neither a username nor a password in the login dialog and presses OK no error occurs (#473).
  • The type loader doesn't throw a bogus "Endless recursion" exception when repeatedly tried to load a type with an invalid URI (#487).
  • Exceptions thrown from request filters (formerly servlet filters) appear in the log file (if file logging is activated) (#474).
  • Webclient model update:
    • When processing the directives of an update request the dm4c.selected_object is properly updated (#488).
    • Construction of the object model passed to a topic/association update request no longer manipulates the dm4c.selected_object in place. This allows a plugin to investigate the selected object's metadata (e.g. timestamps, access control information) before the request is send (#486).
  • Requests issued by the Webclient have no superfluous "?" character at the end as it might confuse the browser's or network proxy's cache heuristic (#483).
  • Web application plugins (derived from WebActivatorPlugin) are detected as DeepaMehta plugins. The ALL_PLUGINS_ACTIVE event is fired properly (#498).

Further changes:

  • The dependency on Felix's proprietary "Extended HTTP Service" is dropped. Thus we are ready to replace Felix HTTP Service with OPS4J Pax Web soon (#448). OPS4J Pax Web is the far more modern and flexible OSGi HTTP Service implementation which enables e.g. server push and WebSockets as well as binding the web server socket to a specific network interface (#39).
  • Core Service REST API: the URLs for topic/association update (PUT) requests are REST-conform (#482).
  • The REST service no longer enriches topic/association responses with user-related permission information. Instead permissions are explicitly requested through the Access Control service (#489). This makes topic/association responses eligible for the browser cache (#478).
  • The DeepaMehta Karaf Distribution comes with the same default configuration as the DeepaMehta Standard Distribution (#447).
  • COPYRIGHT.txt is updated (#434).

2013-03-11: DeepaMehta 4.1

DeepaMehta 4.1 is the most important DM4 release so far as it comes with a Data sustainability guarantee. For the first time, data you enter in DM4 is guaranteed to be transferred to all future DM4 releases automatically. So, you can start real DM4-based projects with real data now.

Besides that, there are fixes of crucial bugs and some improvements in usability and functionality. Furthermore the DM Core is further optimized and the plugin development framework is improved. Update operations perform faster. Plugin developers benefit from a DB-attached CompositeValue object which simplifies complex update operations.

GUI improvements:

  • In the type builder: easy navigation to a type's View Configuration (#364).
  • Clicking the user name link in the upper/right corner reveals the User Account topic of the current user. This is useful for changing the password (#415).
  • The "Edit" command is also available in the topic's and association's context menu (#416).

Further improvements:

  • File browser access control: the "Upload File" and "Create Folder" commands are available only for authorized users (#409).
  • Encoded passwords are not visible in the webclient (#375).
  • More complex searches for composite topics: you can e.g. search a person by its entire name. And you can search Persons or Institutions by combined Address terms (#420).
  • Updating composite values perform faster (#339).
  • More familiar wording of DM Core concepts: "Parent/Child" replaces "Whole/Part". This benefits both, API and GUI (#67).
  • For developers: the Neo4j Shell can be launched while DeepaMehta is running [3601ae4a].

Access Control bug fixes:

  • The admin user can change hers password (#369).
  • A User Account is editable only by a) the respective user, and b) by the creator of the User Account (#375).
  • The View Configurations of the standard types, e.g. Person, can be edited via GUI. They have access control information and Workspace assignments (#377).
  • Association types get Workspace assignments (analogous to topic types) (#376).

Further bug fixes:

  • View Configuration default values are reflected in the GUI. In particular the "Viewable", "Editable", and "Rows" settings are no longer changed by accident (#208).
  • Multiple-value fields (cardinality "Many") can be involved in labeling rules (#250).
  • Search topics and Webpage topics show no "Edit" button (#259, #248).
  • After a multi-facet update topics do not appear twice in the webclient (#339).
  • Deleting all Email Addresses or Phone Numbers from a Person or Institution does not throw an error (#414).
  • A Person or an Institution can still be updated if Address child instances (Street, Postal Code, City, Country) are missing (#407).

Plugin Development Framework:

  • The core class CompositeValue is attached to the DB. So, for complex update operations of composite values the plugin developer must not care about model updates vs. DB-updates. The underlying model and the DB are always in-sync automatically. CompositeValue is now on a par with all the other Core objects (#339).
  • Composite values are loaded lazily (#411).
  • The core classes CompositeValue and CompositeValueModel provide convenience accessors which take a "defaultValue" argument (#418).

Updating from previous DeepaMehta versions is not supported.

See the README for installation instructions.

2013-01-30: DeepaMehta 4.0.14

Main focus of DeepaMehta 4.0.14 is better Performance for large data amounts. Read about the problem background in this posting.

DeepaMehta 4.0.14 comes with a completely rewritten storage layer.

Main aspects of the new storage layer:

  • High-speed traversal: Traversal is significantly speed up by the means of a Lucene index for association metadata. In particular, highly connected nodes (so called "supernodes") have no negative impact on traversal speed (#389).
  • Compact architecture: The concept of a DM-independant MehtaGraph API is abolished. A storage implementation is coded directly to the DeepaMehta Model API. The additional bridging layer is dropped. There is no dependency on the external Neo4j MehtaGraph library anymore (#389).
  • Modular storage layer: a service provider interface ( allows 3rd-party developers to implement alternate storage layers for DeepaMehta, based on DBs other than Neo4j. A Storage layer implementation is deployed as an OSGi service (#391).
  • 1st-class associations: Association user data is indexed as well (just like topic user data) (#389).

Additional performance measures:

  • For DB read operations no transactions are created (#406).
  • Delivering core events involves no runtime reflection (#352).

Further improvements:

  • The AssociationDefinition API is simplified and redundancy is removed from the serialization format (#393).
  • Neo4j is updated from 1.8 to 1.8.1

Bug fixes:

  • This exception should no longer occur (#392): java.lang.IllegalArgumentException: Reference error: ID 1234 refers to a MehtaEdge when the caller expects a MehtaNode
  • Association's Instantiation associations can be queried by type (#338).

Updating from previous DeepaMehta versions is not supported.

See the README for installation instructions.

2012-12-24: DeepaMehta 4.0.13

One main aspect of this release is to revoke the Performance loss introduced in DeepaMehta 4.0.12 in conjunction with Access Control. DeepaMehta 4.0.13 uses a different storage approach for access control information and thus returns to the old performance. Further highlights include: Geomaps are a new topicmap type for displaying geo-related topics on an OpenStreetMap. A graphical Association Type Editor allows the user to create custom association types. Furthermore, a whole bunch of GUI changes improves usability e.g. through Cluster Moves and more informed Topic Revelation.

Of interest for administrators of a client-server installation is the new Apache Karaf-based DeepaMehta distribution. This makes it easy to run DeepaMehta as a daemon process and to access it via a remote shell. Starting from version 4.0.13 DeepaMehta comes in 2 flavors: the known "Standard Distribution" which focuses on small download size and easy setup for single users and the Karaf Distribution for client-server setups.

Furthermore, DeepaMehta 4.0.13 is ready for server-side HTML generation based on Thymeleaf templates. So, along with single-page AJAX applications, the DeepaMehta plugin/application developer can choose between 2 architectural styles. To start with server-side HTML generation install the external DeepaMehta 4 Web Activator plugin. Please note: while being functional, this plugin is in an very early state.

Several improvements in the DeepaMehta framework further simplify the life of plugin developers, in particular when listening to events and providing/consuming services. Last but not least several 3rd-party components have been updated, most notably Neo4j 1.2 -> 1.8.

Updating from previous DeepaMehta versions is not supported.

See the README for installation instructions.

A list of the DeepaMehta 4.0.13 main changes follows. For each item detailed information for users and developers is found in the linked tickets and commit messages.

New Features:

  • The Geomaps plugin is included (#379). Find usage info here:
  • Apache Karaf-based distribution for easy client-server setup and maintenance (#349).
  • Association Type editor: Allows the user to create custom association types. The color is configurable on a per-type basis. Simple and complex association types are supported (analogous to topic types) (#48).
  • Association instance editor: Let the user enter data for an association instance according to the association's type definition (analogous to topic types) (#335).
  • For developers: Server-side HTML generation with Thymeleaf templates (#365).

GUI Improvements:

  • Topic revelation via Page Panel:
    • More informative page panel: Topics which are already visible on the canvas are displayed with an disabled icon. This provides a useful hint when revealing topics (#308).
    • Differentiated gestures for revealing topics via the page panel: a) Clicking the topic's icon reveals it, b) Clicking the topic's label reveals and focuses it (#387).
    • Page panel: Associations are grouped by type, using the association type names as group headers (#256).
  • Optimized Canvas:
    • Cluster move: Moving an association moves the visually connected subnetwork (#327).
    • Canvas auto-panning ensures that auto-positioned topics are always visible within in the current viewport (#303).
    • Topic labels on canvas: a) Line breaks are preserved, b) Long labels are truncated (#300).
  • Working with associations:
    • Keyboard shortcut: Create associations via shift-drag (#304).
    • Once an association is created the Edit mode is entered automatically (#314).
    • When an association is retyped the association form is updated immediately. The user must no longer leave and re-enter the form (#347).
  • Fulltext seach: Wildcards, phrase search, and escaping is supported (#302).

Further Improvements:

  • Performance: A different storage aproach for the Access Control information brings back the performance known from DM 4.0.11 and before (#344).
  • Better support for virtual host environments: The new config property allows the admin to specify the installation's public URL [a9ffcf77].
  • Data model: Meta Types are applicable as child types in association definitions (#363).
  • 3rd-party components are updated, most notably Neo4j 1.2 -> 1.8 (#350).
  • Internal: Refactored object fetch/store code (#340).

Bug Fixes:

  • Handle transitive plugin service dependencies (#351).
  • Join users to workspaces: Interactively created associations between a Username and a Workspace are editable (#331).
  • Delete search topics (#317).
  • Don't select toolbar accidentally (#301).
  • Don't create circular associations [36791f41].
  • Edit an association type's View Configuration interactively (#342).
  • Edit a meta type's View Configuration via REST API (#378).
  • Redeploy the Core while active HTTP sessions exist (#299).

Plugin Development Framework:

  • Simplified service providing/consumption:
    • A plugin consumes services by annotation. The consumedServiceInterfaces config property is no longer required (#367).
    • A plugin's provided service is automatically picked up by the Core. The providedServiceInterface config property is no longer required (#368).
  • Further server-side improvements:
    • The concept of "internal plugin events" is replaced by method overriding. Thus, importing certain Listener interfaces is no longer required (#366).
    • Flexible REST resources registration: A plugin which provides no Root Resource can still provide JAX-RS Provider classes [2b464811].
    • More efficient aggregation update logic and idempotent operations (#319).
    • 3 new core events: PreUpdateAssociation, PostUpdateAssociation, IntroduceAssociationType [654d9c7b][3645932c].
    • The "association" part of a RelatedTopic is serialized (#266).
  • Client-side improvements:
    • Client-side load mechanism for auxiliary scripts: Scripts located in script/helper/ are loaded synchronously before the plugin is loaded. This allows e.g. renderers to share a common base class (#372).
    • New client-side event option_topics allows filtering the selection lists. Applies to both, combo boxes and checkbox lists (#345).
    • Webclient API: The Topic's and Association's composite property contains true Topic objects (instead of plain JavaScript objects) and thus provides access to the client-side Topic API [3105fee2].

2012-09-18: DeepaMehta 4.0.12

This release is all about publishing and collaboration. For the first time there are Access Control and Security features. This enables a whole range of new use cases for DeepaMehta. Topicmap Publishing: everybody can access published topicmaps in a read-only fashion while the topicmaps are still fully interactive. Team Collaboration: per-object Access Control Lists (ACL) and 5 differentiated user roles allow fine-grained control about who has access to what (not yet configurable via GUI). File Sharing: authorized users can upload files to a structured repository and enable common access.

For plugin developers there are fundamental improvements as well. More Convention Over Configuration simplifies plugin development significantly and provides a much more dynamic feeling. As another highlight, Hot Deployment finally works as expected and makes the edit-compile-run cycle a true breeze.

Usage and configuration hints about the new use cases are summarized in a mailing list posting. The remainder is a detailed list of all changes in DeepaMehta 4.0.12. Usage and configuration hints for each change are found in the linked tickets and commit messages.

New Features:

  • Access Control Foundation (#262).
    • Each topic, association, and type is attached with a Access Control List. There are 2 operations: WRITE, CREATE. There are 5 user roles: CREATOR, OWNER, MEMBER, USER, EVERYONE.
    • Scenario 1: Publishing fully interactive read-only topicmaps (#269).
    • Scenario 2: Fully closed workgroup installations [a661efb0].
  • Backend Security (#293).
  • Shared File Repository (#291).


  • The detail panel lists the topics associated with the selected association (#306).
  • Modelers can utilize a Checkbox Renderer for multiple selection (#270) [6c4d87ad].
  • Launching and reloading the Webclient is speeded up (#286).

Bug Fixes:

  • For plugin developers: Hot Deployment works as expected. When a plugin is re-compiled the OSGi runtime shuts it (and only it!) down and redeploys it automatically. All dependencies to other plugins are handled by the framework (#272, #274).
  • Pressing the Return key inside a (multi-line) text area, e.g. the CKEditor's source view, does not trigger the OK button (#206, #288).
  • The default Topic Renderer works with hidden many composite child topics (#283).

Plugin Development Framework:

  • More Convention Over Configuration:
    • A plugin's REST resources and (JAX-RS) Provider classes are registered automatically. Plugins must no longer provide (JAX-RS) Application classes nor do manual configuration (#272) [a39e39c1].
    • All (JAX-RS) Provider classes are available to all plugins automatically [44d49e12].
    • A plugin's client-side main file is picked up automatically (#276) [b30004d6].
    • A plugin's custom renderers are picked up automatically (#284) [19aca819].
    • A plugin's CSS stylesheets are picked up automatically (#285) [2bee421c].
    • Plugin developers must no longer care about firing PRE_SEND (formerly POST_FETCH) events (#297, #268).
    • A plugin's client-side part is no longer required to contain a main file (plugin.js). This is perfect for plugins whose only purpose is to provide custom renderers [3a4a0cbe].
  • Plugin infrastructure:
    • A plugin can publish a directory of the server's file system to the web (#292) [dea0910b].
    • A plugin can register a (Servlet API) filter (#293) [520c95c0].
    • A plugin's client-side part is namespaced per URI for friendly co-existence (#275) [082a4651][faf8d006].
    • Custom renderer implementations (page renderers, simple renderers, multi renderers) are namespaced per URI for friendly co-existence (#282) [9bb0c6a7][4aab34b1].
    • A plugin can register listeners for 4 new Core Events: PRE_CREATE_ASSOCIATION, POST_CREATE_ASSOCIATION, PRE_SEND_ASSOCIATION [98fb628d], INITIALIZE_PLUGIN [435f4285].
    • A plugin can operate on the logged in user's HTTP session (#293) [faa7485e].
  • Renderer Framework:
    • New renderer type: Multi Renderer. A plugin can provide custom renderers for multi-value topics (in conjunction with cardinality "Many") (#270) [6c4d87ad][7fe0a806].
    • Topicmap renderers have a server-side part as well (#294).
  • Core consolidation and optimization:
    • The core service is now able to process update requests where aggreagted composite child topics are involved (#30, #267).
    • For handling core events plugins implement listener interfaces instead of overriding methods. A plugin's listeners are registered automatically. The core delivers events to the registered listeners instead of iterating over all plugins. This is the more efficient approach (#261) [b59fff18].
    • The application layer is separated from the network layer. This avoids high-rate firing of unnecessary core events (#268).
    • Core is modularized and its API is cleaned up (#281).
  • Miscellaneous:
    • The Proxy plugin is dropped. Its features are transfered to the Files plugin (#292).
    • The Facets plugin is included to the DeepaMehta Standard Distribution (required by the Access Control and Workspaces plugins).
    • The Javadoc Maven plugin is configured to generate cross-referenced API Docs with inlined class hierarchy diagrams [5d6b13bc].
    • A lot of API changes and extensions in various plugins, e.g. the Facets API supports multi-value facets.
    • Updated jQuery 1.7 -> 1.7.2 and jQuery UI 1.8.16 -> 1.8.21

Updating from previous DeepaMehta versions is not supported.
See the README for installation instructions.

2012-05-19: DeepaMehta 4.0.11

This release provides substantial improvements for users and a serious bunch of under-the-hood improvements for developers. For regular users the highlight feature is Implicit Saving: the user must no longer care about saving; DM automatically ensures nothing is lost. The highlight feature for power users who create custom data models is the Type Editor with support for Cardinality "Many" at last. Last but not least 3 external plugins have been updated in order to be compatible with this release.


  • Implicit Saving. The user must no longer care about saving. DM ensures nothing is lost, e.g. when the user selects another topic while being in edit mode. The "Save" and "Cancel" buttons are replaced by an "OK" button. The "OK" button just allows the user to say "I'm done with editing". There is no need to press it. (#243).
  • The detail panel's type editor is now fully functional. Select a type and press "Edit". You can change the Association type (Composition or Aggregation) and Cardinality (#77).
  • Consolidated data model: the "many" cardinality is now operational. For "many" the detail panel's form generator automatically provide the user with "Add another ..." and "Remove" buttons. Thus, its easy to add e.g. another phone number or email address to a Person topic (#76).
  • Nested detail panel rendering: The detail panel visualizes the composite structure as nested boxes, filled with a distinct color for each nesting-level. This is useful in particular with cardinality "many" (#104).

Bug Fixes:

  • Links in the detail panel's Associations list are truncated (#247).
  • Invalid association definitions doesn't prevent the Webclient from starting (#253).

Plugin development framework:

  • Webclient: revised FieldRenderer? and PageRenderer? APIs make the plugin code more clean [ebcbb429][7e5cdfd0][d0a960cc][d3f656e2].
  • Core: An ObjectFactory? supports the development of system-near plugins, like e.g. the Type Editor [c57ca5fb][c0034f0c][2b77e475].
  • The core service accepts update requests in 2 formats: the canonic format and a simplified format. The former contains full topic models and is required for cardinality "many" associations. The latter contains just the topic values and is sufficient for cardinality "one" associations. Within one request both formats can be mixed (#237).
  • The updateTopicType() core service call returns a set of directives. Thus, a client is provieded with detailed hints about how to keep the GUI in-sync [377ed738].
  • New directive DELETE_TOPIC_TYPE [37c66c51].

Compatibility with 3 updated plugins (optional install):

Updating from DeepaMehta 4.0.7 or later is supported.
See the README for installation and update instructions.

2012-03-24: DeepaMehta 4.0.10

This minor release just contains 2 bug fixes.

Due to other work like building the new website this release took a comparatively long time. Now we're back on the development track.

Bug fixes:

  • The Back button works cross-topicmap again (#231).
  • Building from scratch with a pristine maven repo works again (#234).

Updating from DeepaMehta 4.0.7 or later is supported.
See the README for installation and update instructions.

2012-02-03: DeepaMehta 4.0.9

This is a pure bug fix release that fixes the new CKEditor (introduced in yesterday's release).

Bug fix:

  • CKEditor works in non-english environments (#191).

Thanks Matthias Melcher for reporting!

Updating from DeepaMehta 4.0.7 or later is supported.
See the README for installation and update instructions.

2012-02-02: DeepaMehta 4.0.8

This release features an alternative WYSIWYG editor. CKEditor provides a much better look & feel than TinyMCE. Furthermore it loads faster, that is it appears more instantly when pressing the Edit button.

GUI improvement:

  • CKEditor replaces TinyMCE (#189).

Plugin development framework:

  • Client-side "post_destroy_form" hook replaces "post_submit_form" and has slightly changed semantics [a9939b89].

Updating from DeepaMehta 4.0.7 is supported.
See the README for installation and update instructions.

2012-01-19: DeepaMehta 4.0.7

The main feature of this release is the compatibility with the "DM4 Kiezatlas 2.0" plugin and the attendant plugin development framework extensions. Furthermore there are some general GUI improvements and bug fixes.

Compatibility with 1 new plugin (optional install):

Compatibility with 2 updated plugins (optional install):

GUI improvements:

  • Auto-positioned topics appear near selection. This results in less mouse drags and less canvas clutter (#174).
  • New icon for "search result" that replaces the bucket: a pile of balls [69aa3fd4].

Bug fixes:

  • The topicmap state (translation) is persistent after auto scroll (#170).
  • Deleted associations resulting from combobox value changes are removed from the canvas (#176).

Plugin development framework:

  • Webclient performance improvement through new hook mechanism: hook code is explicitly registered at the webclient (instead of placed in dedicated methods) (#173).
  • Customizable GUI:
    • Decouple canvas from page panel: the topic selected on the canvas and the topic displayed on the page panel can be a different one [ce27623b][ac819a9a].
    • Customizable page panel rendering in case of nothing is selected (new hook default_page_rendering). Splash screen by default. [40cb0f8f].
    • The default page renderer and form generator are customizable (new hook pre_render_page) [69866e36][bb7cc70b][af4f2ff9].
  • More flexible update requests: plugins can attach application-specific data to update requests and provide the corresponding server-side processing logic [b54822fc].
  • More convenient client-side API for accessing (nested) topic values [616e35d6].
  • Cleaner exception logs from REST resource methods [ebd02479].

2011-11-27: DeepaMehta 4.0.6

This release has mostly improvements for plugin developers. It is compatible with 2 new external plugins (see below). There are some GUI improvements though.

The DeepaMehta 4.0.6 installation is described in the README. You must perform a clean install. You can't use content from a previous DeepaMehta installation.

New feature for plugin developers:

  • Map type extension architecture: plugins can provide additional map types, e.g. a geo map or a time map (#52). Each map type can have a distinguished data model, rendering facility, and interaction style.

Improvements for plugin developers:

  • Clients can benefit from an extended composite value format (#146).
  • Server-side plugins can extend a topic before it is send to the client (new postFetchTopicHook) [874271b8].
  • Client-side plugins can access the model of the selected topicmap (#147).
  • Client-side plugins can set/get the split panel's slider position (#148).

GUI improvements:

  • Topicmaps remember their translation (#154).
  • Design: the toolbar is more plain and saves screen space.
  • Design: the entire GUI uses an uniform font.

GUI fix:

  • Menus opened within dialog boxes are not constrained to the dialog box dimension (#165).

Compatible with 2 new plugins (optional install):

Updated 3rd party components:

  • jQuery 1.7 (updated from 1.4.2)
  • jQuery UI 1.8.16 (updated from 1.8.2)

2011-10-20: DeepaMehta 4.0.5

There are crucial Windows and Apache related bug fixes and 3 hot features.

New features:


Improvements for developers and power users:

  • Plugins can interfere with browser history and permalink construction (#106) [448e95cd].
  • Extended webclient view configuration: also complex child types can be non-viewable/non-editable.
  • Extended REST API: create association types. See REST API.

2011-09-27: DeepaMehta 4.0.4

Main features of this release are file management, GUI customization, and daemon support.

New features:

  • Icon picker: change the topic type icons (#49). See usage info.
  • Custom icons: attach your own icons to topic types (#49). See usage info.
  • User-defined topic labeling rules (#41). See usage info.
  • File management*): View/play your text/image/audio/video/PDF files right in DeepaMehta (#78). See usage info.
  • File browser*): browse your disk (#90). See usage info.
  • Configurable proxy service*): access local and remote resources (#90). Interesting for client-server installation. See usage info.
  • Running DeepaMehta server as a daemon (#46). Interesting for client-server installation. See Ubuntu daemon setup.


  • User-defined child type order (for content panel rendering) (#77). See usage info.
  • First support for larger topic amounts (thousands of topics) (#98).
  • Search results are alphabetically sorted (#69).
  • Design: smaller icon rendering in content panel and menus.

*)These features doesn't work on the Windows platform. There is a known bug (#91). It will be fixed in the upcoming 4.0.5 release.

2011-08-22: DeepaMehta 4.0.3

After a long series of backend changes the focus of this release is to bring the frontend on a par. This release brings 2 new featues and a lot of GUI improvements and fixes.

New features:

  • Webbrowsing (early state): render webpages directly in DM! Right in the content panel or in a separate window/tab. URL topics provide 2 commands: "Open URL" and "Open URL in new window". (#21, #73)
  • Type Search: query all topics of a given type (#68)


  • More intuitive Create menu (#11)
  • Focus first input field when creating a new topic (#12)
  • Trigger Save by hitting Return (#13)
  • Create topics via keyboard (#14)
  • Type Resource is now called Web Resource. URL field first. (#20)
  • The webclient has a "favicon" (#44)
  • Creating a bunch of topic types without caring about unique URIs (#58)
  • The webclient's URL is simply http://localhost:8080/ (#66)
  • Topic type menus are sorted (#68)
  • About box with version/license info and credits (#36, #70)
  • Minor design and layout improvements


  • Closing menus when clicking elsewhere (#29)
  • Proper dragging when creating an association (#31)
  • Searching requires a given search term (#57)
  • Toolbar menus reflect renamed topicmaps and workspaces (#59)
  • Suppress pointless browser window scrollbars (#60)
  • Long menus do scroll instead the entire browser window (#71)
  • Fix canvas drawing and event handling oddities (#72)

Improvements for Developers:

  • No webclient 404/503 errors when build from source (#17) [4391f3ef]
  • Multi-context commands: A plugin can attach its commands to both at the same time, the context menu and the page panel (#21) [baad6eb7]
  • Revised file upload support [b593ce31]
  • URL topics can be queried by their URL (#55) [a58824f2]
  • Plugin authors can specify a custom URI namespace where the plugin's web resources are mapped to (#66) [3aa32aba]
  • A request to a / web resource is mapped to /index.html (#66) [3aa32aba]
  • REST API: "getRelatedTopics" request provides 3 more filter parameters [45e6dc93]
  • Page Renderer classes can CSS style the content panel [326556d8]
  • Access the webclient's toolbar via a dedicated toolbar object [80754bd8]
  • JavaScript? GUIToolkit API simplified and more object-like [aa9f8453][be5c4133]

2011-08-02: DeepaMehta 4.0.2

This release fixes a bug ( There was an encoding issue with the binary distribution in a client/server setup. This is now fixed. No problems with umlauts anymore.


For installation and update instructions see the README:

2011-07-28: DeepaMehta 4.0.1

This release fixes a bug: when editing an association (e.g. retyping) the role types are not compromised (ticket #18).
Thanks Malte for reporting!

You can update a 4.0 installation while keeping your content.
However, a 4.0.1 clean install is recommended (see comments on ticket #18).

See the README for installation and update instructions:


Build/Update? from Source:

Furthermore, these 3rd party components are updated in 4.0.1:

  • Jersey 1.5 -> 1.8
  • Jettison 1.2 -> 1.3
  • Neo4j Mehtagraph 0.7 -> 0.8

2011-07-24: DeepaMehta 4.0

Related to the 1st release candidate (4 days ago) there is just one Firefox-related bug fix.
Thanks Matthias for reporting!


Build from Source:

Further information in the README:

2011-07-20: DeepaMehta 4.0 RC1

This is the first release with the all-new property-less data model as recently described:>

The version planned as "DeepaMehta 3 v0.5" now become "DeepaMehta 4.0".
From now on DeepaMehta's version numbers follow the classic major.minor.bugfix schema.

Improvements for users:

  • new type editor. All values are represented as reusable semantics-attached topics.
  • new topic type "Resource" to collect web resources
  • new icons
  • bug fix in topicmap handling (when you have multiple topicmaps open)
  • cleaner display, less clutter

The cleaner display is because not all the plugins (workspaces, time, access control, ...) are adapted to the new data model so far. So, for the moment there is not so much meta data displayed (timestamps, workspaces assignments, creator, modifier, ...).

Improvement for developers:

  • New core service API. All the domain objects (Topic, Association, ...) are attached to the database. So, the developer must not care about DB-updates.
  • Domain models (type definitions) provided by a plugin can be build upon the domain models provided by other plugins. The dependencies are handled by the framework.

Download the release: Start as usual via the provided startscripts.

Build from Source:

For further information see the README:

If the browser shows 404 while this exception appears in the terminal ...
com.sun.jersey.api.container.ContainerException: No WebApplication provider is present
... then refresh the HTTP Jetty Bundle by typing "refresh 1" in the terminal (checkout the proper bundle ID before by using the "lb" command).

Thanks go to Jürgen and Danny who helped to organize this release!