Operation method, device, equipment, medium and program product for visual programming

Abstract

This application discloses a visual programming operation method, apparatus, device, medium, and program product, relating to the field of human-computer interaction. The method includes: displaying a programming interface, which includes a tool area and a work area; receiving a history viewing operation on the tool area, the history viewing operation being used to view historical programming blocks used in building program content through the work area within a historical time period; and responding to the history viewing operation by displaying the historical programming blocks used within the historical time period. Through this method, users can quickly view historical programming blocks used within a historical time period via the history viewing operation, enabling them to quickly apply these historical programming blocks to the work area for an efficient program content building process, thus improving human-computer interaction efficiency. This application can be applied to various scenarios such as cloud technology and artificial intelligence.

Description

Technical Field

[0001] This application relates to the field of human-computer interaction, and in particular to a visual programming operation method, apparatus, device, medium, and program product. Background Technology

[0002] With the development of computer technology, more and more people are learning the basics of programming to enhance their competitiveness and creativity in the field of science and technology. Programming skills have gradually become an important skill in various industries. In order to make it easier for beginners to learn programming knowledge more intuitively and in a more fun way, web-based visual programming environments have emerged. In visual programming environments, programs are usually built using blocks.

[0003] In related technologies, visual programming environments include a tool area and a work area. The tool area includes various tool functions such as events, controls, conditions, and functions. Each tool function includes a corresponding block type. As the basic unit in visual programming, blocks can be dragged from the tool area to the work area to build programs and learn programming.

[0004] However, while the tools in the current tool area cover a variety of programming functions and can help users gain a basic understanding of programming knowledge, they do not fully consider the interrelationships between multiple building blocks in the overall programming process. This makes it difficult for users to summarize and review the programming process effectively, thus affecting the user experience. Summary of the Invention

[0005] This application provides a visual programming operation method, apparatus, device, medium, and program product, enabling users to quickly view historical programming blocks used within a historical time period through a history viewing operation. This allows for the rapid application of historical programming blocks to the work area to achieve an efficient program content construction process and improve human-computer interaction efficiency. The technical solution is as follows.

[0006] On the one hand, a visual programming operation method is provided, the method including:

[0007] The programming interface is displayed, which includes a tool area and a work area. The tool area is used to display multiple programming blocks, which are the basic units used to represent programming logic in visual programming. The work area is used to visually represent the construction process of program content based on the programming blocks.

[0008] Receive a history viewing operation for the tool area, the history viewing operation being used to view the historical programming blocks used when building program content through the work area within a historical time period;

[0009] In response to the history viewing operation, the historical programming blocks used within the historical time period are displayed.

[0010] On the other hand, a visual programming operating device is provided, the device comprising:

[0011] The display module is used to display the programming interface, which includes a tool area and a work area. The tool area is used to display multiple programming blocks, which are the basic units used to represent programming logic in visual programming. The work area is used to visually represent the construction process of program content based on the programming blocks.

[0012] The receiving module is configured to receive historical viewing operations for the tool area, wherein the historical viewing operations are used to view the historical programming blocks used when building program content through the work area within a historical time period;

[0013] The display module is also configured to, in response to the history viewing operation, display the history programming blocks used during the history time period.

[0014] In an optional embodiment, the receiving module is further configured to receive a first history viewing operation for the tool area, wherein the first history viewing operation is an operation to view the historical programming blocks used within a first historical time period based on the usage time of the historical programming blocks;

[0015] The display module is also configured to respond to the first history viewing operation by displaying the historical programming blocks used within the first historical time period based on the usage time corresponding to the historical programming blocks within the first historical time period.

[0016] In an optional embodiment, the display module is further configured to, in response to the first history viewing operation, arrange and display the at least one historical programming block based on the usage time corresponding to the at least one historical programming block used within the first historical time period; wherein the first usage time corresponding to the i-th historical programming block is later than the second usage time corresponding to the (i+1)-th historical programming block, and i is a positive integer.

[0017] In an optional embodiment, the receiving module is further configured to receive a second history viewing operation for the tool area, the second history viewing operation being an operation to view the historical programming blocks used within the second historical time period based on the usage frequency of the historical programming blocks;

[0018] The display module is also used to respond to the second history viewing operation and display the historical programming blocks used in the second historical time period based on the usage frequency of the historical programming blocks in the second historical time period.

[0019] In an optional embodiment, the display module is further configured to, in response to the second history viewing operation, arrange and display the at least one historical programming block in order of usage counts corresponding to at least one historical programming block used within the second historical time period; wherein the usage count corresponding to the historical programming block displayed at the j-th position is higher than the usage count corresponding to the historical programming block displayed at the (j+1)-th position, and j is a positive integer.

[0020] In an optional embodiment, the display module is further configured to display the number of times the historical programming block is used in the preset area corresponding to the at least one historical programming block.

[0021] In an optional embodiment, the display module is further configured to, in response to the history viewing operation, highlight a first historical programming block among a plurality of historical programming blocks based on the presence status of the programming blocks in the work area; the first historical programming block is a historical programming block predicted to be selected in the work area based on the programming blocks in the work area.

[0022] In an optional embodiment, the display module is further configured to, in response to the history viewing operation, display the programming block combination used within the history time period, the programming block combination representing at least two historical programming blocks combined in the work area.

[0023] In an optional embodiment, the receiving module is further configured to receive a selection operation on a second historical programming block, the selection operation being used to construct the program content using the second historical programming block within the working area.

[0024] In an optional embodiment, the receiving module is further configured to receive a drag operation that drags the second historical programming block to the work area as the selection operation; or, to receive a specified trigger operation on the second historical programming block as the selection operation.

[0025] In an optional embodiment, the display module is further configured to display a parameter fill box corresponding to the programming block, the parameter fill box being used to fill in block parameter information; and to receive a parameter fill operation for the parameter fill box, the parameter fill operation being used to determine the logic implementation method based on the block parameter information while performing the logical function corresponding to the programming block.

[0026] In an optional embodiment, the display module displays the first programming block in the work area in response to the selection operation; wherein the first programming block is adjusted via the work area.

[0027] In an optional embodiment, the display module is further configured to receive a favorite operation for a second programming block in the work area; and in response to the favorite operation, display the second programming block in the favorites bar.

[0028] In an optional embodiment, the display module is further configured to receive a program execution operation for the programming interface; and in response to the program execution operation, display the execution result of executing the program content.

[0029] On the other hand, a computer device is provided, the computer device including a processor and a memory, the memory storing at least one instruction, at least one program, code set or instruction set, the at least one instruction, the at least one program, the code set or instruction set being loaded and executed by the processor to implement the visual programming operation method as described in any of the above embodiments of this application.

[0030] On the other hand, a computer-readable storage medium is provided, wherein at least one instruction, at least one program, code set, or instruction set is stored therein, wherein the at least one instruction, the at least one program, the code set, or the instruction set is loaded and executed by a processor to implement the visual programming operation method as described in any of the above embodiments of this application.

[0031] On the other hand, a computer program product or computer program is provided, which includes computer instructions stored in a computer-readable storage medium. A processor of a computer device reads the computer instructions from the computer-readable storage medium and executes the computer instructions, causing the computer device to perform any of the visual programming operation methods described in the above embodiments.

[0032] The beneficial effects of the technical solutions provided in this application include at least the following:

[0033] During visual programming, a history view is available in the tool area of ​​the programming interface to display the programming blocks used in building program content within a historical time period. Programming blocks, as the basic units representing programming logic in visual programming, can be selected specifically through the tool area and combined within the work area to represent the program's construction process. Introducing a history view function in the tool area allows users to quickly review the programming blocks used within a historical time period. This facilitates the rapid application of previously used blocks to the work area when they need to be reused, enabling efficient program construction, saving visual programming time, improving efficiency and accuracy, more comprehensively meeting users' programming needs, and enhancing human-computer interaction efficiency. Attached Figure Description

[0034] To more clearly illustrate the technical solutions in the embodiments of this application, 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 this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0035] Figure 1 This is a structural block diagram of an operating system provided in an exemplary embodiment of this application;

[0036] Figure 2 This is a flowchart of a visual programming operation method provided in an exemplary embodiment of this application;

[0037] Figure 3 This is a schematic diagram of a programming interface provided in an exemplary embodiment of this application;

[0038] Figure 4 This is a flowchart of a visual programming operation method provided in another exemplary embodiment of this application;

[0039] Figure 5 This is a schematic diagram of an interface for selecting programming blocks provided in an exemplary embodiment of this application;

[0040] Figure 6 This is a schematic diagram of an interface for constructing program content in a work area using the parameter editing function of programming blocks, provided by an exemplary embodiment of this application.

[0041] Figure 7 This is a schematic diagram of an interface for implementing a history viewing function through a history control, provided in an exemplary embodiment of this application.

[0042] Figure 8 This is a schematic diagram of an interface for displaying historical programming blocks provided in an exemplary embodiment of this application;

[0043] Figure 9 This is a schematic diagram of an interface for displaying programming blocks in a work area, provided by an exemplary embodiment of this application;

[0044] Figure 10 This is a schematic diagram of an interface for triggering the display of recently used control history programming blocks according to an exemplary embodiment of this application;

[0045] Figure 11 This is a schematic diagram of an interface for displaying programming blocks in a work area, provided by another exemplary embodiment of this application;

[0046] Figure 12This is a schematic diagram of an interface for triggering the display of recently used control history programming blocks, provided by another exemplary embodiment of this application;

[0047] Figure 13 This is a schematic diagram of an interface for displaying programming blocks in a work area, provided by yet another exemplary embodiment of this application;

[0048] Figure 14 This is a schematic diagram of an interface for triggering the display of recently used control history programming blocks, provided in another exemplary embodiment of this application.

[0049] Figure 15 This is a schematic diagram of an interface for triggering the display of historical programming blocks using frequently used controls, provided in an exemplary embodiment of this application.

[0050] Figure 16 This is a schematic diagram of an interface for triggering the display of historical programming blocks using frequently used controls, provided in another exemplary embodiment of this application.

[0051] Figure 17 This is a schematic diagram of an interface for triggering the display of historical programming blocks using frequently used controls, provided in another exemplary embodiment of this application.

[0052] Figure 18 This is a schematic diagram of an interface for triggering the display of historical programming blocks using frequently used controls, provided in another exemplary embodiment of this application.

[0053] Figure 19 This is a schematic diagram of an interface for triggering the display of historical programming blocks using a frequently used control, provided in another exemplary embodiment of this application.

[0054] Figure 20 This is a flowchart of a visual programming operation method provided in another exemplary embodiment of this application;

[0055] Figure 21 This is a schematic diagram of an interface for displaying a combination of programming blocks provided in an exemplary embodiment of this application;

[0056] Figure 22 This is a schematic diagram of an interface for highlighting programming blocks provided in an exemplary embodiment of this application;

[0057] Figure 23 This is a schematic diagram of the interface for a collection operation provided in an exemplary embodiment of this application;

[0058] Figure 24 This is a schematic diagram of an interface for displaying saved programming blocks in the favorites bar, provided by an exemplary embodiment of this application.

[0059] Figure 25This is a schematic diagram of an interface for dragging and dropping recently used programming history blocks provided in an exemplary embodiment of this application;

[0060] Figure 26 This is a schematic diagram of an interface for dragging and dropping frequently used historical programming blocks, provided in an exemplary embodiment of this application.

[0061] Figure 27 This is a schematic diagram of the interface of a programming block provided in an exemplary embodiment of this application;

[0062] Figure 28 This is an interactive schematic diagram of a visual programming operation method under a first history viewing operation provided in an exemplary embodiment of this application;

[0063] Figure 29 This is a schematic diagram of a portion of the programming interface for a first history viewing operation provided in an exemplary embodiment of this application;

[0064] Figure 30 This is an interactive schematic diagram of a visual programming operation method under a first history viewing operation provided by another exemplary embodiment of this application;

[0065] Figure 31 This is a schematic diagram of a portion of the programming interface for the first history viewing operation provided in another exemplary embodiment of this application;

[0066] Figure 32 This is an interactive schematic diagram of a visual programming operation method under a first history viewing operation provided in another exemplary embodiment of this application;

[0067] Figure 33 This is a schematic diagram of a portion of the programming interface for the first history viewing operation provided in another exemplary embodiment of this application;

[0068] Figure 34 This is an interactive schematic diagram of a visual programming operation method under a first history viewing operation provided in another exemplary embodiment of this application;

[0069] Figure 35 This is a schematic diagram of a portion of the programming interface for the first history viewing operation provided in yet another exemplary embodiment of this application;

[0070] Figure 36 This is an interactive schematic diagram of a visual programming operation method under a second history viewing operation provided in an exemplary embodiment of this application;

[0071] Figure 37 This is a schematic diagram of a portion of the programming interface for the second history viewing operation provided in an exemplary embodiment of this application;

[0072] Figure 38This is an interactive schematic diagram of a visual programming operation method under a second history viewing operation provided in another exemplary embodiment of this application;

[0073] Figure 39 This is a schematic diagram of a portion of the programming interface for the second history viewing operation provided in another exemplary embodiment of this application;

[0074] Figure 40 This is an interactive schematic diagram of a visual programming operation method under a second history viewing operation provided in another exemplary embodiment of this application;

[0075] Figure 41 This is a schematic diagram of a portion of the programming interface for the second history viewing operation provided in another exemplary embodiment of this application;

[0076] Figure 42 This is an interactive schematic diagram of a visual programming operation method under a second history viewing operation provided in another exemplary embodiment of this application;

[0077] Figure 43 This is a schematic diagram of a portion of the programming interface for the second history viewing operation provided in yet another exemplary embodiment of this application;

[0078] Figure 44 This is a diagram showing the correspondence between the programming interface and the code provided in an exemplary embodiment of this application;

[0079] Figure 45 This is a diagram showing the correspondence between a programming interface and code provided in another exemplary embodiment of this application;

[0080] Figure 46 This is a structural block diagram of a visual programming operation device provided in an exemplary embodiment of this application;

[0081] Figure 47 This is a structural block diagram of a terminal provided in an exemplary embodiment of this application. Detailed Implementation

[0082] To make the objectives, technical solutions, and advantages of this application clearer, the embodiments of this application will be described in further detail below with reference to the accompanying drawings.

[0083] First, a brief introduction to the terms used in the embodiments of this application will be given.

[0084] Visual programming aims to help developers create graphical programming editors. It provides an intuitive interface that allows users to build programs by dragging and connecting various program blocks (building blocks). Each block represents a programming concept or operation, such as loops, conditional statements, mathematical operations, etc. Visual programming typically supports multiple programming languages, such as JavaScript, Python, and Lua. This means users can use the same graphical editor to create programs in different languages ​​and convert them into the corresponding source code.

[0085] The Toolbox is a component in visual programming that contains all available blocks, organized into different categories. Users can drag and drop desired blocks from the toolbar into the toolbox for programming. The Toolbox can be customized to display specific block sets based on actual needs.

[0086] Workspace: Users can drag and drop blocks to build programs within this area. The workspace provides various operations for blocks, such as deleting, modifying, copying, and pasting.

[0087] In related technologies, visual programming environments include a tool area and a workspace. The tool area contains various tools and functions such as events, controls, conditions, and functions. Each tool and function includes corresponding block types. Blocks serve as the basic units in visual programming, allowing users to build programs and learn programming by dragging and dropping blocks from the tool area to the workspace. However, while the current tools and functions cover various programming functions and can help users gain a basic understanding of programming knowledge, they do not fully consider the relationships between multiple blocks in the overall programming process. This makes it difficult for users to effectively summarize and review the programming process, affecting the user experience.

[0088] This application provides a visual programming method that allows users to quickly view historical programming blocks used within a specific time period. This enables the rapid application of these blocks to the workspace for efficient program content construction, improving human-computer interaction efficiency. The visual programming method provided in this application can be applied to various scenarios, including programming initiation, product development, business process automation, robot programming, audio synthesis, and game development. This application does not limit its application to any particular scenario.

[0089] In one optional embodiment, the following description uses the application of visual programming operation methods to a programming enlightenment scenario as an example.

[0090] To illustrate, a company launches a visual programming application aimed at programming beginners. Users can access the application online or download it. Taking user A downloading and using the application via a terminal as an example, after downloading and opening the application, a programming interface is displayed. This interface includes a tool area and a work area. The tool area displays multiple programming blocks representing basic units of programming logic, while the work area visually represents the program's construction process based on these blocks. Later, when the terminal receives a history view operation on the tool area, it can view the historical programming blocks used during program construction within a specific timeframe. These historical blocks are then displayed on the terminal interface. This allows users to quickly achieve their programming goals using these historical blocks, lowering the barrier to entry for beginners and preventing users from losing interest in learning programming due to difficulty finding previously used blocks, thus improving human-computer interaction efficiency.

[0091] In one optional embodiment, the following description uses the application of visual programming to a game development scenario as an example.

[0092] This illustration illustrates how visual programming can simplify the development process and reduce errors in game development, especially when constructing complex program content. Developers use a graphical interface to program, which includes a tool area and a work area. The tool area displays multiple programming blocks representing basic units of programming logic, while the work area visually represents the program's construction process based on these blocks. The tool area provides various programming functions. If a developer performs a history check, they can view the programming blocks used during the construction of program content within a specific timeframe. This historical display of blocks helps developers quickly apply and achieve the desired programming objectives, improving their efficiency in visual programming. It also facilitates interdisciplinary collaboration between developers and team members without programming backgrounds, enriching the application scenarios of visual programming and enhancing human-computer interaction efficiency.

[0093] It should be noted that this application may display prompt interfaces, pop-ups, or output voice prompts before and during the collection of user data. These prompt interfaces, pop-ups, or voice prompts are used to inform the user that their data is being collected. This ensures that the application only begins the steps for collecting user data after receiving confirmation from the user regarding the prompt interface or pop-up; otherwise (i.e., without user confirmation), the steps for collecting user data end, meaning no user data is collected. In other words, all user data collected in this application is collected with the user's consent and authorization, and the collection, use, and processing of related user data must comply with the relevant laws, regulations, and standards of the relevant regions.

[0094] Secondly, the operating system involved in the embodiments of this application will be described. The visual programming operation method provided in the embodiments of this application can be implemented by the terminal alone, by the server, or by the terminal and the server through data interaction. The embodiments of this application do not limit this. Optionally, the method of visual programming operation executed by the interaction between the terminal and the server will be described as an example.

[0095] This is illustrative; please refer to it. Figure 1 The operating system involves a terminal 110 and a server 120, which are connected via a communication network 130.

[0096] In some embodiments, terminal 110 has a visual programming function. Illustratively, terminal 110 itself has a visual programming function; or, terminal 110 has a visual programming function based on a downloaded visual programming application, etc.

[0097] Optionally, visual programming is a feature built into an application, such as a user-generated content (UCG) editor provided within a game application. The UCG editor supports the creation, adjustment, and sharing of custom content (such as virtual maps, virtual scenes, and virtual characters) using objects. The UCG editor aims to lower the barrier to creation while maintaining high-quality output. The UCG editor also has visual programming capabilities, which are designed to help users of the game application create graphical programming editors. These editors can guide users to build program content using programming blocks through an intuitive programming interface.

[0098] This illustration demonstrates that visual programming functionality is implemented through a programming interface. The interface includes multiple interactive functions, allowing users to engage in the visual programming process. These interactive functions include at least one of several, such as selection, zoom in, zoom out, delete, and move. Users can select programming blocks in the interface using the selection function, adjust the size of the blocks using zoom in / out, and adjust the state of the blocks within the interface using delete and move functions. No specific limitations are imposed on the interactive functions described here.

[0099] To illustrate, when the visual programming process is executed on the terminal 110, the corresponding programming interface is displayed, which includes a tool area and a work area.

[0100] The tool area is used to display multiple programming blocks, which are the basic units used to represent programming logic in visual programming. The work area is used to visually represent the construction process of program content based on programming blocks.

[0101] Indicatively, the tool area and the work area are two independent areas displayed on the interface of terminal 110; the tool area can realize various functions in visual programming, and the work area can realize the logical functions corresponding to the programming blocks by applying them individually or in combination.

[0102] In some embodiments, terminal 110 receives a history viewing operation for the tool area.

[0103] The history view operation is used to view the historical programming blocks used when building program content through the work area within a historical time period.

[0104] Indicatively, terminal 110 receives a trigger operation on a specific control in the tool area to perform a history viewing operation; or, terminal 110 receives a specific gesture operation performed in the tool area to perform a history viewing operation.

[0105] Optionally, the historical time period is a preset time period. The historical viewing operation can view the historical programming blocks used when building the program through the work area within the historical time period. The historical programming blocks are the programming blocks used within the historical time period.

[0106] In some embodiments, terminal 110 responds to a history viewing operation by displaying the history programming blocks used within a historical time period.

[0107] Optionally, the terminal 110 can independently query the usage of historical programming blocks by the objects within a historical time period based on the historical viewing operation.

[0108] Optionally, the terminal 110 generates query request information based on historical viewing operations and sends it to the server 120 through the communication network 130, so as to use the server 120 to query the usage of historical programming blocks by the user within a historical time period; the server 120 can feed back the query results of historical programming blocks to the terminal 110.

[0109] Optionally, if programming blocks are not used through the work area during the historical time period, the historical programming blocks may not be displayed on the interface of terminal 110; if programming blocks are used through the work area during the historical time period, the historical programming blocks that have been used will be displayed on the interface of terminal 110.

[0110] It is worth noting that the above are merely illustrative examples, and the embodiments of this application are not limited thereto.

[0111] It is worth noting that the aforementioned terminals include, but are not limited to, mobile terminals such as mobile phones, tablets, portable laptops, smart voice interaction devices, smart home appliances, and in-vehicle terminals, as well as desktop computers; the aforementioned servers can be independent physical servers, server clusters or distributed systems composed of multiple physical servers, or cloud servers that provide basic cloud computing services such as cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communication, middleware services, domain name services, security services, content delivery networks (CDN), and big data and artificial intelligence platforms.

[0112] Cloud technology refers to a hosting technology that unifies hardware, applications, networks, and other resources within a wide area network (WAN) or local area network (LAN) to achieve data computation, storage, processing, and sharing. Based on the cloud computing business model, cloud technology encompasses network technology, information technology, integration technology, management platform technology, and application technology. It can form resource pools, providing flexible and convenient on-demand access.

[0113] In some embodiments, the server described above can also be implemented as a node in a blockchain system.

[0114] Based on the above-mentioned terminology and application scenarios, the operation method of visual programming provided in this application will be explained, taking the application of this method to a terminal as an example. Figure 2 As shown, the method includes the following steps 210 to 230.

[0115] Step 210: Display the programming interface.

[0116] In this illustration, the programming interface is the interface used for visual programming. Optionally, if visual programming is implemented through a webpage, then the programming interface is the webpage interface; or, if visual programming is implemented through an application, then the programming interface is the application's built-in interface, etc.

[0117] Visual programming is a programming method that allows the creation and editing of programs using objects through graphical elements and visual layouts. Unlike traditional text code editing, visual editing makes the logic and flow of program content more intuitive and easier to understand, which helps to quickly understand the program structure.

[0118] The programming interface includes a tool area and a work area.

[0119] In illustrative terms, a programming interface is an interface displayed on a terminal, which includes at least a tool area and a work area.

[0120] Optionally, the work area and the tool area are independent areas; or, the tool area is located within the work area, etc. Optionally, in the programming interface, the work area and the tool area each occupy half of the display area; or, the work area occupies a larger display area and the tool area occupies a smaller display area; or, the work area occupies a smaller display area and the tool area occupies a larger display area, etc. Optionally, the work area and the tool area are areas of the same shape, such as both being rectangular areas; or, the work area and the tool area are areas of different shapes, such as the work area being a rectangular area and the tool area being a circular area, etc. The display method of the work area and the tool area in the programming interface is not limited here.

[0121] The tool area is used to display multiple programming blocks, which are the basic units used to represent programming logic in visual programming.

[0122] In illustrative terms, programming blocks are graphical elements in visual programming. Different programming blocks represent different concepts and operations in programming and are used to implement different logical functions.

[0123] In one optional embodiment, multiple programming blocks correspond to block types, where a block type is the type of logical function implemented in visual programming.

[0124] Alternatively, if a programming block is understood as a data block that encapsulates data execution logic, then the process of applying a programming block is the process of adopting that data execution logic.

[0125] In illustrative terms, the block type corresponding to the programming block is the logical function type corresponding to the data execution logic, such as: mathematical operation logic function corresponding to mathematical operation type programming block, condition judgment logic function corresponding to condition judgment type programming block, string operation logic function corresponding to string operation type programming block, etc.

[0126] Optionally, the programming interface provides programming functions for various application scenarios, such as: programming game programs through the programming interface, i.e., programming in a game application scenario; or programming text reading programs through the programming interface, i.e., programming in a text reading application scenario; or programming social programs through the programming interface, i.e., programming in a social application scenario, etc.

[0127] Optionally, the block type can be either a type set by the platform itself or a type defined by the user in the programming interface. For example, the platform can set basic data types such as numeric and string types; users can add object attribute types (such as name, grade, etc.) before visual programming or add block types during visual programming, etc., without any restrictions here.

[0128] Optionally, programming blocks of corresponding types can be displayed in the programming interface for different application scenarios. The types of blocks displayed may be the same or different in different application scenarios. For example, when performing visual programming for a game scenario, the types of programming blocks displayed are related to game programming; when performing visual programming for a text programming scenario, the types of programming blocks displayed are related to text programming, and so on.

[0129] This example illustrates the platform-defined block types displayed during visual programming of a game scene. When programming a game program through the interface, the various programming blocks displayed include event types, control types, action types, condition types, value types, function types, and variable types. Event types represent specific events (e.g., start game, stop game); control types control the flow of logic (e.g., continue execution, repeat execution); action types control the actions and postures of virtual objects in the game; condition types set conditions during the game (e.g., eliminate a virtual object when its health reaches 0); value types input relevant numerical information (e.g., rotate 45° to the left); function types determine the execution method based on the input numerical information (e.g., perform mathematical operations, string processing); and variable types assist in adjusting and modifying the logic execution process.

[0130] Optionally, when performing visual programming within the game scene, players can also customize the block types of the programming blocks. For illustration, the object the player customizes is a virtual object A, which corresponds to multiple block types including object name, object level, object health, object mana, object faction, and other categories.

[0131] The work area is used to visually represent the construction process of program content based on programming blocks.

[0132] Indicatively, the workspace is used to hold the programming blocks selected by the user in visual programming, allowing the user to drag, drop, group, configure, and adjust the layout of the programming blocks within the workspace. Optionally, the workspace can be implemented as a blank canvas area; or, the workspace can be implemented as a grid-like canvas area, etc.

[0133] like Figure 3 The diagram shows a schematic programming interface, which includes a work area 310 and a tool area 320. The tool area 320 includes multiple block types 321. Based on the selection of block type 321, multiple programming blocks 322 belonging to that block type 321 can be displayed.

[0134] Step 220: Receive historical viewing operations for the tool area.

[0135] As an illustration, the tool area can display multiple programming blocks and also provides a history viewing function. The history viewing function allows you to view the programming blocks used when building program content through the work area within a historical time period.

[0136] Optionally, the historical time period is a pre-defined past period. For example, the historical time period is the past month; or the historical time period is the past week; or the historical time period is the past three days, etc.

[0137] Among them, the history programming blocks are used to represent the programming blocks used when building program content through the work area within a historical time period.

[0138] In some embodiments, visual programming can be implemented through offline operation. When historical programming blocks are displayed based on historical viewing operations, the current terminal can count the programming blocks used by the terminal when building program content through the work area within a historical time period, thereby identifying these programming blocks as historical programming blocks.

[0139] In some embodiments, visual programming can be implemented through online operation. The programming interface is logged in with a first account. When historical programming blocks are displayed based on historical viewing operations, the current terminal can count the programming blocks used by the first account when building program content through the work area within a historical time period, thereby identifying these programming blocks as historical programming blocks. Alternatively, the current terminal can generate a query request based on historical viewing operations and send it to a server (physical server or cloud server). The server can query the programming blocks used by the first account when building program content through the work area within a historical time period as historical programming blocks, and send the block identifiers corresponding to the historical programming blocks to the terminal, so that the terminal can identify historical programming blocks based on the block identifiers, etc.

[0140] Optionally, a history view control exists in the tool area, and the operation triggered by the history view control is regarded as the history view operation; or, the operation triggered by a specific gesture on the tool area is regarded as the history view operation, such as double-clicking a blank area of ​​the tool area is regarded as performing a history view operation.

[0141] Step 230, in response to the history viewing operation, displays the history programming blocks used within the historical time period.

[0142] As an illustration, after determining the historical programming blocks used when building program content through the work area within a historical time period based on the historical viewing operation, the historical programming blocks are displayed on the programming interface.

[0143] Optionally, historical programming blocks can be displayed in the tool area so that users can quickly select previously used historical programming blocks from the tool area for an efficient visual programming process.

[0144] In some embodiments, if visual programming can be implemented offline, the historical programming blocks used when building program content through the current terminal within a historical time period are displayed in response to a history viewing operation.

[0145] In some embodiments, if visual programming can be implemented online, the history of programming blocks used by the first account logged into the programming interface when building program content within a historical time period is displayed in response to a history viewing operation.

[0146] Optionally, if the programming block was not used within the historical time period, then the historical programming block does not exist, meaning that the historical programming block cannot be displayed in response to the history viewing operation.

[0147] Optionally, if programming blocks were used within a historical time period, at least one historical programming block can be obtained based on historical viewing operation statistics, thereby displaying at least one historical programming block in response to historical viewing operations.

[0148] In some embodiments, the historical time period can be based on content customized using objects.

[0149] Optionally, if the object selects the past month as the historical time period, the historical programming blocks used when building program content in the past month can be displayed in response to the history viewing operation; or, if the object selects the past day as the historical time period, the historical programming blocks used when building program content in the past month can be displayed in response to the history viewing operation, etc.

[0150] It is worth noting that the above are merely illustrative examples, and the embodiments of this application are not limited thereto.

[0151] In summary, during the visual programming process, a history viewing function is implemented in the tool area of ​​the programming interface to display the historical programming blocks used when building program content in the workspace within a historical time period. Programming blocks, as the basic units for representing programming logic in visual programming, can be selectively selected through the tool area and combined in the workspace to represent the program content construction process. Introducing a history viewing function in the tool area allows users to quickly review the historical programming blocks used within a historical time period. This facilitates the rapid application of historical programming blocks to the workspace when they need to be reused, achieving an efficient program content construction process, saving visual programming time, improving the efficiency and accuracy of visual programming, more comprehensively meeting the programming needs of users, and enhancing human-computer interaction efficiency.

[0152] In an optional embodiment, the range of historical programming blocks that can be viewed can differ depending on the history viewing operation. For example, a first history viewing operation can view recently used historical programming blocks, while a second history viewing operation can view the most frequently used historical programming blocks. (Illustrative example, such as...) Figure 4 As shown above, Figure 2 The illustrated embodiment can also be implemented as follows: steps 410 to 432.

[0153] Step 410: Display the programming interface.

[0154] The programming interface includes a tool area and a work area. The tool area is used to display multiple programming blocks, which are the basic units used to represent programming logic in visual programming. The work area is used to visually represent the construction process of program content based on programming blocks.

[0155] Indicative, such as Figure 3The diagram shows a schematic of the programming interface, which includes a work area 310 and a tool area 320. The tool area 320 is used to display multiple programming blocks, such as: the programming block "When the game starts" represents the content that makes the game start running, the programming block "When a signal is received" represents the content of the signal received during the game, and the programming block "When the weather changes" represents the process of the weather environment changing in the game, etc.

[0156] In some embodiments, programming blocks belonging to a block type are displayed based on the selection of the block type.

[0157] As an illustration, block types can be divided in a coarse-grained manner or in a fine-grained manner. For example... Figure 3 As shown, when the block type 321 is divided in a coarse-grained manner, multiple block types 321 are obtained, namely event type, control type, action type, condition type, value type, function type, and variable type. When the block type 321 is divided in a fine-grained manner, in addition to the above-mentioned event type, control type, action type, condition type, value type, function type, and variable type, the event type can also include global subtype, interface subtype, player subtype, character subtype, creature subtype, component subtype, special effect subtype, etc.

[0158] In other words, the first-level block types (such as the event type, control type, action type, condition type, value type, function type, and variable type mentioned above) can be displayed in the first-level menu of the tool area. The first-level menu includes second-level menus, which display second-level block types that belong to the first-level block types (such as global subtypes, interface subtypes, player subtypes, character subtypes, creature subtypes, component subtypes, special effects subtypes, etc. that belong to the event type).

[0159] like Figure 3 As shown, the multiple programming blocks 322 displayed in the tool area 320 are programming blocks belonging to the global subtype of the event type.

[0160] In an optional embodiment, a selection operation on a first programming block among a plurality of programming blocks is received; in response to the selection operation, the first programming block is displayed in the work area.

[0161] Indicatively, after displaying multiple programming blocks, a selection operation can be performed on at least one of the multiple programming blocks, where the first programming block is at least one of the multiple programming blocks.

[0162] The selection operation is used to construct program content within the work area using the first programming block.

[0163] Optionally, a drag operation that drags the first programming block to the work area can be received as a selection operation.

[0164] An illustrative drag operation is performed on the first programming block to drag the first programming block from the tool area to the work area, and this drag operation is used as a selection operation on the first programming block.

[0165] like Figure 5 The diagram shows an interface for selecting programming blocks via drag-and-drop operations. The tool area 510 includes multiple programming blocks. Taking the first programming block 511 as an example ("When the game starts"), dragging the first programming block 511 to the work area 520 allows selection of the first programming block 511. Similarly, other programming blocks can be used as the first programming block 511, and selection can be achieved by dragging them.

[0166] Optionally, a specified trigger operation on the first programming block can be received as a selection operation.

[0167] In a schematic way, an object can autonomously select a programming block as the first programming block. The first programming block can be selected by specifying various trigger operations such as double-clicking, single-clicking, and long-pressing.

[0168] In some embodiments, the first programming block corresponding to the selected operation is displayed in the work area.

[0169] As an illustration, while the first programming block is displayed in the work area, it can continue to be displayed in the tool area because the selection of the programming block is repeatable; or, if the selection of the programming block is not repeatable (such as the programming block at the end of the game), the first programming block can be dedisplayed in the tool area.

[0170] like Figure 5 As shown, after selecting the first programming block 511, the first programming block 511 is displayed in the work area 520, while the first programming block 511 continues to be displayed in the tool area 510.

[0171] In this process, the first programming block is adjusted through the work area.

[0172] This is illustrative of the various editing functions available in the work area. The work area allows users to zoom in, zoom out, delete, and perform other editing functions on the selected first programming block. No specific limitations are specified here.

[0173] In an optional embodiment, some programming blocks have parameter editing functions. The parameter editing functions are used to adjust the parameter information corresponding to the programming blocks when applying them, so as to determine the implementation method of the logic while giving full play to the logic function corresponding to the programming blocks.

[0174] In some embodiments, a parameter fill box corresponding to the programming block is displayed; and a parameter fill operation is received for the parameter fill box.

[0175] The parameter filling box is used to fill in the block parameter information; the parameter filling operation is used to determine the logic implementation method based on the block parameter information while performing the corresponding logical function of the programming block.

[0176] In illustrative terms, the parameter editing function of a programming block is implemented through at least one parameter fill box. By filling the parameter fill box, at least one parameter can be entered, allowing the logic implementation method to be determined based on the parameter information while simultaneously utilizing the corresponding logical function of the programming block. For example, programming block 1 includes two parameter fill boxes, used to fill the offset angles in the x-axis and y-axis directions respectively, to locate the orientation of the virtual object in the virtual environment. For instance, filling both the x-axis and y-axis directions with 45° roughly determines that the virtual object is facing northeast in the virtual environment.

[0177] like Figure 6 The image shows a schematic diagram of the interface for building program content within the work area using the parameter editing function of programming blocks.

[0178] The work area 610 includes multiple selected programming blocks, which have a combination relationship. Through the combination process, multiple programming blocks can be constructed into program content. Some programming blocks have parameter fill boxes 620, which can be filled with at least one parameter information, such as numerical information, angle information, text information, etc., based on the custom fill process of the object.

[0179] In addition, below the work area 610 is an editing area 630, which is used to adjust the multiple programming blocks or combinations of multiple programming blocks in the work area 610, such as copying combined programming blocks, inserting other programming blocks, deleting programming blocks or combinations of programming blocks, annotating programming blocks, disabling programming blocks or combinations of programming blocks, etc.

[0180] Step 421: Receive the first history view operation for the tool area.

[0181] As an illustration, the tool area provides a history viewing function to view the historical programming blocks used when building program content through the work area within a historical time period; the history viewing function enables the tool area to receive history viewing operations.

[0182] Optionally, the history viewing function is implemented through a history viewing control in the tool area. The history viewing control is a control that is pre-configured in the tool area. The history viewing operation performed on the tool area is realized by triggering the history viewing control.

[0183] The first history viewing operation is an operation that views the historical programming blocks used within the first historical time period based on the usage time of the historical programming blocks.

[0184] In an optional embodiment, the history viewing function includes two history viewing sub-functions, namely a first history viewing sub-function and a second history viewing sub-function. The first history viewing sub-function can realize the first history viewing operation, which can view the historical programming blocks used when building program content through the work area within a first historical time period, based on the analysis of the usage time of the historical programming blocks.

[0185] Optionally, the first history viewing sub-function is implemented through the first history viewing control, and the first history viewing operation is implemented based on the first trigger operation of the first history viewing control.

[0186] For illustrative purposes, the first historical time period corresponding to the first historical viewing operation is a pre-set time period, such as: the most recent month, the most recent week, the most recent three days, the most recent day, etc.; based on the first historical viewing operation, the historical programming blocks used when constructing program content through the work area within the first historical time period are determined.

[0187] like Figure 7 As shown, the programming interface includes a history control 710, which is used to implement the history viewing function. Under the history control 710, there are recently used controls 711 and frequently used controls 712.

[0188] Among them, the recently used control 711 is the first history viewing control. By triggering the recently used control 711, the first history viewing operation can be realized to view the historical programming blocks used when building program content through the work area in the most recent first historical time period.

[0189] Step 431: In response to the first history viewing operation, display the historical programming blocks used within the first historical time period based on the usage time corresponding to each historical programming block within the first historical time period.

[0190] Indicatively, in response to the first history viewing operation, the programming blocks used when building program content through the work area within the first historical time period are determined, and the programming blocks used within the first historical time period are displayed on the interface as historical programming blocks.

[0191] like Figure 8 As shown, taking the first historical time period as the time period after the start of the current visual programming as an example, if there are no programming blocks in the work area 810 on the left, it means that no programming blocks were used in the first historical time period. Therefore, after triggering the recently used control 821 (first history viewing control), it will be empty in the recently used history list 822.

[0192] In some embodiments, the selected programming block is displayed in the work area based on the selection operation of the programming block.

[0193] like Figure 9 As shown, after selecting the global subtype under the event type, multiple programming blocks belonging to the global subtype are displayed. If the process of dragging the programming block "When the game starts" in the tool area 910 to the work area 920 is regarded as a selection operation of the programming block, then the programming block "When the game starts" can be displayed in the work area 920.

[0194] exist Figure 9 Then it can be displayed as follows Figure 10 The programming interface shown has a programming block "When the game starts" in the left work area 1010, which means that the programming block "When the game starts" was used when building program content through the work area in the most recent first historical time period. Therefore, if the recently used control 1021 (first history viewing control) is triggered, the historical programming block "When the game starts" will be displayed in the recently used history list 1022.

[0195] Optionally, such as Figure 11 As shown, after dragging the programming block "When the game starts" to the work area 1110, if the control subtype under the control type is selected, multiple programming blocks belonging to the control subtype will be displayed in the tool area 1120. At this time, the programming block "Repeat" can also be dragged to the work area 1110 based on the selection of the user object to achieve the selection operation of the programming block "Repeat".

[0196] based on Figure 11 The drag-and-drop operation in the middle can display as follows Figure 12 The interface diagram shown indicates that if the recently used control 1210 (first history view control) is triggered, the historical programming blocks displayed in the recently used history list 1220 include "Repeat Execution" and "When the game starts".

[0197] In an optional embodiment, in response to a first history viewing operation, at least one historical programming block is arranged and displayed based on the usage time corresponding to at least one historical programming block used within a first historical time period.

[0198] Indicatively, based on the first history viewing operation, in addition to determining at least one historical programming block used within the first historical time period, the usage time corresponding to each of the at least one historical programming block used can also be determined. The usage time is used to indicate the time when the selected historical programming block is applied to the work area.

[0199] For example, if programming block 1 is dragged to the work area at 12:36, it is considered that programming block 1 has been selected, programming block 1 is the history programming block 1, and the current usage time corresponding to history programming block 1 is 12:36; if programming block 2 is dragged to the work area at 13:42, it is considered that programming block 2 has been selected, programming block 1 is the history programming block 2, and the current usage time corresponding to history programming block 2 is 13:42, and so on.

[0200] Here, the first usage time corresponding to the i-th historical programming block is later than the second usage time corresponding to the (i+1)-th historical programming block, where i is a positive integer.

[0201] Indicatively, at least one historical programming block is arranged in order of usage time from most recent to oldest, with the most recent historical programming block placed first and the oldest historical programming block placed last, thus displaying at least one historical programming block in order of usage time.

[0202] Optionally, if the same historical programming block is reused in the first historical time period, at least one historical programming block is displayed based on the usage time corresponding to the most recently used historical programming block.

[0203] To illustrate, if a historical programming block is used repeatedly within the first historical time period, then the current historical programming block corresponds to at least two usage times. For example, if historical programming block 1 is used at 12:36 and then used again at 12:38, then historical programming block 1 corresponds to two usage times at 12:36 and 12:38 respectively.

[0204] When displaying at least one historical programming block based on the usage time, if you want to avoid repeatedly displaying the same historical programming block, you can determine the most recent usage time among the at least two usage times corresponding to the historical programming block. For example, if the current time is 12:40, then the most recent usage time corresponding to historical programming block 1 is 12:38. Therefore, the display order of historical programming block 1 is determined based on the usage time of 12:38 when displaying at least two historical programming blocks.

[0205] In other words, when the same programming block is used repeatedly, the most recent usage time is overwritten by the previous usage time of the programming block. That is, the most recent usage time of the programming block is recorded as the order determination condition when displaying historical programming blocks.

[0206] Optionally, such as Figure 13 As shown, after dragging the programming blocks "When the game starts" and "Repeat" to the work area 1310, if the global subtype under the action type is selected, multiple programming blocks belonging to the global subtype will be displayed in the tool area 1320. At this time, based on the selection of the user object, the programming block "Send a custom signal" can also be dragged to the work area 1310 to achieve the selection operation of the programming block "Send a custom signal".

[0207] For illustrative purposes, the programming block "Send Custom Signal" is a programming block with parameter editing function. The parameter editing function is used to adjust the parameter information of the programming block when applying it, so as to determine the implementation method of the logic while giving full play to the logic function of the programming block. After dragging the programming block "Send Custom Signal" to the work area 1310, the parameter fill box 1330 is displayed. The parameter fill box 1330 is used to fill the parameters defined by the user object, or the parameters selected by the user object based on the system configuration, or the default parameters are automatically filled, etc., without limitation here.

[0208] like Figure 13 As shown, if the programming block "Send Custom Signal" is dragged to the work area 1310 twice, two identical programming blocks "Send Custom Signal" will be displayed in the work area 1310. Considering that the dragging process is usually a sequential operation, the two programming blocks "Send Custom Signal" displayed in the work area 1310 correspond to different usage times.

[0209] Optionally, if historical programming blocks are displayed based on the most recent usage time of the programming blocks, their display order will be determined based on the usage time of the programming blocks most recently dragged to the work area.

[0210] like Figure 14 As shown, in Figure 13If the recently used control 1410 (the first history view control) is then triggered, the historical programming blocks displayed in the recently used history list 1420 include "Repeat Execution", "When Game Starts", and "Send Custom Signal". Since "Send Custom Signal" is the last programming block dragged into the workspace, it is ranked first in the recently used history list 1420. Similarly, since "When Game Starts" is the first programming block dragged into the workspace, it is ranked last in the recently used history list 1420. Likewise, since "Repeat Execution" is the second programming block dragged into the workspace, it is ranked in the middle in the recently used history list 1420.

[0211] It is worth noting that the above-described drag-and-drop method for selecting and displaying historical programming blocks is merely an illustrative example, and the embodiments of this application do not limit this.

[0212] Step 422: Receive the second history viewing operation for the tool area.

[0213] As an illustration, the tool area provides a history viewing function, which allows the tool area to receive history viewing operations.

[0214] Optionally, the history viewing function is implemented through a history viewing control in the tool area. The history viewing control is a control that is pre-configured in the tool area. The history viewing operation performed on the tool area is realized by triggering the history viewing control.

[0215] The second history viewing operation is an operation that views the historical programming blocks used within a second historical time period based on the frequency of use of the historical programming blocks.

[0216] In an optional embodiment, the history viewing function includes two history viewing sub-functions, namely a first history viewing sub-function and a second history viewing sub-function. The second history viewing sub-function can realize the second history viewing operation, which can view the historical programming blocks used when building program content through the work area within a second historical time period by analyzing the usage frequency of historical programming blocks.

[0217] Optionally, the second history viewing sub-function is implemented through a second history viewing control, and the second history viewing operation is implemented based on a second trigger operation on the second history viewing control.

[0218] For illustrative purposes, the second historical time period corresponding to the second historical viewing operation is a pre-set time period. The second historical time period and the first historical time period may be the same or different, such as the first historical time period being shorter or longer than the second historical time period. For illustrative purposes, the second historical time period may be the most recent month, the most recent week, the most recent day, the most recent 12 hours, etc.; the historical programming blocks used when constructing program content through the work area within the first historical time period are determined based on the second historical viewing operation.

[0219] like Figure 7 As shown, the programming interface includes a history control 710, which is used to implement the history viewing function. Under the history control 710, there are recently used controls 711 and frequently used controls 712.

[0220] Among them, the frequently used control 712 is the first history viewing control. By triggering the recently used control 712, the second history viewing operation can be realized. Based on the usage frequency of the history programming blocks, the history programming blocks used when building program content through the work area within the second historical time period can be viewed.

[0221] Step 432: In response to the second history viewing operation, display the historical programming blocks used in the second historical time period based on their respective usage frequencies within the second historical time period.

[0222] The usage frequency describes how often the historical programming blocks were used when building program content through the work area during the second historical time period, with each historical programming block corresponding to a usage frequency.

[0223] Indicatively, in response to a second history viewing operation, the programming blocks used when constructing program content through the work area within a second historical time period are determined, and the programming blocks used within the second historical time period are displayed on the interface as historical programming blocks.

[0224] like Figure 15 As shown, taking the second historical time period as the time period after the start of the current visual programming as an example, if there are no programming blocks in the work area 1510 on the left, it means that no programming blocks were used in the second historical time period. Therefore, after triggering the frequently used control 1521 (second history viewing control), it will be empty in the frequently used history list 1522.

[0225] In some embodiments, the selected programming block is displayed in the work area based on the selection operation of the programming block.

[0226] like Figure 9As shown, dragging the programming block "When the game starts" from the tool area 910 to the work area 920 is considered a selection operation of the programming block, and the programming block "When the game starts" can be displayed in the work area 920.

[0227] exist Figure 9 Then it can be displayed as follows Figure 16 The programming interface shown has a programming block "When the game starts" in the left work area 1610, which means that the programming block "When the game starts" was used when building program content through the work area in the most recent second historical time period. Therefore, if the frequently used control 1621 (second history viewing control) is triggered, the historical programming block "When the game starts" will be displayed in the frequently used history list 1622.

[0228] Optionally, such as Figure 11 As shown, the programming block "Repeat" from multiple programming blocks can also be dragged to the work area 1110 to perform the selection operation of the programming block "Repeat".

[0229] based on Figure 11 The drag-and-drop operation in the middle can display as follows Figure 17 The interface diagram shown indicates that if the frequently used control 1710 (second history view control) is triggered, the history programming blocks displayed in the frequently used history list 1720 include "Repeat" and "When the game starts".

[0230] In an optional embodiment, in response to a second history viewing operation, at least one historical programming block is arranged and displayed based on the number of times each historical programming block was used within the second historical time period.

[0231] Optionally, taking the number of uses as the frequency of use as an example, each historical programming block corresponds to a frequency of use. If the frequency of use of historical programming block 1 is 1, it means that historical programming block 1 was used once when building program content through the work area in the second historical time period; if the frequency of use of historical programming block 1 is 3, it means that historical programming block 1 was used 3 times when building program content through the work area in the second historical time period, and so on.

[0232] In illustratively, based on the second history viewing operation, in addition to determining at least one historical programming block used within the second historical time period, it is also possible to determine the number of times each of the at least one historical programming block used is used, and then determine the display order of each of the at least one historical programming block based on the number of times it is used.

[0233] The number of times the historical programming block at position j is used is higher than the number of times the historical programming block at position j+1 is used, where j is a positive integer.

[0234] Indicatively, at least one historical programming block is arranged in descending order of usage frequency, with the historical programming block with higher usage frequency placed first and the historical programming block with lower usage frequency placed last, thus displaying at least one historical programming block based on usage frequency.

[0235] Optionally, if there are historical programming blocks with the same number of uses in the second historical time period, at least one historical programming block is displayed based on the usage time corresponding to the historical programming block.

[0236] To illustrate, if programming block 1 was used twice, programming block 2 was used once, and programming block 3 was used once during the second historical time period, then programming block 1 will be displayed first. The display order of programming block 2 and programming block 3 will be determined according to the usage time of programming block 2 and programming block 3. For example, if programming block 2 was used at 12:38 and programming block 3 was used at 12:40, then programming block 3 will be displayed first, followed by programming block 2. That is, the order of displaying multiple historical programming blocks is: programming block 1, programming block 3, programming block 2.

[0237] In other words, when displaying historical programming blocks based on the second history viewing operation, in addition to considering the number of times they are used, the time of use can also be considered. The number of times they are used has a higher priority, while the time of use has a lower priority. When the number of times they are used is the same, the historical programming blocks are displayed in order of their respective times of use.

[0238] Optionally, such as Figure 13 As shown, dragging the programming block "Send Custom Signal" from multiple programming blocks to the work area 1310 twice will display two identical programming blocks "Send Custom Signal" in the work area 1310. Considering that the dragging process is usually a sequential operation, the two programming blocks "Send Custom Signal" displayed in the work area 1310 correspond to different usage times.

[0239] Optionally, if the historical programming blocks are displayed based on the number of times and the time of use of the programming blocks in response to the second history viewing operation, the historical programming blocks that have been used more times are displayed first; and if the number of times they have been used is the same, the historical programming blocks that have been used more recently are displayed first, thereby achieving the purpose of displaying the historical programming blocks at once.

[0240] like Figure 18 As shown, in Figure 13If frequently used control 1810 (the second history view control) is then triggered, the historical programming blocks displayed in the frequently used history list 1820 include "Send Custom Signal", "Repeat Execution", and "When Game Starts". Since "Send Custom Signal" is used twice, and "Repeat Execution" and "When Game Starts" are both used once, based on the second history view operation, "Send Custom Signal", which is used the most frequently, is ranked first. Then, "Repeat Execution" and "When Game Starts" are analyzed. Since "When Game Starts" is used first, and "Repeat Execution" is used later, "Repeat Execution" was used more recently, and "When Game Starts" was used more distantly. Therefore, based on ranking "Send Custom Signal" first, "Repeat Execution" is ranked second, and "When Game Starts" is ranked third, and so on.

[0241] In some embodiments, when multiple historical programming blocks are arranged and displayed, the number of times each historical programming block is used is displayed in a preset area corresponding to each of the multiple historical programming blocks.

[0242] As an illustration, since the second history viewing operation is based on the number of times the historical programming blocks are used, in addition to displaying multiple historical programming blocks in sequence based on the number of times they are used, the number of times each of the multiple historical programming blocks is used can also be displayed in the preset area corresponding to the historical programming blocks.

[0243] Optionally, the preset area is a pre-defined area, such as the periphery of a historical programming block.

[0244] like Figure 19 As shown, taking the upper right corner of the preset area corresponding to the history programming blocks as an example, based on the trigger operation of the frequently used control 1910 (the second history viewing control), the history programming blocks displayed in the frequently used history list 1920 are "Send Custom Signal", "Repeat Execution", and "When Game Starts". Since "Send Custom Signal" is used 2 times, "2 times" is displayed in the upper right corner of the programming block for "Send Custom Signal". Similarly, "1 time" is displayed in the upper right corner of the programming block for "Repeat Execution", and "1 time" is displayed in the upper right corner of the programming block for "When Game Starts", etc.

[0245] Optionally, the display of usage count can be a custom setting for the object. That is, when the object is selected to display usage count, it will display something like this: Figure 19 The interface shown displays the number of uses; when the user selects to display the number of uses, it will display something like this. Figure 18 The interface shown does not display the number of uses.

[0246] Optionally, in addition to the display of usage counts being customizable, the block categories in the tool area of ​​the programming interface, the hierarchical relationships between block categories and block subcategories, and the editing functions in the work area (such as copy, insert, etc.) are all customizable and are not limited here.

[0247] It is worth noting that the above are merely illustrative examples, and the embodiments of this application are not limited thereto.

[0248] In summary, during the visual programming process, a history viewing function is implemented in the tool area of ​​the programming interface to display the historical programming blocks used when building program content in the workspace within a historical time period. Programming blocks, as the basic units for representing programming logic in visual programming, can be selectively selected through the tool area and combined in the workspace to represent the program content construction process. Introducing a history viewing function in the tool area allows users to quickly review the historical programming blocks used within a historical time period. This facilitates the rapid application of historical programming blocks to the workspace when they need to be reused, achieving an efficient program content construction process, saving visual programming time, improving the efficiency and accuracy of visual programming, more comprehensively meeting the programming needs of users, and enhancing human-computer interaction efficiency.

[0249] This application describes how to display historical programming blocks through different history viewing operations. The first history viewing operation arranges the historical programming blocks according to their usage time, allowing users to quickly find recently used blocks and improving search efficiency. The second history viewing operation arranges the historical programming blocks according to their usage frequency, allowing users to quickly find the most frequently used blocks, avoiding the limitations of relying solely on usage time, increasing the diversity of block display, and improving human-computer interaction efficiency.

[0250] In an optional embodiment, after displaying the history programming blocks, a selection operation can be performed on the history programming blocks to reuse them in the work area. (Illustrative example, such as...) Figure 20 As shown above, Figure 2 The illustrated embodiment can also be implemented as follows: steps 2010 to 2050.

[0251] Step 2010: Display the programming interface.

[0252] The programming interface includes a tool area and a work area. The tool area is used to display multiple programming blocks, which are the basic units used to represent programming logic in visual programming. The work area is used to visually represent the construction process of program content based on programming blocks.

[0253] In some embodiments, selected programming blocks can be combined in the work area. For example, programming block 2 can be combined after programming block 1 so that when the program content is executed subsequently, the logic encapsulated in programming block 2 is executed after the logic encapsulated in programming block 1.

[0254] In some embodiments, annotations can be added to selected programming blocks in the work area to provide a more detailed explanation of the meaning of the current programming block.

[0255] In some embodiments, the work area also provides various editing functions such as undo, clear, and disable, so that users can perform more diverse operations on the programming blocks through the work area.

[0256] Step 2020: Receive historical viewing operations for the tool area.

[0257] The history view operation is used to view the historical programming blocks used when building program content through the work area within a historical time period.

[0258] This is illustrative; a historical time period is a pre-defined period of time in the past. For example, a historical time period might be the past month, the past week, or the past three days.

[0259] In some embodiments, visual programming can be implemented through offline operation. When historical programming blocks are displayed based on historical viewing operations, the current terminal can count the programming blocks used by the terminal when building program content through the work area within a historical time period, thereby identifying these programming blocks as historical programming blocks.

[0260] In some embodiments, visual programming can be implemented through online operation. The programming interface is logged in with a first account. When historical programming blocks are displayed based on historical viewing operations, the current terminal can count the programming blocks used by the first account when building program content through the work area within the historical time period, thereby identifying these programming blocks as historical programming blocks, etc.

[0261] In an optional embodiment, a first history viewing operation targeting the tool area is received as a history viewing operation. The first history viewing operation is an operation to view the historical programming blocks used within a first historical time period based on the usage time of the historical programming blocks.

[0262] In an optional embodiment, a second history viewing operation targeting the tool area is received as a history viewing operation. The second history viewing operation is an operation to view the historical programming blocks used within a second historical time period based on the frequency of use of the historical programming blocks.

[0263] Step 2030: In response to the history viewing operation, display the history programming blocks used within the historical time period.

[0264] Indicatively, historical programming blocks are programming blocks used when program content is built through work areas within a historical time period.

[0265] In some embodiments, the historical time period is a period determined manually by the user object. For example, the user object may manually select the current start time of visual programming as the starting time, and use the time period from the start time to the current time as the historical time period; or, the user object may manually select the most recent day as the historical time period. Differences in the manually configured historical time periods may result in differences in the display of historical programming blocks.

[0266] In an optional embodiment, in response to a first history viewing operation, the historical programming blocks used within the first historical time period are displayed based on the usage time corresponding to each historical programming block within the first historical time period.

[0267] In an optional embodiment, in response to a second history viewing operation, the historical programming blocks used within the second historical time period are displayed based on their respective usage frequencies within the second historical time period.

[0268] In illustrative terms, both the first and second history viewing operations mentioned above are history viewing operations. However, they are differentiated based on different analysis dimensions (the first history viewing operation is based on the usage time dimension, and the second history viewing operation is based on the usage frequency dimension) and the corresponding historical time periods, which results in certain differences in the display range and / or display order of the history programming blocks.

[0269] In some embodiments, in addition to displaying individual historical programming blocks, combinations of historical programming blocks can also be displayed to enable faster programming processes using objects across the work area.

[0270] In an optional embodiment, in response to a history viewing operation, the combination of programming blocks used within a historical time period is displayed.

[0271] Among them, the programming block combination is used to represent at least two historical programming blocks that are combined in the work area.

[0272] Indicative, such as Figure 11As shown, when "When the game starts" and "Repeat" are dragged to the work area 1110, "Repeat" is grouped after "When the game starts", so that "When the game starts" and "Repeat" can be regarded as a programming block combination 1130.

[0273] Optionally, taking the first history viewing operation as an example, such as... Figure 21 As shown, taking the click operation on the recently used control 2110 as the first history viewing operation as an example, in response to the first history viewing operation, in addition to displaying the individual history programming blocks used within the first historical time period in the recently used list 2120, the programming block combination 2140 that has been combined in the work area 2130 will also be displayed.

[0274] In an optional embodiment, in response to a history viewing operation, the first historical programming block among a plurality of historical programming blocks is highlighted based on the presence status of programming blocks in the work area.

[0275] Among them, the first historical programming block is the historical programming block that is predicted to be selected in the working area based on the programming blocks in the working area.

[0276] Schematic, the first historical programming block is at least one of multiple historical programming blocks used when building program content through the workspace within a historical time period. In response to a history viewing operation, in addition to displaying the historical programming blocks used within the historical time period, multiple historical programming blocks are analyzed individually to predict the probability of each historical programming block being selected. The historical programming block with the highest predicted probability is then highlighted to prompt the user to select the highlighted historical programming block.

[0277] Optionally, multiple programming blocks in the working area are multiple historical programming blocks. Based on the code logic encapsulated by each of the multiple historical programming blocks, the program content constructed by integrating multiple code logics in the current working area is determined. The multiple historical programming blocks are analyzed with the goal of making the program content run, thereby predicting the probability of each of the multiple programming blocks being selected.

[0278] Indicative, such as Figure 22As shown, the current workspace contains several historical programming blocks, namely "When the game starts" 2210 and "Repeat" 2220. "When the game starts" 2210 is the code logic that triggers the game to start. In contrast, "Repeat" 2220 is more likely to be reused. Therefore, the predicted probability of "Repeat" 2220 is higher than that of "When the game starts" 2210, which means that the next user is more likely to use "Repeat" 2220. Thus, "Repeat" 2220 can be highlighted to prompt the user to select "Repeat" 2220.

[0279] It is worth noting that the above are merely illustrative examples, and the embodiments of this application are not limited thereto.

[0280] In an optional embodiment, a favorite operation is received for a second programming block in the work area; in response to the favorite operation, the second programming block is displayed in the favorites bar.

[0281] Optionally, the work area displays at least one programming block selected by the object being used, and the second programming block is any one of the at least one programming blocks.

[0282] In illustrative terms, the "favorite" operation is the action of adding a second programming block to the favorites bar, used to help users quickly find saved programming blocks through the favorites bar. Optionally, the favorite operation can be at least one of several triggering operations such as long press, double-click, single click, and drag.

[0283] like Figure 23 As shown, taking a long press operation as a collection operation as an example, the programming blocks included in the working area 2310 are "When the game starts" 2311 and "Repeat execution" 2312; the long press operation on "When the game starts" 2311 in the working area 2310 is received as a collection operation, and "When the game starts" 2311 is the second programming block targeted by the collection operation.

[0284] In response to the favorites action, a second programming block can be displayed in the favorites bar.

[0285] In illustrative terms, the favorites bar can be an independent area within the tool area, an independent area within the work area, or an auxiliary area within the tool area. For example, it can be an additional favorites category added in addition to categories such as history and time to trigger the display of the favorites bar. It can also be a favorites control used to trigger the display of at least one programming block of favorites.

[0286] like Figure 24As shown, taking the collection bar as a subsidiary area of ​​the tool area as an example, an additional collection category 2410 is added in addition to categories such as history and time. The collection bar 2420 is displayed based on the triggered operation of collection category 2410; if... Figure 23 If "When the game starts" is selected as the second programming block to be saved, then "When the game starts" and other similar elements can be displayed in the save bar 2420.

[0287] It is worth noting that the above collection operation and display of the corresponding programming blocks are only illustrative examples. You can also add subcategories such as recently collected and collected in the last three months under the collection category; you can also add a timeline backtracking category to select the programming blocks used at a corresponding time based on the timeline; you can also add a collaboration category to view the programming blocks used when collaborating with other accounts to build program content, etc. There are no limitations here.

[0288] In an optional embodiment, if a first account is logged in on the programming interface, a content sharing operation is received for the programming interface; in response to the content sharing operation, an account selection list is displayed; and based on the selection operation of a second account in the account selection list, the content sharing result is displayed.

[0289] This is illustrative; the programming interface has a primary account logged in, which can be a system account or the application's program account, etc.

[0290] The programming interface features a content sharing function, allowing users to share the currently built program content to other accounts. Optionally, this content sharing function is implemented through a content sharing control, where the triggering action based on the control is considered the content sharing action. Based on the content sharing action, an account selection list can be displayed, containing multiple candidate accounts. These candidate accounts can be friends of the first account, recent contacts of the first account, group accounts, etc., without limitation here.

[0291] Optionally, if a selection operation is performed on the second account in the account selection list, the currently built program content is sent to the second account. This program content can be content that can run normally, content that has not yet been built, or content that has been built incorrectly, etc. The program content is sent to the second account based on the account selection operation, thereby displaying the content sharing result.

[0292] For illustrative purposes, the content sharing result includes either a successful sharing result or a failed sharing result; the content sharing result indicates whether the content of the target program has been successfully sent to the second account.

[0293] Content sharing helps both the first and second accounts work together to build program content, and also encourages the second account to assist the first account in building more comprehensive and accurate program content. In addition, content sharing allows for online sharing of the content building process, enabling more timely sharing of content building progress among multiple parties and improving the efficiency of program content building.

[0294] Step 2040: Receive the selection operation for the second history programming block.

[0295] The selection operation is used to construct program content within the work area using the second history programming blocks.

[0296] As an illustration, after displaying multiple history programming blocks, you can select one of the history programming blocks. The second history programming block is one of the history programming blocks.

[0297] The selection operation is used to construct program content within the work area using the second history programming blocks.

[0298] In an optional embodiment, a drag operation that drags a second history programming block to the work area is received as a selection operation.

[0299] Indicatively, a drag operation is performed on the second history programming block to move it from the tool area to the work area, and this drag operation is used as a selection operation on the second history programming block.

[0300] In some embodiments, in response to a first history viewing operation, the historical programming blocks used within the first historical time period are displayed based on the usage times corresponding to the historical programming blocks within the first historical time period; and a drag operation on a second historical programming block is received as a selection operation.

[0301] like Figure 25 As shown, based on the first history viewing operation, multiple history programming blocks are displayed in the recently used list 2510. These multiple history programming blocks can be dragged to the work area 2520 as second history programming blocks. For example, drag "Repeat" to the work area 2520.

[0302] In some embodiments, in response to a second history viewing operation, the historical programming blocks used within the second historical time period are displayed based on their respective usage frequencies within the second historical time period; and a drag operation on the second historical programming block is received as a selection operation.

[0303] like Figure 26As shown, multiple historical programming blocks are displayed in the frequently used list 2610 based on the second history viewing operation. These historical programming blocks can be dragged into the work area 2620 as second historical programming blocks. For example, "Send Custom Signal" can be dragged into the work area 2620.

[0304] In an optional embodiment, a specified trigger operation on the second historical programming block is received as a selection operation. Illustratively, an object autonomously selects a historical programming block as the second historical programming block. This selection can be achieved through specified trigger operations in various forms, such as double-clicking, single-clicking, and long-pressing, to select the second historical programming block.

[0305] Step 2050: In response to the selection operation, display the second history programming block in the work area.

[0306] Indicatively, a second history programming block can be displayed in the work area based on a selection operation, allowing the second history programming block to participate in the process of building program content.

[0307] In an optional embodiment, a program execution operation is received for the programming interface; in response to the program execution operation, the execution result of the executed program content is displayed.

[0308] This is illustrative; the program execution operation is used to run the program content constructed from multiple programming blocks in the work area. Optionally, the program execution operation can be implemented based on a trigger operation of the execution control; or, the program execution operation can be automatically executed when no new programming blocks exist in the work area within a preset time period, etc., without limitation here.

[0309] The execution result is used to represent the result obtained by executing the program content. Optionally, the execution result is the result of successful execution or execution failure; or, the execution result is the game interface obtained based on the program content; or, the execution result is the result of simulated jump between multiple interfaces, etc., without limitation here.

[0310] It is worth noting that the above are merely illustrative examples, and the embodiments of this application are not limited thereto.

[0311] In summary, during the visual programming process, a history viewing function is implemented in the tool area of ​​the programming interface to display the historical programming blocks used when building program content in the workspace within a historical time period. Programming blocks, as the basic units for representing programming logic in visual programming, can be selectively selected through the tool area and combined in the workspace to represent the program content construction process. Introducing a history viewing function in the tool area allows users to quickly review the historical programming blocks used within a historical time period. This facilitates the rapid application of historical programming blocks to the workspace when they need to be reused, achieving an efficient program content construction process, saving visual programming time, improving the efficiency and accuracy of visual programming, more comprehensively meeting the programming needs of users, and enhancing human-computer interaction efficiency.

[0312] This application describes a selection operation for historical programming blocks to utilize their content. By selecting historical programming blocks, previously used blocks can be quickly reused, improving the efficiency of building program content and facilitating the efficient implementation of the same functions using the same historical blocks. Furthermore, it introduces features such as favorites and content sharing, enabling more diverse functions through the programming interface. This avoids the problem of low programming efficiency caused by relying solely on existing functions, and to some extent overcomes the high barrier to entry in programming, thus improving the efficiency of human interaction.

[0313] In an optional embodiment, the above-described visual programming operation method can also be called "a method for displaying the history of visual programming implementation using building blocks". Visual programming can be implemented through a code editor, or through other technologies such as Scratch and Microsoft MakeCode. When running related technologies, the programming interface of visual programming is displayed, thereby executing the visual programming process based on the programming interface.

[0314] Indicatively, the programming interface in related technologies is implemented as follows: Figure 5 The interface shown is shown below. The right-hand tool area 510, also known as the block toolbar, contains a search function entry 530 and seven primary menus, along with their corresponding secondary menus and block displays. The primary menus include Event, Control, Action, Condition, Value, Function, and Variable, etc. Each primary menu has a corresponding secondary menu containing more specific types of programming blocks. For example, under the Event type, you can find various blocks related to game events, such as "When the game starts" and "When the player wins"; under the Control type, you can find common program control blocks, such as "Repeat" and "Execute Task".

[0315] The left-hand workspace 520 can also be called the block workspace. Users can drag and drop programming blocks within this area to build program content. The block workspace provides various operations for programming blocks, such as adding, deleting, modifying, copying, and pasting. Simultaneously, the block workspace also supports scaling and panning of blocks, facilitating large-scale programming operations using objects.

[0316] As can be seen, in such Figure 5 The visual programming environment shown in the related technologies allows for easy programming operations. However, the programming interface of the aforementioned visual programming does not provide a function to record and display the user's historical use of blocks. When the user wants to find or recall previously used programming blocks, they need to search manually or rely on memory, which can become quite difficult in some cases, especially when the user needs to handle large projects or long-term programming tasks.

[0317] like Figure 6 As shown, if an object wants to implement the function of "displaying different information to the player's screen when different signals are received" in a game by dragging and dropping programming blocks, the programming blocks involved in this function are the same; only the block parameters filled in the programming blocks may differ. Therefore, there are actually many repetitive programming blocks dragged out during the implementation of this function. If the object needs to reuse a previously used programming block during the programming process, it needs to search again in the block toolbar or switch to the corresponding first-level or second-level menu to select the corresponding programming block. This undoubtedly increases the complexity and time cost of visual programming.

[0318] Based on this, this application introduces a history viewing function to record, store, and display the programming blocks that the user has used in the programming process. This makes it easier to quickly find and use recently used or frequently used programming blocks, thereby improving programming efficiency, optimizing user experience, and reducing the risk of misoperation. Both professional programmers and programming beginners can use this method to achieve more efficient and convenient operations when performing visual programming, thus better completing visual programming.

[0319] In an optional embodiment, the technical implementation of receiving the first history viewing operation for the tool area and displaying the history programming blocks based on the usage time corresponding to the history programming blocks within the first historical time period is described.

[0320] Optionally, an array structure can be used to store information about all programming blocks dragged into the workspace. Each time a new programming block is dragged into the workspace using an object, its information—including the block's type and the current timestamp (time of use)—is added to the end of the array. The order of the array elements reflects the order in which each programming block was first dragged into the workspace.

[0321] like Figure 27 As shown, three programming blocks are displayed: "When the game starts" 2710, "Repeat execution" 2720, and "Send a custom signal" 2730.

[0322] Each programming block in the tools area has a corresponding type, for example:

[0323] The programming block "When the game starts" has the type Event_Global_OnGameStart;

[0324] The programming block "Repeat" has the type Control_Global_Reapeat;

[0325] The programming block "Send Custom Signal" has the type Action_Global_SendSignal.

[0326] Optionally, the following approach can be used: An array named `recentBlocks` is defined on the code side, with empty contents. When a new programming block is dragged from the tool area to the workspace, the `recentBlocks` array is checked to see if a programming block of that type already exists. If it doesn't exist, the block's information (including its type and current timestamp) is added to the end of the array; if it does exist, the timestamp is updated to the current timestamp. This ensures that the block information in the `recentBlocks` array is always up-to-date. When a user clicks the "Recently Used" submenu, the `recentBlocks` array is sorted in descending order based on the timestamp. The sorted array is then converted to a block configuration format supported by the tool area and inserted into the corresponding `contents` field, thus displaying the corresponding historical programming blocks in the tool area.

[0327] like Figure 28 , Figure 30 , Figure 32 as well as Figure 34 The diagram shows the interaction diagram corresponding to the first history viewing operation, which involves the object being used, the tool area, the work area, the recently used block array, the sorted array, and the content configuration. The following four operations are shown with reference to the above execution method.

[0328] (I) Operation 1

[0329] like Figure 28 As shown, if the programming block "When the game starts" in the tool area 2820 is dragged to the work area 2830 using object 2810, "When the game starts" will be displayed in the work area 2830. At this time, a block information will be added to the recently used block array 2840. If the recently used block array can be represented as the recentBlocks array, the added block information can be represented as "type = Event_Global_OnGameStart".

[0330] If object 2810 clicks "Recently Used Controls", the tool area 2820 will request to sort the recently used block array 2840. The recently used block array 2840 will be sorted based on the usage time (time stamp) to obtain the sorted array 2850 and store it in the content configuration 2860.

[0331] Content configuration 2860 sends the most recently used blocks to be displayed to tool area 2820, thereby displaying at least one recently used historical programming block in tool area 2820, such as... Figure 29 As shown, the trigger action based on "Recently Used" 2910 is displayed as "When the game starts".

[0332] (II) Operation 2

[0333] like Figure 30 As shown, if the programming block "Repeat" in the tool area 3020 is dragged to the work area 3030 using object 3010, "Repeat" will be displayed in the work area 3030; at this time, a block information will be added to the recently used block array 3040. If the recently used block array can be represented as the recentBlocks array, the added block information can be represented as "type = Control_Global_Repeat".

[0334] If object 3010 clicks "Recently Used Controls", the tool area 3020 will request to sort the recently used block array 3040. The recently used block array 3040 will be sorted based on the usage time (time stamp) to obtain the sorted array 3050 and store it in the content configuration 3060.

[0335] Content configuration 3060 sends the most recently used blocks to be displayed to tool area 3020, thereby displaying at least one recently used historical programming block in tool area 3020, i.e., arranging them as "Repeat" and "When Game Starts", such as... Figure 31As shown, the trigger actions based on "Recently Used" 3110 are arranged to display "Repeated Execution" and "When Game Starts".

[0336] (III) Operation 3

[0337] like Figure 32 As shown, if the programming block "Send Custom Signal" in the tool area 3220 is dragged to the work area 3230 using object 3210, "Send Custom Signal" will be displayed in the work area 3230; at this time, a block information will be added to the recently used block array 3240. If the recently used block array can be represented as the recentBlocks array, the added block information can be represented as "type = Action_Global_SendSignal".

[0338] If object 3210 clicks "Recently Used Controls", the tool area 3220 will request to sort the recently used block array 3240. The recently used block array 3240 will be sorted based on the usage time (time stamp) to obtain the sorted array 3250 and store it in the content configuration 3260.

[0339] Content configuration 3260 sends the most recently used blocks to be displayed to tool area 3220, thereby displaying at least one recently used historical programming block in tool area 3220, such as... Figure 33 As shown, the trigger operations based on "Recently Used" 3310 are arranged as "Send Custom Signal", "Repeat", and "When Game Starts".

[0340] (iv) Operation 4

[0341] like Figure 34 As shown, if the programming block "Send Custom Signal" in the tool area 3420 is dragged again to the work area 3430 using object 3410, another "Send Custom Signal" will be displayed in the work area 3430. At this time, the information of the block will be adjusted in the recently used block array 3440. For example, the recently used block array can be represented as the recentBlocks array. Since the recentBlocks array already has information on a block with type = Action_Global_SendSignal, only the timestamp of the block with type = Action_Global_SendSignal in the recentBlocks array will be updated, that is, updated to the most recent usage time of the programming block.

[0342] If object 3410 clicks "Recently Used Controls", the tool area 3420 will request to sort the recently used block array 3440. The recently used block array 3440 will be sorted based on the usage time (time stamp) to obtain the sorted array 3450 and store it in the content configuration 3460.

[0343] Content configuration 3460 sends the most recently used blocks to be displayed to tool area 3420, thereby displaying at least one recently used historical programming block in tool area 3420, such as... Figure 35 As shown, the trigger operations based on "Recently Used" 3510 are arranged as "Send Custom Signal", "Repeat", and "When Game Starts".

[0344] It is worth noting that the above are merely illustrative examples, and the embodiments of this application are not limited thereto.

[0345] In an optional embodiment, the technical implementation of receiving the second history viewing operation for the tool area and displaying the history programming blocks based on the usage frequency of the history programming blocks within the second historical time period is described.

[0346] Optionally, an object structure can be used to store the usage count information of all programming blocks dragged into the work area. Whenever a new programming block is dragged into the work area using the object, the usage count of that programming block [with the block's type as the key] is incremented in the object. The key-value pairs of the object represent the usage count of each type of programming block in the work area.

[0347] Optionally, the following method can be used: An object named `frequentBlocks` is defined on the code side, with empty content. When a user drags a new programming block from the tool area to the work area, the `frequentBlocks` object checks if a programming block of that type already exists. If it doesn't exist, a key-value pair is added to the `frequentBlocks` object, where the key is the programming block's type, and the value is the drag-in timestamp (usage time) and usage count. If it exists, the value of the corresponding key=type in the `frequentBlocks` object is updated to the latest timestamp and usage count. This ensures that the block information in `frequentBlocks` always maintains the latest usage time and usage count. When a user clicks the "Frequently Used" sub-menu, the programming blocks are sorted in descending order based on the usage count in the `frequentBlocks` object, and an array of block information is output. Then, the sorted array is converted into a block configuration format supported by the tool area and inserted into the corresponding `contents` field, thus arranging and displaying the corresponding historical programming blocks in the tool area.

[0348] like Figure 36 , Figure 38 , Figure 40 as well as Figure 42 The diagram shows the interaction corresponding to the second history viewing operation, which involves the object being used, the tool area, the work area, the recently used block array, the sorted array, and the content configuration. The following four operations are shown with reference to the above execution method.

[0349] (I) Operation 1

[0350] like Figure 36 As shown, if the programming block "When the game starts" in the tool area 3620 is dragged to the work area 3630 using object 3610, "When the game starts" will be displayed in the work area 3630. At this time, a block information will be added to the frequently used block array 3640. For example, the frequently used block array can be represented as a frequentBlocks object. The frequentBlocks object will add a key-value pair indicating that the programming block "When the game starts" is used 1 time in the work area 3630, and record the time of use.

[0351] If object 3610 clicks "Frequently Used Controls", the tool area 3620 will request to sort the frequently used blocks array 3640. The frequently used blocks array 3640 will sort the frequentBlocks objects in descending order based on the number of times they are used, resulting in a sorted array 3650, which will be stored in the content configuration 3660.

[0352] Content configuration 3660 sends frequently used programming blocks that need to be displayed to tool area 3620, thereby displaying at least one frequently used historical programming block in tool area 3620, such as... Figure 37 As shown, the trigger action based on "Frequently Used" 3710 is displayed as "When the game starts".

[0353] (II) Operation 2

[0354] like Figure 38 As shown, if the programming block "Repeat Execution" in the tool area 3820 is dragged to the work area 3830 using object 3810, "Repeat Execution" will be displayed in the work area 3830. At this time, a block information will be added to the frequently used block array 3840. For example, the frequently used block array can be represented as a frequentBlocks object. Then, a key-value pair will be added to the frequentBlocks object to indicate that the "Repeat Execution" programming block has been used 1 time in the work area, and the time of use will be recorded.

[0355] If object 3810 clicks "Frequently Used Controls", the tool area 3820 will request to sort the frequently used blocks array 3840. The frequently used blocks array 3840 will sort the frequentBlocks objects in descending order based on the number of times they are used, resulting in a sorted array 3850, which is then stored in the content configuration 3860.

[0356] Content configuration 3860 sends frequently used blocks that need to be displayed to tool area 3820, thereby displaying at least one frequently used historical programming block in tool area 3820, i.e., arranging "Repeat" and "When Game Starts", such as... Figure 39 As shown, if the number of times "repeated execution" and "when the game starts" are used is 1, "when the game starts" and "repeated execution" can be displayed in a sorted manner based on the trigger operation of "frequently used" 3910; "repeated execution" and "when the game starts" can also be displayed in a sorted manner based on the time of use, without any limitation here.

[0357] (III) Operation 3

[0358] like Figure 40As shown, if the programming block "Send Custom Signal" in the tool area 4020 is dragged to the work area 4030 using object 4010, "Send Custom Signal" will be displayed in the work area 4030. At this time, a block information will be added to the frequently used block array 4040. If the frequently used block array can be represented as a frequentBlocks object, then a key-value pair will be added to the frequentBlocks object to indicate that the "Send Custom Signal" programming block has been used 1 time in the work area, and the time of use will be recorded.

[0359] If object 4010 clicks "Frequently Used Controls", the tool area 4020 will request to sort the frequently used block array 4040. The frequently used block array 4040 will be sorted based on the time of use, resulting in a sorted array 4050, which will be stored in the content configuration 4060.

[0360] Content configuration 4060 sends frequently used blocks that need to be displayed to tool area 4020, thereby displaying at least one frequently used historical programming block in tool area 4020, such as... Figure 41 As shown, if the number of times "repeated execution" and "when the game starts" are used is 1, "when the game starts", "repeated execution" and "send custom signal" can be displayed in a sorted manner based on the trigger operation of "frequently used" 4110; in addition, "send custom signal", "repeated execution" and "when the game starts" can also be displayed in a sorted manner based on the time of use, without limitation here.

[0361] (iv) Operation 4

[0362] like Figure 42 As shown, if the programming block "Send Custom Signal" in the tool area 4220 is dragged again to the work area 4230 using object 4210, another "Send Custom Signal" will be displayed in the work area 4230. At this time, the information of the block will be adjusted in the frequently used block array 4240. For example, the frequently used block array can be represented as a frequentBlocks object. Since the frequentBlocks object already has a key-value pair with type = Action_Global_SendSignal, only the number of times and the time of use of the programming block with type = Action_Global_SendSignal in the frequentBlocks object will be updated.

[0363] If the "Frequently Used Controls" are clicked by object 4210, the tool area 4220 will request the sorting of the frequently used block array 4240. The frequently used block array 4240 will be sorted based on the time of use, resulting in a sorted array 4250 which is stored in the content configuration 4260.

[0364] Content configuration 4260 sends frequently used blocks that need to be displayed to tool area 4220, thereby displaying at least one frequently used historical programming block in tool area 4220, such as Figure 43 As shown, the trigger operations based on "Frequently Used" 4310 are arranged to display "Send Custom Signal", "When Game Starts", and "Repeated Execution"; it is also possible to arrange "Send Custom Signal", "Repeated Execution", and "When Game Starts" in combination with the number of times it is used and the time of use, which is not limited here.

[0365] It is worth noting that the above first and second history viewing operations are merely illustrative examples, and the embodiments of this application do not limit them.

[0366] In an optional embodiment, the correspondence between the display of the programming interface and the code is described, such as... Figure 44 As shown, the event types in the programming interface 4410 have corresponding name definitions in the code interface 4420; the control types and action types in the programming interface 4410 also have corresponding name definitions in the code interface 4420; the global subtypes in the programming interface 4410 have related configuration code in the code interface 4420, etc.

[0367] In an optional embodiment, the correspondence between the display of "Recently Used" and "Frequently Used" in the programming interface and the code information is explained, such as... Figure 45 As shown, the historical types in the programming interface 4510 have corresponding name definitions in the code interface 4520; the "recently used" subtype and "frequently used" subtype in the programming interface 4510 have related configuration code in the code interface 4520, etc.

[0368] It is worth noting that the correspondence between the above code and the display interface is only illustrative and is not limited in this application embodiment.

[0369] In summary, during the visual programming process, a history viewing function is implemented in the tool area of ​​the programming interface to display the historical programming blocks used when building program content in the workspace within a historical time period. Programming blocks, as the basic units for representing programming logic in visual programming, can be selectively selected through the tool area and combined in the workspace to represent the program content construction process. Introducing a history viewing function in the tool area allows users to quickly review the historical programming blocks used within a historical time period. This facilitates the rapid application of historical programming blocks to the workspace when they need to be reused, achieving an efficient program content construction process, saving visual programming time, improving the efficiency and accuracy of visual programming, more comprehensively meeting the programming needs of users, and enhancing human-computer interaction efficiency.

[0370] In this embodiment, two history viewing functions, "Recently Used" and "Frequently Used," are introduced. These functions can update the "Recently Used" and "Frequently Used" block lists in real time based on the usage of programming blocks, ensuring that the block lists are always up-to-date. This allows users to view and use the blocks at any time, avoiding the need to repeatedly search for the required blocks in a large library, thus saving time and improving programming efficiency. It also avoids repeated comparisons among many similar blocks, reducing the process of selecting from a large number of blocks and preventing the incorrect selection of blocks that do not meet the requirements. This reduces the risk of misoperation, improves programming accuracy, and provides users with a more convenient and efficient visual programming experience.

[0371] Figure 46 This is a structural block diagram of a visual programming operation device provided in an exemplary embodiment of this application, such as... Figure 46 As shown, the device includes the following parts:

[0372] Display module 4610 is used to display a programming interface, which includes a tool area and a work area. The tool area is used to display multiple programming blocks, which are the basic units used to represent programming logic in visual programming. The work area is used to visually represent the construction process of program content based on the programming blocks.

[0373] The receiving module 4620 is configured to receive a history viewing operation for the tool area, wherein the history viewing operation is used to view the historical programming blocks used when building program content through the work area within a historical time period;

[0374] Display module 4610 is also configured to, in response to the history viewing operation, display the history programming blocks used during the history time period.

[0375] In an optional embodiment, the receiving module 4620 is further configured to receive a first history viewing operation for the tool area, wherein the first history viewing operation is an operation to view the historical programming blocks used within a first historical time period based on the usage time of the historical programming blocks;

[0376] The display module 4610 is further configured to respond to the first history viewing operation by displaying the historical programming blocks used within the first historical time period based on the usage time corresponding to the historical programming blocks within the first historical time period.

[0377] In an optional embodiment, the display module 4610 is further configured to, in response to the first history viewing operation, arrange and display the at least one historical programming block based on the usage time corresponding to the at least one historical programming block used within the first historical time period; wherein the first usage time corresponding to the i-th historical programming block is later than the second usage time corresponding to the (i+1)-th historical programming block, and i is a positive integer.

[0378] In an optional embodiment, the receiving module 4620 is further configured to receive a second history viewing operation for the tool area, the second history viewing operation being an operation to view the historical programming blocks used within a second historical time period based on the usage frequency of the historical programming blocks;

[0379] The display module 4610 is also configured to respond to the second history viewing operation and display the historical programming blocks used in the second historical time period based on the usage frequency of the historical programming blocks in the second historical time period.

[0380] In an optional embodiment, the display module 4610 is further configured to, in response to the second history viewing operation, arrange and display the at least one historical programming block in order of usage counts corresponding to at least one historical programming block used within the second historical time period; wherein the usage count corresponding to the historical programming block displayed at the j-th position is higher than the usage count corresponding to the historical programming block displayed at the (j+1)-th position, and j is a positive integer.

[0381] In an optional embodiment, the display module 4610 is further configured to display the number of times the historical programming block is used at the preset area corresponding to the at least one historical programming block.

[0382] In an optional embodiment, the display module 4610 is further configured to, in response to the history viewing operation, highlight a first historical programming block among a plurality of historical programming blocks based on the presence status of the programming blocks in the work area; the first historical programming block is a historical programming block predicted to be selected in the work area based on the programming blocks in the work area.

[0383] In an optional embodiment, the display module 4610 is further configured to, in response to the history viewing operation, display a combination of programming blocks used during the historical time period, the combination of programming blocks being used to represent at least two historical programming blocks combined in the work area.

[0384] In an optional embodiment, the receiving module 4620 is further configured to receive a selection operation on a second historical programming block, the selection operation being used to construct the program content using the second historical programming block within the working area.

[0385] In an optional embodiment, the receiving module 4620 is further configured to receive a drag operation that drags the second historical programming block to the work area as the selection operation; or, to receive a specified trigger operation on the second historical programming block as the selection operation.

[0386] In an optional embodiment, the display module 4610 is further configured to display a parameter fill box corresponding to the programming block, the parameter fill box being used to fill in block parameter information; and to receive a parameter fill operation for the parameter fill box, the parameter fill operation being used to determine the logic implementation method based on the block parameter information while performing the logic function corresponding to the programming block.

[0387] In an optional embodiment, the display module 4610 displays the first programming block in the work area in response to the selection operation; wherein the first programming block is adjusted via the work area.

[0388] In an optional embodiment, the display module 4610 is further configured to receive a favorite operation for a second programming block in the work area; and in response to the favorite operation, display the second programming block in the favorites bar.

[0389] In an optional embodiment, the display module 4610 is further configured to receive a program execution operation for the programming interface; and in response to the program execution operation, display the execution result of executing the program content.

[0390] In summary, during the visual programming process, a history viewing function is implemented in the tool area of ​​the programming interface to display the historical programming blocks used when building program content in the workspace within a historical time period. Programming blocks, as the basic units for representing programming logic in visual programming, can be selectively selected through the tool area and combined in the workspace to represent the program content construction process. Introducing a history viewing function in the tool area allows users to quickly review the historical programming blocks used within a historical time period. This facilitates the rapid application of historical programming blocks to the workspace when they need to be reused, achieving an efficient program content construction process, saving visual programming time, improving the efficiency and accuracy of visual programming, more comprehensively meeting the programming needs of users, and enhancing human-computer interaction efficiency.

[0391] It should be noted that the visual programming operation device provided in the above embodiments is only an example of the division of the above functional modules. In actual applications, the above functions can be assigned to different functional modules as needed, that is, the internal structure of the device can be divided into different functional modules to complete all or part of the functions described above. In addition, the visual programming operation device and the visual programming operation method embodiments provided in the above embodiments belong to the same concept, and the specific implementation process can be found in the method embodiments, which will not be repeated here.

[0392] Figure 47 A structural block diagram of an electronic device 4700 provided in an exemplary embodiment of this application is shown. The electronic device 4700 may be a portable mobile terminal, such as a smartphone, in-vehicle terminal, tablet computer, MP3 player (Moving Picture Experts Group Audio Layer III), MP4 player (Moving Picture Experts Group Audio Layer IV), laptop computer, or desktop computer. The electronic device 4700 may also be referred to as a user device, portable terminal, laptop terminal, desktop terminal, or other names.

[0393] Typically, electronic device 4700 includes a processor 4701 and a memory 4702.

[0394] Processor 4701 may include one or more processing cores, such as a quad-core processor, an octa-core processor, etc. Processor 4701 may be implemented using at least one hardware form selected from DSP (Digital Signal Processing), FPGA (Field-Programmable Gate Array), and PLA (Programmable Logic Array). Processor 4701 may also include a main processor and a coprocessor. The main processor, also known as a CPU (Central Processing Unit), is used to process data in the wake-up state; the coprocessor is a low-power processor used to process data in the standby state. In some embodiments, processor 4701 may integrate a GPU (Graphics Processing Unit), which is responsible for rendering and drawing the content required to be displayed on the screen. In some embodiments, processor 4701 may also include an AI (Artificial Intelligence) processor, which is used to handle computational operations related to machine learning.

[0395] Memory 4702 may include one or more computer-readable storage media, which may be non-transitory. Memory 4702 may also include high-speed random access memory and non-volatile memory, such as one or more disk storage devices or flash memory devices. In some embodiments, the non-transitory computer-readable storage media in memory 4702 is used to store at least one instruction, which is executed by processor 4701 to implement the visual programming operation method provided in the method embodiments of this application.

[0396] In some embodiments, the electronic device 4700 further includes one or more sensors. These one or more sensors include, but are not limited to, proximity sensors, gyroscope sensors, and pressure sensors.

[0397] A proximity sensor, also known as a distance sensor, is typically located on the front panel of an electronic device 4700. The proximity sensor is used to detect the distance between the user and the front of the electronic device 4700.

[0398] The gyroscope sensor can detect the orientation and rotation angle of the electronic device 4700. The gyroscope sensor can work in conjunction with the accelerometer sensor to collect 3D motion data from the user on the electronic device 4700. Based on the data collected by the gyroscope sensor, the processor 4701 can perform the following functions: motion sensing (e.g., changing the UI based on the user's tilt), image stabilization during shooting, game control, and inertial navigation.

[0399] A pressure sensor can be installed on the side bezel and / or the lower layer of the display screen of the electronic device 4700. When the pressure sensor is installed on the side bezel of the electronic device 4700, it can detect the user's grip signal on the electronic device 4700, and the processor 4701 can perform left / right hand recognition or quick operation based on the grip signal collected by the pressure sensor. When the pressure sensor is installed on the lower layer of the display screen, the processor 4701 can control the operable controls on the UI interface based on the user's pressure operation on the display screen. Operable controls include at least one of button controls, scroll bar controls, icon controls, and menu controls.

[0400] In some embodiments, the electronic device 4700 also includes other component parts, as those skilled in the art will understand. Figure 47 The structure shown does not constitute a limitation on the electronic device 4700, and may include more or fewer components than shown, or combine certain components, or use different component arrangements.

[0401] Embodiments of this application also provide a computer device that can be implemented as follows: Figure 1 The terminal or server shown. The computer device includes a processor and a memory, the memory storing at least one instruction, at least one program, code set, or instruction set, wherein the at least one instruction, at least one program, code set, or instruction set is loaded and executed by the processor to implement the visual programming operation method provided in the above-described method embodiments.

[0402] Embodiments of this application also provide a computer-readable storage medium storing at least one instruction, at least one program, code set, or instruction set, wherein the at least one instruction, at least one program, code set, or instruction set is loaded and executed by a processor to implement the visual programming operation method provided in the above-described method embodiments.

[0403] Embodiments of this application also provide a computer program product or computer program, which includes computer instructions stored in a computer-readable storage medium. A processor of a computer device reads the computer instructions from the computer-readable storage medium and executes the computer instructions, causing the computer device to perform any of the visual programming operation methods described in the above embodiments.

[0404] Optionally, the computer-readable storage medium may include: read-only memory (ROM), random access memory (RAM), solid-state drives (SSDs), or optical discs, etc. The random access memory may include resistive random access memory (ReRAM) and dynamic random access memory (DRAM). The sequence numbers of the embodiments in this application are merely descriptive and do not represent the superiority or inferiority of the embodiments.

[0405] Those skilled in the art will understand that all or part of the steps of the above embodiments can be implemented by hardware, or by a program instructing related hardware. The program can be stored in a computer-readable storage medium, such as a read-only memory, a disk, or an optical disk. The above descriptions are merely optional embodiments of this application and are not intended to limit the application. Any modifications, equivalent substitutions, or improvements made within the spirit and principles of this application should be included within the scope of protection of this application.

Claims

1. An operation method of visual programming, characterized by, The method includes: The programming interface is displayed, which includes a tool area and a work area. The tool area is used to display multiple programming blocks, which are the basic units used to represent programming logic in visual programming. The work area is used to visually represent the construction process of program content based on the programming blocks. The trigger operation for a specific control in the tool area is received as a history viewing operation, which is used to view the historical programming blocks used when building program content through the work area within a historical time period; In response to the history viewing operation, the historical programming blocks used within the historical time period are arranged and displayed; wherein, the first history viewing operation is used to arrange and display the historical programming blocks used within the first historical time period based on the usage time corresponding to each of the historical programming blocks within the first historical time period; the second history viewing operation is used to arrange and display the historical programming blocks used within the second historical time period based on the usage frequency corresponding to each of the historical programming blocks within the second historical time period.

2. The method of claim 1, wherein, The method further includes: In response to the first history viewing operation, the at least one historical programming block is arranged and displayed based on the usage time corresponding to the at least one historical programming block used within the first historical time period; Here, the first usage time corresponding to the i-th historical programming block is later than the second usage time corresponding to the (i+1)-th historical programming block, where i is a positive integer.

3. The method according to claim 1 or 2, characterized in that, The method further includes: In response to the second history viewing operation, the at least one historical programming block is arranged and displayed based on the number of times it was used within the second historical time period. The number of times the historical programming block at position j is used is higher than the number of times the historical programming block at position j+1 is used, where j is a positive integer.

4. The method of claim 3, wherein, The method further includes: The number of times the historical programming block is used is displayed in the preset area corresponding to each of the at least one historical programming block.

5. The method according to claim 1 or 2, characterized in that, The method further includes: In response to the history viewing operation, based on the existence status of the programming blocks in the work area, the first historical programming block among multiple historical programming blocks is highlighted; the first historical programming block is a historical programming block that is predicted to be selected in the work area based on the programming blocks in the work area.

6. The method of any of claims 1 or 2, wherein, The method further includes: In response to the history viewing operation, the combination of programming blocks used within the historical time period is displayed, the combination of programming blocks being used to represent at least two historical programming blocks combined in the work area.

7. The method according to claim 1 or 2, characterized in that, The method of responding to the history viewing operation by arranging and displaying the historical programming blocks used within the historical time period, further includes: Receive a selection operation on a second history programming block, the selection operation being used to construct the program content using the second history programming block within the work area.

8. The method of claim 7, wherein, The receiving of the selection operation for the second history programming block includes: The selection operation is received by dragging the second historical programming block to the work area.

9. The method of claim 1 or 2, wherein, The method of responding to the history viewing operation by arranging and displaying the historical programming blocks used within the historical time period, further includes: Display the parameter fill box corresponding to the programming block, and the parameter fill box is used to fill in the block parameter information; The parameter filling operation is received for the parameter filling box. The parameter filling operation is used to determine the logic implementation method based on the block parameter information when performing the logic function corresponding to the programming block.

10. The method of claim 1 or 2, wherein, The method further includes: Receive a selection operation for the first programming block among the plurality of programming blocks; In response to the selection operation, the first programming block is displayed in the work area; wherein the first programming block is adjusted through the work area.

11. The method according to claim 1 or 2, characterized in that, The method further includes: Receive a collection operation for the second programming block in the work area; In response to the collection operation, the second programming block is displayed in the collection bar.

12. The method according to claim 1 or 2, characterized in that, The method further includes: Receive program execution commands for the programming interface; In response to the program execution operation, the execution result of the program content is displayed.

13. An operating device for visual programming, characterized in that The device includes: The display module is used to display the programming interface, which includes a tool area and a work area. The tool area is used to display multiple programming blocks, which are the basic units used to represent programming logic in visual programming. The work area is used to visually represent the construction process of program content based on the programming blocks. A receiving module is used to receive trigger operations for specific controls in the tool area as history viewing operations, wherein the history viewing operations are used to view the historical programming blocks used when building program content through the work area within a historical time period; The display module is further configured to respond to the history viewing operation by arranging and displaying the historical programming blocks used within the historical time period; wherein, the first history viewing operation is configured to arrange and display the historical programming blocks used within the first historical time period based on the usage time corresponding to each of the historical programming blocks within the first historical time period; and the second history viewing operation is configured to arrange and display the historical programming blocks used within the second historical time period based on the usage frequency corresponding to each of the historical programming blocks within the second historical time period.

14. A computer device, comprising: The computer device includes a processor and a memory, the memory storing at least one program, which is loaded and executed by the processor to implement the visual programming operation method as described in any one of claims 1 to 12.

15. A computer-readable storage medium, characterized in that, The storage medium stores at least one program segment, which is loaded and executed by a processor to implement the visual programming operation method as described in any one of claims 1 to 12.

16. A computer program product, characterised in that, It includes computer instructions that, when executed by a processor, implement the visual programming operation method as described in any one of claims 1 to 12.

Images