Information processing device, control method for information processing device, program, and storage medium

Abstract

To allow waiting time resulting from time required for processing to be virtually felt in the case of virtually reproducing an operation of application software.SOLUTION: An information processing device according to one embodiment of the present invention comprises: display control means of performing control to display a screen to be displayed by application software; and control means of performing control to display predetermined display content without executing specific processing according to the performance of a specific operation corresponding to an operation for instructing the execution of the specific processing when the screen is displayed, to display a predetermined display item showing the waiting time of processing for a predetermined time before displaying the predetermined display content according to the specific operation and to display the predetermined display content after the display of the predetermined display item.SELECTED DRAWING: Figure 28

Description

Technical Field

[0001] The present invention relates to an information processing apparatus for virtually reproducing the operation of application software, a control method for the information processing apparatus, a program, and a recording medium.

Background Art

[0002] When creating application software for customers, first, by listening to the customer's needs and creating the application software, it is possible to reduce rework and improve development efficiency.

[0003] In particular, different from the internal logic, the screen and operation procedures, etc., operating as per the user's requirements can enhance customer satisfaction.

[0004] Patent Document 1 discloses that while listening to the user's needs, determining the requirements in line with the needs, and simultaneously generating and completing the source code of an application program that can be used for a physical machine on the spot to solve the above problems.

Prior Art Documents

Patent Documents

[0005]

Patent Document 1

Summary of the Invention

Problems to be Solved by the Invention

[0006] Patent Document 1 describes generating mockup files for application software and generating source code for mockup application software that implements mockup screen transitions. However, since the screen transitions of the generated mockup application software are read from a web server, screen transitions take time, making development inefficient in the development environment. On the other hand, if the mockup application software is made into application software that runs only on the client side, it is not easy to reproduce the waiting times such as data communication time and server calculation time that occur during screen transitions in the production environment, because the prototype application software is executed in an environment that does not communicate with a server.

[0007] The objective of the present invention is to virtually reproduce the operation of application software, thereby making the waiting time caused by the processing time also feel virtually real. [Means for solving the problem]

[0008] To solve the above problems, an information processing device according to one embodiment of the present invention includes: a display control means for controlling the display of a screen shown by application software; and a control means for controlling the display of predetermined display content without executing a specific process when a specific operation corresponding to an operation instructing the execution of a specific process is performed while the screen is being displayed, the control means for controlling the display of predetermined display content without executing the specific process, wherein, in response to the specific operation, a predetermined display item indicating a waiting time for processing is displayed for a predetermined time before the predetermined display content is displayed, and thereafter the predetermined display content is displayed. [Effects of the Invention]

[0009] According to the present invention, when virtually reproducing the operation of application software, the waiting time caused by the processing time can also be virtually perceived. [Brief explanation of the drawing]

[0010] [Figure 1] This is a system configuration diagram showing an example of the configuration of the program development device, execution server, database server, and client device of this embodiment. [Figure 2] This block diagram shows an example of hardware configurations applicable to the program development device, execution server, database server, and client device of this embodiment. [Figure 3] This is an example of the software configuration of this embodiment. [Figure 4] This is a functional configuration diagram of the program development device according to this embodiment. [Figure 5] This is a flowchart for generating the prototype application software of this embodiment. [Figure 6] This is a flowchart of the screen definition input acceptance process in this embodiment. [Figure 7] This is a flowchart of the prototype data input acceptance process in this embodiment. [Figure 8] This is a flowchart of the prototype application source code generation process in this embodiment. [Figure 9] This is a flowchart of the processing during execution of the prototype application of this embodiment. [Figure 10] This is an example of the screen display in this embodiment. [Figure 11] This is an example of the screen display in this embodiment. [Figure 12] This is an example of the screen display in this embodiment. [Figure 13] This is an example of the screen display in this embodiment. [Figure 14] This is an example of the screen display in this embodiment. [Figure 15] This is an example of the screen display in this embodiment. [Figure 16] This is an example of the screen display in this embodiment. [Figure 17] This is an example of the screen display in this embodiment. [Figure 18] This is an example of the screen display in this embodiment. [Figure 19]This is an example of a screen display in this embodiment. [Figure 20] This is an example of a screen display in this embodiment. [Figure 21] This is a diagram showing an example of the screen definition 402 in this embodiment. [Figure 22] This is a diagram showing an example of the screen definition 402 in this embodiment. [Figure 23] This is a diagram showing an example of controlling the screen size of the prototype application screen 442 in this embodiment. [Figure 24] This is a diagram showing an example of the screen display of the prototype application screen 442 in this embodiment. [Figure 25] This is a diagram for explaining the relationship between the prototype application screen and the prototype operation panel in this embodiment. [[ID=第十九]] [[ID=第二十]] [Figure 26] [[ID=二十一]]This is a flowchart when the prototype application in this embodiment is executed. [[ID=二十二]] [[ID=二十三]] [Figure 27] [[ID=二十四]]This is a flowchart when the prototype application in this embodiment is executed. [[ID=二十五]] [[ID=二十六]] [Figure 28] [[ID=二十七]]This is a flowchart when the prototype application in this embodiment is executed. [[ID=二十八]] [[ID=二十九]] [Figure 29] [[ID=三十]]This is a flowchart when the prototype application in this embodiment is executed. [[ID=三十一]] [[ID=三十二]] [Figure 30] [[ID=三十三]]This is a diagram showing an example of a device that can be displayed on the browser in this embodiment. [[ID=三十四]] [[ID=三十五]] [Figure 31] [[ID=三十六]]This is an example of a screen display in this embodiment. [[ID=三十七]] [[ID=三十八]] [Figure 32] [[ID=三十九]]This is an example of a screen display in this embodiment. [[ID=四十]] [[ID=四十一]] [Figure 33] [[ID=四十二]]This is an example of a screen display in this embodiment. [[ID=四十三]] [[ID=四十四]] [Figure 34] [[ID=四十五]]This is an example of a screen display in this embodiment. [[ID=四十六]] [[ID=四十七]] [Figure 35] [[ID=四十八]]This is an example of a screen display in this embodiment. [[ID=四十九]] [[ID=五十]] [[ID=五十一]]

Mode for Carrying Out the Invention

[0011] [[ID=五十五]] [[ID=五十六]]Hereinafter, embodiments of the present invention will be described in detail with reference to the drawings.

[0012] <First Embodiment>

[0013] Figure 1 is a system (information processing system) configuration diagram showing an example of the configuration of the program development device (information processing device operated by developers to generate web application software), execution server, database server, and client device in this embodiment.

[0014] The program development device 101 defines screen layouts and database search instructions according to the developer's instructions. The program development device 101 generates application software, including the program.

[0015] In this embodiment, the application software generated by the program development device 101 is web-based application software, but it is not limited to this. It may also be application software that runs on information processing devices such as mobile phones, smartphones, and tablets, or embedded software, and does not necessarily have to be application software that utilizes web-based communication.

[0016] The execution server 102 executes application software (application programs included in the application software) developed by the program development device 101. It can also operate in connection with the database server 103.

[0017] The database server 103 is a database used by the developed application software, and in this embodiment, it may also be used during development for operational verification, etc. For example, for use by developers, the database server 103 may be configured on the same device as the program development device 101 and the execution server 102, or it may be located within a network 105 such as a LAN.

[0018] The client device 104 (information processing device) is an end-user input terminal that operates application programs developed on the program development device 101 in cooperation with the execution server 102. This client device 104 may also be an information processing device such as a mobile phone terminal.

[0019] Furthermore, any one of the program development device 101, execution server 102, database server 103, and client device 104 may be located on the internet, such as in the cloud, or several information processing devices may be housed in a single enclosure.

[0020] Figure 2 is a block diagram showing an example of hardware configurations applicable to the program development device 101, execution server 102, database server 103, and client device 104 of this embodiment.

[0021] In Figure 2, CPU 201 is at least one processor that centrally controls each device connected to the system bus 204.

[0022] Furthermore, the ROM 203 or external memory 211 stores the operating system (OS), which is the control program for the CPU 201, and programs for realizing various functions of the information processing devices, such as servers, clients, and other devices, as described later. The ROM 203 or external memory 211 is at least one memory.

[0023] RAM202 functions as the main memory, work area, and temporary storage area for CPU201.

[0024] The input controller 205 controls the input from the input unit 209. In an information processing device, the input unit 209 may include a keyboard, a pointing device such as a mouse, or a touch panel.

[0025] Furthermore, if the input unit 209 is a touch panel, the user can give various instructions by pressing (touching with a finger, etc.) the icons, cursors, or buttons displayed on the touch panel.

[0026] Furthermore, the touch panel may be a multi-touch screen or other touch panel capable of detecting the positions of multiple fingers touching it.

[0027] The output controller 206 controls the display of the output unit 210. Examples of the output unit 210 include CRTs and liquid crystal displays. It also includes the display of a notebook computer integrated with the main unit. Furthermore, a projector may also be used.

[0028] The external memory controller 207 controls access to the external memory 211, which stores boot programs, various application software, font data, user files, editing files, printer drivers, etc. The external memory 211 stores various tables and parameters for realizing various functions of each server, client device, etc. Examples of this external memory 211 include hard disks (HDs), flexible disks (FDs), CompactFlash® cards connected to PCMCIA card slots via adapters, SmartMedia, etc.

[0029] The CPU 201 enables display on the output unit 210 by, for example, performing outline font expansion (rasterization) processing in the display information area of ​​RAM 202. The CPU 201 also enables developer instructions via a mouse cursor (not shown) on the output unit 210.

[0030] The communication interface controller 208 performs communication control processing with external devices via the network. For example, it can perform communication using TCP / IP.

[0031] The program 212 for implementing this embodiment is stored in external memory 211 and is executed by the CPU 201 when loaded into RAM 202 as needed.

[0032] Figure 3 is an example of a block diagram showing the software configuration of this embodiment.

[0033] The program development device 101 includes the following functional units.

[0034] The definition unit 301 is a functional unit that receives screen definition information from the developer, such as the arrangement of screens and items (input / output items) displayed in the application software, and screen transition definition information that defines the procedure for the application software's screen to transition to the next screen. Specifically, this corresponds to the flowchart in Figure 6 and the explanatory diagrams in Figures 10 to 14.

[0035] The operation control file generation unit 302 is a functional unit that generates a prototype application (operation control file) for virtually reproducing (previewing) the screens defined in the definition unit 301 and the procedures for transitioning between screens. Specifically, this corresponds to the processing in the flowchart shown in Figure 8.

[0036] The data acquisition unit 304 is a functional unit that acquires data from the user to be displayed as items (input / output items) on the prototype application. Specifically, this corresponds to step S706 in Figure 7 and the explanatory diagrams in Figures 15 and 18.

[0037] The operation panel generation unit 305 is a functional unit that generates a prototype operation panel that controls the screen environment and transition methods of the prototype application, and specifically performs the processing shown in S810 in Figure 8. The generated prototype operation panel is the prototype operation panel 3102 shown in Figure 31, etc.

[0038] Figure 4 is a diagram showing the configuration of the program development device 101, the execution server 102, and the client device 104.

[0039] The program development device 101 includes a repository definition unit 400, a prototype application generation unit 410, and a repository definition editor unit 420. In this embodiment, the prototype application differs from application software that searches for data from a database or creates diagrams from calculated data results, as in a production environment. Instead, it is a mock-up application software that displays pre-set values ​​and pre-drawn diagrams, and mimics screen transitions and display changes like actual application software.

[0040] The execution server 102 corresponds to the execution server unit 430 in Figure 4, and the client device 104 includes the client device unit 435.

[0041] The program development device 101 generates source code (prototype application) for software to display the prototype display screen 440 (display screen by the prototype application) using the prototype application generation unit 410. In this embodiment, the term "developer" refers not only to contract developers of application software, but also to a wide range of users of the program development device 101, such as business users and sales representatives.

[0042] The repository definition section 400 stores the application definition 401, screen definition 402, screen component definition 403, screen transition definition 404, actions 405 associated with screen component definition 403, and prototype data 406 associated with action 405. Prototype data refers to the data displayed on the application software screen when the prototype application is executed. It does not involve searching for data from a database or creating diagrams from calculated data results as in a production environment, but rather refers to values ​​and diagrams pre-set by the developer. These definitions 401 to 406 are input, set, or placed by the developer via the application software development tool.

[0043] Application definition 401 holds the overall settings for the application software that the developer is developing.

[0044] The screen definition 402 holds information on various screen component definitions 403 and screen transition definitions 404 that are placed on each screen included in the application software. The screen definition 402 also includes information on actions 405 set for each component and prototype data 406 associated with actions 405.

[0045] The prototype application generation unit 410 analyzes the repository definition unit 400 set by the developer and generates source code for the software (prototype application) to display the prototype display screen 440. After generating the prototype application, it also deploys the source code for the software (prototype application) to the execution server unit 430.

[0046] The repository definition analysis unit 411 analyzes the repository definition unit 400 set by the developer.

[0047] The prototype code generation unit 412 generates source code for the prototype application according to the analysis results of the repository definition analysis unit 411.

[0048] The source code compilation unit 413 compiles the source code generated by the prototype code generation unit 412 and deploys instruction information for displaying the prototype display screen 440, which includes compiled Java® code and HTML / JSP / JavaScript®, to the execution server unit 430.

[0049] The repository definition editor unit 420 is an example of a procedure for a user to configure the repository definition unit 400. The repository definition editor unit 420 includes a screen definition editor unit 421, a screen transition definition editor unit 422, a responsive component control unit 423, an action selection unit 424, and a prototype data input unit 425.

[0050] The screen definition editor section 421 is a graphical editor that allows developers to intuitively create their desired screen layouts.

[0051] The screen transition definition editor section 422 is an editor that allows developers to set properties for each screen component they have placed.

[0052] The responsive component control unit 423 is a functional unit that allows developers to control the display format of screen components (screen layout and component width) according to the client's screen width.

[0053] An example of the responsive component control unit 423 will be explained with reference to Figures 23 and 24.

[0054] Figure 23 is a schematic diagram illustrating the control of the screen size of the prototype application screen 442 in this embodiment.

[0055] For example, as shown in the display example 2300 in Figure 23, the application software generation screen displays toggle buttons to switch between multiple types of client display screens, such as a personal computer (PC) screen button 2301, a tablet screen button 2302, and a smartphone screen button 2303.

[0056] Information 2310 is data that stores the screen size displayed on the client device 104 when the switching button in display example 2300 is pressed. For example, when the PC screen button 2301 is pressed, the displayed screen size is 1920 x 1080 (2311); when the tablet screen button 2302 is pressed, the displayed screen size is 1023 x 1366 (2312); and when the smartphone screen button 2303 is pressed, the displayed screen size is 414 x 896. Examples of the screens displayed depending on which button is pressed will be explained with reference to Figure 24.

[0057] Figure 24 shows an example of the screen display of the prototype application screen 442 of this embodiment.

[0058] For example, in Figure 24, screen area 2402 is an example of a PC screen display, screen area 2403 is an example of a tablet screen display, and screen area 2404 is an example of a smartphone screen display. Screen area 2402 simulates the display screen when the production application program is executed on a PC, and is at least a part of the entire area of ​​the display of the client device 104, and is an area of ​​1920 pixels wide x 1080 pixels high as defined in information 2310 as the PC screen size. Screen area 2403 simulates the display screen when the production application program is executed on a tablet, and is at least a part of the entire area of ​​the display of the client device 104, and is an area of ​​1023 pixels wide x 1366 pixels high x 1080 pixels high as defined in information 2310 as the PC screen size. Screen area 2404 simulates the display screen when the production application program is executed on a smartphone, and is at least a part of the entire area of ​​the display of the client device 104, and is an area of ​​414 pixels wide x 896 pixels high as defined in information 2310 as the smartphone screen size. Each component has a different size; for example, component 2422 (display component) in screen area 2402 representing a PC screen becomes component 2423 in screen area 2403 representing a tablet screen, and component 2424 in screen area 2404 representing a smartphone screen. The responsive component control unit 423 controls the display of the same components 2422, 2423, and 2424 in a predetermined proportion of the total width of each screen area (2402, 2403, and 2404), as shown in Figure 24. That is, on a PC screen, component 2422 occupies 2 / 12 of the total screen area 2402; on a tablet screen, component 2423 occupies 3 / 12 of the total screen area 2403; and on a smartphone screen, component 2424 occupies 6 / 12 of the total screen area 2404. Returning to the explanation of the configuration diagram in Figure 4.

[0059] The action selection unit 424 is a functional unit that selects an action (action event) for the developer to select the action to which prototype data 406 will be set.

[0060] The prototype data input unit 425 is a graphical editor for intuitively setting prototype data 406 associated with a specific action 405.

[0061] The execution server unit 430 (102) is a functional unit that stores instruction information (prototype application) for displaying the prototype display screen 440 generated by the prototype application generation unit 410 and transmits it to the client device 104.

[0062] The prototype display screen 440 is a display screen using a prototype application generated by the prototype application generation unit 410. The prototype display screen 440 is a display screen using a prototype application that allows users such as business users (customer decision-makers) and sales representatives who make proposals to customers to reproduce and display the display content and operation of the application software generated by the program development device 101 during application software development. The prototype display screen 440 includes the prototype operation panel 441 and the prototype application screen 442.

[0063] The prototype operation panel 441 is a module within the prototype display screen 440 that has user interface functionality. It is a panel (screen) that accepts settings from the developer, such as reproduction of the screen size of the client device 104, reproduction of the display image for each user privilege, reproduction of the processing waiting time on the server, and reproduction of the display screen when an error occurs on the server.

[0064] The prototype application screen 442 is an area that reproduces and displays the display content and operation of the application software generated by the program development device 101.

[0065] The client device unit 435 downloads data from the execution server unit 430 to display the prototype display screen 440. The client device unit 435 uses a web browser 450 to display the prototype display screen 440, which is composed of an SPA (Single Page Application).

[0066] Although not shown in the diagram, the system also includes an application code generation unit that generates actual working application code, not just a prototype application. The actual working application code is the code for the production application software. The application code generation unit, using the repository definition analysis unit 411, reads and analyzes the application definition 401, screen definition 402, separately defined database definition, data model definition, and business process definition from the repository definition unit 400. The web application code generation unit uses the code generation rules stored in external memory 211 and the content analyzed by the repository definition analysis unit 411 to generate a web application module including compiled Java® code and HTML / JSP / JavaScript® via the source code compilation unit 413.

[0067] Figure 5 shows an example flowchart for generating a prototype application of a web application software. Note that each step in the flowchart below is executed by the CPU 201 of the program development device 101.

[0068] The flowchart in Figure 5 shows the processing flow initiated by the program development device 101 when a developer attempts to generate a prototype application.

[0069] First, in step S501, the program development device 101 receives a screen definition input. Details of the process in step S501 will be described later with reference to Figure 6.

[0070] Next, in step S502, the program development device 101 determines whether there has been a request for input of prototype data 443. Specifically, it determines whether the display element 1201 (icon) and display element 1202 (selection item) in Figure 12, or the display element 1203 (icon) and display element 1301 (selection item) in Figure 13, which are examples of the action selection unit 424, have been pressed.

[0071] The action control module included in the prototype application controls which prototype data is displayed and at what timing during the execution of the prototype display screen 440, from among multiple prototype data set by the developer. The action control module also controls the actions associated with each action of the components placed on the screen. In other words, prototype data is linked to actions (action events).

[0072] The program development device 101 accepts the press in order to have the developer specify which action the prototype data they are about to input is associated with.

[0073] If it is determined in step S502 that a request for prototype data input has been received, the process proceeds to step S503.

[0074] On the other hand, if there is no request for prototype data input in step S502, the process proceeds to step S504.

[0075] An example of the action selection area when display element 1201 is pressed is shown in display element 1202. Similarly, an example of the action selection area when display element 1203 is pressed is shown in display element 1301. Display element 1301 displays a list of actions included in the currently displayed screen definition, but it may also display a list of actions included in the application definition.

[0076] When the process moves to step S503, the program development device 101 receives prototype data input from the developer. Details of the process in step S503 will be described later with reference to Figure 7. After that, the process moves to step S504.

[0077] In step S504, the program development device 101 determines whether a screen definition save request has been made. If it determines that a screen definition save request has been made, it proceeds to step S505; otherwise, it proceeds to step S506.

[0078] When the process moves to step S505, the program development device 101 saves the screen definition to the repository definition unit 400. Then, the process moves to step S506.

[0079] When the process transitions to step S506, the program development device 101 determines whether a prototype generation request has been made. If it determines that a prototype generation request has been made, the process transitions to step S507. On the other hand, if there is no prototype generation request, the process transitions to step S501.

[0080] When the process moves to step S507, the program development device 101 generates the source code for the prototype application. Details of the process in step S507 will be described later with reference to Figure 7.

[0081] Next, in step S508, the program development device 101 compiles the source code generated in step S507.

[0082] In step S509, the program development device 101 deploys the prototype application compiled in step S508 to the execution server 102 (430).

[0083] From here on, the explanation will be based on an example where the program development device 101, execution server 102, and client device 104 are all operated on the same information processing device. However, if each of these is operated on a separate information processing device, each information processing device will launch its respective application software (such as a prototype application or a web browser) and execute the processing.

[0084] In step S510, the program development device 101 starts the prototype application deployed on the execution server 102.

[0085] In step S511, the program development device 101 launches a web browser and begins accessing the URL of the prototype application. Note that the processes in steps S510 and S511 are examples where the program development device 101 is using both the execution server 102 and the client device 104. If they are in separate enclosures, the process in step S510 will be executed by the execution server 102, and the process in step S511 will be executed by the client device 104.

[0086] This concludes the explanation of Figure 5. Subsequent processing will be described later with reference to Figure 9. In the explanation from Figure 9 onward, the prototype application is described as being executed on the client device 104 with a web browser launched, rather than on the program development device 101. However, it may also be executed on the program development device 101 with a web browser launched, similar to the client device 104.

[0087] Next, the details of the process in step S501 will be explained with reference to Figure 6.

[0088] Figure 6 shows an example of a flowchart for receiving input for the screen definition of a web application software. Note that each step in the following flowchart is executed by the CPU 201 of the program development device 101.

[0089] The flowchart in Figure 6 shows the sequence of processes that begin when the process transitions to step S501 in the flowchart in Figure 5.

[0090] First, in step S601, the program development device 101 accepts the placement of screen components by the developer. Specifically, it accepts the placement of components by drag and drop 1003 from area 1001 (an example of the responsive component control unit 423) to area 1002 (an example of the screen definition editor unit 421) in Figure 10. Figure 10 shows an example of dragging and dropping a button component from the responsive component control unit to the screen definition editor unit. The method of placing screen components is not limited to drag and drop from the responsive component control unit 423 to the screen definition editor unit 421; it may also be a method of moving already placed components or a method of duplicating already placed components by copy and paste. Furthermore, it may be possible to delete components that have been placed once.

[0091] In the case of Figure 10, as shown in Layout Example 1004, a screen (a screen in the generated application software) is created that has two text input fields (an ID input field and a name input field) and a registration button for registering the ID and name.

[0092] Next, in step S602, the program development device 101 determines whether a component containing an action event has been placed. If it determines that a component containing an action event has been placed, it proceeds to step S603; otherwise, it proceeds to step S604.

[0093] When the process transitions to step S603, the program development device 101 registers the actions set for the component that includes the action event. Specifically, it registers the action if the component has an action called onClick in its source code. In the definition information 2100 (source code) in Figure 21, which is an example of screen definition 402, the definition of "actions" 2102 corresponding to the production environment and the definition of "examples" 2103 corresponding to the prototype application are written. In the example in Figure 21, the data storage format is a JSON file as an example of the implementation method, but the data storage format may be a file in another format or a database. After that, the process transitions to step S604.

[0094] Next, in step S604, the program development device 101 determines whether a property input request has been made. Specifically, it determines whether the display element 1101 (icon) in Figure 11, which is an example of a property input request button for a selected component, has been pressed.

[0095] If it is determined that a property input request has been received, the process proceeds to step S605. If no property input request has been received, the screen definition input acceptance process ends.

[0096] When the process transitions to step S605, the program development device 101 accepts input from the developer regarding properties for a screen component. Specifically, it displays the display element 1102 (dialog box) shown in Figure 11, which is an example of a screen property editor, and accepts input for setting the properties of the screen component. In the example in Figure 11, the screen property editor is displayed near the component to enable intuitive operation by the developer, but a specific area within the screen may be reserved as the screen property editor. Alternatively, the screen property editor may be displayed as a modal dialog.

[0097] This concludes the explanation of Figure 6.

[0098] Next, the details of the process in step S503 will be explained with reference to Figure 7.

[0099] Figure 7 shows an example of a flowchart for receiving input of prototype data to be displayed on the screen when generating a prototype application of web application software. Note that each step of the following flowchart is executed by the CPU 201 of the program development device 101.

[0100] The flowchart in Figure 7 shows the sequence of processes that begin when the process transitions to step S503 in the flowchart in Figure 5.

[0101] First, in step S701, the program development device 101 reads the settings for the action items specified by the developer in step S502 in Figure 5. Specifically, it performs the following two actions. First, it defines the arrangement example 1004 in Figure 10, which is an example of the screen component definition 403 of the screen component selected by the developer, and reads the definition 2101 in Figure 21. The data for definition 2101 is assumed to have been input from 1102 in Figure 11 in step S605 of the flowchart in Figure 6. Next, it reads the definition 2102 of “actions” corresponding to the production environment of the screen component selected by the developer, and the definition 2103 of “examples” corresponding to the prototype application.

[0102] Next, in step S702, the program development device 101 determines whether the setting of the action item read in step S701 involves a screen transition. Specifically, it determines whether a value is set in the "nextUi" property (next screen property in 1102), which is an example of a screen transition definition 404 of definition 2101, which is an example of a screen component definition 403. In this embodiment, the program development device 101 stores the screen transition definition 404 in the screen component definition 403, but it may also store it in the action 405.

[0103] If it is determined that the settings of the action item read in step S701 involve a screen transition, the process proceeds to step S703. If the settings of the action item read in step S701 do not involve a screen transition, the process proceeds to step S704.

[0104] When the program transitions to step S703, the program development device 101 displays the destination screen for the screen transition associated with the setting of the action item read in step S701. Specifically, it displays screen 1300 in Figure 13, which is the screen set in "nextUi" of definition 2101. Note that the prototype data display component 1302 of the destination screen in Figure 13 is also assumed to have been set in advance by the developer's operation (step S601). Note that a screen like the prototype data display component 1302 may be displayed by either overwriting the currently displayed screen definition editor unit 421 or by launching a new screen definition editor unit 421.

[0105] The initial display action of the screen (destination screen) displayed in the screen definition editor section 421 is read and set as the action specified by the developer. After this process, the process transitions to step S704.

[0106] In step S704, the program development device 101 displays on the screen the prototype data already set for the action read in S701, or the action read in S703 (for example, if data like the prototype data 2201 in Figure 22 is already set, that data).

[0107] Next, in step S705, the program development device 101 accepts the developer's selection of a prototype data display component. Here, a prototype data display component refers to a component that displays data (prototype data) in advance when running a prototype application. Specifically, this is an example of displaying prototype data in a list, such as the prototype data display component 1302 of the transition destination screen shown in Figure 13, which is displayed in the screen definition editor unit 421. In the prototype data display component 1402 shown in Figure 14, for example, the selection of a prototype data display component can be accepted by right-clicking the mouse (not shown) in the "Name" field and pressing the edit button 1403. Also, as shown in the prototype data display component 1701 in Figure 17, if the entire list is selected and the table input button 1702 is pressed, the entire list of the prototype data display component 1701 can be selected as the prototype data display component.

[0108] In the next step, S706, the program development device 101 accepts prototype data input from the developer. Specifically, it displays the prototype data input dialog 1501 shown in Figure 15, which is an example of the prototype data input unit 425. The prototype data input dialog 1501 is the dialog that is displayed when the edit button 1403 is pressed in the "Name" field in the popup item 1401 shown in Figure 14. In the case of the prototype data input dialog 1501, the developer has entered the prototype data "Noriyuki Tanikawa" in the "Name" field. After the developer enters the value, pressing the "OK" button in the prototype data input dialog 1501 determines whether or not to confirm the input in step S707.

[0109] Furthermore, as another example of step S706, an example of the prototype data input unit 425 will be described with reference to Figure 18.

[0110] The prototype data input dialog 1801 in Figure 18 is a dialog that appears when the table input button 1702 in Figure 17 is pressed. The text input field of the prototype data input dialog 1801 accepts input of data sets to be displayed in the list shown on the prototype data display component 1701. In the case of the prototype data input dialog 1801, the first row contains "(blank)", "Noriyuki Tanikawa", "(blank)", the second row contains "1001", "Ai Hori", "2019 / 10 / 10", and the third row contains "1002", "Ruriko Yamamura", "2019 / 09 / 18". This data input can also be applied by selecting a CSV file or spreadsheet file from a file selection screen (not shown) that appears when the file selection button 1802 is pressed, and then applying the contents of that file.

[0111] After the developer enters a value into the text input field, or after the data is reflected following file selection, pressing the "OK" button 1803 determines whether or not the input in step S707 is confirmed.

[0112] In step S706, the system may accept a locale specification in order to switch the prototype data displayed depending on the language. Furthermore, while the system shows a modal dialog as a method for accepting prototype data input, this input method may also involve directly accepting input for the display components selected by the developer in S705, or it may involve batch input via an external file.

[0113] In the next step, S707, the program development device 101 determines whether the developer has confirmed the input of prototype data. Specifically, it determines whether the "OK" button in the prototype data input dialog 1501 in Figure 15 or the "OK" button 1803 in Figure 18 has been pressed. If direct input to a component is received in the input acceptance method in step S706, the determination is made by whether the focus has been removed from that component.

[0114] If it is determined that the prototype data input has been confirmed (the "OK" button is pressed), the process proceeds to step S708. If it is determined that the prototype data input has not been confirmed, the process proceeds to step S706.

[0115] In step S708, the program development device 101 writes the prototype data entered by the developer to the screen definition 402. Specifically, it writes it to prototype data 2201, which is an example of prototype data 406 associated with action 405 in the screen definition 402.

[0116] However, with this method, it is not possible to change the data displayed on the screen after the transition by the action that is executed. This is because the prototype data is held in the initial display action of the screen after the transition. However, by holding the prototype data to be displayed on the screen after the transition on the side of the action that is executed, it may be possible to change the data displayed on the screen after the transition by the action that is executed. Specifically, by holding the objects under “onLoad” of prototype data 2201 under “onClick” of definition 2103, the original button that transitions to the screen (for example, the “Register” button placed on screen 1000 in Figure 10) may be given the data to be displayed on the screen after the transition.

[0117] In this way, by displaying prototype data on screens that transition between screens for each action event within the prototype application, it is possible to grasp an overview of how the application will function as a mockup before actually creating working application software (for example, searching from a database or creating diagrams from retrieved data). This concludes the explanation of Figure 7.

[0118] Next, the details of the process in step S507 will be explained with reference to Figure 8.

[0119] Figure 8 is an example flowchart illustrating the process of generating source code for a prototype application of a web application software. Each step in the following flowchart is executed by the CPU 201 of the program development device 100.

[0120] The flowchart in Figure 8 shows the sequence of processes that begin when the process transitions to step S507 in the flowchart in Figure 5.

[0121] First, in step S801, the program development device 101 reads the application definition 401 specified by the developer from the repository definition unit 400. The repository definition analysis unit 411 analyzes the read definition and stores it in the ROM 203, and the analyzed definition is referenced as appropriate by each generation unit.

[0122] In step S802, the program development device 101 reads the screen definition 402 included in the application definition 401 read in step S801 from the repository definition unit 400.

[0123] In step S802, when loading the screen definition, information on the display permissions defined for each screen display item is also obtained. This will be explained with reference to the example in Figure 34. In Figure 34, if the row that changes the display item depending on the user's permission is defined as the underlined part 3402, then information linking the user's permission name 821 in the display permission data 820 in Figure 8 and the corresponding input / output display permission item 822 is obtained. The display permission data 820 in Figure 8 is the display permission information defined for "Attendance Confirmation," one of the screen display items included in the screen in Figure 34. In the case of the display permission data 820 in Figure 8, the permission names "User," "Admin," and "Guest" are defined as user permissions, and the input / output display permission items corresponding to each permission name are defined. As input / output permission items, the element items that should be displayed according to the permission are defined from the group of element items (Remarks, Attendance Confirmation (User), Attendance Confirmation (Admin), Update Button) included in the screen display item "Attendance Confirmation" in Figure 34. Furthermore, this display item definition information may also define input / output display permissions (element items that should be displayed according to permissions from the group of element items included in the "Attendance Confirmation" field (Remarks, Attendance Confirmation (User), Attendance Confirmation (Admin), Update button)). Alternatively, this display item definition information may also define input / output display prohibition items (element items that should not be displayed according to permissions from the group of element items included in the "Attendance Confirmation" field (Remarks, Attendance Confirmation (User), Attendance Confirmation (Admin), Update button)). In addition, display permissions may be defined collectively for all display items, or they may be defined individually for each display item, as in display permission data 820.

[0124] In step S803, the program development device 101 reads the screen component definition 403 included in the screen definition 402 read in step S802 from the repository definition unit 400.

[0125] In step S804, the program development device 101 reads the screen transition definition 404 included in the screen definition 402 read in step S802 from the repository definition unit 400.

[0126] In step S805, the program development device 101 collects the permissions (roles) associated with the display items acquired in step S802. For example, it acquires user permission data 830.

[0127] In step S806, the program development device 101 reads the prototype data 406 contained in the screen definition 402 read in step S802 from the repository definition unit 400. The data read here in the screen definition 402 is the "examples" data in Figures 21 and 22, which corresponds to the prototype data, and the "actions" data, i.e., the data for the production environment, is not used. Having these two sets of data makes it possible to create screen definitions for both prototype data and the production environment in a common way, and application software screens created for mockups can be defined directly as application software screens.

[0128] In step S807, the program development device 101 generates source code for the prototype application using the prototype code generation unit 412, based on the information read in steps S801 to S806. The generated source code also includes the source code for the prototype operation panel (such as the prototype operation panel 3102 in Figure 31) that is displayed when the prototype application is started.

[0129] Figure 31 is an example of a prototype display screen (a screen displayed by a prototype application) in this embodiment. Figure 31 is an example of the prototype operation panel displayed on the initial screen when the prototype application is launched according to the source code generated by S807. The prototype operation panel is an operation panel that sets how the prototype application screen 442, which is displayed by the prototype application and mimics the screen transitions of the application software in the production environment, is displayed.

[0130] Referring to Figure 31, the prototype operation panel will be explained. The prototype operation panel 3102 in Figure 31 is a panel screen that receives instructions from the user (for example, a developer demonstrating an application software prototype under development to a customer) for display settings and transition settings when displaying a prototype screen or transitioning between prototype screens. The prototype operation panel 3102 allows settings such as the display device (PC, tablet, smartphone, etc.), the orientation of the display device's screen, user access rights (Admin privileges (administrator privileges) or User privileges (general user privileges), whether or not to display the server processing time, and whether or not to display when an error occurs. Depending on these settings set in response to user operations on the prototype operation panel, the display in the prototype application changes as follows: Specifically, the screen size and orientation change depending on the display device and the orientation of the display device. The content displayed in the prototype application changes depending on the user access rights settings. Whether or not a virtual display of the server processing time is shown changes depending on the setting for whether or not to display the server processing time. Whether or not a virtual display of an error occurs changes depending on the setting for whether or not to display when an error occurs. Display device settings can be configured using display device setting item 3111, user permission settings using permission setting item 3121, processing wait time settings using processing time setting item 3131, and error display settings using error setting item 3141. For example, by pressing (clicking) button 3112 to set the screen size to PC, the display device settings (screen size settings) can be set to PC.

[0131] The relationship between the prototype application screen and the prototype operation panel 3102 when the prototype operation panel 3102 is open will be explained with reference to Figures 25 and 31.

[0132] Figure 25 illustrates the relationship between the prototype application screen and the prototype operation panel.

[0133] The base prototype display screen 2501 is the parent screen displayed in the browser, and the prototype application screen 2502 is displayed within the parent screen using an iframe. Furthermore, the prototype operation panel 2503 (the same as the prototype operation panel 3102 in Figure 31) is displayed superimposed on the prototype application screen 2502, and both a portion of the prototype application screen 2502 and the prototype operation panel 2503 are displayed on the prototype display screen 2501 so that they can be viewed simultaneously.

[0134] The prototype operation panel 3102 (2503) can be hidden, allowing most of the prototype display screen 2501 to be used as the prototype application screen 2502. The prototype operation panel 3102, as shown in Figure 31, accepts user settings. When the user requests, for example, to minimize (hide) the prototype operation panel 3102 (2503) via the minimize icon 3103, the prototype application screen 3201, as shown in Figure 32, which hides the prototype operation panel 3102, is displayed. In this case, it corresponds to the prototype display screen 2521 in Figure 25, and the prototype application screen 3201 in Figure 32 corresponds to the prototype application screen 2502 in Figure 25. To return from the prototype application screen 3201 (2522) to the screen displaying the prototype operation panel 3102 (2503), the user presses button 3202 (2523), which functions as a prototype operation panel display button, to transition to the prototype application screen 3101 in Figure 31, where the prototype operation panel 3102 is displayed. In other words, when the button 3202 (icon 2523 in Figure 25) displayed on the prototype application screen 3201 (prototype application screen 2502 in Figure 25) is operated, the display returns to the state shown in Figure 31 (the display state of the prototype display screen 2501 in Figure 25), and the prototype operation panel 3102 (prototype operation panel 2503 in Figure 25) is redisplayed. Return to the explanation of the flowchart in Figure 8.

[0135] The source code generated in step S807 is TypeScript source code that is started when the prototype operation panel is operated and the browser's memory area (Web Storage or Cookie information) where the operation is stored is changed.

[0136] Next, in step S808, the program development device 101 generates source code to change the screen display according to the user's privileges. The generated source code is the source code for a program that determines user privileges and controls the display and hiding of screen components to which user privileges apply. In other words, step S808 is the process of generating a program to display a prototype screen when user privileges are set.

[0137] In step S809, the program development device 101 generates source code to reproduce the screen display that occurs when connecting to the server. The generated source code is the source code for the program portion that displays the prototype display screen, reflecting the settings made in the processing time setting item 3131 and the error setting item 3141 in the option setting section of the prototype operation panel 3102. This is an example of source code that is executed when a processing time (processing waiting time) value is entered in the processing time setting item 3131, or when the error setting is turned on in the error setting item 3141, and it is a program that displays a prototype screen that reflects the processing settings of the simulated server obtained from the browser's memory. In other words, step S809 is the process of generating a program to reproduce the simulated communication and server status when communicating with the server.

[0138] In step S810, the program development device 101 generates a program to display the prototype application screen 2502 (iFrame) reflecting the settings configured in the display device setting item 3111 of the prototype operation panel 2503 (3102). The generated source code is, for example, TypeScript source code for displaying the prototype application screen 2502 in different sizes and layouts depending on whether the display device setting item 3111 of the prototype operation panel 3102 is set to PC or smartphone.

[0139] The above source code is generated, completing the processing of the flowchart in Figure 8. Note that the source code generated in S807-S810 uses TypeScript as an example, but source code in other languages ​​is also acceptable, including source code written in JavaScript.

[0140] This concludes the explanation of Figure 8.

[0141] Next, the process flow when executing the prototype application deployed in step S509 of Figure 5 and initiating communication with the Web browser (450) of the client device 104 will be explained with reference to Figure 9. Note that, as shown in Figure 5, the Web browser launched in step S511 of the program development device 101 may begin communicating with the deployed prototype display screen application, or, as shown in Figure 9, the Web browser launched on the client device 104 may begin communicating with the deployed execution server 102.

[0142] Figure 9 is a flowchart illustrating an example of the operation in which information for displaying the prototype display screen 440 deployed in step S509 of Figure 5 is downloaded to the client device 104 and executed. Note that each step in the following flowchart is executed by the CPU 201 of the client device 104.

[0143] The flowchart in Figure 9 shows the processing flow that begins when a user accesses the prototype display screen 440 from the web browser 450 of the client device 104, after the prototype display screen 440 has been deployed to the execution server 102 (430).

[0144] In step S901, the client device 104 first reads the browser's locale information. This locale information allows the display language of the prototype data to be switched.

[0145] In step S902, the client device 104 downloads an SPA (Single Page Application) from the execution server 102 (430) on which the prototype display screen (the application software generated in steps S807 to S810 in Figure 8) will run. In this embodiment, the prototype display screen 440 is described as an SPA, but it does not necessarily have to be an SPA. It may also be a specification that communicates with the execution server 102 via screen transition commands, in which case the initial screen information of the prototype application is downloaded.

[0146] Furthermore, in step S902, the client device 104 obtains user permission information from the prototype application.

[0147] Furthermore, in step S902, the client device 104 starts (displays) the prototype display screen 2501 (prototype display screen 440) from the program obtained from the execution server 102 (430). In other words, step S902 is a step in which the process of downloading and starting a program for displaying a screen like the prototype application screen 3101 in Figure 31 is performed.

[0148] In step S903, the client device 104 launches the prototype application screen 2502 in the iFrame section of the prototype display screen 2501. An example of the launched screen is the prototype application screen 3201 in Figure 32. However, in the next step S904, the prototype operation panel 3102 is displayed on top (similar to the relationship between the prototype application screen 2502 and the prototype operation panel 2503 in Figure 25).

[0149] In step S904, the client device 104 activates the prototype operation panel (iFrame) 2503 in the iFrame section of the prototype display screen 2501. As a result, the prototype operation panel 3102 is superimposed on the prototype application screen 3101, as shown in Figure 31. By changing the settings displayed on this prototype operation panel 3102, the display settings and screen transition settings of the prototype application can be controlled.

[0150] In step S905, the client device 104 displays a change to the display screen or transition screen of the prototype application screen 3201 (442) according to the respective settings entered into the prototype operation panel 3102. The process of displaying the prototype display screen 440 or the transition screen according to each setting will be described later in Figures 26 to 29.

[0151] Next, in step S906, the client device 104 either finishes reproducing the application software using the prototype application or waits for instructions from the developer. If it finishes reproducing the application software, it exits this flowchart; if it receives instructions to reproduce it again, it returns to step S902.

[0152] Next, as a detailed explanation of the process in step S905, the flow of the process of changing the display screen or transition screen of the prototype application screen 3201 (442) according to the respective settings entered into the prototype operation panel 3102 will be described with reference to Figures 26 to 29. The processes in Figures 26 to 29 are implemented by a program (i.e., the prototype application) based on the source code generated in the process in Figure 8. The respective settings are the switching of the display device, the change of user privileges, the reproduction of the processing time with the server, and the reproduction of the occurrence of an error.

[0153] Figure 26 is a flowchart showing the processing flow when switching display devices. Note that each step in the flowchart below is executed by the CPU 201 of the client device 104.

[0154] The flowchart in Figure 26 shows the process that begins when a user accesses the client device 104 via the web browser 450 and the SPA (Single Page Application) on the prototype display screen 440 is downloaded to the web browser 450. Note that some of the explanations in Figures 26 to 29 overlap with the explanation in Figure 9.

[0155] The processes in steps S2601 and S2602 are the same as the processes in steps S902 and S903 in Figure 9.

[0156] In step S2603, the client device 104 starts the prototype operation panel (iFrame) 2503 of the iFrame section of the prototype display screen 2501. Up to this point, the process is the same as in step S904 in Figure 9. What follows is a detailed explanation of the process in S905 in Figure 9.

[0157] When the prototype operation panel 3102 is displayed, if the user interacts with the display device setting item 3111 and changes the display device setting (screen size setting), the process transitions to the next step, S2604. The display device setting item 3111 displays various terminals with predefined screen sizes (PC, tablet (portrait), tablet (landscape), smartphone (portrait), smartphone (landscape)) as selectable options. For tablets and smartphones, users can choose to set either portrait or landscape orientation. Both portrait and landscape orientations are available because tablets and smartphones can be controlled to display in either portrait or landscape orientation.

[0158] Returning to the flowchart in Figure 26, when the process transitions to the next step S2604, the client device 104 receives an instruction on the prototype operation panel 3102 to change the screen size of the modified device.

[0159] In step S2605, the client device 104 displays the prototype application screen 2502, adjusting the iFrame portion to the size of the device received in step S2604. Figure 33 shows an example of how the prototype application screen 2502 is displayed when set to smartphone (portrait orientation).

[0160] The prototype application screen 3301 in Figure 33 is displayed within the area 3302, which is smartphone-sized. Even though the screen is displayed at smartphone size, the processing of the prototype application is executed, and for example, when a predetermined button is pressed, the destination screen reflecting the prototype data corresponding to that action can be displayed.

[0161] Through the above process, it is possible to easily create prototype applications with different display formats for each device.

[0162] Next, referring to Figure 27, we will explain the process of changing the screen display when user permissions are changed.

[0163] Figure 27 is a flowchart showing the processing flow when user privileges are switched. Note that each step in the following flowchart is executed by the CPU 201 of the client device 104.

[0164] The flowchart in Figure 27 is a flowchart that starts when a user accesses the client device 104 via the web browser 450 and the SPA of the prototype display screen 440 is downloaded to the web browser 450.

[0165] The processes in steps S2701 and S2702 are the same as the processes in steps S902 and S903 in Figure 9.

[0166] In step S2701, the client device 104 obtains user permission information for the prototype application. An example of the data obtained is user permission data 2710. This data is the same as the user permission data 830 obtained in step S805 when the prototype application was generated.

[0167] In step S2703, the client device 104 starts the prototype operation panel (iFrame) 2503 of the iFrame section of the prototype display screen 2501. Up to this point, the process is the same as in step S904 in Figure 9. The following is a detailed explanation of the process in S905 in Figure 9. Note that among the permission setting items 3121 in Figure 31, the checkbox for setting user permissions is generated based on the user permission data 830 obtained in step S2710.

[0168] If the prototype operation panel 3102 is displayed and the user performs an operation on the permission setting item 3121, and the permission setting is changed, the process will proceed to the next step, S2704.

[0169] When the process transitions to step S2704, the client device 104 stores the value of the permission setting item 3121 that was changed on the prototype operation panel 3102 in the browser's local storage.

[0170] In step S2705, the client device 104 displays the prototype application screen 2502 with the user permission settings stored in step S2704. Figure 34 shows an example of how the prototype application screen 2502 is displayed when the permission setting item 3121 is set to "user".

[0171] Unlike the prototype application screen 3201 in Figure 32, the prototype application screen 3401 in Figure 34 shows a newly added "Attendance Confirmation (User)" field in the area indicated by the underline 3402. This is an image diagram that reflects the input / output permission item data 820 for each user permission obtained in step S802 when the prototype application was generated. In other words, since the permission setting item 3521 has been changed to "user", the permission name (Name) corresponding to "user" in the user permission data 830 is "User", and the input / output permission items for the "User" permission are "Attendance Confirmation (User)" and "Remarks". Therefore, the prototype application screen 3401 in Figure 34 displays the "Attendance Confirmation (User)" field and the "Remarks" field, as indicated by the underline 3402.

[0172] Another example is also explained.

[0173] On the other hand, in the permission setting item 3121 in Figure 31, it is also possible to check all three options: "guest," "user," and "admin." If all three options are checked, according to the data 820 and user permission data 830 in Figure 8, the "Remarks" field, the attendance confirmation (User) field, the attendance confirmation (Admin) field, and the update button are the input / output permitted items.

[0174] Figure 35 shows an example of the display when the permission setting item 3121 is configured to check all three options: "guest," "user," and "admin."

[0175] Unlike the prototype application screen 3201 in Figure 32, the prototype application screen 3501 in Figure 35 has newly added Attendance Confirmation (Admin) and Attendance Confirmation (User) 3503 sections in the underlined area 3502, and also displays an update button 3504 on the right side of the screen.

[0176] The above process has the effect of creating prototype application software that performs screen transitions depending on the user's role. In other words, if prototype application software that only performs normal screen transitions is generated, it will only be able to display predetermined screens or perform predetermined screen transitions, regardless of user privileges. However, in this embodiment, there is a setting for a prototype operation panel that switches user privileges, and it is possible to reproduce the fact that the displayed screen switches according to the user privileges.

[0177] Next, referring to Figure 28, we will explain the process flow for displaying the reproduction of the processing time on the server.

[0178] Figure 28 is a flowchart showing the processing flow when the processing time on the virtual server is changed. Note that each step in the following flowchart is executed by the CPU 201 of the client device 104.

[0179] The flowchart in Figure 28 is a flowchart that starts when a user accesses the client device 104 via the web browser 450 and the SPA of the prototype display screen 440 is downloaded to the web browser 450.

[0180] The processes in steps S2801 and S2802 are the same as the processes in steps S902 and S903 in Figure 9.

[0181] In step S2803, the client device 104 starts the prototype operation panel (iFrame) 2503 of the iFrame section of the prototype display screen 2501. Up to this point, the process is the same as in step S904 in Figure 9. The process from here on is a detailed description of the process in S905 in Figure 9.

[0182] With the prototype operation panel 3102 displayed, if the user interacts with the processing time setting item 3131 and the processing time setting is changed, the process transitions to the next step S2804. The processing time setting item 3131 is a setting field that reproduces the display of screen transitions on the prototype application screen 2502, taking into account the processing time on the server.

[0183] For example, the processing time setting item 3131 on the prototype operation panel 3102 in Figure 31, which is set to "0.2 seconds," can be changed to "2 seconds" according to the user's operation.

[0184] When the process transitions to step S2804, the client device 104 stores the value of the server processing time setting item 3131 (e.g., 2 seconds) that was changed on the prototype operation panel 3902 in the browser's local storage.

[0185] In the next step, S2805, the client device 104 changes the prototype application screen 2502 to a setting that waits for the processing time stored in step S2804, and then modifies the prototype application to proceed to the next screen.

[0186] If the processing time is set to "2 seconds" in the processing time setting item 3131, for example, when the search button 1602 on the prototype application screen 1601 in Figure 16 is pressed, a display item 1902 will be displayed in the center for 2 seconds, as shown in the example display in Figure 19, indicating that the server is processing the request. The duration for which this processing display item 1902 is displayed is the time set in the processing time setting item 3131. After displaying the display item 1902 for the set time, the next destination screen, such as Figure 32, is displayed.

[0187] The above process has the effect of creating prototype application software that virtually reproduces the waiting time during screen transitions. In other words, it can reproduce the processing time that occurs on the server side when the application software (product application) in the production environment is run. For example, when business users or sales representatives demonstrate a prototype application to general users, they can reproduce the processing time with the server that would actually take time, and reproduce what screens are displayed during that processing time with the server. Since this prototype application is composed of a Single Page Application (SPA), actual communication with the server is not required. Therefore, if you simply run the prototype application (screen transitions), there is no processing time, and the prototype application will transition screens one after another according to the user's operation. Because the operation of the application software (product application) in the production environment does not take into account the processing time on the server, general users who are convinced by only seeing a demonstration that does not take into account the processing time on the server may feel a discrepancy in the performance of the developed deliverable. With the demonstration of this embodiment, the server processing time can be freely set, so the risk of discrepancies in the performance of the developed deliverable is reduced. In addition, by displaying the prototype operation panel, the virtual processing time on the server can be changed even while the prototype application is running.

[0188] According to this embodiment, even the display screen of the prototype application (for example, the prototype application screen 1601 in Figure 16) is displayed using the same screen definition information as the application software displayed in the production environment, so that a screen identical to that of the production environment can be displayed.

[0189] In the production environment screen of the application software, when the search button is pressed (clicked), i.e., when an operation to instruct a search is performed, a time-consuming search process is initiated from an internet database based on the search keyword ("self-care"). After the search process is complete, the results based on the search results are displayed.

[0190] On the other hand, in the display screen of the prototype application (for example, Figure 16), when the search button 1602 is pressed (clicked), corresponding to a search instruction operation in the production environment, prototype data, which is predetermined display content, is displayed as shown in Figure 32, without searching a database on the internet or communicating with the internet. The prototype data displayed in Figure 32 is display content that mimics the display based on the results of the search process. At this time, if the processing time setting item 3131 is set to a value greater than zero (i.e., the display item 1902 is set to be displayed), when the search button 1602 is pressed in Figure 16, before transitioning to the display in Figure 32, the display item 1902, which virtually indicates the waiting time for the search process, is displayed for the set time. After that, the display in Figure 32 (display of prototype data, which is predetermined display content) is performed.

[0191] Prototype data is not displayed based on the search results.

[0192] Furthermore, the time for displaying item 1902 is the time set by the user for processing time setting item 3131, and is not related to the time required for the search process. Furthermore, the time taken to display item 1902 is a time to virtually reproduce the time required for the search process.

[0193] Furthermore, if the processing time is set to zero by the processing time setting item 3131, or if the display item 1902 is not displayed, when the search button 1602 is pressed in Figure 16, the display will transition directly from Figure 16 to Figure 32 without displaying the display item 1902. In this case, there is no waiting period.

[0194] Furthermore, in the prototype application screen, if an operation corresponding to an instruction to execute a process that takes longer than the search process (for example, image processing) is performed (for example, clicking the "Image Processing Button (not shown)"), the display item 1902 may be displayed for a longer time than the time set by the processing time setting item 3131, so that the user can experience that the process takes longer (the waiting time increases). For example, the display item 1902 may be displayed for 5 seconds longer than the time set by the processing time setting item 3131. After that, predetermined display content that mimics the display of the image processing execution result is displayed. In this case as well, since it is a prototype application, the image processing is not executed.

[0195] Next, referring to Figure 29, we will explain the process flow for displaying the reproduction of errors that occur on the server or communication errors.

[0196] Note that each step in the following flowchart is executed by the CPU 201 of the client device 104.

[0197] The flowchart in Figure 29 is a flowchart that starts when a user accesses the client device 104 via the web browser 450 and the SPA of the prototype display screen 440 is downloaded to the web browser 450.

[0198] The processes in steps S2901 and S2902 are the same as the processes in steps S902 and S903 in Figure 9.

[0199] In step S2903, the client device 104 starts the prototype operation panel (iFrame) 2503 of the iFrame section of the prototype display screen 2501. Up to this point, the process is the same as in step S904 in Figure 9. What follows is a detailed explanation of the process in S905 in Figure 9.

[0200] If the prototype operation panel 3102 is displayed and the user performs an action on the error setting item 3141, changing the setting for the occurrence of a virtual error from "off" to "on", the process will proceed to the next step, S2904.

[0201] When the process transitions to step S2904, the client device 104 stores the "on" value of the error setting item 3141, which was changed on the prototype operation panel, as the error setting state in the browser's local storage.

[0202] In step S2905, the client device 104 retrieves the error setting status stored in step S2904 from the prototype application screen 2502.

[0203] Next, the system receives a screen transition instruction from the user on the prototype application screen. In the case of Figure 16, a screen transition instruction is received when the search button 1602 is pressed (clicked). Upon receiving the screen transition instruction, the process proceeds to the next step S2806.

[0204] In the next step, S2906, the client device 104 divides the process depending on whether the acquired error setting status is on (enabled) or off (disabled). If the error setting status is on, the process transitions to step S2907; if the error setting status is off, the process transitions to step S2908. Upon transitioning to step S2908, since the error setting status was off, the client device 104 transitions to Figure 32, which is the normal transition screen of the prototype application.

[0205] On the other hand, when the process transitions to step S2907, the client device 104 proceeds with processing assuming that an error has occurred in the prototype application. Specifically, it transitions from the screen in Figure 16 to the screen in Figure 20.

[0206] Figure 20 shows Error Notification 2002 as the error message displayed when an error occurs during processing by pressing the search button 1602. Error Notification 2002 includes a warning icon and the message "An error occurred during server processing."

[0207] Through the above process, it is possible to create a prototype application that can virtually reproduce the error screen that appears when a screen transition fails. In other words, it is possible to virtually reproduce errors that occur on the server side or during communication when running the application software (product application) in the production environment. Since this prototype application is composed of a Single Page Application (SPA), actual communication with the server is not required. Therefore, if you simply run the prototype application (screen transitions), no server errors or communication errors will occur. The need of developers and general users to reproduce the display screen when an error occurs can be fulfilled with an SPA. Furthermore, as a method to reproduce the error display more realistically, it is combined with the reproduction of a virtual processing time on the server, as shown in Figure 28.

[0208] As the prototype display screen described above is composed of a Single Page Application (SPA) that can be launched within the browser of various devices, by downloading the generated prototype application, as shown in the prototype display screen 2501 in Figure 30, to a PC or tablet, the prototype application screen 2502 can be reproduced on each device. For example, by downloading the prototype application to tablet 3001, the prototype operation panel 2503 and prototype application screen 2502 can be operated on the tablet. Sales representatives can run the prototype display screen application on a tablet without having to bring a PC. The prototype application that reproduces the processing time on the server can also be run on a tablet, and the display on the tablet (3002) can reproduce the display at smartphone size (3003). Therefore, when demonstrating to customers, bringing just one device allows for the reproduction of screens displayed on any device and the patterns of screen transitions.

[0209] As described above, it goes without saying that the object of the present invention can also be achieved by supplying a recording medium containing a program that realizes the functions of the embodiments described above to a system or device, and by having the computer (or CPU or MPU) of that system or device read and execute the program stored on the recording medium.

[0210] In this case, the program read from the recording medium itself realizes the novel function of the present invention, and the recording medium on which that program is recorded constitutes the present invention.

[0211] For recording media used to supply programs, examples include flexible disks, hard disks, optical disks, magneto-optical disks, CD-ROMs, CD-Rs, DVD-ROMs, magnetic tapes, non-volatile memory cards, ROMs, EEPROMs, silicon disks, and the like.

[0212] Furthermore, it goes without saying that the functions of the aforementioned embodiments are realized not only by the computer executing the program it has read, but also by the operating system (OS) running on the computer performing some or all of the actual processing based on the instructions of that program, thereby realizing the functions of the aforementioned embodiments.

[0213] Furthermore, it goes without saying that this also includes cases where, after a program read from a recording medium is written to the memory of a function expansion board inserted into a computer or a function expansion unit connected to a computer, the CPU or other components of the function expansion board or function expansion unit perform some or all of the actual processing based on the instructions of the program code, and the functions of the aforementioned embodiments are realized through that processing.

[0214] Furthermore, the present invention may be applied to a system consisting of multiple devices or to a device consisting of a single device. It goes without saying that the present invention can also be applied when the results are achieved by supplying a program to a system or device. In this case, by reading a recording medium containing a program for achieving the present invention into the system or device, the system or device can enjoy the effects of the present invention.

[0215] The above program may consist of object code, program code executed by an interpreter, script data supplied to the OS (operating system), and the like.

[0216] Furthermore, by downloading and reading the program for achieving the present invention from a server, database, etc. on a network using a communication program, the system or device can enjoy the effects of the present invention. It should be noted that configurations combining the above-described embodiments and their variations are all included in the present invention. [Explanation of symbols]

[0217] 101 Program Development Equipment 102 Execution Server 103 Database Server 104 Client Devices 105 Network

Claims

1. an application software generating means for generating application software that displays a predetermined display content without executing a specific process in response to a specific operation that instructs the specific process to be executed by the application software; an input receiving means for receiving an input of a value for specifying a timing for displaying the predetermined display content in the application software generated by the application software generating means; The application software generating means generates application software for displaying the predetermined display content at a timing specified based on the specific operation and the value received by the input receiving means.

23. An information processing apparatus comprising:

2. 2. The information processing apparatus according to claim 1, wherein the value is a value related to a set time for virtually reproducing a time required for the specific process.

3. The information processing device described in Claim 2, characterized in that the application software generation means generates application software that displays the predetermined display content after a time period determined based on the value accepted by the input accepting means has elapsed since the specific operation was performed.

4. The information processing device described in Claim 3, characterized in that the application software generation means generates application software that displays a predetermined display item indicating the time during which the specific processing is being executed between the time the specific operation is performed and the time the predetermined display content is displayed.

5. the input receiving means receives settings related to display of the predetermined items; The information processing device according to claim 4, characterized in that when the input accepting means accepts a setting to not display the specified display items, the application software generation means generates application software that displays the predetermined display content without displaying the specified display items in response to the specific operation being performed.

6. The input receiving means stores the set time in a local storage of a browser, The information processing device according to claim 4, characterized in that the application software generated by the application software generation means acquires the set time stored in the local storage of the browser, displays the specified display item for the set time, and then displays the predetermined display content.

7. The information processing device of claim 4, characterized in that the application software generation means generates application software which, in response to a second operation corresponding to an instruction to execute a second process that takes a longer time to process than the specific process, displays a display item indicating the processing time for a second time longer than the set time without executing the second process, and then displays predetermined display content that simulates the display of the execution result of the second process.

8. 8. The information processing apparatus according to claim 1, wherein the specific operation is an operation on a specific screen part displayed on a screen of the application software.

9. the specific process includes searching a database; the predetermined display content is a display content simulating a display of a result of searching the database, 9. The information processing apparatus according to claim 1, wherein said application software generating means generates application software for displaying said predetermined display contents without searching said database.

10. the specific process includes communicating with the Internet; 10. The information processing apparatus according to claim 1, wherein the application software generating means generates application software for displaying the predetermined display content without communicating with the Internet.

11. the screen of the application software is a screen displayed as a prototype of the application software, An information processing device as claimed in any one of claims 1 to 10, characterized in that when the specific operation is performed while the production screen of the application software is displayed, the application software generation means generates application software that executes the specific processing and displays based on the results of the execution of the specific processing.

12. an application software generating step of generating application software that displays predetermined display content without executing a specific process in response to a specific operation instructing the specific process to be executed by the application software; an input receiving step of receiving an input of a value for specifying a timing for displaying the predetermined display content in the application software generated in the application software generating step; The application software generating step generates application software that displays the predetermined display content at a timing specified based on the specific operation and the value received by the input receiving means.

23. A method for controlling an information processing apparatus comprising:

13. A program for causing a computer to function as each of the means of the information processing device according to any one of claims 1 to 11.

14. 12. A computer-readable storage medium storing a program for causing a computer to function as each of the means of the information processing device according to claim 1.

Images