Event-Based Architecture for Expand-Collapse UI Operations
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
MVC-based applications often suffer from code redundancy and complexity due to the integration of model-type code in view or controller code, leading to large, difficult-to-maintain codebases and performance issues, especially when using widgets.
Innovation Solution
An event-based architecture that passes user-initiated expand/collapse operations as asynchronous events to a datasource module, allowing the view module to receive insert or delete events and update the user interface without managing complex data acquisition or transformation, thereby simplifying view module code and enabling asynchronous operations.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If MVC architecture integrates model-type code in view or controller code, then the application can handle complex data operations, but the codebase becomes large and difficult to maintain
Solution Approach 1:
The patent extracts model-type code from view and controller components into a separate datasource module. This datasource module handles all data acquisition, transformation, and manipulation operations independently, while the view module receives only the processed data through standardized event mechanisms. This extraction eliminates code redundancy and reduces view module complexity while preserving full data operation capabilities.
Solution Approach 2:
The architecture segments the application into distinct functional modules: the view module handles user interface events, the datasource module handles data operations, and an event mechanism coordinates communication. This segmentation allows each module to be independently developed, tested, and maintained, reducing overall system complexity while maintaining versatility.
2Ease of operation
If MVC architecture uses widgets for user interface, then the application provides rich user interactions, but code redundancy increases and performance decreases
Solution Approach 1:
The datasource module serves as a universal component that handles data operations for multiple views and widgets through a standardized event interface. Instead of each widget having its own data handling code, they all communicate with the single datasource module via events, eliminating code redundancy and improving performance while maintaining rich user interactions.
3Ease of operation
If view module manages data acquisition and transformation, then the view can control data presentation, but the view module code becomes complex and redundant
Solution Approach 1:
The patent introduces an event mechanism as an intermediary between the view module and datasource module. The view module sends event notifications to the datasource module, which processes data acquisition and transformation in response. This intermediary approach allows the view to control data presentation through simple event triggers without managing complex data operations, reducing view module complexity while maintaining control capability.
Data Source
AI summary
Techniques are disclosed for event-based architectures for implementing expand-collapse input-output operations in user interfaces. Certain techniques are disclosed herein that allow for a expand and/or collapse functionality via passing asynchronous events to a datasource module, which may or may not be routed through a view module. The datasource module determines what data is to be shown or hidden and issues an insert/delete event back to the view module. The insert/delete event may include additional data to be inserted into the user interface, and may include an identifier of where, within the displayed user interface, data is to be inserted or deleted. A view module may be configured to receive insert or delete events, and, in response, cause the user interface to be modified based upon the event. The view module may perform these updates by inserting or removing Document Object Model (DOM) nodes from a DOM associated with the user interface.