Obsydian 3.0, internally known as the "Diamond" release, represents a major upgrade to Synon’s enterprise development environment. This paper describes the features of Obsydian 3.0.

Obsydian 3.0 contains extensive and exciting new features. These enhancements are born from input gathered from both customers and leading industry experts. The combination of new technology and feature-rich productivity enhancements make Obsydian 3.0 Synon’s most ambitious and powerful release yet.

32-bit

Obsydian is now a 32-bit tool. We have re-built the product with the same Microsoft Foundation Classes on which Obsydian-developed applications rely. By moving Obsydian to a 32-bit MFC environment we have opened the tool to take better advantage of the 32-bit operating systems, Windows 95 and Windows NT. For example, you will notice many user interface improvements and you may now run multiple instances of Obsydian on your workstation.

16-bit support

Obsydian 3.0 continues to be the only development tool that allows you to generate & deploy applications for both 16-bit & 32-bit clients from the same design.

Looking to the future, Synon’s close working relationship with Microsoft has afforded us the unique opportunity to preview upcoming technology. By doing so we are able to put together development plans which we believe will ensure that Obsydian keeps pace with these complex emerging technologies. We feel that these plans will allow Obsydian to continue to evolve to meet the challenging demands of your business.

On the horizon are the upcoming releases of Windows 98 and Windows NT 5.0.

In order to fully exploit the features available in those upcoming state of the art environments, Synon has decided to stabilize support for 16-bit deployment at Obsydian 3.1 planned for 1Q 1998. This will mean that Obsydian 3.1 will be the last release that will contain support for deploying 16-bit applications.

The most immediate changes you will notice in Obsydian 3.0 are to the tool’s user interface. Since we introduced Obsydian in 1994 we have learned much about how our customers use the product and how we can change the interface to make it simpler for new Obsydian developers. We also incorporated the expert feedback of Human Factors International; they conducted a detailed usability survey on our behalf. From what we’ve learned, we redesigned key aspects of the tool’s GUI (graphical user interface). We think you’ll find Obsydian 3.0 much more consistent, much easier to use, and much easier to learn. Here is a description of the main changes in Obsydian’s user interface. From feedback we’ve already received, these changes help make developers using Obsydian even more productive.

Toolbars

The Obsydian Toolbars have been completely redesigned. You’ll find the toolbars are now "dockable." You may drag any dockable toolbar to any of edge of Obsydian’s window or you may undock any toolbar and let it act as a floating, re-sizable tool palette. There are several toolbars that group buttons into related tasks.

Obsydian, by default, shows the most appropriate toolbars at any time. You, however, can choose to hide or show any toolbar at any time. Most noticeably, we’ve given each toolbar button colorful, easy to intuit graphics. Each toolbar button also has fly-over hint text describing what each button does. As before, the TOOLBAR.HLP file in the Obsydian product directory contains all the current toolbar button bitmaps for use in your applications.

Right-mouse menus

Obsydian has always provided context-sensitive shortcuts to various options and commands through pop-up menus activated with a "right-mouse click." Developers working with Obsydian 3.0 will find these menus are more functional, more consistent and now accessible from most every possible place within Obsydian. We’ve added significant commands to each pop-up menu; the most common tasks in each editor or browser are now available from these menus. You can access these context sensitive menus from more places within the tool including the Model Editor. This makes model navigation simpler and eliminates the need to jump to other editors or browsers from the model editor.

Other UI improvements

We’ve enhanced several other portions of Obsydian’s user interface.

• All tree-view panels now follow the Windows 95 Explorer standard with a cleaner look and single-click expansion/contraction of branches. Examples of tree-view panels include the Object Browser and the Generate and Build window.
• Obsydian will now remember the location of the Object and Inheritance Browsers not only when you hide and show them but now when you close and re-open them.

• The tool’s General Options dialog has been expanded and simplified. A tab-dialog divides the tool configuration choices into "General," "Format," "Mouse," and "Advanced" groupings.

• The Model Configuration panel is much cleaner and easier to use. Each model attached as a library to your group model appears on a grid with its current variant, national language, version, and level. When creating a new local model, the settings for each group model default to the level with the highest sequence number in the most recently created version.

• The Help Topic Editor now includes the style description in the style list box, not just the style code.

• The Message Log has a new Quiet Mode. This mode prevents the Message Log from opening every time a new error has occurred. This is less disruptive than the Retain Focus After Error mode which it replaces.

Diagrams are great communicators. You’ll find Obsydian 3.0 diagrams richer and easier to use. First, we’ve improved diagram printing to include true WYSIWYG. With true WYSIWYG, printed diagrams more closely match their screen representations. Printing in color is now supported as is pure black & white printing. The pure black & white option and is more economical and simplifies shading and coloring for output on a black and white printer.

Second, printed and screen-viewed diagrams can show more in-depth information.

• Show/hide Resolved Keys: Resolved Keys are the fields that Obsydian places in an entity as the result of an Owned By or Refers To relationship with another entity. Obsydian 3.0 lets you decide if you want to show these on your diagrams.

• Show/hide Virtuals: Virtual fields are those that appear on a view of an entity as the result of a database join.

• Show/hide Scoped Objects: Inheritance in Obsydian is one of its most powerful features. Not only can you define new objects based on others, all objects can contain many other objects. We refer to an object as a Scoped Object when it helps form larger objects. Example: you may create an object called "Insurance Policy" which includes the policy header and the coverage details. Within Insurance Policy are the scoped objects Insurance Policy.Header and Insurance Policy.Detail. When you diagram such a complex object, the diagrammer will now let you hide or show Scoped Objects.

• Show/hide Inherited Links: Complex objects that contain several scoped objects may also contain the relationships defined between the scoped objects. Using the example above, if we say that Insurance Policy is a OBASE/Simple transaction, we inherit the "owned by," one-to-many relationship between header and detail. The diagrammer can show or hide inherited links (relationships).

Lastly, we’ve added three diagram layout features.

• Auto-layout of Sub-nodes: A sub-node is a node (shown, perhaps, as a box or an ellipse) that graphically sits inside another node. Examples of sub-nodes include fields inside entities on an Entity Attributes diagram and functions inside function suites on Function Decomposition diagrams. Obsydian 3.0 includes Auto-layout functionality that will properly size and space sub-nodes. This is especially handy when showing/hiding virtuals, resolved keys, etc. Also, when you drag an object with sub-nodes onto a diagram, you can use this Auto-layout feature to prevent "bunching." Instead of sitting inconveniently atop one another, sub-nodes will spread themselves out nicely.
• Overlapping Nodes: When we first created Obsydian, we thought that overlapping nodes was a bad idea. After listening to how our customers want to use their diagrams, we’ve changed our thoughts. Overlapping is now allowed and you’ll find it gives you greater flexibility to place diagram comments and use diagram layers.
• Improved zooming: you can now view your diagram at any zooming level between 10 and 200%.

In the Action Diagrammer we’ve added intelligence to parameter mapping and made building abstract functions simpler.

Parameter Mapping

There are three changes the way developers edit the parameters passed on an action diagram call to another function or message. First, we’ve renamed the sometimes confusing "Formal Parameter" and "Actual Parameter" to the obvious "To" and "From."

Second, when specifying an individual parameter to pass, the Field Selection dialog automatically shows only those variables, or groups of fields, that have fields appropriate for passing. You no longer have to search through variables that don’t contain field valid for passing. As well, the tree-style Field Selection Dialog opens with all variables expanded to show their constituent fields. Third, a minor but useful enhancement: to edit the mapping of a parameter, just double-click it.

Collection Points

The day-to-day work in Action Diagrams involves editing pre-built functions inherited from patterns. It’s the job of the pattern author to write the pre-built logic and include any necessary Edit Points. When you inherit these functions, Obsydian limits you to working only in the pre-defined Edit Points. This preserves the integrity of inherited functions. Obsydian developers benefit from this architecture because they can build and maintain applications much faster than with traditional, code-based tools.

In Obsydian 3.0, we’ve augmented the capability of Edit Points with a new feature called the Collection Point. A Collection Point is like an Edit Point; you can use them to add logic to an otherwise protected Action Diagram. Unlike an Edit Point, a Collection Point remains editable no matter how many layers of inheritance you have. With Collection Points, Obsydian maintains all Action Diagram constructs from all inherited Action Diagrams. The order in which the constructs appear is determined by the order of antecedent functions in the Inheritance Browser.

Because they accumulate logic through all inheritance layers, Collection Points let pattern authors include complex functionality without the worry that someone inheriting from their patterns might overwrite their logic. We intend that pattern authors will use Collection Points exclusively. Developers building applications from these patterns will continue to use Edit Points.

You don’t insert Collection Points; they are automatically associated with Edit Points. For each Edit Point, Obsydian adds a "Pre Point" and a "Post Point." You may choose to show or hide Collection Points when editing your Action Diagrams.

ActiveX Controls

Obsydian 3.0 supports ActiveX controls for 32-bit panels. ActiveX controls are to 32-bit panels what VBX controls are to 16-bit panels. Like VBX controls, ActiveX controls bundle rich functionality and handy GUI (graphical user interface) objects. Just as there are thousands of VBX controls on the market, you can choose from a growing selection of ActiveX controls to extend the function of your Obsydian-designed applications. For more information on ActiveX controls, see http://www.microsoft.com/activex.

To insert an ActiveX control, use the context (right-hand mouse click) menu and choose "Create ActiveX Control." Obsydian will display a list of all registered ActiveX controls. (If the ActiveX control you need is not on this list, see the vendor’s documentation for installing controls.) From this list, select the control you need. Once installed, you can set the control’s properties, map its events to Obsydian logical events, and even test it interactively from within the Panel Designer.

In addition to setting properties and mapping events, ActiveX controls allow further, in depth manipulation through scripting. To access the full power of ActiveX controls, Obsydian 3.0 supports ActiveX scripting. Scripts are implemented as source code objects using Obsydian’s new full-screen source editor. You may write scripts in either JavaScript or VBScript. JavaScript is a Java-like language created by Netscape. VBScript, from Microsoft, is a subset of Visual Basic.

You may insert ActiveX controls in 32-bit panels. For 16-bit panels, continue to use VBX controls. The Panel Designer in Obsydian 3.0 now sports a 16/32-bit toggle so that you can view your panels as they would look with VBX controls (16-bit) or ActiveX controls (32-bit).

Default Layout Wizard

To make it simpler to set panel design standards, the Panel Designer has a new Default Layout Wizard. The Default Layout Wizard lets you specify region & button orientation (vertical or horizontal),starting points and pixel spacing for the whole panel or selected regions.

Panel Re-sizing Improvements

The Obsydian 3.0 Panel Designer lets you use your mouse to resize the your panel. Before, this was only possible if you designed your panel to be re-sizable at runtime.

Windows 95/NT 4.0 Panel Defaults option

In Obsydian 3.0, we have added a new choice to the General Options dialog. By selecting the "Use Windows 94/NT 4.0 Panel Defaults" option, you instruct Obsydian to set your panel design defaults to

• Use normal (not bold) fonts,

• Indented borders, and
• The Windows standard background color (chosen by the user) instead of a hard-coded color.

Note that normal fonts generally take up less panel space than bold fonts. You will have more room on your panel designs; you may see small differences in control positioning on existing panels.

Windows System Color Support

Instead of hard-coding colors, you can now specify that a particular element gets its color from the Windows default color settings. Each end user can specifies their color scheme preferences using the Control Panel. When you use system colors in your panel designs, your applications will conform to the end users’ desktop preferences.

Tab Stop Property for Grids

Introduced in Obsydian Release 2.51a, the Tab Stop property indicates whether, at runtime, a control can gain focus as the result of the end user pressing the tab key. If set to No, the end user will see focus skip over the control in question. In Obsydian 3.0, we’ve enabled this property for grid controls.

Obsydian users have always been able to extend and integrate their applications with native, 3GL source code. In Obsydian 3.0, we have added a full screen source code editor. Use this to work with source code objects like the new ActiveX scripts or low-level integration code snips.

Filtering of Objects by Implementation Language

When selecting objects to be generated and/or built, you can filter the list of objects by object type and now, by implementation language. This makes it simpler to, say, just generate WinC++ client functions.

16/32-bit Indicator

The Generate and Build window now indicates whether you are creating 16 or 32-bit clients. Look for Win32 or Win16 in the status bar of the window.

MS Developer Studio Integration

For 32-bit C++ builds, Obsydian does away with the DOS-box and instead uses Microsoft’s Visual Studio. Visual Studio is the common code & test environment for programmers using MSVC++, Java, Visual Basic, Visual FoxPro, and Visual InterDev. When you get a license of Visual C++ 5.0, you get Visual Studio. For more information about Visual Studio, see the Obsydian Installation Guide and http://www.microsoft.com/vstudio.

Column Sorting in Grids

You can create grids that allow your users to select the sorting order of a grid by selecting the column by which to sort. Use the new Sortable property in the Panel Designer to indicate that a column should be sort enabled. Multiple-column sorting is available through a newly implemented API.

Right-Mouse Behavior in Grids

Like Windows Explorer, right-clicking a runtime grid row will select that row. If you have defined a pop-up menu for the grid-row, it will pop-up when the user releases the mouse button.

Enhanced Multi-line Edit Controls

Multi-line edit controls now support up to 32K of data.

TCP/IP to the AS/400

If you target the AS/400 as one of your deployment platforms, you may know that client connections to this machine have historically required a router product (from Netsoft or IBM, for example). In Obsydian 3.0, you may choose to eliminate the router and connect client applications to the AS/400 servers via TCP/IP. This is useful if your end users do not require other router services like terminal emulation or shared folders. The TCP/IP configuration details for each client is stored in an .ini file and can be changed at runtime.

You can also take advantage of TCP/IP to the AS/400 as an Obsydian developer. For building applications to the AS/400, use the new configuration screen to configure your build communications protocol.

Multi-threading of NT Server Functions

If you are using the Obsydian for NT/BackOffice generator, your NT server functions can optionally run as multiple threads within a single NT process. This can reduce OS overhead and improve performance. Select to use this feature with a new option in the NT Dispatch Manager.

Simpler Partitioning Setup

The NT Environment Manager provides a wizard that makes it easy to add the registry entries required to support dynamic application partitioning.

32-bit Debugging

The Action Diagram Debugger helps you locate logic errors in your Action Diagrams. In Obsydian 3.0, the Action Diagram Debugger now supports 32-bit C++ client and NT Server programs in addition to 16-bit C++ clients.

User Interface Improvements

In addition to the general UI improvements seen throughout Obsydian 3.0, we’ve made some helpful changes to the Group Model windows. These include:

Library Licensing

To help software vendors protect their intellectual property investments, Obsydian 3.0 supports licensing of group models. As a Pattern Library vendor, you will find this delivers a flexible, low-overhead solution. You can secure your products with authorization codes. Synon has also made it easy for you to distribute these codes.

Product Licensing Enhancement

The licensing files for Obsydian 3.0 are now in a subdirectory of the Windows or WinNT directory. You will find that this minor change makes future upgrades much simpler.

Configuration refers to how Obsydian stores many renditions of your models. Obsydian will track changes to your model based on National Language, Levels and Versions, and Variants. In Obsydian 3.0, we’ve improved configuration in three areas.

Variant and national language verb behavior

Triples entered in the Model Editor at a non-base variant or language now override any corresponding triple existing in the base variant or language.

Triple sequence configured by level

The sequence of triples as seen in the Model Editor is now configured by level. Changing the sequence of triples effectively deletes a triple and then adds a new one. The sequence of triples seen at an earlier level is unaffected.

XXX implement SYS now variant-dependent

The various XXX implement SYS triples are now variant-dependent. Triples created in earlier versions are automatically assigned to the base variant when you use the model with Obsydian 3.0.

Also available in conjunction with Obsydian 3.0 is Obsydian for Java.

Obsydian for Java lets you create n-tier client-server applications with Java servers and Windows C++ clients. As with the Obsydian for NT/BackOffice generator, your Java applications can be dynamically partitioned.

Generated servers use Java Database Connectivity (JDBC) for data access; developers can either use the JDBC driver that is included with the Java Developers’ Kit, or obtain a JDBC driver directly from their DBMS vendor.

Remote generation, building, and administration capabilities are included.