Information processing device, control method for information processing device, program, and recording 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 device for virtually reproducing the operation of application software, a method for controlling the information processing device, a program, and a recording medium. [Background technology]

[0002] When creating application software for a customer, if you first understand the customer's requests and then create the application software, you can reduce rework and increase development efficiency.

[0003] In particular, screens and operating procedures differ from internal logic and operate according to user wishes, which increases customer satisfaction.

[0004] Patent Document 1 discloses a method for solving the above problem by listening to the user's requests, determining requirements that meet those requests, and simultaneously generating and completing source code for an application program that can be used on a real device on the spot. [Prior art documents] [Patent documents]

[0005] [Patent Document 1] Japanese Patent Application Laid-Open No. 2015-210639 Summary of the Invention [Problem to be solved by the invention]

[0006] Patent Document 1 describes generating application software mockup files and generating source code for mockup application software that realizes mockup screen transitions, but the screen transitions of the generated mockup application software are read from a web server, which takes time and makes development inefficient in the development environment.On the other hand, if the mockup application software is application software that runs only on the client, the prototype application software is executed in an environment that does not communicate with the server, so it is not easy to reproduce the waiting time, such as data communication time and server calculation time, that occurs during screen transitions in the production environment.

[0007] An object of the present invention is to virtually reproduce the operation of application software, so that the waiting time caused by the time required for processing can also be virtually felt. [Means for solving the problem]

[0008] In order to solve the above problem, an information processing device according to one embodiment of the present invention has a display control means for controlling the display of a screen displayed 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 the specific process is performed while the screen is being displayed, and the control means for controlling the display of predetermined display content without executing the specific process when the specific operation is performed, and the control means for controlling the display of a predetermined display item indicating a waiting time for processing for a predetermined period of time before displaying the predetermined display content, and then displaying the predetermined display content. [Effects of the Invention]

[0009] According to the present invention, when the operation of application software is virtually reproduced, the waiting time due to the time required for processing is also virtually felt. [Brief explanation of the drawings]

[0010] [Figure 1] FIG. 1 is a system configuration diagram showing an example of the configuration of a program development device, an execution server, a database server, and a client device according to an embodiment of the present invention. [Figure 2] 1 is a block diagram showing an example of a hardware configuration applicable to a program development device, an execution server, a database server, and a client device according to an embodiment of the present invention; [Figure 3] 2 is an example of a software configuration of the present embodiment. [Figure 4] FIG. 2 is a functional configuration diagram of the program development device according to the present embodiment. [Figure 5] 10 is a flowchart of generating prototype application software according to the present embodiment. [Figure 6] 10 is a flowchart of a screen definition input reception process according to the present embodiment. [Figure 7] 10 is a flowchart of a prototype data input reception process according to the present embodiment. [Figure 8] 10 is a flowchart of a prototype application source code generation process according to the present embodiment. [Figure 9] 10 is a flowchart of a process performed when a prototype application is executed according to the present embodiment. [Figure 10] 10 is a diagram illustrating an example of a screen display according to the present embodiment. [Figure 11] 10 is a diagram illustrating an example of a screen display according to the present embodiment. [Figure 12] 10 is a diagram illustrating an example of a screen display according to the present embodiment. [Figure 13] 10 is a diagram illustrating an example of a screen display according to the present embodiment. [Figure 14] 10 is a diagram illustrating an example of a screen display according to the present embodiment. [Figure 15] 10 is a diagram illustrating an example of a screen display according to the present embodiment. [Figure 16] 10 is a diagram illustrating an example of a screen display according to the present embodiment. [Figure 17] 10 is a diagram illustrating an example of a screen display according to the present embodiment. [Figure 18] 10 is a diagram illustrating an example of a screen display according to the present embodiment. [Figure 19]10 is a diagram illustrating an example of a screen display according to the present embodiment. [Figure 20] 10 is a diagram illustrating an example of a screen display according to the present embodiment. [Figure 21] FIG. 4 is a diagram showing an example of a screen definition 402 according to the present embodiment. [Figure 22] FIG. 4 is a diagram showing an example of a screen definition 402 according to the present embodiment. [Figure 23] FIG. 10 is a diagram showing an example of control of the screen size of a prototype application screen 442 according to this embodiment. [Figure 24] FIG. 4 is a diagram showing an example of a prototype application screen 442 displayed on the screen in this embodiment. [Figure 25] 10A and 10B are diagrams illustrating the relationship between a prototype application screen and a prototype operation panel according to the present embodiment. [Figure 26] 10 is a flowchart illustrating a process of executing a prototype application according to the present embodiment. [Figure 27] 10 is a flowchart illustrating a process of executing a prototype application according to the present embodiment. [Figure 28] 10 is a flowchart illustrating a process of executing a prototype application according to the present embodiment. [Figure 29] 10 is a flowchart illustrating a process of executing a prototype application according to the present embodiment. [Figure 30] FIG. 10 is a diagram illustrating an example of a device that can be displayed by the browser of the present embodiment. [Figure 31] 10 is a diagram illustrating an example of a screen display according to the present embodiment. [Figure 32] 10 is a diagram illustrating an example of a screen display according to the present embodiment. [Figure 33] 10 is a diagram illustrating an example of a screen display according to the present embodiment. [Figure 34] 10 is a diagram illustrating an example of a screen display according to the present embodiment. [Figure 35] 10 is a diagram illustrating an example of a screen display according to the present embodiment. DETAILED DESCRIPTION OF THE INVENTION

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

[0012] First Embodiment

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

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

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

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

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

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

[0019] Any 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 integrated into one housing.

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

[0021] In FIG. 2, a CPU 201 is at least one processor, and controls all devices connected to a system bus 204 .

[0022] The ROM 203 or the external memory 211 also stores an operating system (OS), which is a control program for the CPU 201, and programs for realizing various functions (to be described later) of the information processing device, such as each server, client, device, etc. The ROM 203 or the external memory 211 is at least one memory.

[0023] The RAM 202 functions as the main memory, work area, temporary save area, etc. for the CPU 201.

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

[0025] If the input unit 209 is a touch panel, the user can give various instructions by pressing (touching with a finger or the like) an icon, cursor, or button displayed on the touch panel.

[0026] The touch panel may also be a touch panel capable of detecting positions touched by multiple fingers, such as a multi-touch screen.

[0027] The output controller 206 controls the display of the output unit 210. Examples of the output unit 210 include a CRT or a liquid crystal display. This also includes a display of a notebook computer integrated into the main body. It may also be a projector.

[0028] The external memory controller 207 controls access to an external memory 211 that stores a boot program, various application software, font data, user files, edit 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 a hard disk (HD), a flexible disk (FD), a CompactFlash (registered trademark) card connected to a PCMCIA card slot via an adapter, and a SmartMedia card.

[0029] The CPU 201 enables display on the output unit 210 by, for example, executing outline font development (rasterization) processing on a display information area in the RAM 202. The CPU 201 also enables the developer to give instructions using a mouse cursor (not shown) or the like on the output unit 210.

[0030] A communication I / F controller 208 controls communication with external devices via a network, for example, communication using TCP / IP.

[0031] A program 212 for realizing this embodiment is recorded in the external memory 211, and is executed by the CPU 201 by being loaded into the RAM 202 as required.

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

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

[0034] The definition unit 301 is a functional unit that receives from the developer screen definition information such as the layout of screens and items (input / output items) displayed in the application software, and screen transition definition information that defines the procedure for transitioning from one screen of the application software 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 the screens, and specifically corresponds to the processing of the flowchart in Figure 8.

[0036] The data acquisition unit 304 is a functional unit that acquires data to be displayed in items (input / output items) on the prototype application from the user, and specifically corresponds to step S706 in FIG. 7 and the explanatory diagrams in FIGS.

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

[0038] FIG. 4 is a configuration diagram 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. Note that the prototype application of this embodiment differs from application software that searches for data from a database or creates diagrams from calculated data results, as in a production environment, in that it is application software that serves as a mockup that displays preset values ​​and pre-drawn diagrams, and imitates screen transitions and display changes, etc., in the same way as actual application software.

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

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

[0042] The repository definition unit 400 stores an application definition 401, a screen definition 402, a screen component definition 403, a screen transition definition 404, an action 405 linked to the screen component definition 403, and prototype data 406 linked to the action 405. The prototype data refers to the data displayed on the application software screen when the prototype application is executed, and refers to values ​​and diagrams set in advance by the developer, rather than data searched from a database or diagrams drawn from calculated data results as in the production environment. These definitions 401 to 406 are input, set, or arranged by the developer via an application software development tool.

[0043] The application definition 401 holds the overall settings of the application software developed by the developer.

[0044] The screen definition 402 holds information on various screen component definitions 403 and screen transition definitions 404 that are arranged on each screen included in the application software. The screen definition 402 includes information on actions 405 that are set for various components and prototype data 406 that is linked to the actions 405.

[0045] The prototype application generation unit 410 analyzes the repository definition unit 400 set by the developer and generates source code for software (prototype application) for displaying the prototype display screen 440. After the prototype application is generated, the source code for software (prototype application) for displaying the prototype display screen 440 is deployed 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 in accordance with the analysis results of the repository definition analysis unit 411 .

[0048] The source code compiling unit 413 compiles the source code generated by the prototype code generating unit 412 and deploys instruction information to the execution server unit 430 for displaying a prototype display screen 440 including compiled Java (registered trademark) code and HTML / JSP / JavaScript (registered trademark).

[0049] The repository definition editor unit 420 is an example of a procedure for a user to set 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 unit 421 is a graphical editor that allows a developer to intuitively create a desired screen layout.

[0051] The screen transition definition editor unit 422 is an editor for setting properties for each screen component placed by the developer.

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

[0053] An example of the responsive component control unit 423 will be described with reference to FIGS.

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

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

[0056] When the switching button in display example 2300 is pressed, data storing the screen size displayed on client device 104 is information 2310. For example, when PC screen button 2301 is pressed, the displayed screen size is 1920×1080 (2311), when tablet screen button 2302 is pressed, the displayed screen size is 1023×1366 (2312), and when smartphone screen button 2303 is pressed, the displayed screen size is 414×896. Display examples of screens displayed in response to pressing each button will be described with reference to FIG. 24.

[0057] FIG. 24 is a display example showing an example of the prototype application screen 442 of this embodiment.

[0058] 24 is a display example of a PC screen, screen area 2403 is a display example of a tablet screen, and screen area 2404 is a display example of a smartphone screen. Screen area 2402 is a simulation of the display screen when the production application program is executed on a PC, and is at least a part of the entire display area of ​​client device 104, and is an area of ​​1920 pixels wide by 1080 pixels high, defined in information 2310 as the screen size of a PC. Screen area 2403 is a simulation of the display screen when the production application program is executed on a tablet, and is at least a part of the entire display area of ​​client device 104, and is an area of ​​1023 pixels wide by 1366 pixels high by 1080 pixels high, defined in information 2310 as the screen size of a PC. Screen area 2404 is a simulation of the display screen when the production application program is executed on a smartphone, and is at least a part of the entire display area of ​​client device 104, and is an area of ​​414 pixels wide by 896 pixels high, defined in information 2310 as the screen size of a smartphone. The size of each component, for example, component 2422 (display component) in screen area 2402 representing a PC screen is component 2423 in screen area 2403 representing a tablet screen, and component 2424 in screen area 2404 representing a smartphone screen, is controlled by responsive component control unit 423 so that components 2422, 2423, and 2424, which are the same components, are displayed at a predetermined ratio to the overall width of the respective screen areas (2402, 2403, and 2404) as shown in FIG. 24 . That is, component 2422 is controlled to be displayed at 2 / 12 of the entire screen area 2402 on the PC screen, component 2423 is controlled to be displayed at 3 / 12 of the entire screen area 2403 on the tablet screen, and component 2424 is controlled to be displayed at 6 / 12 of the entire screen area 2404 on the smartphone screen. Returning to the description of the configuration diagram in FIG. 4 ,

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

[0060] The prototype data input section 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 of the prototype application generated by the prototype application generation unit 410. The prototype display screen 440 is a display screen of the prototype application that allows users such as business users (decision makers for customers) and sales representatives who make proposals to customers to reproduce and display the display contents, operations, etc. of application software generated by the program development device 101 when developing application software. The prototype display screen 440 includes a prototype operation panel 441 and a prototype application screen 442.

[0063] The prototype operation panel 441 is a module of the prototype display screen 440 that has the user interface function, and is a panel (screen) that accepts settings from the developer, such as reproduction at the screen size of the client device 104, reproduction of the display image for each user authority, reproduction of the processing wait 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 where the display contents, operations, etc. of the application software generated by the program development device 101 are reproduced and displayed.

[0065] The client device unit 435 downloads data for displaying the prototype display screen 440 from the execution server unit 430. The client device unit 435 uses a web browser 450 to display the prototype display screen 440 configured as an SPA (single page application).

[0066] Although not shown, the system also has an application code generation unit that actually runs, rather than a prototype application. The application code that actually runs is the code of production application software. The application code generation unit 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 using a repository definition analysis unit 411. The web application code generation unit uses the code generation rules stored in the external memory 211 and the contents analyzed by the repository definition analysis unit 411 to generate a web application module including compiled Java (registered trademark) code and HTML / JSP / JavaScript (registered trademark) via a source code compilation unit 413.

[0067] 5 is a diagram showing an example of a flowchart for generating a prototype application for Web application software. Note that each step of the following flowchart is executed by CPU 201 of program development device 101.

[0068] The flowchart in FIG. 5 shows the flow of processing that is started 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 accepts a screen definition input. Details of the processing in step S501 will be described later with reference to FIG.

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

[0071] The action control module included in the prototype application controls which data from multiple prototype data set by the developer is displayed and when the prototype display screen 440 is displayed. The action control module also controls the behavior associated with each action of the components placed on the screen. In other words, prototype data is associated with an action (action event).

[0072] The program development device 101 accepts the press to allow the developer to specify which action the prototype data he or she is about to input will be linked to.

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

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

[0075] An example of the action selection section when display element 1201 is pressed is shown in display element 1202. An example of the action selection section 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 proceeds to step S503, the program development device 101 accepts input of prototype data from the developer. Details of the process of step S503 will be described later with reference to Fig. 7. After that, the process proceeds to step S504.

[0077] In step S504, the program development device 101 determines whether a screen definition save request has been made. If it is determined that a screen definition save request has been made, the process proceeds to step S505, and if a screen definition save request has not been made, the process proceeds to step S506.

[0078] When the process proceeds to step S505, the program development device 101 saves the screen definition in the repository definition unit 400. After that, the process proceeds to step S506.

[0079] In step S506, the program development device 101 determines whether a prototype generation request has been made. If it is determined that a prototype generation request has been made, the program development device 101 proceeds to step S507. On the other hand, if a prototype generation request has not been made, the program development device 101 proceeds to step S501.

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

[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] In the following, we will explain an example in which the program development device 101, execution server 102, and client device 104 are implemented on the same information processing device, but if they are each separate information processing devices, 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 starts a web browser and starts accessing the URL of the prototype application. Note that the processes of steps S510 and S511 are an example of a case where the program development device 101 uses both the execution server 102 and the client device 104. If they are in separate housings, the process of step S510 is executed by the execution server 102, and the process of step S511 is executed by the client device 104.

[0086] This concludes the explanation of Fig. 5. The subsequent processing will be described later with reference to Fig. 9. In the explanation of Fig. 9 and subsequent figures, the prototype application is assumed to be executed not by the program development device 101 but by the client device 104 that has launched a web browser. However, the prototype application may also be executed by the program development device 101 that has launched a web browser in the same way as the client device 104.

[0087] Next, the details of the process in step S501 will be described with reference to FIG.

[0088] 6 is a diagram showing an example of a flowchart for accepting input of a screen definition for Web application software. Note that each step of the following flowchart is executed by CPU 201 of program development device 101.

[0089] The flowchart in FIG. 6 shows the flow of processing that starts when the processing transitions to step S501 in the flowchart in FIG.

[0090] First, in step S601, the program development device 101 accepts the placement of screen components by the developer. Specifically, the program development device 101 accepts the placement of components by dragging and dropping 1003 from area 1001 (an example of the responsive component control unit 423) in FIG. 10 to area 1002 (an example of the screen definition editor unit 421). FIG. 10 shows an example in which a button component is dragged and dropped from the responsive component control unit to the screen definition editor unit. The method of arranging screen components is not limited to dragging and dropping from the responsive component control unit 423 to the screen definition editor unit 421, but may also be a method of moving an already placed component or a method of duplicating an already placed component by copying and pasting. Furthermore, components that have been placed may be deleted.

[0091] In the case of Figure 10, as 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 including an action event has been placed. If it is determined that a component including an action event has been placed, the process proceeds to step S603, and if a component including an action event has not been placed, the process proceeds to step S604.

[0093] When the process proceeds to step S603, the program development device 101 registers the action set for the component including the action event. Specifically, the action is registered when the component has an action called onClick in the source code of the component. In the definition information 2100 (source code) of FIG. 21, which is an example of the screen definition 402, a definition 2102 of "actions" corresponding to the production environment and a definition 2103 of "examples" corresponding to the prototype application are written. Note that in the example of FIG. 21, the data storage format is a JSON file as an example of implementation means, but the data storage format may be other file formats or a database. Then, the process proceeds 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 a display element 1101 (icon) in FIG. 11, which is an example of a property input request button for the selected component, has been pressed.

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

[0096] When the process proceeds to step S605, the program development device 101 accepts input of properties for the screen component by the developer. Specifically, a display element 1102 (dialog box) in FIG. 11, which is an example of a screen property editor, is displayed, and input of settings for the properties of the screen component is accepted. In the example of FIG. 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. The screen property editor may also be displayed in a modal dialog.

[0097] This concludes the description of FIG.

[0098] Next, the details of the process in step S503 will be described with reference to FIG.

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

[0100] The flowchart in FIG. 7 shows the flow of processing that starts when the processing transitions to step S503 in the flowchart in FIG.

[0101] First, in step S701, the program development device 101 reads the settings of the action item specified by the developer in step S502 of Fig. 5. Specifically, the following two steps are performed. First, the layout example 1004 of Fig. 10, which is an example of the screen component definition 403 of the screen component selected by the developer, is defined, and definition 2101 of Fig. 21 is read. The data of definition 2101 is assumed to have been input from 1102 of Fig. 11 in step S605 of the flowchart of Fig. 6. Next, definition 2102 of "actions" corresponding to the production environment of the screen component selected by the developer and definition 2103 of "examples" corresponding to the prototype application are read.

[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 the screen transition definition 404 of the definition 2101, which is an example of the screen component definition 403. In this embodiment, the program development device 101 holds the screen transition definition 404 in the screen component definition 403, but it may also hold it in the action 405.

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

[0104] When the process proceeds to step S703, the program development device 101 displays the destination screen of the screen transition associated with the setting of the action item read in step S701. Specifically, the program development device 101 displays the screen 1300 in FIG. 13, which is the screen set in "nextUi" of the definition 2101. Note that the prototype data display component 1302 of the destination screen in FIG. 13 is also assumed to have been set in advance by the developer's operation (step S601). Note that a screen such as the prototype data display component 1302 may be displayed by either rewriting 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 (transition destination screen) displayed in screen definition editor section 421 is read and set as the action designated by the developer. After this processing, the process proceeds 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 such as prototype data 2201 in Figure 22 has already been 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) before a prototype application is run. Specifically, this is an example in which prototype data is displayed in a list, such as the prototype data display component 1302 of the transition destination screen shown in FIG. 13, displayed in the screen definition editor unit 421. In the prototype data display component 1402 shown in FIG. 14, for example, the developer can right-click the mouse (not shown) in the "Name" field and press the edit button 1403 to accept the selection of the prototype data display component. Furthermore, after selecting the entire list, as in the prototype data display component 1701 shown in FIG. 17, pressing the table input button 1702 selects the entire list of the prototype data display component 1701 as the prototype data display component.

[0108] In the next step S706, the program development device 101 accepts prototype data input by the developer. Specifically, it displays a prototype data input dialog 1501 in FIG. 15, which is an example of the prototype data input unit 425. The prototype data input dialog 1501 is a prototype data input dialog that is displayed when the edit button 1403 is pressed in the "Name" field of the pop-up item 1401 in FIG. 14. In the case of the prototype data input dialog 1501, an example is shown in which the developer has entered prototype data "Tanigawa Noriyuki" in the "Name" field. After the developer has entered the value, a determination is made in step S707 as to whether the input has been confirmed by pressing the "OK" button in the prototype data input dialog 1501.

[0109] As another example of step S706, an example of prototype data input section 425 will be described with reference to FIG.

[0110] The prototype data input dialog 1801 in Figure 18 is a dialog that is displayed 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 a group of data to be displayed in a list table displayed in the prototype data display component 1701. In the case of the prototype data input dialog 1801, the following data is entered in the first line: "(blank)", "Tanigawa Noriyuki", "(blank)", in the second line: "1001", "Hori Ai", "2019 / 10 / 10", and in the third line: "1002", "Yamamura Ruriko", "2019 / 09 / 18". This data entry may be adapted to the contents of a CSV file or spreadsheet file selected from a file selection screen (not shown) that is displayed by pressing the file selection button 1802.

[0111] After the developer inputs a value into the text input field, or after the data is reflected after the file is selected, by pressing the "OK" button 1803, it is determined in step S707 whether the input has been confirmed.

[0112] In step S706, a locale specification may be accepted to switch the prototype data to be displayed depending on the language. Also, although a method of displaying a modal dialog is shown as a method for accepting prototype data input, the input acceptance method may be a method of accepting input directly to the display component selected by the developer in S705, or a method of accepting input in bulk from an external file.

[0113] In the next step S707, the program development device 101 determines whether the prototype data input by the developer has been confirmed. Specifically, it determines whether the "OK" button in the prototype data input dialog 1501 in Fig. 15 or the "OK" button 1803 in Fig. 18 has been pressed. Note that in the input acceptance method in step S706, if direct input to a component has been accepted, it determines 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 has been pressed), the process proceeds to step S708, and 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 input by the developer to the screen definition 402. Specifically, the prototype data is written to the prototype data 2201, which is an example of the prototype data 406 linked to the action 405 of the screen definition 402.

[0116] Note that with this method, it is not possible to change the data displayed on the post-transition screen depending on the action to be executed. This is because the prototype data is stored in the initial display action of the post-transition screen. However, by storing the prototype data to be displayed on the post-transition screen on the side of the action to be executed, it may be possible to change the data to be displayed on the post-transition screen depending on the action to be executed. Specifically, by storing the objects under "onLoad" in prototype data 2201 under "onClick" in definition 2103, the original button that transitions the screen (for example, the "Register" button located on screen 1000 in FIG. 10) may have data to be displayed on the post-transition screen.

[0117] In this way, by displaying the prototype data on a prototype application with screen transitions for each action event, you can get an overview of how the mockup will work before creating the actual application software (for example, searching a database or drawing from the extracted data). This concludes the description of FIG.

[0118] Next, the details of the process in step S507 will be described with reference to FIG.

[0119] 8 is an example of a flowchart illustrating the flow of a process for generating source code for a prototype application of Web application software. Note that each step of the following flowchart is executed by CPU 201 of program development device 100.

[0120] The flowchart in FIG. 8 shows the flow of processing that starts when the processing transitions to step S507 in the flowchart in FIG.

[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 by each generation unit as appropriate.

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

[0123] In step S802, when the screen definition is read, information on display permissions defined for each of the screen display items (items) is also acquired. This will be described with reference to the example of FIG. 34. In FIG. 34, if the underlined portion 3402 defines the lines that change display items (items) depending on the user's authority, information linking the user's authority name 821 in the display authority data 820 of FIG. 8 with the corresponding input / output display permission items 822 is acquired. The display authority data 820 of FIG. 8 is display authority information defined for "Attendance Confirmation," which is one of the screen display items (items) included in the screen of FIG. 34. In the case of the display authority data 820 of FIG. 8, the authority names "User," "Admin," and "Guest" are defined as user authorities, and the input / output display permission items corresponding to each authority name are defined as the input / output permission items. The element items to be displayed corresponding to the authority are defined as the input / output permission items from the element item group (remarks, attendance confirmation (User), attendance confirmation (Admin), and update button) included in the screen display item "Attendance Confirmation" of FIG. 34. This display item definition information may also define input / output display permissions (element items that should be displayed according to the authority among the element items included in the "Attendance Confirmation" column (Notes, Attendance Confirmation (User), Attendance Confirmation (Admin), Update button))). This display item definition information may also define input / output display prohibition items (element items that should not be displayed according to the authority among the element items included in the "Attendance Confirmation" column (Notes, Attendance Confirmation (User), Attendance Confirmation (Admin), Update button)). Display authority may be defined for the display items collectively, or may be defined individually for each display item, as in display authority data 820.

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

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

[0126] In step S805, the program development device 101 collects the authority (role) associated with the display item acquired in step S802, for example, the user authority data 830.

[0127] In step S806, the program development device 101 reads the prototype data 406 included in the screen definition 402 read in step S802 from the repository definition unit 400. The data in the screen definition 402 read here is the "examples" data in Figures 21 and 22 that corresponds to the prototype data, and "actions," i.e., the data for the production environment, is not used. By having these two pieces of data, it becomes possible to create a common screen definition for the prototype data and a screen definition for the production environment, and the application software screen created for the mockup can be defined as the application software screen as is.

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

[0129] Fig. 31 is an example of a prototype display screen (a display screen by a prototype application) in this embodiment. Fig. 31 is an example of a prototype operation panel that is displayed on the initial screen when the prototype application is started in accordance with the source code generated in S807. The prototype operation panel is an operation panel for setting how the prototype application screen 442, which is displayed by the prototype application and which imitates the screen transitions of application software in the production environment, is to be displayed.

[0130] The prototype operation panel will be described with reference to FIG. 31. The prototype operation panel 3102 in FIG. 31 is a panel screen that accepts instructions from a user (for example, a developer who is demonstrating a prototype of application software under development for a customer) regarding display settings and transition settings when displaying a prototype screen or transitioning between prototype screens. The prototype operation panel 3102 can set the display device (such as a PC, tablet, or smartphone), the display device's screen orientation, the user's access rights (such as Admin authority or User authority), whether to display server processing time, and whether to display error information. Depending on these settings, which are set in response to user operations on the prototype operation panel, the display in the prototype application changes as follows: That is, the screen size and orientation change depending on the settings for the display device and the display device's screen orientation. The display content displayed in the prototype application changes depending on the user's access rights setting. Depending on the setting for whether to display server processing time, whether a hypothetical server processing time is displayed or not changes. Depending on the setting for whether to display error information, whether a hypothetical error information is displayed or not changes. Display device settings can be set using a display device setting item 3111, user authority settings using an authority setting item 3121, processing wait time settings using a processing time setting item 3131, and error display settings using an error setting item 3141. For example, by pressing (clicking) a button 3112 for setting 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 described with reference to FIGS.

[0132] FIG. 25 is a diagram for explaining the relationship between the prototype application screen and the prototype operation panel.

[0133] A prototype display screen 2501, which serves as the base for the parent screen, is displayed on the browser, and within the parent screen, a prototype application screen 2502 is displayed in an iFrame. Furthermore, a prototype operation panel 2503 (the same as the prototype operation panel 3102 in Fig. 31) is displayed superimposed on the prototype application screen 2502, and is displayed on the prototype display screen 2501 so that part of the prototype application screen 2502 and the prototype operation panel 2503 can be confirmed simultaneously.

[0134] The prototype operation panel 3102 (2503) can be hidden, and most of the prototype display screen 2501 can be used as the prototype application screen 2502. When a user setting operation is accepted on the prototype operation panel 3102 shown in Fig. 31, and an operation to reduce the prototype operation panel 3102 (2503) (to hide it) is accepted by the user, for example, by operating the reduce icon 3103, a prototype application screen 3201 shown in Fig. 32 is displayed, on which the prototype operation panel 3102 is hidden. In this case, the screen corresponds to the prototype display screen 2521 shown in Fig. 25, and the prototype application screen 3201 shown in Fig. 32 corresponds to the prototype application screen 2502 shown in Fig. 25. To return from the prototype application screen 3201 (2522) to the screen displaying the prototype operation panel 3102 (2503), the user presses the button 3202 (2523), which is a button icon that functions as a prototype operation panel display button, to transition to the prototype application screen 3101 shown in Fig. 31, on which the prototype operation panel 3102 is displayed. That is, when button 3202 (icon 2523 in FIG. 25) displayed on prototype application screen 3201 (prototype application screen 2502 in FIG. 25) is operated, the display state returns to that of FIG. 31 (the display state of prototype display screen 2501 in FIG. 25), and prototype operation panel 3102 (prototype operation panel 2503 in FIG. 25) is displayed again. Returning to the explanation of the flowchart in FIG. 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 storage area (Web Storage and Cookie information) where the operation is stored is changed.

[0136] Next, in step S808, the program development device 101 generates source code for changing the screen display for each user authority. The generated source code is source code for a program that determines the user authority and controls the display / non-display of screen components to which the user authority is applied. In other words, step S808 is processing for generating a program for displaying a prototype (trial) screen when the user authority is set.

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

[0138] In step S810, the program development device 101 generates a program for displaying the prototype application screen 2502 (iFrame) reflecting the settings made 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 a PC or a smartphone.

[0139] Once the above source code is generated, the processing of the flowchart in Figure 8 is completed. Note that although the source code generated in S807 to S810 is in TypeScript, it may be source code in another language, or may be source code written in JavaScript or the like.

[0140] This concludes the description of FIG.

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

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

[0143] The flowchart in FIG. 9 shows the flow of processing that starts when a user accesses the prototype display screen 440 from a web browser 450 on a 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 locale information of the browser, which allows the display language of the prototype data to be switched.

[0145] In step S902, the client device 104 downloads from the execution server 102 (430) an SPA (single-page application) on which the prototype display screen (the application software generated in steps S807 to S810 in FIG. 8) runs. Note that in this embodiment, the prototype display screen 440 is described as an SPA, but it does not necessarily have to be an SPA and may be configured to communicate with the execution server 102 using a screen transition command, in which case the initial screen information of the prototype application is downloaded.

[0146] In step S902, the client device 104 also acquires user authority information for the prototype application.

[0147] Furthermore, in step S902, the client device 104 launches (displays) the prototype display screen 2501 (prototype display screen 440) from the program acquired from the execution server 102 (430). That is, step S902 is a step for downloading and launching a program for displaying a screen such as the prototype application screen 3101 in Figure 31.

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

[0149] In step S904, the client device 104 launches the prototype operation panel (iFrame) 2503 in the iFrame portion of the prototype display screen 2501. As a result, a prototype operation panel 3102 is displayed superimposed on the prototype application screen 3101, as shown in Fig. 31. By changing the settings displayed on this prototype operation panel 3102, it is possible to control the display settings and screen transition settings of the prototype application.

[0150] In step S905, the client device 104 changes the display screen of the prototype application screen 3201 (442) or changes the transition screen according to the settings input to the prototype operation panel 3102. The process of displaying the prototype display screen 440 or the transition screen according to the settings will be described later with reference to FIGS.

[0151] Next, in step S906, the client device 104 waits for an instruction from the developer as to whether to end the reproduction of the application software using the prototype application. If the reproduction of the application software is to be ended, this flowchart ends. If an instruction to reproduce the application software again is received, the process returns to step S902.

[0152] Next, as a detailed description of the processing of step S905, the flow of processing for changing the display screen of the prototype application screen 3201 (442) or changing the transition screen according to the settings entered into the prototype operation panel 3102 will be explained with reference to Figures 26 to 29. The processing of Figures 26 to 29 is realized by a program (i.e., a prototype application) based on the source code generated in the processing of Figure 8. The settings include switching the display device, changing user authority, replicating processing time with the server, and replicating when an error occurs.

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

[0154] 26 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. Note that some of the explanations in FIGS. 26 to 29 overlap with the explanation in FIG. 9.

[0155] The processing in steps S2601 and S2602 is the same as the processing in steps S902 and S903 in FIG.

[0156] In step S2603, the client device 104 launches the prototype operation panel (iFrame) 2503 in the iFrame portion of the prototype display screen 2501. Up to this point, the process is the same as that of step S904 in Fig. 9. What follows is the details of the process of S905 in Fig. 9.

[0157] When the prototype operation panel 3102 is displayed, if the user operates the display device setting item 3111 and the display device setting (screen size setting) is changed, the process proceeds to the next step S2604. The display device setting item 3111 displays the available options for each terminal with a predefined screen size (PC, tablet (portrait), tablet (landscape), smartphone (portrait), smartphone (landscape)). For tablets and smartphones, either portrait or landscape orientation can be selected and set. The reason that portrait and landscape orientations can be set is because tablets and smartphones can be controlled to display in either portrait or landscape orientation.

[0158] Returning to the explanation of the flowchart in FIG. 26, when the process proceeds to the next step S2604, the client device 104 receives an instruction to change the screen size to that of the device changed on the prototype operation panel 3102.

[0159] In step S2605, the client device 104 displays the prototype application screen 2502 by adjusting the iFrame portion to the size of the device accepted in step S2604. An example of the prototype application screen 2502 displayed when set to a smartphone (portrait orientation) is shown in FIG.

[0160] Prototype application screen 3301 in Fig. 33 is displayed within the smartphone-sized area 3302. Even on a screen displayed at smartphone size, the processing of the prototype application as a trial is executed, and for example, when a specific button is pressed, a transition screen that reflects prototype data corresponding to that action can be displayed.

[0161] By performing the above process, it is possible to easily create a prototype application with different display formats for each device.

[0162] Next, with reference to FIG. 27, a process flow for changing the screen display when the user authority is changed will be described.

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

[0164] The flowchart in FIG. 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 processing in steps S2701 and S2702 is the same as the processing in steps S902 and S903 in FIG.

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

[0167] In step S2703, the client device 104 launches the prototype operation panel (iFrame) 2503 in the iFrame portion of the prototype display screen 2501. Up to this point, the process is the same as that of step S904 in Fig. 9. The process from here on is detailed in S905 in Fig. 9. Note that, among the authority setting items 3121 in Fig. 31, the check boxes for setting user authority are generated based on the user authority data 830 acquired in step S2710.

[0168] When the prototype operation panel 3102 is displayed and the user operates the authority setting item 3121 and changes the authority setting, the process proceeds to the next step S2704.

[0169] When the process proceeds to step S2704, the client device 104 stores the value of the authority setting item 3121 changed on the prototype operation panel 3102 in the local storage of the browser.

[0170] In step S2705, the client device 104 displays the prototype application screen 2502 with the user authority setting stored in step S2704. An example of the prototype application screen 2502 displayed when the authority setting item 3121 is set to "user" is shown in FIG.

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

[0172] Another example will be described.

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

[0174] FIG. 35 shows an example of a display that is displayed when the authority setting item 3121 is set with the three options "guest," "user," and "admin" checked.

[0175] The prototype application screen 3501 in Figure 35 differs from the prototype application screen 3201 in Figure 32 in that the underlined section 3502 now displays new Attendance Confirmation (Admin) and Attendance Confirmation (User) 3503, and an update button 3504 is also added to the right of the screen.

[0176] The above process has the effect of enabling the creation of 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 result in a pattern in which only predetermined screen displays and predetermined screen transitions are possible regardless of user authority, but in this embodiment, a prototype operation panel setting that switches user authority is provided, and it is possible to reproduce the situation in which the displayed screen changes for each user authority by switching user authority.

[0177] Next, the flow of processing for displaying a reproduction of the processing time at the server will be described with reference to FIG.

[0178] 28 is a flowchart showing the flow of processing when the processing time in 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 FIG. 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 processing in steps S2801 and S2802 is the same as the processing in steps S902 and S903 in FIG.

[0181] In step S2803, the client device 104 launches the prototype operation panel (iFrame) 2503 in the iFrame portion of the prototype display screen 2501. Up to this point, the process is the same as that of step S904 in Fig. 9. What follows is the details of the process of S905 in Fig. 9.

[0182] When the prototype operation panel 3102 is displayed, if the user operates the processing time setting item 3131 and changes the processing time setting, the process proceeds to the next step S2804. The processing time setting item 3131 is a setting field for reproducing the display of the screen transition of 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 FIG. 31 can be changed from "0.2 seconds" to "2 seconds" in response to a user operation.

[0184] When the process proceeds to step S2804, the client device 104 stores the value (for example, 2 seconds) of the server processing time setting item 3131 changed on the prototype operation panel 3902 in the local storage of the browser.

[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 changes to a prototype application that is reproduced so as to transition 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 Fig. 16 is pressed, a display item 1902 is displayed in the center for 2 seconds, as if the processing is currently being performed on the server, as shown in the display example in Fig. 19. The time for which this display item 1902 indicating that processing is in progress is displayed is the time set in the processing time setting item 3131. After display item 1902 is displayed for the set time, the next transition destination screen, such as Fig. 32, is displayed.

[0187] The above process has the effect of enabling the creation of prototype application software that virtually reproduces the wait time during screen transitions. In other words, it is possible to reproduce the processing time that occurs on the server side when application software (product application) is run in a production environment. For example, when a business user or sales representative demonstrates a prototype application to a general user, they can reproduce the actual processing time with the server and the screen that will be displayed during the server processing time. Because this prototype application is configured as an SPA, communication with an actual server is not required. Therefore, simply executing the prototype application (screen transition) does not require processing time, and the prototype application transitions screens one after another in response to user operations. Because the operation of the production environment application software (product application) does not take into account server processing time, general users who are convinced only by demonstrations that do not take server processing time into account may experience discrepancies in the performance of the development deliverable. With the demonstration of this embodiment, the server processing time can be freely set, reducing the risk of performance discrepancies in the development deliverable. Furthermore, 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, the display screen of the prototype application (e.g., prototype application screen 1601 in FIG. 16) is displayed using the same screen definition information as the application software displayed in the production environment, so that a screen similar to the screen in the production environment can be displayed.

[0189] On the production environment screen using the application software, when the search button is pressed (clicked), i.e., when a search is initiated, a time-consuming search process is performed from a database on the Internet based on the search keyword ("self-care"), and after the search process is complete, the search results are displayed.

[0190] On the other hand, on the display screen of the prototype application (e.g., FIG. 16), in response to pressing (clicking) of Search button 1602, which corresponds to a search instruction operation in the production environment, prototype data, which is predetermined display content, as shown in FIG. 32, is displayed without searching a database on the Internet or communicating with the Internet. The prototype data displayed in FIG. 32 is display content that simulates a display based on the results of search processing. At this time, if the processing time setting item 3131 is set to a value greater than zero (if display item 1902 is set to be displayed), when Search button 1602 is pressed in FIG. 16, display item 1902, which virtually indicates a wait time for search processing, is displayed for the set time before transitioning to the display of FIG. 32. Thereafter, the display of FIG. 32 (display of prototype data, which is predetermined display content) is displayed.

[0191] The prototype data is not displayed based on the results of a search process.

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

[0193] If the processing time is set to zero by the processing time setting item 3131 or if the display items 1902 are set not to be displayed, pressing the search button 1602 in Fig. 16 will cause a direct transition from Fig. 16 to the display in Fig. 32 without displaying the display items 1902. In this case, there is no need to wait for a predetermined time.

[0194] Note that, when an operation (e.g., clicking the "Image Processing button (not shown)") is performed on the prototype application screen corresponding to an instruction to execute a process (e.g., image processing) that takes longer than search processing, 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 processing takes longer (longer waiting time). For example, the display item 1902 is displayed for 5 seconds longer than the time set by the processing time setting item 3131. Thereafter, predetermined display content that simulates the display of the results of image processing is displayed. In this case, too, image processing is not executed because this is a prototype application.

[0195] Next, with reference to FIG. 29, the flow of processing for displaying a reproduction of an error that occurs in a server or a communication error will be described.

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

[0197] The flowchart in FIG. 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 processing in steps S2901 and S2902 is the same as the processing in steps S902 and S903 in FIG.

[0199] In step S2903, the client device 104 launches the prototype operation panel (iFrame) 2503 in the iFrame portion of the prototype display screen 2501. Up to this point, the process is the same as that of step S904 in Fig. 9. What follows is the details of the process of S905 in Fig. 9.

[0200] While the prototype operation panel 3102 is displayed, if the user operates the error setting item 3141 and the setting for virtual error occurrence is changed from "off" to "on", the process transitions to the next step S2904.

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

[0202] In step S2905, the client device 104 acquires the prototype application screen 2502 and the error setting state stored in step S2904.

[0203] Next, a screen transition instruction on the prototype application screen is accepted from the user. In the case of Fig. 16, the screen transition instruction is accepted when the search button 1602 is pressed (clicked). When the screen transition instruction is accepted, the process proceeds to the next step S2806.

[0204] In the next step S2906, the client device 104 performs different processing depending on whether the acquired error setting status is on (enabled) or off (disabled). If the error setting status is on, the processing transitions to step S2907, and if the error setting status is off, the processing transitions to step S2908. When the processing transitions to step S2908, since the error setting status is off, the client device 104 transitions to the normal transition screen of the prototype application, shown in Figure 32.

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

[0206] 20, an error notification 2002 is displayed as an error display when an error occurs in processing by pressing the search button 1602. The error notification 2002 includes a warning icon and a message saying "An error has occurred in server processing."

[0207] The above process makes it 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 or during communication when application software (product application) is executed in a production environment. Because this prototype application is composed of an SPA, communication with an actual server is not required. Therefore, simply executing the prototype application (screen transition) will not cause server or communication errors. SPA can meet the needs of developers and general users who want to reproduce the screen that appears when an error occurs. Furthermore, as a way to more realistically reproduce error displays, it is combined with the reproduction of virtual processing time on the server, as shown in Figure 28.

[0208] Because the prototype display screen described above is composed of an SPA that can be launched within the browsers of various devices, if a prototype application generated as shown in prototype display screen 2501 in Figure 30 is downloaded to a PC or tablet, prototype application screen 2502 can be reproduced on each device. For example, if the prototype application is downloaded 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. A prototype application that reproduces the processing time of the server can also be run on a tablet, and the tablet display (3002) can reproduce the smartphone-sized display (3003). Therefore, even when demonstrating to customers, by bringing a single device, it is possible to reproduce the screens and screen transition patterns that will be displayed on various devices.

[0209] As described above, it goes without saying that the object of the present invention can also be achieved by supplying a recording medium on which a program that realizes the functions of the above-mentioned embodiments is recorded to a system or device, and 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 itself read from the recording medium will realize the novel functions of the present invention, and the recording medium on which the program is recorded will constitute the present invention.

[0211] Examples of recording media for supplying the program include flexible disks, hard disks, optical disks, magneto-optical disks, CD-ROMs, CD-Rs, DVD-ROMs, magnetic tapes, non-volatile memory cards, ROMs, EEPROMs, and silicon disks.

[0212] Furthermore, it goes without saying that not only are the functions of the above-mentioned embodiments realized by the computer executing a program it has read, but also cases are included in which an OS (operating system) running on the computer performs some or all of the actual processing based on the instructions of the program, and the functions of the above-mentioned embodiments are realized through that processing.

[0213] Furthermore, it goes without saying that this also includes cases where a program read from a recording medium is written into a memory provided on a function expansion board inserted into a computer or a function expansion unit connected to the computer, and then a CPU or the like provided on the function expansion board or function expansion unit performs some or all of the actual processing based on the instructions of the program code, thereby realizing the functions of the above-mentioned embodiments.

[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 to a case where the present invention is achieved by supplying a program to a system or device. In this case, the system or device can enjoy the effects of the present invention by reading a recording medium containing a program for achieving the present invention into the system or device.

[0215] The program may be in the form of object code, program code executed by an interpreter, script data supplied to an OS (operating system), or the like.

[0216] Furthermore, by downloading and reading a 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. Note that the present invention also includes configurations that combine the above-mentioned embodiments and their modified examples. [Explanation of symbols]

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

Claims

1. an application software generating means for 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 means for receiving an input of a value for specifying a timing at which the predetermined display content is to be displayed in the application software generated by the application software generating means; the application software generating means 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; The value is a value related to a set time for reproducing the time required for the specific processing. An information processing device characterized by:

2. the application software generating means generates application software that displays the predetermined display content after a time specified based on the value accepted by the input accepting means has elapsed since the specific operation was performed.

2. The information processing device according to claim 1,

3. the application software generating means generates application software that displays a predetermined display item indicating that the specific process is being executed during the period from when the specific operation is performed until when the predetermined display content is displayed.

2. The information processing device according to claim 1,

4. the input receiving means receives settings related to display of the predetermined item; When the input receiving means receives a setting indicating that the predetermined display item is not to be displayed, the application software generating means generates application software that displays the predetermined display content without displaying the predetermined display item in response to the specific operation being performed.

4. The information processing device according to claim 3,

5. the input receiving means stores the set time in a local storage of the browser; The application software generated by the application software generation means acquires the set time stored in the local storage of the browser, displays the predetermined display item for the set time, and then displays the predetermined display content.

2. The information processing device according to claim 1,

6. the application software generation means generates application software that, in response to a second operation corresponding to an instruction to execute a second process that takes a longer time to execute than the specific process, displays a display item indicating a processing time for a second time period that is longer than the set time period without executing the second process, and then displays predetermined display content that imitates a display of a result of execution of the second process.

4. The information processing device according to claim 3,

7. The specific operation is an operation on a specific screen component displayed on the screen of the application software.

7. The information processing device according to claim 1, wherein:

8. the specific process is a process including searching a database, the predetermined display content is a display content that simulates a display of a result of searching the database, The application software generating means generates application software that displays the predetermined display content without searching the database.

8. The information processing device according to claim 1, wherein:

9. the specific process is a process including communicating with the Internet, The application software generating means generates application software that displays the predetermined display content without communicating with the Internet.

9. The information processing device according to claim 1, wherein:

10. the screen of the application software is a screen displayed as a prototype of the application software, When the specific operation is performed while the production screen of the application software is being displayed, the application software generation means executes the specific process and generates application software that displays based on the execution result of the specific process.

10. The information processing device according to claim 1, wherein:

11. An application software generation step in which application software generation means of the information processing device generates 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 in which an input receiving means of the information processing device receives an input of a value for specifying a timing at which the predetermined display content is to be displayed 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; The value is a value related to a set time for reproducing the time required for the specific processing. A method for controlling an information processing device, comprising:

12. 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 10.

13. 11. 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