Templating Mechanism for Graphical Editor Development
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional graphical modeling tools require cumbersome and slow implementation of binding between domain and graphic models, making the development of graphical editors inefficient and non-extensible.
Innovation Solution
A templating mechanism is introduced that generates model-based applications by defining templates for both domain and graphic models, creating binders to associate corresponding elements, and using synchronization frameworks to interpret path expressions for seamless synchronization.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If conventional binding implementation methods are used between domain model and graphic model, then the binding functionality can be achieved, but the implementation becomes cumbersome and slow
Solution Approach 1:
The patent applies preliminary action by pre-defining binding rules and synchronization logic in template files before runtime. The binding between domain model and graphic model is established through pre-written templates that contain binding expressions and synchronization rules, eliminating the need for manual binding implementation during editor development.
Solution Approach 2:
The patent uses copying by generating binding code and synchronization logic automatically from template definitions. Instead of manually programming each binding relationship, the system copies and adapts pre-defined binding patterns from templates to create the actual binding implementation, significantly reducing manual coding effort.
2Productivity
If manual binding code programming is required between domain model and graphic model, then customization is possible, but the development process becomes time-consuming and slow
Solution Approach 1:
Binding rules, synchronization logic, and code patterns are prepared in advance within template files. These pre-defined bindings can be directly applied to multiple domain-graphic model pairs, eliminating repetitive manual coding and significantly reducing development time while maintaining customization capability through template parameters.
Solution Approach 2:
The template-based binding mechanism provides universal binding patterns that can be applied across different domain models and graphic models. A single template can serve multiple binding scenarios by parameterizing the binding rules, making the binding system both efficient and adaptable to various customization needs.
3Adaptability or versatility
If static code generation approach is used as in GMF, then implementation is straightforward, but the system becomes non-extensible and rigid
Solution Approach 1:
The patent implements dynamic binding through runtime interpretation of binding expressions stored in templates. Instead of static code generation, the synchronization framework dynamically evaluates binding rules and generates bindings based on runtime model data, allowing the system to adapt to new domain models and graphic models without requiring code regeneration or modification.
Solution Approach 2:
The patent introduces a binding expression language and interpretation layer as an intermediary between domain models and graphic models. This intermediary layer handles the complexity of synchronization by interpreting high-level binding expressions into actual binding operations, shielding users from implementation complexity while enabling extensibility through the expression language.
Data Source
AI summary
The subject matter described herein relates to a templating system and method. In the templating system and method, each of the domain model and the graphic model are defined according to a template, and the corresponding elements of the domain model and graphic model are created. Next, a binder is created, which associates corresponding attributes in domain and graphic models. Path expressions such as XPath expressions, are used to describe locations in the domain and graphic models. These path expressions, templates, and binders are interpreted or called by a framework, which performs detailed synchronization.