A QT graphical display method, operating system, electronic device and storage medium

Abstract

The application discloses a QT graphical display method, an operating system, electronic equipment and a storage medium. The method comprises the following steps: starting a QT runtime environment and a QT application program; the QT runtime environment communicates with a service end as a client to initialize data, so that a first basic configuration suitable for the QT application program display is realized in the QT runtime environment and a second basic configuration suitable for the QT application program communication is realized in the service end; when the QT application program starts a graphical display service, the QT runtime environment calls an IO controller through the service end, and sends graphical data to a display device determined according to the first basic configuration to realize graphical display. The method can release the dependence of the QT application program on hardware, and can effectively improve the convenience of QT development, testing and deployment.

Description

Technical Field

[0001] This invention relates to the field of container technology, and more particularly to a QT graphics display method, operating system, electronic device, and storage medium. Background Technology

[0002] Qt is a cross-platform application and user interface framework, including cross-platform class libraries, integrated development tools, and cross-platform integrated development environments. Applications can be developed once and deployed across different desktop and embedded operating systems without rewriting the source code.

[0003] Existing QT graphics display methods rely on hardware when running QT applications to display QT graphics. They require specific development boards or specific hardware display devices, and have high requirements for development, testing, and deployment environments. Summary of the Invention

[0004] This invention provides a QT graphics display method, operating system, electronic device, and storage medium to solve the problem that existing QT graphics display methods rely on hardware when running QT applications, requiring specific development boards or specific hardware display devices, and have high requirements for development, testing, and deployment environments.

[0005] According to one aspect of the present invention, a QT graphical display method is provided, applied in an operating system, wherein the operating system deploys a container and a server for external communication, and the container loads different versions of QT base environment image packages and QT applications, wherein the QT base environment image packages provide a QT runtime environment; the method includes:

[0006] Start the QT runtime environment and the QT application;

[0007] The QT runtime environment acts as a client to perform initial data communication with the server, so as to implement a first basic configuration adapted to the display of the QT application in the QT runtime environment and a second basic configuration adapted to the communication of the QT application in the server.

[0008] When the QT application starts the graphics display service, the QT runtime environment calls the IO controller through the server to send the graphics data to the display device determined according to the first basic configuration for graphical display.

[0009] According to another aspect of the present invention, an operating system is provided, wherein a container and a server for external communication are deployed in the operating system, and different versions of QT base environment image packages and QT applications are loaded in the container, wherein the QT base environment image packages provide a QT runtime environment, and the operating system includes:

[0010] The startup module is used to start the QT runtime environment and QT applications;

[0011] A communication module is used for the QT runtime environment to perform initial data communication with the server as a client, so as to implement a first basic configuration adapted to the display of the QT application in the QT runtime environment and a second basic configuration adapted to the communication of the QT application in the server.

[0012] The display module is used so that when the QT application starts the graphics display service, the QT runtime environment calls the IO controller through the server to send the graphics data to the display device determined according to the first basic configuration for graphical display.

[0013] According to another aspect of the present invention, an electronic device is provided, the electronic device comprising: at least one processor; and

[0014] A memory communicatively connected to the at least one processor; wherein,

[0015] The memory stores a computer program that can be executed by the at least one processor, the computer program being executed by the at least one processor to enable the at least one processor to perform the QT graphics display method according to any embodiment of the present invention.

[0016] According to another aspect of the present invention, a computer-readable storage medium is provided, the computer-readable storage medium storing computer instructions for causing a processor to execute and implement the QT graphics display method according to any embodiment of the present invention.

[0017] The technical solution of this invention is applied to an operating system with a container and a server for external communication. The container contains different versions of QT basic environment image packages and QT applications. The QT basic environment image package provides a QT runtime environment. By starting the QT runtime environment and the QT application, the QT runtime environment, acting as a client, performs initial data communication with the server to implement a first basic configuration adapted to the display of the QT application in the QT runtime environment and a second basic configuration adapted to the communication of the QT application in the server. When the QT application starts the graphics display service, the QT runtime environment calls the IO controller through the server to send graphics data to the display device determined according to the first basic configuration for graphical display. This solves the problem in the prior art that running QT applications for QT graphics display depends on hardware, requiring specific development boards or specific hardware display devices, and placing high demands on the development, testing, and deployment environments. It eliminates the hardware dependency of running QT applications for QT graphics, effectively improving the speed and convenience of QT development, testing, and deployment.

[0018] It should be understood that the description in this section is not intended to identify key or essential features of the embodiments of the present invention, nor is it intended to limit the scope of the invention. Other features of the invention will become readily apparent from the following description. Attached Figure Description

[0019] To more clearly illustrate the technical solutions in the embodiments of the present invention, the accompanying drawings used in the description of the embodiments will be briefly introduced below. Obviously, the accompanying drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0020] Figure 1 This is a flowchart illustrating a QT graphics display method provided in Embodiment 1 of the present invention;

[0021] Figure 2 This is a flowchart illustrating a QT graphics display method provided in Embodiment 2 of the present invention;

[0022] Figure 3 A flowchart illustrating a QT graphics display method provided in an example embodiment of the present invention;

[0023] Figure 4 This is a schematic diagram of the structure of an operating system provided in Embodiment 3 of the present invention;

[0024] Figure 5 This is a schematic diagram of an example structure of an operating system provided in Embodiment 3 of the present invention;

[0025] Figure 6 This is a schematic diagram of the structure of an electronic device using the QT graphics display method according to an embodiment of the present invention. Detailed Implementation

[0026] To enable those skilled in the art to better understand the present invention, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are merely some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort should fall within the scope of protection of the present invention. It should be understood that the various steps described in the method embodiments of the present invention can be performed in different orders and / or in parallel. Furthermore, the method embodiments may include additional steps and / or omit the steps shown. The scope of the present invention is not limited in this respect.

[0027] The term "comprising" and its variations as used herein are open-ended inclusions, meaning "including but not limited to". The term "based on" means "at least partially based on". The term "one embodiment" means "at least one embodiment"; the term "another embodiment" means "at least one additional embodiment"; the term "some embodiments" means "at least some embodiments". Definitions of other terms will be given in the description below.

[0028] It should be noted that the terms "first," "second," etc., in the specification, claims, and accompanying drawings of this invention are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that such data can be interchanged where appropriate so that the embodiments of the invention described herein can be implemented in orders other than those illustrated or described herein. Furthermore, the terms "comprising" and "having," and any variations thereof, are intended to cover a non-exclusive inclusion; for example, a process, method, system, product, or apparatus that comprises a series of steps or units is not necessarily limited to those steps or units explicitly listed, but may include other steps or units not explicitly listed or inherent to such processes, methods, products, or apparatus.

[0029] It should be noted that the terms "a" and "a plurality of" used in this invention are illustrative rather than restrictive. Those skilled in the art should understand that, unless otherwise expressly indicated in the context, they should be understood as "one or more".

[0030] The names of the messages or information exchanged between the multiple devices in the embodiments of the present invention are for illustrative purposes only and are not intended to limit the scope of these messages or information.

[0031] Example 1

[0032] Figure 1 This is a flowchart illustrating a QT graphics display method provided in Embodiment 1 of the present invention. This method is applicable to situations where QT graphics are displayed by running a QT program. This method can be executed by an operating system, which can be implemented by software and / or hardware. The operating system is deployed in an electronic device. In this embodiment, the electronic device includes, but is not limited to, a computer device.

[0033] like Figure 1 As shown, the QT graphics display method provided in Embodiment 1 of the present invention includes the following steps:

[0034] S110, Start the QT runtime environment and QT application.

[0035] In this embodiment, containers and servers can be deployed within the operating system. Containers are a technology used to bundle an application and all its necessary files into a single runtime environment. As a unit, a container can be easily moved and run on any operating system in any environment. Using containers isolates software, enabling it to run independently across different operating systems, hardware, networks, storage systems, and security policies. This allows container-based applications to seamlessly transition between development, testing, and production environments. Because the operating system is not packaged within the container, each container requires minimal computing resources, resulting in a small footprint and easy installation. Different versions of the QT base environment image package and QT applications can be configured within the container. The server is used for external communication.

[0036] The operating system can include embedded operating systems, general-purpose operating systems, and smartphone operating systems. For example, embedded operating systems can include Linux and ARM; general-purpose operating systems can include Windows and Unix; and smartphone operating systems can include Android, iOS, and WinPhone. No specific restrictions are placed on the operating system here.

[0037] In this embodiment, the container contains different versions of the QT base environment image package. The QT base environment image package is obtained by image packaging the QT environment base package. Different versions of the QT base environment image package exist, and different versions can be set by modifying the configuration file of the QT base environment image package.

[0038] The QT base environment image package provides the QT runtime environment, which is essential for QT applications to run. A QT application can be a C++ graphical user interface application; the QT runtime environment can be understood as the software environment required for a QT application to run.

[0039] In this embodiment, the QT application can be launched after the QT runtime environment is started in the operating system. There is no restriction on how the QT runtime environment and QT application are launched.

[0040] S120. The QT runtime environment, acting as a client, performs initial data communication with the server to implement a first basic configuration adapted to the display of the QT application in the QT runtime environment and a second basic configuration adapted to the communication of the QT application in the server.

[0041] In this embodiment, after the QT application starts, a connection is established in the QT runtime environment. Then, the QT runtime environment can act as a client to perform initial data communication with the server through the communication module in the container environment. Here, initial data communication can be understood as performing initial configuration.

[0042] In this embodiment, initial data communication between the QT runtime environment and the server allows for the implementation of a first basic configuration and a second basic configuration within the QT runtime environment. The first basic configuration can be understood as the basic configuration adapted to the display of the QT application; the second basic configuration can be understood as the basic configuration adapted to the communication of the QT application on the server side. Configuration can be completed using the editing tools within the operating system.

[0043] The first basic configuration may include: configuring the X client configuration file and configuring the .xinitrc file for communication with QT applications; the second basic configuration file may include: configuring the server configuration file and configuring the .serverrc file for display with QT applications. The content of the first and second basic configurations is not specifically limited here.

[0044] S130. When the QT application starts the graphics display service, the QT runtime environment calls the IO controller through the server to send the graphics data to the display device determined according to the first basic configuration for graphical display.

[0045] The graphic data can be calculated by the graphics processing device, which determines what kind of graphics will be displayed on the display device. Since the display device number is configured in the first basic configuration, it is known which display device the graphic data generated by the graphics processing device will be sent to for graphical display.

[0046] In this embodiment, when the QT application starts the graphics display service, the QT runtime environment can communicate with the server to inform the server to display QT graphics. The server can call the graphics processor hardware acceleration interface to enable the graphics processor to send graphics data to the IO controller. After the IO controller obtains control of the graphics data, it can draw QT graphics according to the graphics data and send them to the local display device corresponding to the display device number in the first basic configuration for graphical display.

[0047] It's worth noting that QT applications also send control data beyond graphical display. This control data is sent directly to the I / O controller via the server, and the I / O controller then controls external hardware. For example, external hardware may include a keyboard, mouse, printer, and other hardware.

[0048] This invention provides a QT graphics display method in an operating system. The operating system deploys a container and a server for external communication. The container contains different versions of QT base environment image packages and QT applications. The QT base environment image package provides a QT runtime environment. First, the QT runtime environment and QT applications are started. Then, the QT runtime environment, acting as a client, performs initial data communication with the server to implement a first basic configuration adapted to the display of the QT application in the QT runtime environment and a second basic configuration adapted to the communication of the QT application in the server. Finally, when the QT application starts the graphics display service, the QT runtime environment calls the I / O controller through the server to send graphics data to the display device determined according to the first basic configuration for graphical display. This method, by containerizing the graphics display and using the server as the external communication terminal, eliminates the hardware dependency on the QT runtime environment, considering only the presence of an operating system environment. This method removes the hardware dependency for running QT applications and QT graphics, effectively improving the speed and convenience of QT development, testing, and deployment.

[0049] Based on the above embodiments, modified embodiments of the above embodiments are proposed. It should be noted that, in order to keep the description brief, only the differences from the above embodiments are described in the modified embodiments.

[0050] Furthermore, the first basic configuration includes a configuration client configuration file and a configuration client file; wherein, the configuration client file includes setting one or more of the following configuration items: the network, display device, program location, graphics processor hardware acceleration, container running status required by the QT application, and creating a QT application to start a graphics display service.

[0051] The client configuration file can be an x-client configuration file, and the client file can be a .xinitrc file. Configuring the client file requires setting the window manager on the server and setting the display device number. The window manager is used to set the identifier of the display device, which is used to determine which local display device to use to display the QT graphics.

[0052] The "QT application launch graphics service" can be understood as a service that launches graphics display through a QT application. This can include both automatic and manual launch by the QT application. After creating the QT application launch graphics service in the operating system, it can be written into the operating system's service manager, systemd.

[0053] Optionally, the startup process of the QT application startup service can be further optimized to exclude programs that affect container startup and QT application startup, as well as programs that take a long time to run.

[0054] The optimization methods can include the following: 1. Adjusting the order of startup initialization programs; 2. Prohibiting the startup of unnecessary initialization programs; 3. Adjusting and shortening the startup time of necessary initialization programs; 4. Prioritizing the startup of graphical interface initialization programs.

[0055] Furthermore, the configuration client configuration file specifically includes at least one of the following settings: local container configuration file, network parameters required by the QT application, display parameters required by the QT application, graphics processor hardware acceleration file, display parameters running in the container, and QT application executable file running in the container.

[0056] For example, configuring the client configuration file may include at least one of the following steps: configuring a local container configuration file; setting the network parameter -net in the configuration file; setting the display parameter -device in the configuration file; setting the authentication directory -volume in the configuration file; setting the GPU hardware acceleration file / dev / dri in the configuration file; setting the display parameter DISPLAY running in the container in the configuration file; and setting the QT program executable file running in the container in the configuration file.

[0057] Furthermore, the second basic configuration includes a configuration server configuration file and a configuration server file.

[0058] The configuration server configuration file and configuration server file can be adapted for QT application communication. After the server is configured, the QT application can communicate with the outside world through the server.

[0059] Example 2

[0060] Figure 2 This is a flowchart illustrating a QT graphics display method provided in Embodiment 2 of the present invention. Embodiment 2 is an optimization based on the above embodiments. For details not covered in this embodiment, please refer to Embodiment 1.

[0061] like Figure 2 As shown, the QT graphics display method provided in Embodiment 2 of the present invention includes the following steps:

[0062] S210, Start the QT runtime environment and QT application.

[0063] S220. The QT runtime environment, acting as a client, performs initial data communication with the server to implement a first basic configuration adapted to the display of the QT application in the QT runtime environment and a second basic configuration adapted to the communication of the QT application in the server.

[0064] S230. The QT runtime environment calls the hardware acceleration interface of the graphics processing device through the server to calculate graphics data separately through the graphics processing device.

[0065] Since the graphics processor hardware acceleration file has been configured in the first basic configuration, after the QT runtime environment communicates with the server, the QT runtime environment can call the graphics processor hardware acceleration interface through the server. After calling the graphics processor hardware acceleration interface, it can obtain the graphics data calculated by the graphics processing unit.

[0066] It's understandable that graphics can be displayed through integrated devices on the motherboard without using the graphics processing unit's hardware acceleration interface, but at a slower speed. However, calculating graphics data separately through the graphics display device can significantly accelerate the graphics data processing.

[0067] S240. After the server calls the graphical processing device and the IO controller obtains control, the QT runtime environment calls the IO controller through the server to organize the graphical data.

[0068] In this process, after the server calls the graphics processing device, the I / O controller gains control of the graphics processing device. The I / O controller can then obtain the graphics data calculated by the graphics processing device, process the data, and send an ACK signal back to the graphics processing device to inform it that the graphics data obtained by the I / O controller has been processed and can be directly sent to the display device for graphical display. Thus, the graphics data calculated by the graphics processing device each time can be directly sent to the display device for graphical display through the I / O controller. S250, when the QT application starts the graphics display service, the QT runtime environment calls the I / O controller through the server to send the graphics data to the display device determined according to the first basic configuration for graphical display.

[0069] S260. After packaging the QT application into an image, migrate it together with the QT base environment image packages of different versions to the operating system of the deployed container environment, so as to complete the QT graphical display by directly starting the QT runtime environment and the packaged QT application in the operating system.

[0070] In this embodiment, after the QT application is image-packaged, the image-packaged QT application and different versions of the QT basic environment image package are migrated to the operating system of the deployed container environment. Then, the QT runtime environment and QT application can be started directly in the container to achieve the display of QT graphics.

[0071] Embodiment 2 of this invention provides a QT graphics display method, which specifies the process of QT graphics display based on a container. In this method, the QT runtime environment calls the IO controller on the server side to organize the graphics data, enabling the IO controller to directly send the graphics data to the display device for graphical display. The QT application can be image-packaged and migrated to other system environments for out-of-the-box use without hardware dependencies. This embodiment of the invention provides a specific implementation method based on the technical solutions of the above embodiments.

[0072] As one specific implementation method of this embodiment. Figure 3 This is a flowchart illustrating a QT graphics display method provided in an example embodiment of the present invention, as shown below. Figure 3 As shown, the process includes the following:

[0073] ① Start the QT runtime environment and QT application;

[0074] ② The QT runtime environment performs initial data communication with the Xserver;

[0075] Here, Xserver is the X server. The QT runtime environment communicates with Xserver to initialize data, so as to implement a first basic configuration adapted to the display of the QT application in the QT runtime environment and a second basic configuration adapted to the communication of the QT application in the server.

[0076] ③Xserver calls the GPU hardware acceleration interface;

[0077] GPU stands for Graphics Processing Device.

[0078] ④ The GPU is ready and is taken over by the I / O controller;

[0079] ⑤ The X server calls the IO controller to process the data;

[0080] ⑥ The I / O controller communicates with and controls external physical hardware;

[0081] The physical hardware can include display devices, keyboards, mice, printers, and other hardware.

[0082] ⑦ The QT application initiates image display communication to graphically display the image on the display device;

[0083] In the Xserver, the xfwm window manager can obtain the identification number of the display device, which is used to tell the IO controller which hardware device to send the QT graphics to for display.

[0084] ⑧ Migrate to other operating systems and use it out of the box.

[0085] By packaging the QT runtime environment and QT application image and migrating it to other operating systems, the QT runtime environment and QT application can be directly launched in the container of other operating systems to achieve QT graphical display.

[0086] Example 3

[0087] Figure 4 This is a schematic diagram of the structure of an operating system provided in Embodiment 3 of the present invention. The operating system is applicable to situations where QT graphics are displayed by running QT programs. The operating system can be implemented by software and / or hardware and is generally integrated on electronic devices.

[0088] like Figure 4 As shown, the operating system includes: a boot module 410, a communication module 420, and a display module 430.

[0089] Startup module 410 is used to start the QT runtime environment and QT applications.

[0090] The communication module 420 is used for the QT runtime environment to perform initialization data communication with the server as a client, so as to implement a first basic configuration adapted to the display of the QT application in the QT runtime environment and a second basic configuration adapted to the communication of the QT application in the server.

[0091] Display module 430 is used to send graphics data to a display device determined according to the first basic configuration for graphical display when the QT application starts the graphics display service, and the QT runtime environment calls the IO controller through the server.

[0092] In this embodiment, the operating system first starts the QT runtime environment and QT application through the startup module 410; then, the communication module 420 is used for the QT runtime environment to perform initial data communication with the server as a client, so as to implement a first basic configuration adapted to the display of the QT application in the QT runtime environment and a second basic configuration adapted to the communication of the QT application in the server; finally, when the QT application starts the graphics display service through the display module 430, the QT runtime environment calls the IO controller through the server to send the graphics data to the display device determined according to the first basic configuration for graphical display.

[0093] This embodiment provides an operating system that can eliminate the hardware dependency of running QT applications and QT graphics, effectively improving the speed and convenience of QT development, testing, and deployment.

[0094] Furthermore, the first basic configuration includes a configuration client configuration file and a configuration client file; wherein, the configuration client file includes setting one or more of the following configuration items: the network, display device, program location, graphics processor hardware acceleration, container running status required by the QT application, and creating a QT application to start a graphics display service.

[0095] Furthermore, the configuration client configuration file specifically includes at least one of the following settings: local container configuration file, network parameters required by the QT application, display parameters required by the QT application, graphics processor hardware acceleration file, display parameters running in the container, and QT application executable file running in the container.

[0096] Furthermore, the second basic configuration includes a configuration server configuration file and a configuration server file.

[0097] Furthermore, the operating system also includes a calling module. Before the QT application starts the graphics display service, the calling module is used for: the QT runtime environment calling the hardware acceleration interface of the graphics processing device through the server to calculate graphics data separately through the graphics processing device; after the server calls the graphics processing device and the IO controller obtains control, the QT runtime environment calling the IO controller through the server to organize the graphics data.

[0098] Furthermore, the communication module 420 is used to: after the QT application starts, establish a connection in the QT runtime environment so that the QT runtime environment can communicate with the server through the communication module in the container environment.

[0099] Furthermore, the operating system also includes a migration module, used to: migrate the QT application, after image packaging, together with the QT base environment image packages of different versions to the operating system of the deployed container environment, so as to complete the QT graphical display in the operating system by directly starting the QT runtime environment and the image-packaged QT application.

[0100] The aforementioned operating system can execute the QT graphics display method provided in any embodiment of the present invention, and has the corresponding functional modules and beneficial effects of executing the method.

[0101] Figure 5 This is a schematic diagram of an example structure of an operating system provided in Embodiment 3 of the present invention, as shown below. Figure 5 As shown, the operating system is Linux. The system deploys Docker containers on the hardware. C represents QT application, X-server represents X server, and x11 represents graphical management window.

[0102] Example 4

[0103] Figure 6 A schematic diagram of an electronic device 10, which can be used to implement embodiments of the present invention, is shown. The electronic device includes the operating system described in the embodiments of the present invention. The electronic device is intended to represent various forms of digital computers, such as laptop computers, desktop computers, workstations, personal digital assistants, servers, blade servers, mainframe computers, and other suitable computers. The electronic device may also represent various forms of mobile devices, such as personal digital processors, cellular phones, smartphones, wearable devices (such as helmets, glasses, watches, etc.), and other similar computing devices. The components shown herein, their connections and relationships, and their functions are merely illustrative and are not intended to limit the implementation of the invention described and / or claimed herein.

[0104] like Figure 6As shown, the electronic device 10 includes at least one processor 11 and a memory, such as a read-only memory (ROM) 12 or a random access memory (RAM) 13, communicatively connected to the at least one processor 11. The memory stores computer programs executable by the at least one processor. The processor 11 can perform various appropriate actions and processes based on the computer program stored in the ROM 12 or loaded from storage unit 18 into the RAM 13. The RAM 13 may also store various programs and data required for the operation of the electronic device 10. The processor 11, ROM 12, and RAM 13 are interconnected via a bus 14. An input / output (I / O) interface 15 is also connected to the bus 14.

[0105] Multiple components in electronic device 10 are connected to I / O interface 15, including: input unit 16, such as keyboard, mouse, etc.; output unit 17, such as various types of displays, speakers, etc.; storage unit 18, such as disk, optical disk, etc.; and communication unit 19, such as network card, modem, wireless transceiver, etc. Communication unit 19 allows electronic device 10 to exchange information / data with other devices through computer networks such as the Internet and / or various telecommunications networks.

[0106] Processor 11 can be a variety of general-purpose and / or special-purpose processing components with processing and computing capabilities. Some examples of processor 11 include, but are not limited to, a central processing unit (CPU), a graphics processing unit (GPU), various special-purpose artificial intelligence (AI) computing chips, various processors running machine learning model algorithms, a digital signal processor (DSP), and any suitable processor, controller, microcontroller, etc. Processor 11 performs the various methods and processes described above, such as the QT graphics display method.

[0107] In some embodiments, the QT graphics display method may be implemented as a computer program tangibly contained in a computer-readable storage medium, such as storage unit 18. In some embodiments, part or all of the computer program may be loaded and / or installed on electronic device 10 via ROM 12 and / or communication unit 19. When the computer program is loaded into RAM 13 and executed by processor 11, one or more steps of the QT graphics display method described above may be performed. Alternatively, in other embodiments, processor 11 may be configured to execute the QT graphics display method by any other suitable means (e.g., by means of firmware).

[0108] Various embodiments of the systems and techniques described above herein can be implemented in digital electronic circuit systems, integrated circuit systems, field-programmable gate arrays (FPGAs), application-specific integrated circuits (ASICs), application-specific standard products (ASSPs), systems-on-a-chip (SoCs), payload-programmable logic devices (CPLDs), computer hardware, firmware, software, and / or combinations thereof. These various embodiments may include implementations in one or more computer programs that can be executed and / or interpreted on a programmable system including at least one programmable processor, which may be a dedicated or general-purpose programmable processor, capable of receiving data and instructions from a storage system, at least one input device, and at least one output device, and transmitting data and instructions to the storage system, the at least one input device, and the at least one output device.

[0109] Computer programs used to implement the methods of the present invention may be written in any combination of one or more programming languages. These computer programs may be provided to a processor of a general-purpose computer, a special-purpose computer, or other programmable data processing device, such that when executed by the processor, the computer programs cause the functions / operations specified in the flowcharts and / or block diagrams to be performed. The computer programs may be executed entirely on a machine, partially on a machine, or as a standalone software package, partially on a machine and partially on a remote machine, or entirely on a remote machine or server.

[0110] In the context of this invention, a computer-readable storage medium can be a tangible medium that may contain or store a computer program for use by or in conjunction with an instruction execution system, apparatus, or device. A computer-readable storage medium may include, but is not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, apparatus, or devices, or any suitable combination thereof. Alternatively, a computer-readable storage medium may be a machine-readable signal medium. More specific examples of machine-readable storage media include electrical connections based on one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fibers, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination thereof.

[0111] To provide interaction with a user, the systems and techniques described herein can be implemented on an electronic device having: a display device (e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor) for displaying information to the user; and a keyboard and pointing device (e.g., a mouse or trackball) through which the user provides input to the electronic device. Other types of devices can also be used to provide interaction with the user; for example, feedback provided to the user can be any form of sensory feedback (e.g., visual feedback, auditory feedback, or tactile feedback); and input from the user can be received in any form (including sound input, voice input, or tactile input).

[0112] The systems and technologies described herein can be implemented in computing systems that include backend components (e.g., as data servers), or computing systems that include middleware components (e.g., application servers), or computing systems that include frontend components (e.g., user computers with graphical user interfaces or web browsers through which users can interact with implementations of the systems and technologies described herein), or any combination of such backend, middleware, or frontend components. The components of the system can be interconnected via digital data communication of any form or medium (e.g., communication networks). Examples of communication networks include local area networks (LANs), wide area networks (WANs), blockchain networks, and the Internet.

[0113] A computing system can include clients and servers. Clients and servers are generally located far apart and typically interact through communication networks. The client-server relationship is created by computer programs running on the respective computers and having a client-server relationship with each other. The server can be a cloud server, also known as a cloud computing server or cloud host, which is a hosting product within the cloud computing service system to address the shortcomings of traditional physical hosts and VPS services, such as high management difficulty and weak business scalability.

[0114] It should be understood that the various forms of processes shown above can be used, with steps reordered, added, or deleted. For example, the steps described in this invention can be executed in parallel, sequentially, or in different orders, as long as the desired result of the technical solution of this invention can be achieved, and this is not limited herein.

[0115] The specific embodiments described above do not constitute a limitation on the scope of protection of this invention. Those skilled in the art should understand that various modifications, combinations, sub-combinations, and substitutions can be made according to design requirements and other factors. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of this invention should be included within the scope of protection of this invention.

Claims

1. A QT graphics display method, applied in an operating system, characterized in that, The operating system deploys containers and a server for external communication. Different versions of QT base environment image packages and QT applications are loaded within the containers. The QT base environment image packages provide the QT runtime environment. The method includes: Start the QT runtime environment and the QT application; The QT runtime environment acts as a client to perform initial data communication with the server, so as to implement a first basic configuration adapted to the display of the QT application in the QT runtime environment and a second basic configuration adapted to the communication of the QT application in the server; wherein, the first basic configuration is a basic configuration adapted to the display of the QT application; and the second basic configuration is a basic configuration adapted to the communication of the QT application in the server. When the QT application starts the graphics display service, the QT runtime environment calls the IO controller through the server to send the graphics data to the display device determined according to the first basic configuration for graphical display; The first basic configuration includes configuring the client configuration file and configuring the client file; The configuration client file includes setting one or more of the following configuration items: the network, display device, program location, graphics processor hardware acceleration, container running status required by the QT application, and creating a QT application to start the graphics display service.

2. The method according to claim 1, characterized in that, The configuration client configuration file specifically includes at least one of the following settings: The local container configuration file, the network parameters required by the QT application, the display parameters required by the QT application, the graphics processor hardware acceleration file, the display parameters running in the container, and the QT application executable file running in the container.

3. The method according to claim 1, characterized in that, The second basic configuration includes configuring the server-side configuration file and configuring the server-side file.

4. The method according to claim 1, characterized in that, Before the QT application starts the graphics display service, it also includes: The QT runtime environment calls the hardware acceleration interface of the graphics processing device through the server to calculate graphics data separately through the graphics processing device. After the server calls the graphical processing device and the IO controller gains control, the QT runtime environment uses the server to call the IO controller to process the graphical data.

5. The method according to claim 1, characterized in that, After the QT application starts, a connection is established in the QT runtime environment so that the QT runtime environment can communicate with the server through the communication module in the container environment.

6. The method according to claim 1, characterized in that, Also includes: After the QT application is image-packaged, it is migrated together with the QT base environment image packages of different versions to the operating system of the deployed container environment, so that QT graphical display can be completed by directly starting the QT runtime environment and the image-packaged QT application in the operating system.

7. An operating system, characterized in that, The operating system deploys containers and a server for external communication. Different versions of QT base environment image packages and QT applications are loaded within the containers. The QT base environment image packages provide the QT runtime environment. The operating system includes: The startup module is used to start the QT runtime environment and QT applications; A communication module is used for the QT runtime environment to perform initial data communication with the server as a client, so as to implement a first basic configuration adapted to the display of the QT application in the QT runtime environment and a second basic configuration adapted to the communication of the QT application in the server; wherein, the first basic configuration is a basic configuration adapted to the display of the QT application; and the second basic configuration is a basic configuration adapted to the communication of the QT application in the server. The display module is used so that when the QT application starts the graphics display service, the QT runtime environment calls the IO controller through the server to send the graphics data to the display device determined according to the first basic configuration for graphical display. The first basic configuration includes a configuration client configuration file and a configuration client file; wherein, the configuration client file includes setting one or more of the following configuration items: the network, display device, program location, graphics processor hardware acceleration, container running status required by the QT application, and creating a QT application to start the graphics display service.

8. An electronic device, characterized in that, The electronic device includes: At least one processor; and A memory communicatively connected to the at least one processor; wherein, The memory stores a computer program that can be executed by the at least one processor, the computer program being executed by the at least one processor to enable the at least one processor to perform the QT graphics display method according to any one of claims 1-6.

9. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores computer instructions that cause a processor to execute the QT graphics display method according to any one of claims 1-6.

Images