- IPAD-Pro is a visual CASE tool builder. It allows software developers to build complex visual tools tailored to their particular requirements or sub apps targeted at niche markets within their specialist problem domain. The resulting tools are built around the IPAD-Pro core and inherit most of the visual functionality, underlying object intelligence and platform independence of IPAD-Pro.
Example sub apps already built and available for evaluation are :
ZMECH - a complete state machine CASE tool XEBOT - a complete visual application builder IPAD - a complete intelligent vector drawing package
- Extremely powerful visual editing interface available to the developer in the production of sub apps and to the end user of the resulting sub app. This interface allows easy editing across files using multiple overlapping windows. The graphics objects drawn and edited using the interface have built in intelligence and react to the mouse and each other so as to maximize user productivity and reduce tedious repetitive setup sequences (see the IPAD vector drawing package for more information on the visual edit capabilities available to the developer and end user).
- The self contained execution environment of the multiplatform core allows both sub apps and apps to be built that:
- run directly on systems without GUI support (e.g. MSDOS or DRDOS)
- replace the native GUI where it is considered bloated or unpredictable.
- run on all supported platforms without the usual porting overheads. This lets the developer design the sub app and app once and use it through the same interface on many platforms.
- Fast prototyping of partial designs allows incremental interactive development of complex tools.
- The IPAD-Pro core manages many form and dialog functions which other GUIs normally require the app take responsibility for.
- Complex forms and dialogs are easily built and maintained using XEBOT and can then be used directly within a new IPAD-Pro sub app (see XEBOT for more information)
- The concise coding model allows functionality to be quickly and easily added to code objects such as form controls or diagram elements without the need to intercept and decode GUI event messages or build and send special messages between communicating components (see ZMech events, states, etc. and XEBOT form controls).
- The IPAD-Pro core has a sophisticated API which allows complex data gathering, validation and mapping between the IPAD-Pro core and all components of the app including visual components such as buttons, text entry fields, check boxes and diagram elements. There is no need to provide hundreds of API defined functions and buffers just to collect data and perform validation from myriad's of points within the code.
- The IPAD-Pro core provides a sophisticated interpreted C like language (called XPE) which allows small sections of code to be embedded within objects such as diagram elements. This removes the need to write external code fragments for tiny sections of code and greatly simplifies development and maintenance of the sub app. XPE supports modules (similar to C++ classes) which allow components to encapsulate data and functionality. It also supports 'named' indirect functions calls, methods, dynamic structures and 'named' indirect structure member lookup.
- Supports hot swap dynamic linking of externally compiled modules (written in C, C++ and assembler) allowing in situ upgrades. This is of particular value when the app is part of a monitoring or control process since there is no need to reboot the system or restart the IPAD-Pro core.
- External code can easily be accessed from the visual components of an app (such as diagram elements and form controls). The external code can also directly access components within the app. For example when reporting errors the external code can simply ask for the ID of the message box with the name "error_messages" and write to it. Another example is the state machine diagrams which change colour while they are being traced from within ZMech, the diagram being modified directly from the state machine while it is running (the state machine is originally generated from the diagram, compiled, dynamically linked and executed).
- Protected sub app data file formats preventing other cheaper sub apps being engineered from IPAD-Pro to take advantage of proprietary info build into competing sub app. e.g. IPAD (the drawing package) cannot directly read ZMech (the state machine CASE tool) native data files unless explicitly exported and exporting of proprietary code can be inhibited so that only visual shapes are readable. Importing proprietary code is completely blocked and requires that the owner of that code makes it available for the alternate sub app in native file format.
- The sophisticated category system allows complex properties to be easily defined for an object and directly available to the end user of a sub app.
- The relationships between diagram elements is maintained by the core so there is no need for the developer to build complex internal lists or worry about updating these lists as the diagram is edited.
- Diagram elements can cooperate to perform a task e.g. rather than outputting the diagram to a back end code generator that needs to parse the diagram and build an internal representation of the types of objects and their relationships to one another and then generate code, the objects in the IPAD-Pro diagram themselves can take part in the process since they know what they are and what they are connected to. ZMech is an example sub app that uses this approach to generate executable code from the state diagram that the end user draws. It is also able to indicate where errors in a state diagram lie by highlighting the effected parts of the diagram rather than trying to describe the position of the error as might be the case with a back end generator.
- Simple diagram elements can be combined into complex objects with complex functionality and then be used as complete diagram elements in their own right. e.g. an object with several inputs, outputs and internal mapping between them can easily be built (see the self contained state machines in the ZMech crisis diagram).
- Source Code Availability
- Due to the design of the IPAD-Pro core / sub app API, there is no need to modify the IPAD-Pro core to produce a sub app. The source code for the core is only available under commercial license.
- Availability / Evaluation
- IPAD-Pro can be evaluated through the restricted sub apps XEBOT, ZMech and IPAD which provide concrete examples of what the IPAD-Pro product can do.
Please direct all purchase enquiries to: email@example.com