Multi-JVM Java GUI Layout via XML
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Java Swing's single-threaded nature causes GUIs to freeze when handling events, limiting performance on multi-monitor systems and requiring recompilation for layout changes, which is inflexible and inefficient.
Innovation Solution
Implementing multiple Java Virtual Machines (JVMs) for each monitor, with a separate event queue and using XML files to define GUI layouts, allowing dynamic changes without recompilation and improving responsiveness across multiple displays.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Device complexity
If a single event queue and processing thread is used for all monitors, then the system structure is simple, but the GUI freezes when handling events and performance is limited
Solution Approach 1:
The patent divides the single event queue into multiple separate event queues, with each monitor having its own dedicated event queue and processing thread. This segmentation allows events on different monitors to be processed independently and concurrently, preventing GUI freezing and improving overall system responsiveness while maintaining manageable complexity through clear separation of concerns.
2Productivity
If multiple threads are spawned to process event handling code, then GUI freezing is reduced, but display updates must be done on the event queue thread causing graphic intensive processes to still freeze all GUIs
Solution Approach 1:
The patent segments the system into multiple independent JVMs, each with its own event queue and display surface controller. This allows event handling to occur in separate threads within each JVM while display updates are managed independently per monitor, preventing graphic-intensive processes from freezing all GUIs across multiple monitors simultaneously.
Solution Approach 2:
The patent introduces display surface controllers as intermediary components that manage the interface between event processing threads and display update operations. These controllers coordinate updates across multiple monitors and JVMs, ensuring display consistency while allowing concurrent event handling without blocking graphic-intensive operations system-wide.
3Reliability
If GUI layouts are defined in compiled code, then the structure is rigid and type-safe, but layout changes require recompilation which is inflexible and inefficient
Solution Approach 1:
The patent introduces XML configuration files as an intermediary layer between the compiled Java code and the actual GUI layout definitions. The XML files store layout specifications in a human-readable, editable format that can be modified without recompiling the Java code. The system parses these XML files at runtime to construct and modify GUI layouts, providing flexibility while maintaining the type-safety and structure of the compiled Java framework.
4Device complexity
If a single JVM runs as a single process on a physical computer, then the system is simple to manage, but the system cannot take advantage of multiple processors and receives no performance enhancement
Solution Approach 1:
The patent segments the single JVM architecture into multiple separate JVMs running as independent processes on the physical computer. Each JVM can utilize different CPU cores and processors, enabling parallel execution of GUI event processing and application logic across multiple processors. This segmentation increases complexity slightly but delivers significant performance enhancements through multi-processor utilization and concurrent execution.
Data Source
AI summary
A method and system are provided which allows enhanced support to graphical user interface (GUI) displays on multiple monitors. An extended markup language file provides code to configure each GUI. GUI software need not be re-compiled in order to implement changes in the layout of displays or to accommodate additional monitors. Potential display event handling delays are minimized by providing multiple Java Virtual Machines (JVMs) for GUIs. In one aspect, one JVM is provided for each GUI.