Method, apparatus, device and medium for dynamically configuring window control and layout

Abstract

The application relates to a method, device, equipment and medium for dynamically configuring window controls and layouts. First, an XML configuration file is acquired and parsed to generate a data model tree of a structured window interface in memory. Then, objects are dynamically created based on a Qt reflection mechanism, and attributes and signal slots are set to fully utilize Qt reflection characteristics, make object creation and attribute processing flexible and efficient, and do not need to hard code interface elements in a compilation stage. The required controls and layouts can be dynamically generated according to the data model tree, and the dynamicity and expandability of interface configuration are greatly enhanced. In the recursive traversal process, a parent-child relationship tree between controls and layouts is established, and a complete interface tree is obtained. Finally, layout calculation and rendering are performed to generate a display interface, automation of interface layout is realized, interface element layout can be automatically adjusted according to the data model tree structure, and efficient dynamic configuration of window controls and layouts is realized.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of computer, in particular to a method and device for dynamically configuring window control and layout, computer equipment, storage medium and computer program product. BACKGROUND

[0002] In the traditional Qt application development mode, window control and layout are mainly fixedly set by means of visual interface designer in the design stage. The developer determines the key elements such as the position, size, type and layout mode of the control in the design, and fixes them in the code.

[0003] However, when the software enters the iterative update and individual customization stage, or needs to adapt to the diversified needs of different users, this fixed mode exposes serious drawbacks. Once the control related properties or layout mode needs to be adjusted, the developer must re-edit the code and carefully adjust the modified part to ensure that the new design can be accurately implemented. After the code modification is completed, the entire project needs to be recompiled to generate a new executable file. This process is complex and time-consuming, which greatly reduces the development efficiency.

[0004] Therefore, there is an urgent need for an efficient dynamic configuration of window control and layout scheme. SUMMARY

[0005] Therefore, there is an urgent need for an efficient dynamic configuration of window control and layout scheme.

[0006] In a first aspect, the present application provides a method for dynamically configuring window control and layout. The method comprises:

[0007] obtaining and parsing an XML configuration file to obtain a data model tree of a structured window interface in memory;

[0008] recursively traversing the data model tree, dynamically creating objects based on Qt reflection mechanism and setting properties and signal slots;

[0009] establishing a parent-child relationship tree between the control and the layout in the recursive traversal process to obtain a complete interface tree;

[0010] performing layout calculation on the complete interface tree, rendering the drawn interface obtained by the calculation, and generating a display interface.

[0011] In one embodiment, the recursive traversal of the data model tree, the dynamic creation of objects based on the Qt reflection mechanism, and the setting of properties and signal slots comprise:

[0012] recursively traversing the data model tree to access each node in the data model tree layer by layer;

[0013] identifying a control type of the traversed node, the control type including a control node and a layout node;

[0014] dynamically creating an object and setting properties and signal slots based on a Qt reflection mechanism according to the control type.

[0015] In one embodiment, the dynamically creating an object and setting properties and signal slots based on a Qt reflection mechanism according to the control type includes:

[0016] For a control node, reading a control type class name from a property set of the control node; dynamically creating a control instance, setting control properties, and connecting signal slots based on a Qt reflection mechanism according to the read control type class name;

[0017] For a layout node, reading a layout type class name from a property set of the layout node; dynamically creating a layout manager instance and setting layout properties based on a Qt reflection mechanism according to the layout type class name.

[0018] In one embodiment, the dynamically creating an object and setting properties and signal slots based on a Qt reflection mechanism according to the control type includes:

[0019] For a control node, reading a control type class name from a property set of the control node;

[0020] Dynamically creating a control instance based on the read control type class name and based on a Qt reflection mechanism;

[0021] Traversing property child nodes of the current control node, for each property child node, setting a corresponding property for the newly created control instance based on a Qt reflection mechanism;

[0022] Traversing signal child nodes of the current control node, for each signal child node, dynamically connecting a preset target signal to an existing slot function based on a Qt reflection mechanism.

[0023] In one embodiment, the dynamically creating an object and setting properties and signal slots based on a Qt reflection mechanism according to the control type includes:

[0024] For a layout node, reading a layout type class name from a property set of the layout node;

[0025] Based on the layout type class name, a corresponding layout manager instance is dynamically created using Qt reflection mechanism;

[0026] General properties are set for the created layout manager instance, including spacing property, margin property and stretch factor.

[0027] In one embodiment, the parent-child relationship tree between controls and layouts is established during the recursive traversal process to obtain a complete interface tree, which includes:

[0028] The parent-child relationship trees among controls and layouts, layouts and layouts, and controls / layouts and windows are synchronously established during the recursive traversal process to obtain a complete interface tree.

[0029] In one embodiment, the complete interface tree is subjected to layout calculation, and the rendered interface obtained by the calculation is rendered to generate a display interface, which further includes:

[0030] When the XML configuration file is updated by the file system monitor, the updated XML configuration file is parsed to regenerate the data model tree of the structured window interface in memory to obtain a new data model tree;

[0031] The new data model tree and the data model tree are compared using a tree difference comparison algorithm to identify added nodes, deleted nodes and attribute changed nodes;

[0032] The parent-child relationship tree between controls and layouts is reconstructed for the added nodes, and the added nodes are dynamically added to the complete interface tree; for the deleted nodes, corresponding control objects or layout objects are searched in the complete interface tree, and the searched control objects or layout objects are deleted; for the attribute changed nodes, corresponding control objects are searched in the complete interface tree, and the attribute information of the searched control objects is updated;

[0033] The complete interface tree after the update is subjected to layout calculation, and the rendered interface obtained by the calculation is rendered to generate a new display interface.

[0034] In one embodiment, the method for dynamically configuring window controls and layouts further includes:

[0035] When an exception occurs during XML configuration file parsing, or dynamic object creation, property setting and signal-slot process, the exception is captured and a predefined error handling strategy is executed, which includes logging, replacing or ignoring invalid nodes with default controls;

[0036] Before dynamically creating the object, the control type class name and the layout type class name specified in the XML configuration file are checked in a white list, and the white list checking is used to prevent instantiation of unauthorized classes.

[0037] In a second aspect, the application further provides a device for dynamically configuring window controls and layouts. The device comprises:

[0038] a parsing module configured to obtain and parse an XML configuration file to obtain a data model tree of a structured window interface in memory;

[0039] a layout module configured to recursively traverse the data model tree, dynamically create objects based on a Qt reflection mechanism, and set attributes and signal slots;

[0040] a parent-child relationship analysis module configured to establish a parent-child relationship tree between controls and layouts during the recursive traversal to obtain a complete interface tree;

[0041] a rendering and display module configured to perform layout calculation on the complete interface tree and render a drawn interface obtained by the calculation to generate a display interface.

[0042] In one embodiment, the device for dynamically configuring window controls and layouts further comprises:

[0043] an error handling module configured to capture exceptions and perform a predefined error handling strategy when an exception occurs during the parsing, object creation, attribute setting, or signal slot connection, the error handling strategy including logging, replacing with a default control, or ignoring invalid nodes;

[0044] a security checking module configured to check the control type class name and the layout type class name specified in the XML configuration file in a white list before dynamically creating the object, the white list checking being used to prevent instantiation of unauthorized classes.

[0045] In a third aspect, the application further provides a computer device. The computer device comprises a memory and a processor, the memory storing a computer program, and the processor implementing the following steps when executing the computer program:

[0046] obtaining and parsing an XML configuration file to obtain a data model tree of a structured window interface in memory;

[0047] recursively traversing the data model tree, dynamically creating objects based on a Qt reflection mechanism, and setting attributes and signal slots;

[0048] establishing a parent-child relationship tree between controls and layouts during the recursive traversal to obtain a complete interface tree;

[0049] Layout calculation is performed on the complete interface tree, and the rendered interface is rendered to generate a display interface.

[0050] In a fourth aspect, the present application provides a computer readable storage medium. The computer readable storage medium has a computer program stored thereon, and the computer program, when executed by a processor, implements the following steps:

[0051] An XML configuration file is obtained and parsed to obtain a data model tree of a structured window interface in memory;

[0052] The data model tree is recursively traversed, objects are dynamically created based on a Qt reflection mechanism, and attributes and signal slots are set;

[0053] A parent-child relationship tree between controls and layouts is established during the recursive traversal to obtain a complete interface tree;

[0054] Layout calculation is performed on the complete interface tree, and the rendered interface is rendered to generate a display interface.

[0055] In a fifth aspect, the present application provides a computer program product. The computer program product includes a computer program, and the computer program, when executed by a processor, implements the following steps:

[0056] An XML configuration file is obtained and parsed to obtain a data model tree of a structured window interface in memory;

[0057] The data model tree is recursively traversed, objects are dynamically created based on a Qt reflection mechanism, and attributes and signal slots are set;

[0058] A parent-child relationship tree between controls and layouts is established during the recursive traversal to obtain a complete interface tree;

[0059] Layout calculation is performed on the complete interface tree, and the rendered interface is rendered to generate a display interface.

[0060] The method, device, computer device, storage medium and computer program product for dynamically configuring window controls and layouts, first, an XML configuration file is acquired and parsed to generate a data model tree of a structured window interface in memory; then, objects are dynamically created based on a Qt reflection mechanism and properties and signal slots are set to make full use of Qt reflection characteristics to make object creation and property processing flexible and efficient, without hard-coding interface elements in the compilation phase, and the required controls and layouts can be dynamically generated according to the data model tree, which greatly enhances the dynamicity and scalability of interface configuration, reduces code redundancy and maintenance costs; and a parent-child relationship tree between controls and layouts is established in the recursive traversal process to obtain a complete interface tree; finally, layout calculation and rendering are performed to generate a display interface, realizing the automation of interface layout, automatically adjusting the layout of interface elements according to the data model tree structure, significantly improving interface adaptability, and realizing efficient dynamic configuration of window controls and layouts. BRIEF DESCRIPTION OF DRAWINGS

[0061] Figure 1 An application environment diagram of the method for dynamically configuring window controls and layouts in an embodiment;

[0062] Figure 2 A flowchart of the method for dynamically configuring window controls and layouts in an embodiment;

[0063] Figure 3 A flowchart of the method for dynamically configuring window controls and layouts in another embodiment;

[0064] Figure 4 A structural block diagram of the device for dynamically configuring window controls and layouts in an embodiment;

[0065] Figure 5 An internal structure diagram of the computer device in an embodiment. DETAILED DESCRIPTION

[0066] In order to make the purpose, technical scheme and advantages of the present application clearer, the present application will be further described in detail below with reference to the drawings and embodiments. It should be understood that the specific embodiments described herein are only used to explain the present application and do not limit the present application.

[0067] To explain the technical principle and effects of the method for dynamically configuring window controls and layouts of the present application in detail, the traditional related technologies will be first described in further detail.

[0068] In traditional Qt application development, window controls and layouts are usually fixed in the design stage through a visual interface designer, and once determined, it is cumbersome to modify. If you want to adjust the position, size, type or layout of the control, you often need to re-edit the code and re-compile the project, which is extremely inconvenient in the process of iterative updating, personalized customization and adaptation to different user needs, seriously reducing the development efficiency and limiting the maintainability and extensibility of the software.

[0069] In view of the above defects of the traditional technology, the present application proposes to read the XML configuration file when the Qt application is started, to generate the corresponding control object in memory according to the definition in the file by using the reflection mechanism and dynamic object creation function of Qt, and to arrange and combine according to the layout type set in the XML file to build a complete window interface without hard coding the control class, thereby enhancing the flexibility and maintainability of the system.

[0070] Specifically, the method for dynamically configuring window controls and layouts provided by the embodiments of the present application can be applied in an application environment as shown in Figure 1 The terminal 102 communicates with the server 104 through the network. The data storage system can store the data required to be processed by the server 104. The data storage system can be integrated on the server 104, or placed on the cloud or other network servers. The terminal 102 sends a request for dynamically configuring window controls and layouts to the server 104 in response to user operation, the server obtains and parses the XML configuration file to obtain a data model tree of a structured window interface in memory; recursively traverses the data model tree, dynamically creates objects based on the Qt reflection mechanism and sets attributes and signal slots; establishes a parent-child relationship tree between the controls and the layouts in the recursive traversal process to obtain a complete interface tree; performs layout calculation on the complete interface tree, and renders the drawing interface obtained by the calculation to generate a display interface. The terminal 102 can be, but is not limited to, various personal computers, notebook computers, smart phones, tablet computers, Internet of Things devices and portable wearable devices. The Internet of Things device can be a smart speaker, a smart TV, a smart air conditioner, a smart vehicle device, etc. The portable wearable device can be a smart watch, a smart bracelet, a head-mounted device, etc. The server 104 can be implemented by an independent server or a server cluster composed of multiple servers. Further, the method for dynamically configuring window controls and layouts of the present application can also be directly applied to the terminal, and the terminal can directly execute the above processing to generate a display interface in response to user operation, and the specific process is similar to the above and will not be described in detail.

[0071] In one embodiment, as shown in Figure 2 A method for dynamically configuring window controls and layouts is provided, and the method is applied to Figure 1The server 104 in the system 100 is taken as an example to illustrate the method, including the following steps:

[0072] S200: An XML configuration file is obtained and parsed to obtain a data model tree of the structured window interface in the memory.

[0073] The XML configuration file is a pre-configured file, which can be stored in an execution storage location. When the system (server) is started or receives a reload signal, a configuration file parsing module reads a specified XML configuration file. Using an XML module (such as QXmlStreamReader) or a DOM parser of Qt, the file content is parsed node by node. The data model tree of the structured window interface in the memory is a data collection organized in a tree structure in the memory, which is used to accurately map the hierarchy of the window interface. The root node of the tree represents the entire window, which is at the topmost layer of the entire data model tree and is the starting point of the entire interface. A plurality of child nodes extend downward from the root node, which can be layout nodes or control nodes.

[0074] In short, a structured data model capable of completely representing the entire window interface is generated in the memory at this time. The model is usually a tree structure, with the root node representing the window and the child nodes representing the controls and nested layouts. This process is completely performed at runtime, and a normal and modifiable text file is parsed, rather than a compiled and fixed.ui file, thereby improving subsequent flexibility and improving the efficiency of dynamically configuring window controls and layouts.

[0075] S400: Recursively traversing the data model tree, dynamically creating objects based on the Qt reflection mechanism and setting attributes and signal slots.

[0076] The recursive algorithm starts from the root node of the data model tree and visits each child node in turn. During the recursion, different processing is performed according to the type of the node (control node or layout node). For example, when a control node is encountered, control-related creation and property setting operations are performed; when a layout node is encountered, layout manager-related creation and property setting operations are performed. For each control node or layout node, the type class name is read from the node's property information. Before dynamically creating an object, the class name string read from the node is first subjected to security verification, which is compared with a pre-defined white list of trusted class names to prevent instantiation of potentially dangerous or unsupported classes. If the class name is not in the white list, an error log is recorded and the node is skipped, or a default placeholder control (such as a QLabel) is created to maintain the integrity of the interface structure. Using Qt's Meta-Object System, the corresponding QMetaObject object is found through the QMetaType::fromName() method. If found, the QMetaObject::newInstance() method is called to dynamically create the corresponding control instance or layout manager instance. This process should be placed in an exception capture block (try-catch) to prevent program crashes caused by creation failures. When creation fails, detailed error information should be recorded and an attempt should be made to create a default object. After creating the object, the node's property set is traversed again, and for each property, the object's meta-object is obtained using QMetaObject, and then the property object is obtained using QMetaProperty::fromName(), and the value in the property set is written into the corresponding property of the object using the QMetaProperty::write() method. When setting properties, it is necessary to check whether the property exists and whether the value type is compatible to avoid runtime errors caused by setting invalid properties. At the same time, if the node defines a connection relationship between signals and slots, the QObject::connect() method is used to connect the object's signals to the corresponding slot functions. When connecting signals and slots, it is supported to connect to existing slot functions, and it is also supported to define anonymous slot functions using Lambda expressions to increase flexibility.

[0077] Here, interface elements are dynamically generated according to the data model tree, and they are given the expected properties and interactive functions. Through recursive traversal, all nodes in the data model tree can be processed, ensuring that each control and layout manager is correctly created and configured. The dynamic creation method based on Qt's reflection mechanism improves the flexibility and scalability of the code, allowing the interface elements to be changed by modifying the XML configuration file without modifying the code.

[0078] S600: Establish the parent-child relationship tree between controls and layouts during recursive traversal, and obtain the complete interface tree.

[0079] During the recursive traversal of the data model tree, the objects (controls or layout managers) corresponding to the child nodes are set as the child items of the objects corresponding to the parent nodes according to the hierarchical relationship between the nodes. For layout nodes, the add child item method of the layout manager is used to add the child node object to the parent layout manager. For control nodes, if it is a top-level control (i.e., a control directly belonging to a window), it is set as a child item of the window. By recursively traversing the entire data model tree and continuously establishing the parent-child relationship between controls and layouts and between layouts, a complete interface tree is finally formed.

[0080] Establishing the parent-child relationship tree is a key step in building a complete interface structure. The complete interface tree provides clear hierarchical information for subsequent layout calculation, enabling the layout manager to accurately calculate the position and size of each interface element based on the parent-child relationship, thereby achieving reasonable interface layout.

[0081] S800: Perform layout calculation on the complete interface tree and render the drawing interface obtained by calculation to generate the display interface.

[0082] When the entire interface tree is constructed, the layout management module begins to work. First, the topmost layout is set to the main window or container control using the QWidget::setLayout method. This step associates the interface tree with the actual display container, preparing for subsequent layout calculation and interface rendering. The activate() function of the top-level layout is called or the layout calculation process is triggered automatically by Qt. The Qt layout system automatically recursively calculates the size and position of all child controls and sub-layouts. During the calculation process, the layout system fully considers the size policy (sizePolicy), minimum / maximum size (minimumSize / maximumSize), and stretch factor set in the layout, etc. constraints to determine the specific position and size of each control and layout in the window. For example, for multiple buttons in a horizontal layout, the layout system calculates the display position of each button based on the size of the buttons and the layout spacing settings, so that they can be arranged horizontally in the layout. Qt's rendering engine draws the final interface to the screen based on the layout calculation results. To improve performance, the following optimization strategies can be combined for complex interfaces or frequently updated scenarios:

[0083] 1) Cache mechanism: Cache the parsed data model tree or the created object tree, and directly reuse it when the configuration file does not change, reducing parsing and creation overhead;

[0084] 2) Asynchronous loading and calculation: XML parsing, object creation and layout calculation processes are executed in the background thread to avoid blocking the main thread and causing interface lag, and then rendering is performed in the UI thread after preparation.

[0085] 3) Incremental update: When a configuration file is changed, only the changed part is updated differentially to avoid rebuilding the entire interface tree.

[0086] The rendering engine will choose the appropriate rendering method based on the type and properties of the control. For example, for a button control, the rendering engine will draw the button's background, border, text, and other elements to make it appear on the screen as designed. The rendering process is the key step in converting interface data into actual visual images, and through efficient rendering algorithms, the display quality and performance of the interface can be guaranteed.

[0087] Here, the interface data in memory is converted into an actual displayable interface through layout calculation and interface rendering of the complete interface tree. Layout calculation ensures that each control and layout is properly laid out in the window, resulting in a good visual effect and user experience; interface rendering accurately draws the calculated interface information to the screen, allowing users to see the final window interface.

[0088] The above method of dynamically configuring window controls and layouts first obtains and parses the XML configuration file to generate a data model tree of the structured window interface in memory; then, based on the Qt reflection mechanism, objects are dynamically created and properties and signal slots are set to fully utilize the Qt reflection features to make object creation and property handling flexible and efficient, without the need for hard-coded interface elements in the compilation phase. The required controls and layouts can be dynamically generated based on the data model tree, greatly enhancing the dynamicity and scalability of interface configuration, reducing code redundancy and maintenance costs; and during the recursive traversal process, a parent-child relationship tree is established between the controls and layouts to obtain a complete interface tree; finally, layout calculation and rendering are performed to generate the display interface, achieving automatic interface layout adjustment based on the data model tree structure, significantly improving interface adaptability, and achieving efficient dynamic configuration of window controls and layouts.

[0089] In one embodiment, as shown in FIG. 4, Figure 3 S400 includes:

[0090] S420: Recursively traverse the data model tree to access each node in the data model tree layer by layer.

[0091] Recursion is a programming technique that calls itself within a function. When traversing a data model tree, starting from the root node of the tree, the traversal function is first called on the root node, and then recursively called on each child node of the root node. For example, if the root node has two child nodes A and B, after the root node is visited, the traversal function is first called on child node A, and in the traversal function of child node A, the child nodes of child node A (if any) are visited, and so on, until there are no child nodes. Then, the traversal function of child node A is completed, and the same recursive traversal operation is performed on child node B. In the recursive process, the depth and order of recursion are controlled to achieve layer-by-layer access. Each recursive call passes the current node as a parameter to the next call, while recording the current level. In this way, when each node is accessed, its level can be determined, and the nodes in the data model tree can be accessed in order from the root node to the bottom node.

[0092] S440: Identify the control type of the node traversed, including control nodes and layout nodes.

[0093] In the data model tree, each node contains type identification information. This identification information can be embodied through the attributes of the node or specific markers. Control nodes and layout nodes have different characteristics. Control nodes usually contain attributes related to specific controls, such as the text of a button, the default value of a text box, etc.; while layout nodes mainly contain layout-related attributes, such as the direction of the layout (horizontal, vertical), spacing, etc. By analyzing the attribute set of the node, the type of the node can also be determined.

[0094] S460: Dynamically create objects based on the control type and Qt reflection mechanism, and set attributes and signal slots.

[0095] Qt provides a Meta-Object System, which provides runtime type information and dynamic functionality for objects. Through the QMetaObject class, the meta-information of a class can be obtained, including the class name, properties, methods, signals, and slots, etc. Based on the Qt reflection mechanism, an object is dynamically created, mainly using the QMetaObject::newInstance() method. This method can create a new object instance according to the meta-object information of the class. According to the identified control type, the corresponding class name is obtained. Then the QMetaObject::newInstance() method is used to create an object instance. During the creation process, if the constructor of the class requires parameters, the parameters can also be passed through other methods of QMetaObject to meet the creation needs of different classes. In this process, if the dynamic creation of the object fails, an exception is thrown or a null pointer is returned, and the error handling module that calls this process captures the exception and processes it according to the preset strategy (such as recording error logs, creating default controls, skipping the node) to ensure the program continues to run. After creating the object, the properties of the object need to be set according to the property information stored in the nodes of the data model tree. Qt provides the QMetaProperty class to operate the properties of the object. By obtaining the meta-object of the object, its property list is traversed to find the corresponding property of the node property in the data model tree. Then the QMetaProperty::write() method is used to write the node property value into the object property.

[0096] Signal-slot is an important mechanism for implementing inter-object communication in Qt. When building the control and layout object tree, the signal-slot relationship defined by the nodes in the data model tree needs to be connected to the corresponding slot function according to the signal of the object. Qt provides the QObject::connect() method to realize the connection between signal and slot. By specifying the object that sends the signal, the signature of the signal, the object that receives the signal, and the signature of the slot function, the two are associated. After dynamically creating objects and processing properties and signal slots, these objects are organized according to the hierarchical relationship in the data model tree to build the control and layout object tree. Based on the parent-child relationship in the data model tree, the child object is set as the child item of the parent object.

[0097] In one embodiment, dynamically creating an object according to the control type and based on the Qt reflection mechanism and setting the properties and signal slots include:

[0098] Step 1: For the control node, read the control type class name from the control node's property set; dynamically create a control instance based on the Qt reflection mechanism according to the read control type class name, set the control properties, and connect the signal slots.

[0099] In the data model tree, each control node contains a set of properties, which are stored in a specific data structure, for example, in the form of key-value pairs. By traversing the property set of the control node, the property key related to the control type class name is found, and the corresponding property value is obtained, which is the control type class name. Qt provides a meta-object system (Meta-Object System), in which the QMetaObject class contains the meta-information of the class. First, use the QMetaType::fromName() method to find the corresponding QMetaObject object according to the control type class name read. If the corresponding QMetaObject object is found, call the QMetaObject::newInstance() method, which will dynamically create a new control instance at runtime according to the meta-information of the class. After creating the control instance, its properties need to be set to be consistent with the values defined in the property set of the control node. Again, traverse the property set of the control node, and for each property, use QMetaObject to get the meta-object of the control instance, and then use the property-related methods of QMetaObject. When traversing the property child node of the current control node, for each property, call the QObject::setProperty(const char*name, const QVariant&value) method to set it. This method will automatically perform type conversion and safety checks using Qt's property system. Write the values in the property set to the corresponding properties of the control instance. Signal-slot (signal and slot) is an important mechanism for implementing object communication in Qt. In the property set of the control node, the connection relationship of signals and slots may also be defined. By analyzing this connection relationship information, use the QObject::connect() method to connect the signals of the control instance with the corresponding slot functions.

[0100] Step 2: For the layout node, read the layout type class name from the property set of the layout node; based on the layout type class name and the Qt reflection mechanism, dynamically create a layout manager instance and set the layout properties.

[0101] Similar to the read control type class name, the layout node also has its attribute set. In the attribute set of the layout node, find the attribute key related to the layout type class name, get the corresponding attribute value, which is the layout type class name. Similarly, using Qt's meta-object system, first use the QMetaType::fromName() method to find the corresponding QMetaObject object according to the layout type class name. If found, call the QMetaObject::newInstance() method to dynamically create a layout manager instance. The layout node attribute set also contains layout-related attributes, such as layout direction, spacing, etc. By iterating through the attribute set of the layout node, using QMetaObject to get the meta-object of the layout manager instance, and then using QMetaProperty related methods to set the values in the attribute set to the corresponding properties of the layout manager instance.

[0102] In one embodiment, for a control node, read the control type class name from the attribute set of the control node; dynamically create a control instance based on the read control type class name and based on the Qt reflection mechanism, set control properties, and connect signal slots, including:

[0103] Step 1: For a control node, read the control type class name from the attribute set of the control node.

[0104] In the data model tree obtained by parsing the XML configuration file, locate the currently processed control node. Each control node contains an attribute set, which stores various information of the control. Through a specific parsing method (such as using the interface provided by the XML parser or custom parsing logic), find the attribute named "type" from the attribute set of the control node, and the value of the attribute is the control type class name, which is represented in the form of a string, such as "QPushButton", "QLineEdit", etc.

[0105] Step 2: Dynamically create a control instance based on the read control type class name and based on the Qt reflection mechanism.

[0106] Use Qt's meta-object system (Meta-Object System) to dynamically create a control instance. First, convert the read string type control type class name to a format suitable for Qt meta-object system processing. Call QMetaType or use QMetaObject::newInstance() method, etc. According to the class name of the string type, dynamically create an instance of the control. Specifically, it can be as follows:

[0107] QObject* widget = QMetaType::create<QObject*>(QMetaType::type(typeName.toUtf8()));

[0108] Step 3: Traverse the property child nodes of the current control node, and for each property child node, set the corresponding attribute for the newly created control instance based on the Qt reflection mechanism.

[0109] Under the control node, there may be multiple property child nodes, each representing an attribute of the control. By traversing these property child nodes, the name and value of each attribute are obtained. The attribute name and value are also stored in the XML configuration file in the form of a string. Specifically, by traversing the property child nodes of the control node, the QObject::setProperty() method is used to dynamically set the properties (such as geometry, text, font, etc.) for the control instance just created through the attribute name (string).

[0110] Step 4: Traverse the signal child nodes of the current control node, and for each signal child node, dynamically connect the preset target signal to the existing slot function based on the Qt reflection mechanism.

[0111] The signal child nodes of the control node store the signal information that needs to be connected. By traversing these signal child nodes, the name (string) of each signal is obtained. At the same time, corresponding slot functions have been defined in the application, which are used to handle events after the signal is triggered. Specifically, by traversing the signal child nodes, the QObject::connect() function is used to dynamically connect the signal (string) specified in the configuration file to the existing slot function (string matching) in the application.

[0112] In one embodiment, for the layout node, the layout type class name is read from the attribute set of the layout node; and based on the layout type class name, a layout manager instance is dynamically created and layout attributes are set based on the Qt reflection mechanism, including:

[0113] Step 1: For the layout node, the layout type class name is read from the attribute set of the layout node.

[0114] In the data structure constructed by parsing the XML configuration file, the current processing layout node is located. The layout node contains an attribute set that stores various layout-related information. Through specific parsing logic, such as using the interface provided by the XML parser or a custom parsing function, the "type" attribute is found in the attribute set of the layout node.

[0115] Step 2: Based on the layout type class name, use Qt reflection mechanism to dynamically create the corresponding layout manager instance.

[0116] The dynamic creation of the layout manager instance is achieved using Qt's Meta-Object System. First, the read string type layout type class name is converted to a format suitable for Qt Meta-Object System processing. Then, according to the type identifier obtained, the QMetaType::create<QLayout*>() method is called to dynamically create an instance of the layout manager.

[0117] Step 3: Set the common properties for the created layout manager instance, including spacing property, margin property and stretch factor.

[0118] The spacing property is used to control the spacing between child controls in the layout manager. The margin property is used to set the margin of the layout manager and the parent control or surrounding environment. Setting the common properties (spacing and margin) for the layout manager instance can further customize the appearance and layout effect of the layout. The spacing property can adjust the tightness between child controls, making the interface more beautiful and easy to read; the margin property can control the distance between the layout manager and the surrounding elements, avoiding the layout being too tight or crowded. By dynamically setting these properties, the details of the layout can be flexibly adjusted according to different interface design requirements, improving the quality of the interface and user experience. During layout calculation, the layout manager will consider the sizePolicy (such as Expanding, Fixed, Minimum, etc.) of all controls inside it, the stretch factor and the minimum / maximum size properties, to calculate a reasonable layout geometry.

[0119] In one embodiment, after the complete interface tree is laid out and the rendered interface is calculated, the display interface is generated, and further includes:

[0120] Step 1: When the XML configuration file is updated through the file system monitor, parse the updated XML configuration file, regenerate the data model tree of the structured window interface in memory, and obtain a new data model tree.

[0121] When the XML configuration file is updated, the server starts the parsing process. The updated XML configuration file content is read by the XML parser. According to the hierarchical structure and tag definition of the XML file, the information of each node (including the control node and the layout node) is extracted, such as node type, attribute name and attribute value, etc. According to this information, a structured window interface data model tree is reconstructed in memory, and this new data model tree reflects the updated interface structure of the XML configuration file, denoted as newTree.

[0122] Step 2: Compare the new data model tree with the data model tree using the tree difference comparison algorithm to identify newly added nodes, deleted nodes and attribute changed nodes.

[0123] Compare newTree with the old data model tree (oldTree) corresponding to the current interface. Use the tree difference comparison algorithm (based on depth-first search comparison) to identify newly added nodes (controls / layouts), deleted nodes, and attribute changed nodes.

[0124] Step 3: Rebuild the parent-child relationship tree between controls and layouts for newly added nodes, dynamically add the newly added nodes to the complete interface tree; for deleted nodes, find the corresponding control object or layout object in the complete interface tree, delete the found control object or layout object; for attribute changed nodes, find the corresponding control object in the complete interface tree, update the attribute information of the found control object.

[0125] According to the position and hierarchical relationship of the newly added node in newTree, analyze its parent-child relationship with surrounding controls and layouts. For example, if a newly added button control is located in a horizontal layout manager, the parent object of the button control is the horizontal layout manager. Use the object model and layout management mechanism of Qt to create the control object or layout object corresponding to the newly added node. Then, according to the built parent-child relationship tree, dynamically add the newly added object to the corresponding position in the complete interface tree. For example, use the setLayout() method of QWidget to set the layout manager to the parent control, and use the addWidget() method of the layout manager to add the control to the layout.

[0126] In the complete interface tree, find the control object or layout object corresponding to the deleted node through traversal and search algorithm (such as recursive traversal). Then, call the corresponding delete method, such as removing the control object from the parent layout (using the removeWidget() method of the layout manager), and release the memory space of the object to ensure that the resources are properly recycled.

[0127] Locate the control object corresponding to the property change node in the complete interface tree. Set the new property value to the control object by calling the setProperty() method of the control object. Then, call the update() method of the control object to request the server to redraw the control to reflect the appearance after the property change.

[0128] Step 4: Perform layout calculation on the updated complete interface tree, and render the calculated drawing interface to generate a new display interface.

[0129] Call the layout system of Qt to perform layout calculation on the updated complete interface tree. After the layout calculation is completed, the system performs rendering based on the calculated drawing interface information. The rendering engine of Qt will draw the appearance of the control to the screen to generate a new display interface.

[0130] In one embodiment, the above method of dynamically configuring window controls and layout further includes:

[0131] Step 1: When an exception occurs during XML configuration file parsing, or dynamic object creation, property setting, and signal-slot process, capture the exception and execute a predefined error handling strategy, which includes logging, replacing with a default control, or ignoring invalid nodes.

[0132] During the key operations of XML configuration file parsing, dynamic object creation, property setting, and signal-slot, an exception capture mechanism is set. When these operations have exceptions, the exception information can be captured in time. A predefined error handling strategy is set, including logging, replacing with a default control, or ignoring invalid nodes. The logging function will record the specific time, location, exception type, and related context information of the exception occurrence, so as to facilitate subsequent problem troubleshooting; the default control replacement strategy is to use a pre-set default control to replace the specified control when an exception occurs, which ensures that the interface can still be displayed normally; the invalid node ignoring strategy is to directly skip the invalid nodes in the XML configuration file that do not affect the overall layout and function implementation, avoiding the failure of the entire configuration process due to individual invalid nodes. Here, the stability of parsing and processing is greatly improved through the exception handling mechanism.

[0133] Step 2: Before dynamically creating objects, perform white list verification on the control type class name and layout type class name specified in the XML configuration file, which is used to prevent instantiation of unauthorized classes.

[0134] Before dynamically creating objects, the control type class name and the layout type class name specified in the XML configuration file are whitelisted. The whitelist is a pre-defined list of legal class names, which contains all authorized control classes and layout classes that are allowed to be instantiated in the system. Whitelisting is an important means to ensure system security. In the scenario of dynamically configuring window controls and layouts, if controls and layouts of any class name are allowed to be instantiated, it may pose a serious security risk to the system. A malicious user may introduce malicious classes by tampering with the XML configuration file, thereby achieving attacks on the system, data leakage and other undesirable behaviors. Through whitelisting, unauthorized classes can be effectively prevented from being instantiated, ensuring that only classes that have been strictly reviewed and trusted can run in the system, greatly improving the security and reliability of the program (software).

[0135] It should be understood that, although each step in the flowchart involved in the above embodiments is shown in sequence according to the arrow, these steps are not necessarily executed in the order indicated by the arrow. Unless otherwise specified herein, there is no strict order restriction on the execution of these steps, and these steps can be executed in other orders. Moreover, at least part of the steps in the flowchart involved in the above embodiments can include multiple steps or stages, which are not necessarily executed at the same time, but can be executed at different times, and the execution order of these steps or stages is not necessarily sequential, but can be alternately executed with at least part of other steps or steps or stages in other steps.

[0136] Based on the same inventive concept, the embodiments of the present application also provide a dynamic configuration window control and layout device for implementing the above-mentioned dynamic configuration window control and layout method. The implementation scheme for solving the problem provided by the device is similar to the implementation scheme described in the above method, so the specific limitations in one or more dynamic configuration window control and layout device embodiments provided below can refer to the limitations of the dynamic configuration window control and layout method in the above text, which will not be repeated here.

[0137] In one embodiment, as shown in FIG. 1, Figure 4 a dynamic configuration window control and layout device is provided, comprising:

[0138] The parsing module 200 is configured to obtain and parse an XML configuration file to obtain a data model tree of a structured window interface in memory;

[0139] The layout module 400 is configured to recursively traverse the data model tree, dynamically create objects based on the Qt reflection mechanism, and set attributes and signal slots;

[0140] The parent-child relationship analysis module 600 is configured to establish a parent-child relationship tree between the controls and the layouts during the recursive traversal process, and obtain a complete interface tree.

[0141] The rendering display module 800 is configured to perform layout calculation on the complete interface tree, and perform rendering on a drawing interface obtained by the calculation, to generate a display interface.

[0142] In one of the embodiments, the layout module 400 is further configured to perform a recursive traversal operation on the data model tree, to access each node in the data model tree layer by layer; identify a control type of the node accessed in the traversal, the control type including a control node and a layout node; and dynamically create an object and set an attribute and a signal-slot based on a Qt reflection mechanism according to the control type.

[0143] In one of the embodiments, the layout module 400 is further configured to, for the control node, read a control type class name from an attribute set of the control node; dynamically create a control instance, set a control attribute, and connect a signal-slot based on the Qt reflection mechanism according to the read control type class name; and for the layout node, read a layout type class name from an attribute set of the layout node; and dynamically create a layout manager instance and set a layout attribute based on the Qt reflection mechanism according to the layout type class name.

[0144] In one of the embodiments, the layout module 400 is further configured to, for the control node, read a control type class name from an attribute set of the control node; and dynamically create a control instance based on the read control type class name and the Qt reflection mechanism; traverse a property child node of the current control node, and for each property child node, set a corresponding attribute for the newly created control instance based on the Qt reflection mechanism; and traverse a signal child node of the current control node, and for each signal child node, dynamically connect a preset target signal and an existing slot function based on the Qt reflection mechanism.

[0145] In one of the embodiments, the layout module 400 is further configured to, for the layout node, read a layout type class name from an attribute set of the layout node; and dynamically create a corresponding layout manager instance based on the Qt reflection mechanism according to the layout type class name; and set general attributes for the created layout manager instance, the general attributes including a spacing attribute, a margin attribute, and a stretch factor.

[0146] In one of the embodiments, the parent-child relationship analysis module 600 is further configured to synchronously establish parent-child relationship trees among the controls and the layouts, the layouts and the layouts, and the controls / layouts and windows during the recursive traversal process, to obtain a complete interface tree.

[0147] In one of the embodiments, the apparatus for dynamically configuring window controls and layouts further includes:

[0148] The updating module is configured to, when an XML configuration file update is monitored by the file system monitor, parse the updated XML configuration file, re-generate a data model tree of the structured window interface in memory to obtain a new data model tree, compare the new data model tree and the data model tree by using a tree difference comparison algorithm, identify added nodes, deleted nodes, and attribute changed nodes, re-construct a parent-child relationship tree between controls and layouts for the added nodes, dynamically add the added nodes to the complete interface tree, find corresponding control objects or layout objects in the complete interface tree for the deleted nodes, and delete the found control objects or layout objects, find corresponding control objects in the complete interface tree for the attribute changed nodes, and update attribute information corresponding to the found control objects, perform layout calculation on the updated complete interface tree, render the calculated drawing interface, and generate a new display interface.

[0149] In one of the embodiments, the apparatus for dynamically configuring window controls and layouts further includes:

[0150] The error processing module is configured to, when an exception occurs in the process of parsing, creating an object, setting an attribute, or connecting a signal slot, capture the exception and execute a predefined error processing strategy, the error processing strategy including logging, replacing with a default control, or ignoring an invalid node.

[0151] The security verification module is configured to, before dynamically creating an object, perform white list verification on a control type class name and a layout type class name specified in the XML configuration file, the white list verification being configured to prevent instantiation of unauthorized classes.

[0152] The modules in the apparatus for dynamically configuring window controls and layouts can be implemented by software, hardware, or a combination thereof. The modules can be embedded in or independent of a processor in a computer device in hardware form, or stored in a memory in the computer device in software form, so as to be called and executed by a processor to perform operations corresponding to the modules.

[0153] In one embodiment, a computer device is provided, which can be a server, and an internal structure diagram of the computer device can be as shown in Figure 5As shown in the figure. The computer device includes a processor, a memory and a network interface connected through a system bus. Among them, the processor of the computer device is used to provide computing and control capabilities. The memory of the computer device includes a non-volatile storage medium and an internal memory. The non-volatile storage medium stores an operating system, a computer program and a database. The internal memory provides an environment for the operating system and the computer program in the non-volatile storage medium to run. The database of the computer device is used to store preset data. The network interface of the computer device is used to communicate with the external terminal through the network connection. The computer program is executed by the processor to implement a method for dynamically configuring window controls and layouts.

[0154] Those skilled in the art can understand that, Figure 5 The structure shown in the figure is only a block diagram of part of the structure related to the scheme of the present application, and does not constitute a limitation on the computer device to which the scheme of the present application is applied. The specific computer device can include more or less components than those shown in the figure, or combine certain components, or have a different component arrangement.

[0155] In one embodiment, a computer device is provided, including a memory and a processor, the memory storing a computer program, and the processor executing the computer program to implement the above-mentioned method for dynamically configuring window controls and layouts.

[0156] In one embodiment, a computer readable storage medium is provided, which stores a computer program, and the computer program is executed by the processor to implement the above-mentioned method for dynamically configuring window controls and layouts.

[0157] In one embodiment, a computer program product is provided, including a computer program, and the computer program is executed by the processor to implement the above-mentioned method for dynamically configuring window controls and layouts.

[0158] Those skilled in the art can understand that all or part of the processes in the above-mentioned embodiment methods can be completed by instructing the relevant hardware through a computer program. The computer program can be stored in a non-volatile computer readable storage medium, and when the computer program is executed, the processes of the above-mentioned embodiments of the methods can be included. Any reference to memory, database or other medium used in the embodiments provided in the present application can include at least one of non-volatile and volatile memory. The non-volatile memory can include read-only memory (ROM), magnetic tape, floppy disk, flash memory, optical storage, high-density embedded non-volatile memory, resistive memory (ReRAM), magnetoresistive random access memory (MRAM), ferroelectric memory (FRAM), phase change memory (PCM), graphene memory, etc. The volatile memory can include random access memory (RAM) or external cache memory, etc. As an illustration but not limitation, the RAM can be in various forms, such as static random access memory (SRAM) or dynamic random access memory (DRAM), etc. The database involved in the embodiments provided in the present application can include at least one of a relational database and a non-relational database. The non-relational database can include a distributed database based on a block chain, etc., without being limited thereto. The processor involved in the embodiments provided in the present application can be a general-purpose processor, a central processing unit, a graphics processing unit, a digital signal processor, a programmable logic device, a data processing logic device based on quantum computing, etc., without being limited thereto.

[0159] Any combination of the technical features of the above embodiments can be made. In order to make the description simple, all possible combinations of the technical features in the above embodiments are not described, however, as long as the combination of the technical features does not exist, it should be considered as the scope of the present application.

[0160] The above embodiments only express several implementation manners of the present application, and the description is more specific and detailed, but it should not be understood as a limitation on the scope of the patent of the present application. It should be pointed out that for ordinary skilled in the art, without departing from the concept of the present application, a number of modifications and improvements can be made, which are within the scope of protection of the present application. Therefore, the protection scope of the present application should be subject to the appended claims.

Claims

1. A method of dynamically configuring window controls with a layout, the method comprising: receiving a request to display a window; determining a layout for the window; and displaying the window with the layout. The method comprises: acquiring and parsing an XML configuration file to obtain a data model tree of a structured window interface in memory; recursively traversing the data model tree, dynamically creating objects and setting attributes and signal slots based on a Qt reflection mechanism; establishing a parent-child relationship tree between controls and layouts during the recursive traversal process to obtain a complete interface tree; performing layout calculation on the complete interface tree and rendering the calculated drawing interface to generate a display interface.

2. The method of claim 1, wherein, The recursive traversal of the data model tree, dynamic creation of objects and setting of attributes and signal slots based on the Qt reflection mechanism comprises: recursively traversing the data model tree to access each node in the data model tree layer by layer; identifying the control type of the node being traversed, the control type including a control node and a layout node; dynamically creating objects and setting attributes and signal slots based on the Qt reflection mechanism according to the control type.

3. The method of claim 2, wherein, The dynamic creation of objects and setting of attributes and signal slots based on the Qt reflection mechanism according to the control type comprises: for a control node, reading a control type class name from an attribute set of the control node; dynamically creating a control instance, setting control attributes and connecting signal slots based on the Qt reflection mechanism according to the read control type class name; for a layout node, reading a layout type class name from an attribute set of the layout node; dynamically creating a layout manager instance and setting layout attributes based on the Qt reflection mechanism according to the layout type class name.

4. The method of claim 3, wherein, The dynamic creation of objects and setting of attributes and signal slots based on the Qt reflection mechanism according to the control type comprises: for a control node, reading a control type class name from an attribute set of the control node; based on the read control type class name, dynamically creating a control instance based on the Qt reflection mechanism; traversing the property child nodes of the current control node, for each property child node, setting the corresponding attributes for the newly created control instance based on the Qt reflection mechanism; traversing the signal child nodes of the current control node, for each signal child node, dynamically connecting a preset target signal to an existing slot function based on the Qt reflection mechanism.

5. The method of claim 3, wherein, The dynamic creation of objects and setting of attributes and signal slots based on the Qt reflection mechanism according to the control type comprises: for a layout node, reading a layout type class name from an attribute set of the layout node; based on the layout type class name, dynamically creating a corresponding layout manager instance using the Qt reflection mechanism; setting general attributes for the created layout manager instance, the general attributes including a spacing attribute, a margin attribute and a stretch factor.

6. The method of claim 1, wherein, The establishment of a parent-child relationship tree between controls and layouts during the recursive traversal process to obtain a complete interface tree comprises: Synchronously establish the parent-child relationship tree among the control and the layout, the layout and the layout, and the control / layout and the window during the recursive traversal process, and obtain a complete interface tree.

7. The method of claim 1, wherein, After the layout calculation on the complete interface tree and the rendering on the drawn interface obtained by the calculation are performed, a display interface is generated. When the XML configuration file is updated through the file system monitor, the updated XML configuration file is parsed, a new data model tree of the structured window interface in the memory is regenerated, and a new data model tree is obtained. The new data model tree and the data model tree are compared by using a tree difference comparison algorithm, and added nodes, deleted nodes, and attribute changed nodes are identified. The parent-child relationship tree among the control and the layout is reconstructed for the added nodes, the added nodes are dynamically added to the complete interface tree, the corresponding control object or layout object is searched in the complete interface tree for the deleted nodes, and the searched control object or layout object is deleted, and the corresponding control object is searched in the complete interface tree for the attribute changed nodes, and the attribute information of the searched control object is updated. The layout calculation is performed on the updated complete interface tree, and the rendering is performed on the drawn interface obtained by the calculation, and a new display interface is generated.

8. The method of claim 1, wherein, Further comprising: When an exception occurs in the XML configuration file parsing or the dynamic creation of the object, the setting of the attribute, and the signal slot process, the exception is captured and a predefined error handling strategy is executed, and the error handling strategy includes logging, replacing with a default control, or ignoring an invalid node. Before the dynamic creation of the object, the control type class name and the layout type class name specified in the XML configuration file are subjected to whitelist verification, and the whitelist verification is used to prevent the instantiation of unauthorized classes.

9. An apparatus for dynamically configuring window controls with a layout, the apparatus comprising: The device comprises: The parsing module is configured to obtain and parse an XML configuration file to obtain a data model tree of a structured window interface in the memory. The layout module is configured to recursively traverse the data model tree, dynamically create objects, and set attributes and signal slots based on a Qt reflection mechanism. The parent-child relationship analysis module is configured to establish a parent-child relationship tree among the control and the layout during the recursive traversal process, and obtain a complete interface tree. The rendering display module is configured to perform layout calculation on the complete interface tree, and perform rendering on a drawn interface obtained by the calculation, and generate a display interface.

10. The apparatus of claim 9, wherein, Further comprising: The error handling module is configured to capture an exception and execute a predefined error handling strategy when an exception occurs in the XML configuration file parsing or the dynamic creation of the object, the setting of the attribute, and the signal slot process, and the error handling strategy includes logging, replacing with a default control, or ignoring an invalid node. The security verification module is configured to perform whitelist verification on the control type class name and the layout type class name specified in the XML configuration file before the dynamic creation of the object, and the whitelist verification is used to prevent the instantiation of unauthorized classes.

Images