ModelMaker: Native Refactoring and UML 2.0 modeling for Delphi
ModelMaker 11.10.0 released
ModelMaker in short
- Award winning Delphi™UML 1.4/2.0 Visual modeling and Refactoring tool.
- Native Pascal support - unmatched by any other tool.
- Delphi 7, Delphi 2007-2010, Delphi XE-XE8, Delphi 10 Seattle and Delphi 10.1 Berlin IDE integration
- Delphi 5 and 6 support provided as service.
- Instant Code generation, Reverse engineering (code import)
- Instant visualization.
- Designed for Large scale Restructuring and Refactoring.
- Whole spectrum of UML diagrams supported.
- IntelliReplace™ propagates renames in code.
- Point-and-click, drag-and-drop programming.
- Deploy Design Patterns.
- Improve the design of existing code with build-in Refactorings.
As a result:
- Speed up development
- Produce designs and code of unequaled quality.
- Think of design instead of typing code.
- Design without compromising and Refactor designs until they feel just right.
- Create and maintain magnitudes larger projects in magnitudes less time.
- Document you designs in UML 1.4 or UML 2 style diagrams.
- Document your source in help files by clicking a single button.
- In short: save time and money, making better software.
ModelMaker is a two-way class tree oriented productivity, refactoring and UML-style CASE tool.
ModelMaker is specifically designed for generating native Delphi code. Delphi's Object Pascal language is fully supported. ModelMaker has full reverse engineering capabilities and import existing Delphi code. Delphi IDE Integration experts take care of synchronizing ModelMaker and the Delphi IDE editors.
Customers use ModelMaker for the whole field of software development: real-time, technical and database type applications.
Design and UML Modeler
You design in the UML modeler and/or the code model views. ModelMaker supports the full set of UML diagrams:
- Class Diagrams - classes can be visualized in many different ways.
- Implementation Diagrams - both Component and Deployment diagrams are supported.
- Package Diagrams - including auto generated (Pascal) Unit Dependency Diagrams.
- Use Case Diagrams - any symbol can be linked to other diagrams and external documents.
- Robustness Analysis Diagrams - a bridge between the use cases and detailed design.
- Sequence Diagrams - methods can be created right in the diagram editor. Check movie with some Sequence Diagram Editor features.
- Collaboration Diagrams and Concurrency Diagrams - to model (real time) dynamics.
- State Chart Diagrams - including composite states and Concurrency.
- Activity Diagrams - including Swimlanes and Object Flow visualization.
- UML 2 Interaction Overview Diagrams - combining Activity and Sequence diagam show high level overviews.
- ISO Flow charts - Very similar to UML Activity diagrams but in ISO 9000 style.
- Mind Map Diagrams - Visually organize your thoughts.
Restructuring and Refactoring
ModelMaker's active modeling engine maintains all relationships between classes and their members. This is the base for ModelMaker's restructuring power. For example: Renaming a class or changing its ancestor immediately propagates to the automatically generated source code. If you change a (virtual) method, the overriding methods are automatically updated and regenerated. Tasks like overriding methods, adding events, properties and access methods are reduced to selecting and clicking in dedicated dialogs.
Many build-in refactorings are available on both structural and code level. For example: Extract Method, Extract Class / Interface, Rename Parameter etc.
Apart from those you'll find that you can drag drop (or copy /paste) almost any entity to copy, rearrange or convert it. For example:
- Copy/Move members to another class.
- Convert local variable or procedure to a field or method.
- Add/Remove a class to/from a module.
- Rearrange classes within modules.
- Create a Delegate from a method.
- Create an Event property or Event handler method from a Delegate.
- Much more included, check the user manual chapter Drag and Drop support.
Seamless transformation to code
The main difference between ModelMaker and other CASE tools is that design is strictly related to and native expressed in the Delphi target code. This way there is a seamless transition from design to implementation as currently not found in any other high level CASE tool. At the same time this approach assures your designs remain down to earth.
The main difference between ModelMaker and other Delphi code generators are it's high level overview and restructuring capabilities letting you deal with complex designs.
Visualizing (existing) code
Use instant code visualization to help you understand structure and design of existing code. Classes and their members are displayed in class diagrams along with their structural relations:
- Member Associations: Composition, Aggregation and Dependency
- Interface Support
- Module containment
- (Pascal) Unit dependencies
Different layouts and preset styles make visualization easy and fast.
- Adjustable Auto maintained compartments show class members to any detail.
- Visualize classes on multiple diagrams with different details to show different roles.
- Drag and drop classes from classes or Modules view onto a diagram. Classes and their relations are instantly visualized.
Documenting design and code
- Embed the professional quality UML diagrams in your documentation.
- Copy and paste diagrams in windows metafile format or export diagrams to file in .wmf, .bmp, .png and .jpg format
- Highly configurable visual appearance using (named) styles.
- Stereotype based auto colored symbols
- Print hard copies auto stretched or on multiple pages.
- Enter Documentation and/or One Liner descriptions for entities. These can be generated and imported into / from source code.
- Create your own reports through the ModelMaker ToolsAPI. XML reporter sample included.
A unique feature is the support for Design patterns. A number of patterns are implemented as 'ready to use' active agents. A ModelMaker Pattern not only inserts Delphi code fragments to implement a specific pattern, but it also stays 'alive' to update this code to reflect any changes made to the design.
Design Critics scan your design for oddities and offer solutions wherever possible. You can add your own critics through the ToolsAPI.
The ModelMaker Tools API is a read/write API allowing you to create your own style reports, wizards, based on iteration on classes, members, diagrams etc. This API also integrates Version Control Systems with ModelMaker.
Delphi 5 and 6 support
The Delphi 5 and 6 add-in are included as a service "as long as they compile". New features are not retro-fitted into these IDEs. Support and bug fixing for these IDEs is limited because they cannot be debugged.