CN110908653A

CN110908653A - A window object processing method, device and device

Info

Publication number: CN110908653A
Application number: CN201811075978.9A
Authority: CN
Inventors: 史亚风
Original assignee: Alibaba Group Holding Ltd
Current assignee: Alibaba Group Holding Ltd
Priority date: 2018-09-14
Filing date: 2018-09-14
Publication date: 2020-03-24

Abstract

The application discloses a window object processing method, device and equipment. The method comprises the following steps: determining attribute information of the window object, searching a layout object matched with the attribute information of the window object from a layout object template library, and selectively writing one or more searched layouts into the window object; the layout object is used for setting the area of the component object in the window object.

Description

Window object processing method, device and equipment

Technical Field

The present application relates to the field of computer technologies, and in particular, to a method, an apparatus, and a device for processing a window object.

Background

Window object CWnd, which refers to a HWnd handle that encapsulates a window with a class; where H is a type description, indicating handle, Wnd is a variable object description, indicating a window.

Current window object development schemes typically edit component layouts by developers.

Therefore, a more rapid solution is required.

Disclosure of Invention

The embodiment of the specification provides a window object processing method for improving the development efficiency of window objects.

An embodiment of the present specification further provides a window object processing method, including:

determining attribute information of the window object;

determining a layout object matched with the attribute information in a layout object template library, wherein the layout object is used for setting the area of the component object in the window object;

and writing the layout object into the window object.

Optionally, the attribute information includes a window width/a window height, and the matched layout object is a layout object whose width/height is the same as the window width/the window height.

Optionally, the layout objects include one or more of a layout object of a built-in text field component, a layout object of a built-in property sheet component, and a layout object of a built-in Json object edit box component.

Optionally, writing the layout object into the window object includes:

and writing the matched layout object into the window object by adopting a cascading style.

Optionally, the method further comprises:

determining an html file corresponding to the window object;

and placing the html file in a document object model corresponding to the window object.

Optionally, the method further comprises:

and respectively registering the window object and the component object to a window object.

Optionally, registering the window object and the component object to the window object respectively includes:

registering the window object and the component object to the window object, respectively, based on the method of the encapsulated registration object to the window object.

Optionally, the method further comprises:

an event registered for the component object is determined.

Optionally, the method further comprises:

determining an assigned value data source corresponding to the window object;

assigning values to component objects within the window object based on the assigned data source.

Optionally, the assigned data source includes a correspondence between a component object identifier and assigned data;

wherein assigning the component object inside the window object based on the assigned data source comprises:

acquiring the window object from the window object;

and assigning the assigned data to the component object corresponding to the component object identification based on the corresponding relation.

Optionally, the method further comprises:

and constructing a multi-level window object based on the hierarchical relation between the window object and other window objects.

An embodiment of the present specification further provides a window object processing apparatus, including:

the first determining module is used for determining the attribute information of the window object;

a second determining module, configured to determine a layout object in a layout object template library, where the layout object is matched with the attribute information, and the layout object is used to set an area of a component object in the window object;

and the writing module is used for writing the layout object into the window object.

Optionally, the writing module 83 is specifically configured to:

Optionally, the apparatus further comprises:

the third determining module is used for determining the html file corresponding to the window object; and placing the html file in a document object model corresponding to the window object.

Optionally, the apparatus further comprises:

and the first registration module is used for respectively registering the window object and the component object to the window object.

Optionally, the first registration module is specifically configured to:

Optionally, the apparatus further comprises:

a second registration module to determine events registered for the component object.

Optionally, the apparatus further comprises:

the assignment module is used for determining an assignment data source corresponding to the window object; assigning values to component objects within the window object based on the assigned data source.

wherein, the assignment module is specifically configured to:

acquiring the window object from the window object; and assigning the assigned data to the component object corresponding to the component object identification based on the corresponding relation.

Optionally, the apparatus further comprises:

and the hierarchical processing module is used for constructing a multi-level window object based on the hierarchical relation between the window object and other window objects.

An embodiment of the present specification further provides an electronic device, including:

a processor; and

a memory arranged to store computer executable instructions which, when executed, cause the processor to perform the steps of the window object processing method as described above.

The present specification also provides a computer readable storage medium, which stores a computer program, and when the computer program is executed by a processor, the computer program implements the steps of the window object processing method.

The embodiment of the specification adopts at least one technical scheme which can achieve the following beneficial effects:

by providing a pre-constructed layout object template library, in the process of developing a window object by a developer, a proper layout object can be searched and selected from the layout object template library, and the selected layout object is written into the window object, so as to set the area of the component object in the window object. Compared with the scheme of editing the layout of the components by developers in the prior art, the method has the advantages that the built-in areas of the component objects of different types are set, so that the developers can flexibly arrange the component objects in the window objects, the development workload of the developers is effectively reduced, and the development efficiency of the window objects is improved.

Drawings

The accompanying drawings, which are included to provide a further understanding of the application and are incorporated in and constitute a part of this application, illustrate embodiment(s) of the application and together with the description serve to explain the application and not to limit the application. In the drawings:

fig. 1 is a schematic flowchart of a window object processing method according to an embodiment of the present disclosure;

FIG. 2 is a schematic diagram of an instantiated window layout interface provided by an embodiment of the present description;

FIG. 3 is a flowchart illustrating a step of instantiating a window object according to an embodiment of the present disclosure;

fig. 4 is a flowchart illustrating a window object processing method according to another embodiment of the present disclosure;

FIG. 5 is a schematic diagram illustrating an instantiation after completion of construction of a window object according to another embodiment of the present specification;

FIG. 6 is a flowchart illustrating the component object assignment step according to another embodiment of the present disclosure;

FIG. 7 is a schematic diagram illustrating instantiation of a window object after assignment is completed according to another embodiment of the present disclosure;

fig. 8 is a schematic structural diagram of a window object processing apparatus according to an embodiment of the present disclosure;

fig. 9 is a schematic structural diagram of an electronic device according to an embodiment of the present disclosure.

Detailed Description

In order to make the objects, technical solutions and advantages of the present application more apparent, the technical solutions of the present application will be described in detail and completely with reference to the following specific embodiments of the present application and the accompanying drawings. It should be apparent that the described embodiments are only some of the embodiments of the present application, and not all of the embodiments. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present application.

As stated in the background section, prior art solutions such as easy, Extjs, etc. development frameworks encapsulate the layout and style of components, for example: linear layout, single frame layout, relative layout, absolute layout, etc., and the components are edited by the developer so that the components can meet the layout requirements and are arranged according to the sequence of the layout requirements, thereby forming a window interface seen by the user. However, in the component layouts, the component configuration items are too many and have complicated levels, and the learning cost is high; the development cost for realizing a certain window is not reduced by comparison with redesign, and the relationship and data of the multi-level windows need to be maintained by developers. The development efficiency is low, and the maintenance is difficult because the code structure is disordered due to much maintained data.

Based on the above, the invention provides a window object processing method, which can search and select a proper layout object from a layout object template library by providing a pre-constructed layout object template library in the process of developing a window object by a developer, and write the selected layout object into the window object so as to set the area of a component object in the window object. Compared with the scheme of editing the layout of the components by developers in the prior art, the method can effectively reduce the development workload of the developers and improve the development efficiency of the window objects.

Wherein, the window object CWnd, the class is used to encapsulate the HWnd handle of the window, H is type description, which represents handle, Wnd is variable object description, which represents the window, so the HWnd represents the window handle; the CWnd object is a C + + window object, as opposed to a HWND which represents a Windows window but contains Windows. The Windows window refers to a graphical mode computer user operation interface. The layout object refers to a partition DIV with a width of a window and a height of a constant, and different types of layout objects support different types of built-in component objects.

The technical solutions provided by the embodiments of the present application are described in detail below with reference to the accompanying drawings.

Fig. 1 is a schematic flowchart of a window object processing method provided in an embodiment of this specification, and referring to fig. 1, the method may specifically include the following steps:

step 120, determining attribute information of the window object;

wherein, the attribute information may include at least: window title, window width/window height, window id, and a save time callback onSave.

Step 140, determining a layout object matched with the attribute information in a layout object template library, wherein the layout object is used for setting the area of the component object in the window object;

wherein, the layout objects in the layout object template library at least comprise: one or more of a layout object (noted desc) of the built-in text field component, a layout object (noted table) of the built-in attribute table component and a layout object (noted Json) of the built-in Json object edit box component; in addition, in order to conveniently place component objects (denoted as gadgets) such as text field components, attribute table components, Json object edit box components and the like with the sizes smaller than a preset threshold value, a type of layout object (denoted as normal) for built-in gadgets can be added; the layout object matched with the attribute information is a layout object having the same width/height as the window width/height.

If the window object is a window with a line dimension as a division standard, the attribute information of the window object comprises the width of the window; accordingly, the width of the matched layout object is the window width and the height is a constant, for example:

normal: div with width of window width and height of 40, because of the comparison "shrivel", the inside can be placed with "small" components such as input, select, submit reset button, radio only, checkbox, etc.

Desc: width is the window width and height is div of 80, this height is specifically prepared for the text field textarea, i.e. the description information.

Table: width is the window width and height is div of 340, which height is specifically prepared for the attribute table.

Json: width is window width and height is 340 div, which is specifically prepared for the Json object editor box.

If the window object is a window with the column dimension as the division standard, the attribute information of the window object comprises the height of the window; accordingly, the height of the matched layout object is the window height and the width is constant.

Of course, for other types of component objects or components customized by developers, there are corresponding layout objects, which are not listed one by one here; moreover, the high constants of the illustrated layout objects may be adjusted as appropriate.

Step 160, writing the layout object into the window object. One implementation may be:

and writing the matched layout object into the window object by adopting a cascading style. In connection with fig. 2, an exemplary writing process may be exemplified as:

the developer sequentially selects and writes the table230, the normal220 and the normal210 into the window object, and then sequentially stacks the table230, the normal220 and the normal210 in the window from bottom to top.

If the window object is a window with line dimension as a division standard, the stacking style is stacking from bottom to top according to a selection sequence; if the window object is a window with the column dimension as a division standard, the stacking style is stacking from left to right according to the selection sequence; instantiation is used to expose code logic in a visually observable form.

Optionally, based on the above steps 120 to 160, after completing the development work of an empty window object, the method may further include: the step of instantiating the window object, which may specifically include, in conjunction with fig. 3:

step 320, determining an html file corresponding to the window object;

step 340, placing the html file in a document object model corresponding to the window object;

one implementation of

steps

320 and 340 may be:

the above-mentioned attribute information of the window object, the written layout object, and the like are configured, parsed and converted into html files, and preferably appended to the end of the body node in the document object model dom.

Wherein, the dom is automatically generated by the system in the process of developing the window object.

And step 360, registering the window object to the window object. One implementation may be:

and taking the id of the window object as key and the dom of the window object as value, and binding the window object to the window object, namely the window object [ window id ] ═ window dom object.

The registration method may be a method of pre-packaging a registration window object to the window object.

It can be seen that, in the present embodiment, by providing a pre-constructed layout object template library, in the process of developing a window object, a suitable layout object can be searched and selected from the layout object template library, and the selected layout object is written into the window object, so as to set an area of a component object in the window object. Compared with the scheme of editing the layout of the components by developers in the prior art, the method has the advantages that the built-in areas of the component objects of different types are set, so that the developers can flexibly arrange the component objects in the window objects, the development workload of the developers is effectively reduced, and the development efficiency of the window objects is improved.

Fig. 4 is a schematic flowchart of a window object processing method according to another embodiment of the present disclosure, and referring to fig. 4, the method may specifically include the following steps:

step 420, determining attribute information of the window object;

step 440, determining a layout object matched with the attribute information in a layout object template library, wherein the layout object is used for setting an area of a component object in the window object;

step 460, writing the layout object into the window object;

step 420 to step 460 are similar to step 120 to step 160 in the previous embodiment, and their implementation manners are also similar, so step 420 to step 460 are not described herein again.

Step 480, configuring a component object for the window object based on the attribute information of the layout object to complete the construction of the window object. In connection with fig. 5, the instantiation process of step 480 may be exemplified as:

protocol-related widgets are configured in the partition normal210, such as: http protocol components, dubbo protocol components, and the like; packet-related widgets are configured in the partition normal220, for example: a grouping options component, a grouping name component, and the like; the detail configuration related components are configured in the partition table230, for example: attribute table components for each user object, and so on.

The component objects built in the layout object have different attribute information according to the characteristics of the component objects, and the attribute information at least comprises a component id, a component label, a component width, a component type, a distance (margin) between the component label and the component.

Further, after the steps of the built-in component object illustrated in fig. 5 are completed, step 480 further includes:

and respectively registering the window object and the component object to a window object. One implementation manner of registering the component object may be:

and taking the component id as key and the dom object of the component as value, and binding the component to the window object, namely window [ component id ] ═ component dom object.

Wherein the dom object of the component is automatically generated by the system in the process of the built-in component object; the registration method may be a method of pre-packaging registration component objects to the window object.

Further, step 480 further comprises: registering events for each component object; configuring methods of initializing init, changing change of contents, clicking click, obtaining the value get of the component and the like for each component object, wherein the formats are { component id: { init: function () { … }, get: function () { … } }.

Therefore, the implementation mode separates the component configuration parameters and the component event parameters, and when the event needs to be registered for the component object, the event configuration is taken as a second parameter to be transmitted, so that the implementation mode is more friendly to developers.

It will be appreciated that the process of building component objects is coded such that the interface shown in FIG. 5 is not actually visible, and the description of step 480 is provided herein with reference to FIG. 5 for ease of description and understanding only. Further, the method further comprises: the step of making the built window object visible may be, in combination with fig. 6, one implementation manner of the step:

step 602, obtaining a window dom object through window [ window id ] and making the window dom object visible, see fig. 5; the implementation mode can be exemplified as follows:

firstly, acquiring a window object from the window object by using a packaged method for acquiring the object from the window object; then, based on the window object id, determining an assigned data source corresponding to the window object; for example: and determining an assigned data source of the window object and importing the window object based on the id of the window object.

Wherein, the assigned data source includes a corresponding relationship between the component object identifier and the assigned data, and the format of the corresponding relationship may be [ component id: assigned value data of the component ].

Step 604, traversing all component object ids under the window object, and returning to the next component id;

step 606, whether the traversal is finished or not is judged;

if yes, ending the process; if not, go to step 608;

step 608, whether the current component object has corresponding assigned value data;

if yes, go to step 610; if not, returning to the step 604;

step 610, assigning a value to the current component object.

That is, steps 604 to 610 are to traverse all component object ids in the current window object based on the corresponding relationship between the component object id and the assigned data in step 602, and then not to recursively find the assigned data corresponding to the component object id from the assigned data source, and assign the assigned data to the component object. Referring to FIG. 7, the instantiated window after assignment has been augmented with the contents of the detailed configuration portion relative to the window before assignment shown in FIG. 5.

Optionally, this embodiment further discloses a step of saving window data after assignment is completed, where the step may specifically be exemplified as:

traversing all component object ids in the current window object, and generating an object which takes the component object id as a key and takes assigned value data of the component object as value, so as to get the component object; if the component object has registered the get function, then the return value of get is preferentially used as the value of the component for getting the component object.

By analogy, the steps of the embodiment are repeatedly executed to construct a plurality of window objects, and a multi-level window object can be constructed based on the hierarchical relationship between the window object and other window objects.

Therefore, in the embodiment, the problem of configuration overstock caused by layout and event coupling in the prior art is solved by separating the component layout and the component events, and the development efficiency is improved; moreover, by providing the automatic mapping capability of the window object and the assigned data source, the data and the form are completed by internal conversion, the component object is automatically assigned, and the development efficiency is further improved.

In addition, for simplicity of explanation, the above-described method embodiments are described as a series of acts or combinations, but it should be understood by those skilled in the art that the present invention is not limited by the order of acts or steps described, as some steps may be performed in other orders or simultaneously according to the present invention. Furthermore, those skilled in the art will appreciate that the embodiments described in the specification are presently preferred and that no particular act is required to implement the invention.

Fig. 8 is a schematic structural diagram of a window object processing apparatus according to an embodiment of the present disclosure, and referring to fig. 8, the apparatus may specifically include: a first determination module 81, a second determination module 82, and a write module 83, wherein:

a first determining module 81 for determining attribute information of the window object;

a second determining module 82, configured to determine a layout object in the layout object template library, where the layout object matches the attribute information, and the layout object is used to set an area of a component object in the window object;

a writing module 83, configured to write the layout object into the window object.

Optionally, the writing module 83 is specifically configured to:

Optionally, the apparatus further comprises:

Optionally, the first registration module is specifically configured to:

Optionally, the apparatus further comprises:

wherein, the assignment module is specifically configured to:

Optionally, the apparatus further comprises:

It can be seen that, in the present embodiment, by providing a pre-constructed layout object template library, in the process of developing a window object, a suitable layout object can be searched and selected from the layout object template library, and the selected layout object is written into the window object, so as to set an area of a component object in the window object. Compared with the prior art, the development workload of developers can be effectively reduced, and the development efficiency of the window object is improved. In addition, the embodiment also separates the component layout and the component events, so as to avoid the problem of configuration bloat caused by the coupling of the layout and the events in the prior art, and improve the development efficiency; moreover, by providing the automatic mapping capability of the window object and the assigned data source, the data and the form are completed by internal conversion, the component object is automatically assigned, and the development efficiency is further improved.

In addition, as for the device embodiment, since it is basically similar to the method embodiment, the description is relatively simple, and for the relevant points, reference may be made to part of the description of the method embodiment. Further, it should be noted that, among the respective components of the apparatus of the present invention, the components thereof are logically divided according to the functions to be realized, but the present invention is not limited thereto, and the respective components may be newly divided or combined as necessary.

Fig. 9 is a schematic structural diagram of an electronic device provided in an embodiment of the present disclosure, and referring to fig. 9, the electronic device includes a processor, an internal bus, a network interface, a memory, and a non-volatile memory, and may also include hardware required by other services. The processor reads the corresponding computer program from the nonvolatile memory into the memory and then runs the computer program to form the window object processing device on the logic level. Of course, besides the software implementation, the present application does not exclude other implementations, such as logic devices or a combination of software and hardware, and the like, that is, the execution subject of the following processing flow is not limited to each logic unit, and may also be hardware or logic devices.

The network interface, the processor and the memory may be interconnected by a bus system. The bus may be an ISA (Industry Standard Architecture) bus, a PCI (peripheral component Interconnect) bus, an EISA (Extended Industry Standard Architecture) bus, or the like. The bus may be divided into an address bus, a data bus, a control bus, etc. For ease of illustration, only one double-headed arrow is shown in FIG. 9, but this does not indicate only one bus or one type of bus.

The memory is used for storing programs. In particular, the program may include program code comprising computer operating instructions. The memory may include both read-only memory and random access memory, and provides instructions and data to the processor. The Memory may include a Random-Access Memory (RAM) and may also include a non-volatile Memory (non-volatile Memory), such as at least 1 disk Memory.

The processor is used for executing the program stored in the memory and specifically executing:

determining attribute information of the window object;

and writing the layout object into the window object.

The method performed by the window object processing apparatus or manager (Master) node according to the embodiment shown in fig. 8 of the present application may be applied to or implemented by a processor. The processor may be an integrated circuit chip having signal processing capabilities. In implementation, the steps of the above method may be performed by integrated logic circuits of hardware in a processor or instructions in the form of software. The Processor may be a general-purpose Processor, including a Central Processing Unit (CPU), a Network Processor (NP), and the like; but also Digital Signal Processors (DSPs), Application Specific Integrated Circuits (ASICs), Field Programmable Gate Arrays (FPGAs) or other Programmable logic devices, discrete Gate or transistor logic devices, discrete hardware components. The various methods, steps, and logic blocks disclosed in the embodiments of the present application may be implemented or performed. A general purpose processor may be a microprocessor or the processor may be any conventional processor or the like. The steps of the method disclosed in connection with the embodiments of the present application may be directly implemented by a hardware decoding processor, or implemented by a combination of hardware and software modules in the decoding processor. The software module may be located in ram, flash memory, rom, prom, or eprom, registers, etc. storage media as is well known in the art. The storage medium is located in a memory, and a processor reads information in the memory and completes the steps of the method in combination with hardware of the processor.

The window object processing apparatus may also perform the methods of fig. 1,3,4, and 6, and implement the methods performed by the manager node.

Based on the same invention creation, the embodiment of the present application further provides a computer readable storage medium, which stores one or more programs that, when executed by an electronic device including a plurality of application programs, cause the electronic device to execute the window object processing method provided by the embodiment corresponding to fig. 1,3,4, and 6.

The embodiments in the present specification are described in a progressive manner, and the same and similar parts among the embodiments are referred to each other, and each embodiment focuses on the differences from the other embodiments. In particular, for the system embodiment, since it is substantially similar to the method embodiment, the description is simple, and for the relevant points, reference may be made to the partial description of the method embodiment.

The foregoing description has been directed to specific embodiments of this disclosure. Other embodiments are within the scope of the following claims. In some cases, the actions or steps recited in the claims may be performed in a different order than in the embodiments and still achieve desirable results. In addition, the processes depicted in the accompanying figures do not necessarily require the particular order shown, or sequential order, to achieve desirable results. In some embodiments, multitasking and parallel processing may also be possible or may be advantageous.

As will be appreciated by one skilled in the art, embodiments of the present invention may be provided as a method, system, or computer program product. Accordingly, the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present invention may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.

The present invention is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each flow and/or block of the flow diagrams and/or block diagrams, and combinations of flows and/or blocks in the flow diagrams and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.

These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.

These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.

In a typical configuration, a computing device includes one or more processors (CPUs), input/output interfaces, network interfaces, and memory.

The memory may include forms of volatile memory in a computer readable medium, Random Access Memory (RAM) and/or non-volatile memory, such as Read Only Memory (ROM) or flash memory (flash RAM). Memory is an example of a computer-readable medium.

Computer-readable media, including both non-transitory and non-transitory, removable and non-removable media, may implement information storage by any method or technology. The information may be computer readable instructions, data structures, modules of a program, or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), Static Random Access Memory (SRAM), Dynamic Random Access Memory (DRAM), other types of Random Access Memory (RAM), Read Only Memory (ROM), Electrically Erasable Programmable Read Only Memory (EEPROM), flash memory or other memory technology, compact disc read only memory (CD-ROM), Digital Versatile Discs (DVD) or other optical storage, magnetic cassettes, magnetic tape magnetic disk storage or other magnetic storage devices, or any other non-transmission medium that can be used to store information that can be accessed by a computing device. As defined herein, a computer readable medium does not include a transitory computer readable medium such as a modulated data signal and a carrier wave.

It should also be noted that the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising an … …" does not exclude the presence of other like elements in a process, method, article, or apparatus that comprises the element.

As will be appreciated by one skilled in the art, embodiments of the present application may be provided as a method, system, or computer program product. Accordingly, the present application may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present application may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.

The above description is only an example of the present application and is not intended to limit the present application. Various modifications and changes may occur to those skilled in the art. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present application should be included in the scope of the claims of the present application.

Claims

1. a window object processing method, is characterized in that, comprises:

Determine the attribute information of the window object;

determining a layout object in the layout object template library that matches the attribute information, where the layout object is used to set the area of the component object in the window object;

Write the layout object into the window object.

2. The method according to claim 1, wherein the attribute information comprises window width/window height, and the matched layout object is a layout with the same width/height as the window width/window height object.

3. The method according to claim 1, wherein the layout object comprises one or more of the layout object of the built-in text field component, the layout object of the built-in attribute table component, and the layout object of the built-in Json object edit box component. indivual.

4. The method according to claim 1, wherein writing the layout object into the window object comprises:

The matching layout object is written to the window object using a cascading style.

5. The method of claim 1, further comprising:

determine the html file corresponding to the window object;

The html file is placed in the document object model corresponding to the window object.

6. The method of claim 1, further comprising:

The window object and the component object are respectively registered to the window object.

7. The method according to claim 6, wherein registering the window object and the component object to the window object respectively comprises:

Based on the encapsulated method of registering an object to the window object, the window object and the component object are respectively registered to the window object.

8. The method of claim 1, further comprising:

Determines the events registered for the component object.

9. The method of claim 1, further comprising:

determining the assignment data source corresponding to the window object;

Based on the assignment data source, assign a value to the component object inside the window object.

10. The method according to claim 9, wherein the assignment data source comprises a correspondence between component object identifiers and assignment data;

Wherein, based on the assignment data source, assigning a value to the component object inside the window object includes:

obtain the window object from the window object;

Based on the corresponding relationship, assigning the assignment data to the component object identifies the corresponding component object.

11. The method of claim 1, further comprising:

Based on the hierarchical relationship between the window object and other window objects, a multi-level window object is constructed.

12. An apparatus for processing window objects, comprising:

a first determining module, used for determining attribute information of the window object;

a second determining module, configured to determine a layout object in the layout object template library that matches the attribute information, and the layout object is used to set the area of the component object in the window object;

A writing module, configured to write the layout object into the window object.

13. An electronic device, characterized in that, comprising:

processor; and

a memory arranged to store computer-executable instructions which, when executed, cause the processor to perform the steps of a method as claimed in any one of claims 1 to 11.

14. A computer-readable storage medium, wherein a computer program is stored on the computer-readable storage medium, and when the computer program is executed by a processor, the method according to any one of claims 1 to 11 is implemented A step of.