CN113946332B

CN113946332B - Method and storage medium for displaying attributes based on GUI (graphical user interface)

Info

Publication number: CN113946332B
Application number: CN202110970101.1A
Authority: CN
Inventors: 颜可煌; 黄锦标
Original assignee: Xinhuazhang Technology Co ltd
Current assignee: Xinhuazhang Technology Co ltd
Priority date: 2021-08-23
Filing date: 2021-08-23
Publication date: 2023-04-25
Anticipated expiration: 2041-08-23
Also published as: CN113946332A

Abstract

The present disclosure provides a method for displaying properties based on a GUI interface. The method comprises the following steps: executing instructions for processing an object; obtaining an identifier of the object in response to execution of the instruction; determining from the identifier whether the object satisfies a given condition; acquiring an attribute of the object and a value of the attribute in response to the object satisfying the given condition; and generating the GUI interface according to the attribute of the object and the value of the attribute, wherein the value of the attribute of the object is editable in the GUI interface. According to the embodiment of the disclosure, the identifiers of the existing instructions are fully utilized, so that a plurality of groups of attributes to be displayed and the values of the attributes are obtained, and meanwhile, the GUI interface is developed to provide display or modification operation for the attributes and the values of the attributes, so that the use is convenient, and the development efficiency is improved.

Description

Method and storage medium for displaying attributes based on GUI (graphical user interface)

Technical Field

The embodiment of the disclosure relates to the field of software development, in particular to a method and a storage medium based on GUI interface display attributes.

Background

TCL (Tool Command Language) is a scripting language used in prototyping, scripting, GUI (Graphical User Interface) and testing.

Typically, properties in an object may be viewed or modified by running various instructions in the form of command lines. However, one instruction can only modify the value of a single attribute, which is inefficient. How to facilitate the viewing and modification of the properties of objects is a matter of urgent need.

Disclosure of Invention

In view of this, the present disclosure proposes a method and a storage medium based on GUI interface display properties.

In a first aspect of the present disclosure, a method for displaying properties based on a GUI interface is provided. The method comprises the following steps: executing instructions for processing an object; obtaining an identifier of the object in response to execution of the instruction; determining from the identifier whether the object satisfies a given condition; acquiring an attribute of the object and a value of the attribute in response to the object satisfying the given condition; and generating the GUI interface according to the attribute of the object and the value of the attribute, wherein the value of the attribute of the object is editable in the GUI interface.

In a second aspect of the present disclosure, a computing device is provided that includes a memory to store a set of instructions; and at least one processor configured to execute the shuffling instructions to cause the computing devices to perform the method of the first aspect.

In a third aspect of the present disclosure, there is provided a non-transitory computer readable storage medium storing a set of instructions of a computer for, when executed, causing the computer to perform the method of the first aspect.

According to the embodiment of the disclosure, the identifiers of the existing instructions are fully utilized, so that a plurality of groups of attributes to be displayed and the values of the attributes are obtained, and meanwhile, the GUI interface is developed to provide display or modification operation for the attributes and the values of the attributes, so that the use is convenient, and the development efficiency is improved.

Drawings

For a clearer description of the present disclosure or of the prior art, the drawings that are necessary for the description of the embodiments or of the prior art will be briefly described, it being apparent that the drawings in the description below are only of the present disclosure, from which, without inventive effort, other drawings may be obtained for a person of ordinary skill in the art

Fig. 1 is a schematic diagram of a host according to an embodiment of the present disclosure.

Fig. 2A is a schematic diagram of a process for displaying properties based on a GUI interface according to an embodiment of the present disclosure.

FIG. 2B is a schematic diagram of a TCL object according to an embodiment of the disclosure.

Fig. 2C is a schematic diagram of a GUI interface according to an embodiment of the present disclosure.

Fig. 3 is a flowchart of a method for displaying properties based on a GUI interface according to an embodiment of the present disclosure.

Detailed Description

For the purposes of promoting an understanding of the principles and advantages of the disclosure, reference will now be made to the embodiments illustrated in the drawings and specific language will be used to describe the same.

It is to be noted that unless otherwise defined, technical or scientific terms used in the present disclosure should be taken in a general sense as understood by one of ordinary skill in the art to which the present disclosure pertains. The word "comprising" and the like means that elements or items preceding the word are included in the element or item listed after the word and equivalents thereof without precluding other elements or items.

Fig. 1 shows a schematic diagram of a host 100 according to an embodiment of the present disclosure. As shown in fig. 1, the host 100 may include: processor 102, memory 104, network interface 106, peripheral interface 108, and bus 110. Wherein the processor 102, the memory 104, the network interface 106, and the peripheral interface 108 are communicatively coupled to each other within the host via a bus 110.

The processor 102 may be a central processing unit (Central Processing Unit, CPU), an image processor, a neural Network Processor (NPU), a Microcontroller (MCU), a programmable logic device, a Digital Signal Processor (DSP), an application specific integrated circuit (Application Specific Integrated Circuit, ASIC), or one or more integrated circuits. The processor 102 may be used to perform functions related to the techniques described in this disclosure. In some embodiments, processor 102 may also include multiple processors integrated as a single logical component. As shown in fig. 1, the processor 102 may include a plurality of processors 102a, 102b, and 102c.

The memory 104 may be configured to store data (e.g., instructions, a list of TCL objects, computer code, attributes of objects and values of attributes, etc.). As shown in fig. 1, the data stored by the memory may include program instructions (e.g., program instructions for implementing the GUI interface display attribute-based method of the present disclosure) as well as data to be processed (e.g., the memory may store temporary code generated during compilation, attributes of objects, values of attributes, etc.). The processor 102 may also access program instructions and data stored in the memory and execute the program instructions to perform operations on the data to be processed. The memory 104 may include volatile storage or nonvolatile storage. In some embodiments, memory 104 may include Random Access Memory (RAM), read Only Memory (ROM), optical disks, magnetic disks, hard disks, solid State Disks (SSD), flash memory, memory sticks, and the like.

The network interface 106 may be configured to provide communication with other external devices to the host 100 via a network. The network may be any wired or wireless network capable of transmitting and receiving data. For example, the network may be a wired network, a local wireless network (e.g., bluetooth, wiFi, near Field Communication (NFC), etc.), a cellular network, the internet, or a combination of the foregoing. It will be appreciated that the type of network is not limited to the specific examples described above. In some embodiments, network interface 106 may include any combination of any number of Network Interface Controllers (NICs), radio frequency modules, receivers, modems, routers, gateways, adapters, cellular network chips, etc.

The peripheral interface 108 may be configured to connect the host 100 with one or more peripheral devices to enable information input and output. For example, the peripheral devices may include input devices such as keyboards, mice, touchpads, touch screens, microphones, various types of sensors, and output devices such as displays, speakers, vibrators, and indicators.

Bus 110 may be configured to transfer information between the various components of host 100 (e.g., processor 102, memory 104, network interface 106, and peripheral interface 108), such as an internal bus (e.g., processor-memory bus), an external bus (USB port, PCI-E bus), etc.

It should be noted that, although the above-described host architecture only shows the processor 102, the memory 104, the network interface 106, the peripheral interface 108, and the bus 110, in a specific implementation, the host architecture may also include other components necessary to achieve proper operation. Moreover, those skilled in the art will appreciate that the above-described host architecture may also include only the components necessary to implement the embodiments of the present disclosure, and not all of the components shown in the figures.

The host 100 may support, for example, TCL language operation.

Typically, running an instruction on a TCL object may return an ID of the object to the user. For example, running the TCL code may obtain information for the active window that is the object of the TCL, assign value to variable a, and obtain a return value obj of 0xle591290.

>set a[gui::get_active_window]

obj:0xle591290

However, this return value is meaningless to the user. For example, when the user needs to operate on the active window, the reference and operation on the variable a need to be repeated, as shown in the following code.

>db::show_attributes-of$a

name id type children...

>db::get_attribute id-of$a

101

>db::set_attribute id 102-of$a

According to the exemplary code above, the db:: show_attributes-of $a instruction may be entered when the user needs to view all of the attributes. When the instruction is executed, all attributes (e.g., attribute name, attribute id, attribute type, etc.) may be presented in a return value (name id type child. When a value of a certain attribute needs to be displayed, such as the value of the attribute id, the user can input the db:: get_attribute id-of $a instruction and learn: the value of the attribute id is 101. When the user needs to edit the value of the attribute id to 102, a db:set_attribute id 102-of $a instruction may be entered.

However, this method of operation is neither intuitive nor efficient, nor does the return values associated with the TCL object be utilized.

Fig. 2A is a schematic diagram of a GUI interface display attribute-based process 200 according to an embodiment of the present disclosure. As shown in fig. 2A, process 200 may involve at least: instructions 210, identifiers 220, list of TCL objects 230, memory address 240, attributes 252 of TCL object 250, values 254 of attributes, and GUI interface 260.

Instruction 210 may include a command line entered by a user into a TCL command line window for processing a TCL object (e.g., TCL object 250). The instructions 210 may be executed by a software system running on, for example, the host 100, and are not described in detail herein.

For example, the command line may be set a [ gui:: get_active_window ]. By executing set a gui:: get_active_window ], an identifier 220 may be returned and the variable a assigned the identifier 220. Identifier 220 is the return value (e.g., oa:0x 102383) that results after instruction 210 is executed. The return value may be associated with the TCL object. In some embodiments, the return value may be associated with a memory address of the TCL object. In some embodiments, the identifier 220 may be a number, such as 120598, 102383, etc. in fig. 2A.

The instructions 210 may further include a command line to visually display the TCL object. For example, the command line may be gui:show_object $a. By executing the command line, information about the TCL object may be further retrieved and processed.

In some embodiments, the identifier 220 may be looked up in the list 230 of TCL objects.

The list 230 of TCL objects stores identifiers of a plurality of TCL objects and their corresponding memory addresses. In some embodiments, the identifier 220 (e.g., 102383) may be first looked up in the list 230. If an identifier 220 is found in the list 230, a memory address 240 (e.g., 0x 80008908) corresponding to the identifier 220, i.e., the memory address of the TCL object, is returned. If the identifier 220 does not exist in the list 230, a message is returned indicating that the list 230 does not exist the identifier 220.

In some embodiments, to enable fast searches in the list 230 of TCL objects, the list 230 of TCL objects may be a hash table or a binary tree.

Based on the returned memory address 240, a TCL object (e.g., TCL object 250) may be accessed in memory and the attributes 252 of the TCL object and the values 254 of the attributes read. In some embodiments, the attribute 252 may be a string, for example, the attributes name, type, id and child are both strings. In some embodiments, the type of value 254 of the attribute may be a numeric value, a character, a string of characters, or a TCL object.

The attributes 252 of the TCL object and the values 254 of the attributes may further be visually displayed. For example, GUI interface 260. In GUI interface 260, a user may view or edit properties 252 and values 254 of the properties.

FIG. 2B is a schematic diagram of a TCL object 250 according to an embodiment of the disclosure.

In some embodiments, a user may create a TCL object by executing the following instructions.

>set dlg[gui::create_dialog abc-title abc]

Execution of the above instruction may create a default dialog box named abc, which may contain two buttons (help and close, respectively), such as 250a in fig. 2B.

At the same time that the abc dialog is created, an identifier of TCL object 250a is also generated and the memory address of TCL object 250a is also synchronously acquired. The identifier and memory address of TCL object 250a may be saved to a list of TCL objects (e.g., list 230 of TCL objects) and returned.

On this basis, the user may further create a new TCL object 250b by executing the following instructions.

>set b[gui::create_label lb-label“hellow”-parent$dlg]

By executing the above instruction, a tag 250b may be created in the TCL object 250a, named lb, and having a value of "hellow".

Similarly, an identifier of object 250b is also generated and the memory address of TCL object 250b is also synchronously acquired. The identifier and memory address of TCL object 250b may be saved to a list of TCL objects (e.g., list 230 of TCL objects) and returned.

Corresponding to creating the TCL object, when the TCL object is destroyed, an identifier of the TCL object may be determined according to a memory address of the TCL object, and the identifier and the memory address corresponding to the identifier may be deleted from the list of TCL objects.

By clearing the invalid data, the list of the TCL objects is prevented from infinitely increasing, and the fact that effective TCL objects are always stored in the list of the TCL objects is ensured.

Fig. 2C is a schematic diagram of GUI interface 260 according to an embodiment of the present disclosure. For ease of description, the schematic diagram of FIG. 2C is actually a GUI interface generated by TCL object 250b, that is, a GUI interface generated after running instruction g$b.

As shown in FIG. 2C, attribute in GUI interface 260 corresponds to attribute 252 in TCL object 250b and value in GUI interface 260 corresponds to value 254 of the attribute in TCL object 250b. The attribute 252 may be characteristic information of the TCL object. For example, the value of attribute parent is tclobject < dialog > indicating that TCL object 250B is parasitic on a dialog object (see TCL object 250a of fig. 2B). The value of attribute show is true, indicating that the tag (i.e., the "hellow" flag in fig. 2B) is visible, which would be hidden from view if the attribute show were edited to false. The attribute 252 may also be added by the user himself. For example, the user may enter the instruction db that add_attribute $b-name "xx" -value "yy", then a new attribute xx and the value yy of the attribute (not shown in FIG. 2C) are added to the GUI interface 260.

The user can edit the various properties in the GUI interface because the relevant methods of these properties have been defined. The code is as follows:

in the above example, the get_shown method and the set_shown method are used to display and edit the attribute shown, respectively. Because the attribute parent has no related set method, the value of the attribute parent cannot be changed, and therefore, the attribute parent is a read-only attribute. In contrast, attribute shown is a writable attribute. It will be appreciated that if xx is also a writable attribute, then the instruction db: -add_attribute $ b-name "xx" -value "yy" will automatically establish two methods for attribute xx in the program. For example, two methods named get_xx and set_xx may be used to display and edit property xx, respectively.

In an embodiment of the present disclosure, the host 100 returns the identifier 220 of the TCL object in response to a set b [ gui:: create_labellb-labelhellow "-parent $dlg ] instruction 210 that processes user input, and stores the identifier 220 in variable b. Meanwhile, the host 100 generates an identifier 220 from the memory address of lb in response to the creation of the lb object and stores the identifier 220 together with the memory address of lb in the list 230 of TCL objects. When the user inputs the g$b instruction, the host 100 determines from the identifier 220, i.e., variable b, whether the identifier 220 is in the list 230 of TCL objects. If the identifier 220 is in the list 230 of TCL objects, the host 100 reads the memory address 240 of the TCL object 250 from the list 230 of TCL objects according to the identifier 220, and obtains the attribute 252 and the value 254 of the attribute of the object from the memory address 240. Based on the attributes 252 and the values 254 of the attributes of the objects, the host 100 generates a GUI interface 260, wherein the attributes 252 and the values 254 of the attributes of the objects are editable in the GUI interface 260.

Fig. 3 is a flowchart of a method 300 of displaying properties based on a GUI interface according to an embodiment of the present disclosure. The method may be implemented by a computing device (e.g., host 100 shown in fig. 1). Referring to fig. 3, the method 300 may include the following steps.

In step S310, the host 100 executes an instruction for processing an object (for example, an instruction 210 shown in fig. 2A). In some embodiments, the instruction to process the object is an instruction to create a TCL object, and in response to the creation of the TCL object, store a memory address of the TCL object into a list of the TCL object, generate an identifier associated with the memory address of the TCL object, and return the identifier. In some embodiments, the instruction to process the object is an instruction to destroy a TCL object, and in response to the destruction of the TCL object, determining a memory address of the TCL object; determining an identifier of the TCL object according to the memory address of the TCL object; the identifier is deleted in the list of TCL objects.

In step S320, in response to execution of the instruction, the host 100 obtains an identifier of the object (e.g., the identifier 220 shown in fig. 2A).

In step S330, the host 100 determines whether the object satisfies a given condition according to the identifier. In some embodiments, given that the object is a TCL object (e.g., TCL object 250 shown in fig. 2A), the identifier is looked up in a list of TCL objects (e.g., list 230 of TCL objects shown in fig. 2A); and in response to finding the identifier in the list of TCL objects, determining that the object satisfies a given condition. In some embodiments, the list of TCL objects is a hash table or a binary tree.

In step S340, in response to the object satisfying the given condition, the host 100 acquires the attribute (e.g., attribute 252 shown in fig. 2A) of the object and the value of the attribute (e.g., value 254 of the attribute shown in fig. 2A). In some embodiments, the memory address of the TCL object (e.g., memory address 240 shown in fig. 2A) is read from the list of objects according to the identifier, and the attributes of the object and the values of the attributes are obtained from the memory address of the object.

It will be appreciated that if the object does not meet the given condition, the method 300 ends. For example, when the object does not include an editable property, method 300 may not generate an editable GUI interface for it, at which point method 300 ends.

In step S350, the host 100 generates a GUI interface (e.g., the GUI interface 260 shown in fig. 2A) according to the attribute of the object and the value of the attribute, which is editable in the GUI interface.

It should be noted that the method of the present disclosure may be performed by a single device, such as a computer or server. The method of the embodiment can also be applied to a distributed scene, and is completed by mutually matching a plurality of devices. In the case of such a distributed scenario, one of the devices may perform only one or more steps of the methods of the present disclosure, which interact with each other to complete the methods.

The disclosed embodiments also provide a computing device comprising a memory for storing a set of instructions; and at least one processor configured to execute the shuffling instructions to cause the computing device to perform the GUI interface display attribute-based method provided by embodiments of the present disclosure.

The disclosed embodiments also provide a non-transitory computer readable storage medium storing a set of instructions of a computer for, when executed, causing the computer to perform the GUI interface display attribute-based method provided by the disclosed embodiments.

The foregoing describes some embodiments of the present disclosure. Other embodiments are within the scope of the following claims. In some cases, the actions or steps recited in the claims can 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 are also possible or may be advantageous.

Those of ordinary skill in the art will appreciate that: the discussion of any of the embodiments above is merely exemplary and is not intended to suggest that the scope of the disclosure, including the claims, is limited to these examples; the technical features of the above embodiments or in different embodiments may also be combined under the idea of the present disclosure, the steps may be implemented in any order, and there are many other variations of the different aspects of the present disclosure as described above, which are not provided in details for the sake of brevity.

While the present disclosure has been described in conjunction with specific embodiments thereof, many alternatives, modifications, and variations of those embodiments will be apparent to those skilled in the art in light of the foregoing description. For example, other memory architectures (e.g., dynamic RAM (DRAM)) may use the embodiments discussed.

The present disclosure is intended to embrace all such alternatives, modifications and variances which fall within the broad scope of the appended claims. Accordingly, any omissions, modifications, equivalents, improvements and the like that may be made within the spirit and principles of the disclosure are intended to be included within the scope of the disclosure.

Claims

1. A method of displaying properties based on a GUI interface, comprising:

executing instructions for processing an object;

obtaining an identifier of the object in response to execution of the instruction;

determining from the identifier whether the object satisfies a given condition;

acquiring an attribute of the object and a value of the attribute in response to the object satisfying the given condition; and

generating the GUI according to the attribute of the object and the value of the attribute, wherein the attribute of the object and the value of the attribute are editable in the GUI;

wherein the given condition is that the object is a TCL object, and determining from the identifier whether the object satisfies the given condition further comprises:

searching the identifier in a list of TCL objects; and

in response to finding the identifier in the list of TCL objects, it is determined that the object satisfies the given condition.

2. The method of claim 1, wherein obtaining the attribute of the object and the value of the attribute further comprises:

reading the memory address of the object in the list of the TCL object according to the identifier;

and acquiring the attribute of the object and the value of the attribute according to the memory address of the object.

3. The method of claim 1, wherein the instruction to process the object is an instruction to create a TCL object, and the method further comprises:

storing the identifier and a memory address of the TCL object to a list of the TCL object in response to creation of the TCL object;

generating an identifier associated with a memory address of the TCL object; and

and returning the identifier.

4. The method of claim 1, wherein the instruction to process the object is an instruction to destroy a TCL object, and the method further comprises:

determining a memory address of the TCL object in response to destruction of the TCL object;

determining an identifier of the TCL object according to the memory address of the TCL object;

deleting the identifier from the list of TCL objects.

5. The method of claim 1, wherein the list of TCL objects is a hash table or a binary tree.

6. A computing device, comprising

A memory for storing a set of instructions; and

at least one processor configured to execute the set of instructions to cause the computing device to perform the method of any one of claims 1 to 5.

7. A non-transitory computer readable storage medium storing a set of instructions of a computer for, when executed, causing the computer to perform the method of any one of claims 1 to 5.