JP2022112478A - Information processing apparatus, control method thereof, program, and recording medium - Google Patents

Abstract

To provide an information processing apparatus configured to give a virtual feeling of latency time due to processing time, in virtually reproducing an operation of application software, a control method of the information processing apparatus, a program, and a recording medium.SOLUTION: An information processing apparatus includes: display control means which controls to display a screen to be displayed by application software; and control means which controls, during displaying the screen, to display predetermined display contents without executing, specific processing, in response to a specific operation corresponding to an operation to instruct execution of the specific processing. In response to the specific operation, before displaying the predetermined display contents, the control means displays a predetermined display item which indicates processing latency time for predetermined time, and thereafter displays the predetermined display contents.SELECTED DRAWING: Figure 28

Description

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

When creating application software for a customer, first creating the application software based on the customer's needs can reduce rework and improve development efficiency.

In particular, screens and operation procedures differ from internal logic and work as desired by the user, resulting in increased customer satisfaction.

Patent Literature 1 discloses solving the above-mentioned problem by determining the requirements according to the user's request while simultaneously generating and completing the source code of the application program that can be used on the actual machine on the spot. is doing.

JP 2015-210639 A

Patent Document 1 describes generation of mockup files for application software and generation of source code for mockup application software that realizes mockup screen transitions. Since screen transitions are read from the Web server, screen transitions take time, and development is not efficient in a development environment. On the other hand, if the mockup application software is application software that runs only on the client, the prototype application software will be executed in an environment that does not communicate with the server, so the data communication time that occurs during screen transitions in the production environment, It is not easy to reproduce latency such as server computation time.

SUMMARY OF THE INVENTION An object of the present invention is to make it possible to virtually feel the waiting time caused by the time required for processing when the operation of application software is virtually reproduced.

In order to solve the above problems, an information processing apparatus according to an embodiment of the present invention includes display control means for controlling to display a screen displayed by application software, and a specific control means for controlling to display predetermined display contents without executing the specific process in response to the execution of a specific operation corresponding to the operation for instructing the execution of the process of Then, in response to the specific operation, a predetermined display item indicating a waiting time for processing is displayed for a predetermined time before displaying the predetermined display content, and then the predetermined display item is displayed. and control means for controlling to display predetermined display contents.

According to the present invention, when the operation of the application software is virtually reproduced, the waiting time caused by the time required for the processing can also be virtually felt.

1 is a system configuration diagram showing an example of configurations of a program development device, an execution server, a database server, and a client device according to the present embodiment; FIG. 2 is a block diagram showing an example of hardware configurations applicable as a program development device, an execution server, a database server, and a client device according to the present embodiment; FIG. It is an example of the software configuration of this embodiment. 1 is a functional configuration diagram of a program development device of this embodiment; FIG. 4 is a flowchart of prototype application software generation according to the present embodiment; 8 is a flowchart of screen definition input acceptance processing according to the present embodiment; 4 is a flowchart of prototype data input acceptance processing according to the present embodiment; 4 is a flowchart of prototype application source code generation processing according to the present embodiment; 4 is a flowchart of processing when executing a prototype application according to the embodiment; It is an example of a screen display of this embodiment. It is an example of a screen display of this embodiment. It is an example of a screen display of this embodiment. It is an example of a screen display of this embodiment. It is an example of a screen display of this embodiment. It is an example of a screen display of this embodiment. It is an example of a screen display of this embodiment. It is an example of a screen display of this embodiment. It is an example of a screen display of this embodiment. It is an example of a screen display of this embodiment. It is an example of a screen display of this embodiment. It is a figure which shows an example of the screen definition 402 of this embodiment. It is a figure which shows an example of the screen definition 402 of this embodiment. FIG. 11 is a diagram showing an example of screen size control of a prototype application screen 442 of the present embodiment; FIG. 11 is a diagram showing an example of a screen display of a prototype application screen 442 of this embodiment; FIG. FIG. 4 is a diagram illustrating the relationship between a prototype application screen and a prototype operation panel according to the embodiment; 4 is a flowchart when executing a prototype application according to the embodiment; 4 is a flowchart when executing a prototype application according to the embodiment; 4 is a flowchart when executing a prototype application according to the embodiment; 4 is a flowchart when executing a prototype application according to the embodiment; FIG. 4 is a diagram showing an example of devices that can be displayed by the browser of the embodiment; It is an example of a screen display of this embodiment. It is an example of a screen display of this embodiment. It is an example of a screen display of this embodiment. It is an example of a screen display of this embodiment. It is an example of a screen display of this embodiment.

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

<First Embodiment>

FIG. 1 is a system (information processing system) configuration showing an example of the configuration of a program development device (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. It is a diagram.

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

In this embodiment, the application software generated by the program development apparatus 101 is web application software, but is not limited to this. It does not have to be application software that utilizes communication by Web technology, such as software or built-in software.

The execution server 102 executes application software (an application program included in the application software) developed by the program development apparatus 101 . Also, it is possible to operate by connecting to the database server 103 .

The database server 103 is a database used by developed application software, and in this embodiment, it may also be used for operation confirmation during development. For example, for use by developers, the database server 103 may consist of the same device as the program development device 101 and the execution server 102, or may be arranged in a network 105 such as a LAN.

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

Any one of the program development device 101, the execution server 102, the database server 103, and the client device 104 may be arranged on the Internet such as a cloud, or several information processing devices may be arranged as one housing. good too.

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

In FIG. 2, a CPU 201 is at least one processor and controls each device connected to the system bus 204 in an integrated manner.

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 of information processing apparatuses such as servers, clients, and apparatuses, which will be described later. ROM 203 or external memory 211 is at least one memory.

A RAM 202 functions as a main memory, a work area, a temporary save area, and the like for the CPU 201 .

The input controller 205 controls input from the input unit 209 . Examples of the input unit 209 include a keyboard, a pointing device such as a mouse, and a touch panel in the information processing apparatus.

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.

Also, the touch panel may be a touch panel, such as a multi-touch screen, capable of detecting positions touched by a plurality of fingers.

The output controller 206 controls the display of the output section 210 . Examples of the output unit 210 include a CRT, a liquid crystal display, and the like. It should be noted that the display of the notebook computer integrated with the main body is also included. Also, it may be a projector.

An external memory controller 207 controls access to an external memory 211 that stores boot programs, various application software, font data, user files, edit files, printer drivers, and the like. The external memory 211 stores various tables and parameters for realizing various functions of each server, client device, and the like. Examples of the external memory 211 include a hard disk (HD), flexible disk (FD), compact flash (registered trademark) connected to a PCMCIA card slot via an adapter, smart media, and the like.

It should be noted that the CPU 201 enables display on the output unit 210 by executing outline font expansion (rasterization) processing to a display information area in the RAM 202, for example. The CPU 201 also enables the developer to issue instructions using a mouse cursor (not shown) on the output unit 210 .

A communication I/F controller 208 executes communication control processing with external devices via a network. For example, communication using TCP/IP is possible.

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 necessary.

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

The program development device 101 has the following functional units.

The definition unit 301 stores 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 the screen of the application software to the next screen. This is a functional unit that is received from the developer, and specifically corresponds to the flow chart of FIG. 6 and the explanatory diagrams of FIGS.

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 by the definition unit 301 and the procedure for transitioning the screens. Specifically, the processing in the flowchart of FIG. 8 corresponds to this.

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. do.

The operation panel generation unit 305 is a functional unit that generates a prototype operation panel that controls the screen environment, transition method, and the like of the prototype application. The generated prototype operation panel is the prototype operation panel 3102 in FIG. 31, or the like.

FIG. 4 is a configuration diagram of the program development device 101, the execution server 102, and the client device 104. As shown in FIG.

The program development device 101 comprises a repository definition section 400 , a prototype application generation section 410 and a repository definition editor section 420 . It should be noted that the prototype application of this embodiment differs from application software that searches data from a database or draws a diagram based on calculated data results as in a production environment. It is application software as a mockup that displays diagrams and imitates screen transitions and display changes like actual application software.

The execution server 102 corresponds to the execution server section 430 in FIG.

Program development device 101 generates software source code (prototype application) for displaying prototype display screen 440 (display screen by prototype application) by prototype application generation unit 410 . The developer in the present embodiment refers not only to a contracted developer of application software, but also to a wide range of people who use the program development apparatus 101, such as business users and sales personnel.

The repository definition section 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 . Prototype data refers to the data displayed on the application software screen when running the prototype application. Refers to the values and diagrams preset by the developer. These 401-406 definitions are input or placed by the developer through the application software development tools.

The application definition 401 holds settings for the entire application software developed by the developer.

The screen definition 402 holds information of various screen component definitions 403 and screen transition definitions 404 arranged on each screen included in the application software. The screen definition 402 includes information on actions 405 set for various components and prototype data 406 associated with the actions 405 .

Prototype application generation unit 410 analyzes repository definition unit 400 set by the developer and generates source code of software (prototype application) for displaying prototype display screen 440 . Also, the source code of the software (prototype application) for displaying the prototype display screen 440 after generating the prototype application is deployed to the execution server unit 430 .

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

The prototype code generation unit 412 generates the source code of the prototype application according to the analysis result of the repository definition analysis unit 411 .

The source code compiling unit 413 compiles the source code generated by the prototype code generating unit 412, and displays a prototype display screen 440 including the compiled Java (registered trademark) code and HTML/JSP/Javascript (registered trademark). Deploys the instruction information to the execution server unit 430 .

The repository definition editor section 420 is an example of a procedure for setting the repository definition section 400 by the user. The repository definition editor section 420 includes a screen definition editor section 421 , a screen transition definition editor section 422 , a responsive component control section 423 , an action selection section 424 and a prototype data input section 425 .

The screen definition editor unit 421 is a graphical editor for intuitively creating a desired screen layout by the developer.

The screen transition definition editor unit 422 is an editor for setting properties for each screen component arranged by the developer.

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.

An example of the responsive component control unit 423 will be described with reference to FIGS. 23 and 24. FIG.

FIG. 23 is a schematic diagram illustrating control of the screen size of the prototype application screen 442 of this embodiment.

For example, as in a display example 2300 in FIG. 23, a plurality of types of client display screens such as a personal computer (PC) screen button 2301, tablet screen button 2302, and smartphone screen button 2303 are switched on the application software generation screen. Show button.

Information 2310 is data that stores the screen size displayed on the client device 104 when the switch button in the display example 2300 is pressed. For example, when the PC screen button 2301 is pressed, the displayed screen size is 1920×1080 (2311), and when the tablet screen button 2302 is pressed, the displayed screen size is 1023×1366 (2312). When the smart phone screen button 2303 is pressed, the displayed screen size becomes 414×896. A display example of a screen displayed in response to pressing of each button will be described with reference to FIG.

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

For example, a screen area 2402 in FIG. 24 is a display example of a PC screen, a screen area 2403 is a display example of a tablet screen, and a screen area 2404 is a display example of a smartphone screen. A screen area 2402 is a simulation of the display screen when the production application program is executed on the PC, and is at least part of the entire display area of the client device 104. Information 2310 indicates the screen size of the PC. It is a defined area of 1920 pixels wide by 1080 pixels high. A screen area 2403 is a simulation of the display screen when the production application program is executed on a tablet, and is at least part of the entire display area of the client device 104. Information 2310 indicates the screen size of the PC. It is a defined area of 1023 horizontal pixels by 1366 vertical pixels by 1080 pixels. A screen area 2404 is a simulation of a display screen when the production application program is executed on a smartphone, and is at least a part of the entire display area of the client device 104. Information 2310 indicates the smartphone screen size. It is a defined area of 414 horizontal pixels by 896 vertical pixels. Each component size, for example, the component 2422 (display component) in the screen area 2402 representing the PC screen is the component 2423 in the screen area 2403 representing the tablet screen, and the component 2424 in the screen area 2404 representing the smartphone screen. The responsive component control unit 423 controls components 2422, 2423, and 2424, which are the same components, to be displayed at a predetermined ratio with respect to the overall width of each screen area (2402, 2403, and 2404) as shown in FIG. do. That is, on the PC screen, the component 2422 is 2/12 of the entire screen area 2402, on the tablet screen, the component 2423 is 3/12 of the entire screen area 2403, and on the smartphone screen, the component 2424 is 6/12 of the entire screen area 2404. 2402 parts are controlled to be displayed at a ratio of . Returning to the description of the block diagram of FIG.

The action selection unit 424 is a functional unit that selects an action (action event) for the developer to select a target action for setting the prototype data 406 .

A prototype data input unit 425 is a graphical editor for intuitively setting prototype data 406 associated with a specific action 405 .

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

Prototype display screen 440 is a display screen by the prototype application generated by prototype application generation unit 410 . The prototype display screen 440 allows a user such as a business user (customer's decision maker) or a salesperson who makes a proposal to a customer to use the display contents, operation, etc. of the application software generated by the program development apparatus 101 at the time of application software development. It is a display screen by a prototype application for reproducing and displaying. Prototype display screen 440 includes prototype operation panel 441 and prototype application screen 442 .

The prototype operation panel 441 is a module having a user interface function in the prototype display screen 440, and reproduces the screen size of the client device 104, reproduces the display image for each user authority, reproduces the processing waiting time on the server, This is a panel (screen) that accepts settings from the developer such as display screen reproduction when an error occurs on the server.

The prototype application screen 442 is an area that reproduces and displays the display content, operation, etc. of the application software generated by the program development apparatus 101 .

Client device section 435 downloads data for displaying prototype display screen 440 from execution server section 430 . The client device unit 435 uses a web browser 450 to display a prototype display screen 440 composed of an SPA (single page application).

Also, although not shown, it also has an application code generator that actually operates instead of a prototype application. The application code that actually runs is the code of the production application software. The application code generation unit reads and analyzes the application definition 401 , the screen definition 402 , the separately defined database definition, the data model definition, and the business process definition from the repository definition unit 400 by the 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 compiled Java (registered trademark) files via the source code compilation unit 413 . Generate a web application module containing code and HTML/JSP/JavaScript.

FIG. 5 is a diagram showing an example of a flow chart for 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 .

The flowchart in FIG. 5 is the flow of processing started by the program development device 101 when the developer attempts to generate a prototype application.

First, in step S501, the program development device 101 receives screen definition input. Details of the processing in step S501 will be described later with reference to FIG.

Next, in step S502, the program development device 101 determines whether an input request for the prototype data 443 has been received. Specifically, the display element 1201 (icon) and the display element 1202 (selection item) in FIG. 12, or the display element 1203 (icon) and the display element 1301 (selection item) in FIG. Determines whether it has been pressed.

The action control module included in the prototype application controls which data out of the plurality of prototype data set by the developer is displayed at what timing when the prototype display screen 440 is displayed. Also, the action control module controls actions associated with each action of the parts arranged on the screen. In other words, prototype data is associated with an action (action event).

The program development device 101 accepts the press to specify which action the prototype data to be input by the developer is associated with.

If it is determined in step S502 that there is a prototype data input request, the process proceeds to step S503.

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

A display element 1202 shows an example of an action selection portion when the display element 1201 is pressed. A display element 1301 shows an example of an action selection portion when the display element 1203 is pressed. The display element 1301 displays a list of actions included in the screen definition being displayed, but may display a list of actions included in the application definition.

After transitioning to step S503, program development apparatus 101 accepts an input of prototype data from the developer. Details of the processing in step S503 will be described later with reference to FIG. After that, the process transitions to step S504.

In step S504, the program development apparatus 101 determines whether a screen definition save request has been received. If it is determined that there is a screen definition save request, the process proceeds to step S505, and if there is no screen definition save request, the process proceeds to step S506.

After transitioning to step S<b>505 , the program development apparatus 101 saves the screen definition in the repository definition unit 400 . After that, the process transitions to step S506.

After transitioning to step S506, the program development apparatus 101 determines whether a prototype generation request has been made. If it is determined that a prototype generation request has been made, the process proceeds to step S507. On the other hand, if there is no prototype generation request, the process transitions to step S501.

After transitioning to step S507, the program development device 101 generates the source code of the prototype application. Details of the processing in step S507 will be described later with reference to FIG.

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

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

Hereinafter, an example in which the program development device 101, the execution server 102, and the client device 104 are implemented by the same information processing device will be described. Each application software (prototype application, web browser, etc.) is started to execute processing.

In step S<b>510 , the program development device 101 activates the prototype application deployed on the execution server 102 .

In step S511, the program development apparatus 101 activates the web browser and starts accessing the URL of the prototype application. note that. The processing of steps S510 and S511 is an example in which the program development apparatus 101 uses the execution server 102 and the client apparatus 104 together. is executed, and the process of step S511 is executed by the client apparatus 104 .

This completes the description of FIG. Subsequent processing will be described later with reference to FIG. 9 and subsequent descriptions assume that the prototype application is executed not by the program development apparatus 101 but by the client apparatus 104 that activates the web browser. It may be executed by the development device 101 .

Next, details of the processing in step S501 will be described with reference to FIG.

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

The flowchart of FIG. 6 is a flow of processing that is started when the processing transitions to step S501 in the flowchart of FIG.

First, in step S601, the program development apparatus 101 receives placement of screen components by the developer. Specifically, it accepts placement of a part by drag & drop 1003 from area 1001 (an example of responsive part control section 423) in FIG. 10 to area 1002 (an example of screen definition editor section 421). FIG. 10 shows an example of dragging and dropping a button component from the responsive component control section to the screen definition editor section. 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 it can also be a method of moving an already placed component or a method of duplicating an already placed component by copy and paste. There may be. Also, it may be possible to delete a part that has been placed once.

In the case of FIG. 10, a screen provided with two text input fields (an ID input field and a name input field) and a registration button for registering an ID and a name (a screen in the application software to be generated), as in the layout example 1004. is created.

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 the part containing the action event has been placed, the process proceeds to step S603, and if the part containing the action event has not been placed, the process proceeds to step S604.

After transitioning to step S603, the program development apparatus 101 registers the action set for the component including the action event. Specifically, in the case of a component having an action of onClick in the source code of the component, the action is registered. 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. In the example of FIG. 21, the data holding format is a json file as an example of implementation means, but the data holding format may be a file of another format or a database. After that, the process transitions to step S604.

Next, in step S604, the program development apparatus 101 determines whether there is a property input request. Specifically, it is determined whether the display element 1101 (icon) in FIG. 11, which is an example of the property input request button for the selected part, has been pressed.

If it is determined that there is a property input request, the process proceeds to step S605, and if there is no property input request, the screen definition input reception processing ends.

After transitioning to step S605, the program development apparatus 101 receives property input for the screen component by the developer. Specifically, the display element 1102 (dialog box) in FIG. 11, which is an example of a screen property editor, is displayed to accept input of settings for the properties of the screen component. In the example of FIG. 11, the screen property editor is displayed near the component in order to realize an intuitive operation by the developer, but a specific area within the screen may be reserved for the screen property editor. Alternatively, the screen property editor may be displayed in a modal dialog.

This completes the description of FIG.

Next, details of the processing in step S503 will be described with reference to FIG.

FIG. 7 is a diagram showing 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 .

The flowchart in FIG. 7 is the flow of processing that is started when the process transitions to step S503 in the flowchart in FIG.

First, in step S701, the program development apparatus 101 reads the setting of the action item specified by the developer in step S502 of FIG. Specifically, the following two measures will be implemented. First, the layout example 1004 in FIG. 10, which is an example of the screen component definition 403 of the screen component selected by the developer, is defined, and the definition 2101 in FIG. 21 is read. It is assumed that the data of definition 2101 is input from 1102 in FIG. 11 at step S605 of the flowchart in FIG. Next, the "actions" definition 2102 corresponding to the production environment of the screen component selected by the developer and the "examples" definition 2103 corresponding to the prototype application are read.

Next, in step S702, the program development apparatus 101 determines whether the setting of the action item read in step S701 involves screen transition. Specifically, it is determined 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. FIG. In this embodiment, the program development apparatus 101 holds the screen transition definition 404 in the screen component definition 403 , but may hold it in the action 405 .

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

After transitioning to step S703, the program development apparatus 101 displays a transition destination screen for screen transition accompanying setting of the action item read in step S701. Specifically, the screen 1300 in FIG. 13, which is the screen set in "nextUi" of the definition 2101, is displayed. It is assumed that the prototype data display component 1302 of the transition destination screen in FIG. 13 is also set in advance by the developer's operation (step S601). A screen such as the prototype data display component 1302 may be displayed by rewriting the currently displayed screen definition editor section 421 or by activating a new screen definition editor section 421 .

The initial display action of the screen (transition destination screen) displayed in the screen definition editor unit 421 is read, and this action is designated by the developer. After this process, the process transitions to step S704.

In step S704, program development apparatus 101 reads prototype data already set in the action read in S701 or in the action read in S703 (for example, data such as the prototype data 2201 in FIG. 22 is already set). data) is displayed on the screen.

Next, in step S705, program development device 101 receives selection of a prototype data display component by the developer. Here, the prototype data display component is a component that displays data (prototype data) in advance when the prototype application is operated. Specifically, this is an example of displaying the prototype data in a list such as the prototype data display component 1302 of the transition destination screen in FIG. In the prototype data display component 1402 of FIG. 14, which is the same diagram, for example, by right-clicking the mouse (not shown) in the "Name" column and pressing the edit button 1403, the selection of the prototype data display component can be accepted. When the table input button 1702 is pressed after selecting the entire list like the prototype data display component 1701 in FIG. 17, the entire list of the prototype data display component 1701 can be selected as the selection of the prototype data display component. can.

In the next step S706, program development apparatus 101 accepts input of prototype data by the developer. Specifically, the prototype data input dialog 1501 of FIG. 15, which is an example of the prototype data input unit 425, is displayed. A prototype data input dialog 1501 is a prototype data input dialog displayed when the edit button 1403 is pressed in the "Name" field in the pop-up item 1401 of FIG. In the case of the prototype data input dialog 1501, the prototype data "Noriyuki Tanigawa" is input by the developer in the "Name" field. After the developer inputs the values, by pressing the "OK" button in the prototype data input dialog 1501, it is determined whether or not the input is confirmed in step S707.

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

A prototype data input dialog 1801 in FIG. 18 is a dialog displayed when the table input button 1702 in FIG. 17 is pressed. The text input field of the prototype data input dialog 1801 accepts input of a data group to be displayed in the list displayed on the prototype data display component 1701 . In the case of the prototype data input dialog 1801, "(blank)", "Noriyuki Tanigawa" and "(blank)" are on the first line, and "1001", "Ai Hori" and "2019/10/10" are on the second line. ”, and the data “1002”, Ruriko Yamamura”, and “2019/09/18” are input in the third line. By selecting a CSV file or a spreadsheet file from a file selection screen (not shown) displayed by pressing the file selection button 1802, the contents of the file may be adapted to these data inputs.

After the developer inputs a value in the text input field or reflects the data after file selection, it is determined whether or not the input in step S707 is confirmed by pressing the "OK" button 1803. FIG.

In step S706, locale designation may be accepted in order to switch the prototype data to be displayed depending on the language. Moreover, although a method of displaying a modal dialog is shown as a prototype data input acceptance method, the input acceptance method may be a method of accepting direct input to the display component selected by the developer in S705. , may be batch input by an external file.

In the next step S707, the program development apparatus 101 determines whether the prototype data input by the developer has been confirmed. Specifically, it is determined 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. In the input reception method of step S706, when a direct input to a component is received, determination is made based on whether the component is out of focus.

If it is determined that the prototype data input has been finalized (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 finalized, the process proceeds to step S706.

In step S<b>708 , the program development apparatus 101 writes the prototype data input by the developer to the screen definition 402 . Specifically, it is written to the prototype data 2201 that is an example of the prototype data 406 linked to the action 405 of the screen definition 402 .

In this method, it is not possible to change the data displayed on the post-transition screen by the action to be executed. This is because the prototype data is held in the initial display action of the screen after transition, but by holding the prototype data to be displayed on the screen after transition on the action side to be executed, it is displayed on the screen after transition by the action to be executed. It may be possible to change the data. Specifically, by holding the objects under "onLoad" in the prototype data 2201 under "onClick" in the definition 2103, the original button for screen transition (for example, "Register button" placed on the screen 1000 in FIG. ” button may have data to be displayed on the screen after transition.

In this way, the screen on which the prototype data is displayed is displayed on the prototype application by transitioning the screen for each action event. ), you can get an overview of how it behaves as a mockup before creating it.

Next, details of the processing in step S507 will be described with reference to FIG.

FIG. 8 is an example of a flowchart illustrating the flow of processing for generating the source code of the prototype application of web application software. Each step of the following flowchart is executed by the CPU 201 of the program development device 100. FIG.

The flowchart in FIG. 8 is a flow of processing that is started when the process transitions to step S507 in the flowchart in FIG.

First, in step S801, the program development apparatus 101 reads the application definition 401 specified by the developer from the repository definition unit 400. FIG. The repository definition analysis unit 411 analyzes the read definitions and stores them in the ROM 203, and the analyzed definitions are appropriately referred to by each generation unit.

At step S802, the program development apparatus 101 reads the screen definition 402 included in the application definition 401 read from the repository definition unit 400 at step S801.

In step S802, when reading the screen definition, information on the display authority defined for each screen display item (item) is also obtained. Description will be made with reference to the example of FIG. In FIG. 34, if the underlined portion 3402 is defined as the line that changes the display item (item) according to the user's authority, the user's authority name 821 in the display authority data 820 in FIG. Information that links the item 822 and the like are acquired. The display authority data 820 in FIG. 8 is information on the display authority defined in "attendance confirmation", which is one of the screen display items included in the screen in FIG. In the case of the display authority data 820 in FIG. 8, the authority names of "User", "Admin", and "Guest" as the user authority, and input/output displays corresponding to the respective authority names are displayed. Permissions are defined. Input/output permission items are selected from the group of element items (remarks, attendance confirmation (User), attendance confirmation (Admin), update button) included in the screen display item "attendance confirmation" in FIG. Element items to be displayed are defined. This display item definition information corresponds to the authority among the input/output display permission (group of element items included in the "attendance confirmation" column (remarks, attendance confirmation (User), attendance confirmation (Admin), update button). (element items to be displayed) may be defined. In addition, this display item definition information corresponds to the authority among the input/output display prohibited items (the group of element items included in the "attendance confirmation" column (remarks, attendance confirmation (User), attendance confirmation (Admin), update button) element items that should not be displayed as The display authority may be defined collectively for the display items, or may be defined individually for each display item like the display authority data 820 .

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

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

In step S805, the program development apparatus 101 collects the authority (role/role) associated with the display item acquired in step S802. For example, user authority data 830 is obtained.

In step S806, program development apparatus 101 reads prototype data 406 included in screen definition 402 read in step S802 from repository definition unit 400. FIG. The data in the screen definition 402 to be read here is the "examples" data shown in FIG. 21 and FIG. 22 corresponding to the prototype data, and the "actions", that is, data for the production environment is not used. By having these two data, it becomes possible to create common screen definitions for prototype data and screen definitions for the production environment, and application software screens created for mockups can be defined as application software screens.

In step S807, program development apparatus 101 causes prototype code generation unit 412 to generate the source code of the prototype application based on the information read in steps S801 to S806. The generated source code also includes the source code of the prototype operation panel (such as the prototype operation panel 3102 in FIG. 31) that is displayed when the prototype application is activated.

FIG. 31 is an example of a prototype display screen (display screen by prototype application) in this embodiment. FIG. 31 is a display example of the prototype operation panel displayed on the initial screen when the prototype application is activated according to the source code generated in S807. The prototype operation panel is an operation panel for setting how to display a prototype application screen 442 that imitates screen transitions of application software in a production environment and is displayed by the prototype application.

A prototype operation panel will be described with reference to FIG. A prototype operation panel 3102 in FIG. 31 is used to instruct a user (for example, a prototype of application software under development) of display settings and settings at the time of transition when displaying a prototype screen or transitioning and displaying prototype screens. This is a panel screen for receiving from a developer who conducts demonstrations for customers). The prototype operation panel 3102 includes a display device (PC, tablet, smartphone, etc.), screen orientation of the display device, user access rights (Admin authority (administrator authority), User authority (general user authority), etc.), server Whether or not to display the processing time and whether or not to display when an error occurs can be set. The display in the prototype application changes as follows according to these settings set according to the operation from the user on the prototype operation panel. That is, the size and orientation of the screen change according to the setting of the display device and the orientation of the screen of the display device. The content displayed in the prototype application changes according to the user's access right settings. Depending on whether or not to display the processing time on the server, whether or not to display the hypothetical processing time on the server changes. Depending on the setting of the presence/absence of display when an error has occurred, whether or not the display assuming that an error has occurred changes. A display device setting can be set using a display device setting item 3111, a user authority setting can be set using an authority setting item 3121, a process waiting time setting can be set using a processing time setting item 3131, and an error display setting can be set using an error setting item 3141, respectively. For example, by pressing (clicking) a button 3112 for setting the screen size to PC, the display device setting (screen size setting) can be set to PC.

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. 25 and 31. FIG.

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

A prototype display screen 2501 serving as a base of the parent screen is a parent screen displayed on the browser, and a prototype application screen 2502 is displayed in iFrame in the parent screen. 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 so that a part of the prototype application screen 2502 and the prototype operation panel 2503 can be confirmed at the same time. It is displayed on the prototype display screen 2501 .

Most of the prototype display screen 2501 can be used as the prototype application screen 2502 by hiding the prototype operation panel 3102 (2503). When the prototype operation panel 3102 shown in FIG. 31 accepts a setting operation from the user, and accepts an operation to shrink the prototype operation panel 3102 (2503) by operating the shrink icon 3103 (an operation to hide) from the user, for example, the prototype is displayed. A prototype application screen 3201 as shown in FIG. 32, which is a screen with the operation panel 3102 hidden, is displayed. In this case, it corresponds to prototype display screen 2521 in FIG. 25, and prototype application screen 3201 in FIG. 32 corresponds to prototype application screen 2502 in FIG. To return from the prototype application screen 3201 (2522) to the screen displaying the prototype operation panel 3102 (2503), press the button 3202 (2523), which is a button icon that functions as a prototype operation panel display button, to return to the prototype application screen 3201 (2522). The screen transitions to the prototype application screen 3101 in FIG. 31 on which the 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 in FIG. ), and the prototype operation panel 3102 (prototype operation panel 2503 in FIG. 25) is displayed again. Returning to the description of the flowchart in FIG.

The source code generated in step S807 is the source code of TypeScript that is started when the prototype operation panel is operated and the browser storage area (Web Storage or cookie information) in which the operation is stored is changed.

Next, in step S808, the program development apparatus 101 generates source code for changing screen display for each user authority. The generated source code is the source code of a program that determines user authority and controls display/hide of screen components to which user authority is applied. That is, step S808 is processing for generating a program for displaying a prototype screen when user authority is set.

In step S809, the program development apparatus 101 generates source code for reproducing screen display that occurs when connecting to the server. The generated source code is the source code of the program part for displaying the prototype display screen reflecting the contents set 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 executed when a processing time (processing waiting time) value is entered in the processing time setting item 3131 or when error setting is set to ON in the error setting item 3141, and is stored in the browser. This is a program that displays a prototype (prototype) screen that reflects the processing settings of the pseudo server acquired from the area. In other words, step S809 is a process of generating a program for reproducing pseudo-communication with the server and the status of the server.

In step S810, the program development apparatus 101 generates a program for displaying the prototype application screen 2502 (iFrame) reflecting the content set in the display device setting item 3111 of the prototype operation panel 2503 (3102). The generated source code is 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. It is the source code of TypeScript.

After generating the above source code, the process of the flow chart of FIG. 8 ends. Although TypeScript is used as an example of the source code generated in S807 to S810, the source code may be written in other languages, such as JavaScript.

This completes the description of FIG.

Next, the flow of processing 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. 5, the web browser activated in step S511 of the program development apparatus 101 may start communication with the deployed prototype display screen application. Alternatively, as illustrated in FIG. A web browser may initiate communication with the deployed execution server 102 .

FIG. 9 is a flow chart 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 .

The flowchart of FIG. 9 is a flow of processing that is started when the 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). .

In step S901, the client device 104 first reads the locale information of the browser. With this locale information, it is possible to switch the display language of the prototype data.

In step S902, the client device 104 downloads from the execution server 102 (430) the SPA (single page application) in which the prototype display screen (the application software generated in steps S807 to S810 in FIG. 8) operates. In this embodiment, the prototype display screen 440 is described as an SPA, but it does not have to be an SPA. to download.

Also, in step S902, the client device 104 acquires user authority information for the prototype application.

Further, in step S902, the client device 104 activates (displays) the prototype display screen 2501 (prototype display screen 440) from the program obtained from the execution server 102 (430). That is, step S902 is a step for performing processing for downloading and starting a program for displaying a screen such as the prototype application screen 3101 in FIG.

In step S<b>903 , the client device 104 activates the prototype application screen 2502 in the iFrame portion of the prototype display screen 2501 . A display example of the activated screen is the prototype application screen 3201 in FIG. However, in the next step S904, the prototype operation panel 3102 is displayed in the upper layer (relation like the prototype application screen 2502 and the prototype operation panel 2503 in FIG. 25).

In step S<b>904 , the client device 104 activates the prototype operation panel (iFrame) 2503 in the iFrame portion of the prototype display screen 2501 . As a result, as shown in FIG. 31, a prototype operation panel 3102 is superimposed on the prototype application screen 3101 and displayed. By changing the settings displayed on the prototype operation panel 3102, display settings and screen transition settings of the prototype application can be controlled.

In step S<b>905 , the client device 104 changes the display screen of the prototype application screen 3201 ( 442 ) or changes the transition screen according to each setting input to the prototype operation panel 3102 . Screen display or transition screen display processing of the prototype display screen 440 according to each setting will be described later with reference to FIGS. 26 to 29, respectively.

Next, in step S906, the client device 104 waits for a developer's instruction to finish reproducing the application software by the prototype application. If the reproduction of the application software is to be terminated, this flow chart is terminated, and if an instruction to reproduce the application software is received again, the process returns to step S902.

Next, as details 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 each setting input to the prototype operation panel 3102 is shown in FIG. Description will be made with reference to FIG. The processes in FIGS. 26 to 29 are realized by a program (ie prototype application) based on the source code generated by the process in FIG. The respective settings are switching of the display device, change of user authority, reproduction of processing time with the server, and reproduction when an error occurs.

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

The flowchart of FIG. 26 is a flowchart that is started when the user accesses via the web browser 450 of the client device 104 and the SPA of the prototype display screen 440 is downloaded to the web browser 450 . 26 to 29 partly overlap with the description of FIG.

The processing of steps S2601 and S2602 is the same as the processing of steps S902 and S903 in FIG.

In step S 2603 , the client device 104 activates the prototype operation panel (iFrame) 2503 in the iFrame section of the prototype display screen 2501 . The process up to this point is the same as the process of step S904 in FIG. The details of the processing of S905 in FIG. 9 are described below.

When the user operates the display device setting item 3111 while the prototype operation panel 3102 is displayed and the display device setting (screen size setting) is changed, the process proceeds to the next step S2604. do. In the display device setting item 3111, each terminal (PC, tablet (portrait), tablet (landscape), smartphone (portrait), smartphone (landscape)) whose screen size is predefined is displayed as options that can be set. be. For tablets and smartphones, you can select and set either portrait or landscape orientation. The reason why it is possible to set vertical and horizontal orientations is that tablets and smartphones can be displayed in both vertical and horizontal orientations.

Returning to the description of the flowchart in FIG. 26, when the process transitions to the next step S2604, the client device 104 receives an instruction to change to the screen size of the device changed on the prototype operation panel 3102. FIG.

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. FIG. 33 shows a display example of the prototype application screen 2502 when the smartphone (portrait orientation) is set.

A prototype application screen 3301 in FIG. 33 is displayed within a smartphone-sized area 3302 . Even if the screen is displayed in smartphone size, the process of the prototype application is executed as a prototype. For example, when a predetermined button is pressed, the transition destination screen that reflects the prototype data corresponding to that action is displayed. can do.

Through the above processing, it is possible to easily create a prototype application in which the display mode is changed for each device.

Next, with reference to FIG. 27, the flow of processing for changing screen display when user authority is changed will be described.

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

The flowchart of FIG. 27 is a flowchart that is started when the user accesses via the web browser 450 of the client device 104 and the SPA of the prototype display screen 440 is downloaded to the web browser 450 .

The processing of steps S2701 and S2702 is the same as the processing of steps S902 and S903 in FIG.

Note that in step S2701, the client device 104 acquires user authority information for the prototype application. Examples of data to obtain are data such as user authority data 2710 . This data is together with the user authority data 830 acquired in step S805 when generating the prototype application.

In step S 2703 , the client device 104 activates the prototype operation panel (iFrame) 2503 in the iFrame section of the prototype display screen 2501 . The process up to this point is the same as the process of step S904 in FIG. The details of the processing of S905 in FIG. 9 are described below. Among the authority setting items 3121 in FIG. 31, check boxes for setting user authority are generated based on the user authority data 830 acquired in step S2710.

When the user operates the authority setting item 3121 while the prototype operation panel 3102 is displayed and the authority setting is changed, the process proceeds to the next step S2704.

Upon transitioning the process to step S2704, the client device 104 stores the changed value of the authority setting item 3121 on the prototype operation panel 3102 in the local storage of the browser.

In step S2705, client device 104 displays prototype application screen 2502 with the user authority settings stored in step S2704. FIG. 34 shows a display example of the prototype application screen 2502 when the authority setting item 3121 is set to "user".

A prototype application screen 3401 in FIG. 34 is different from the prototype application screen 3201 in FIG. 32 in that an attendance check (User) is additionally displayed in a portion indicated by an underline 3402 . This is an image diagram reflecting the input/output permission item data 820 for each user authority acquired in step S802 when generating the prototype application. That is, since the authority setting item 3521 has been changed to "user", the authority name (Name) corresponding to "user" of the user authority data 830 is "User", and the input/output permission item is set with the "User" authority. are "attendance confirmation (User)" and "remarks". Therefore, the prototype application screen 3401 in FIG. 34 displays an attendance confirmation (User) column and a remarks column as underlined 3402 .

Another example is also described.

On the other hand, in the authority setting item 3121 in FIG. 31, it is also possible to put a check mark in three of "guest", "user", and "admin". If three items are checked, according to the data 820 and the user authority data 830 in FIG. 8, the "remarks" column, the attendance confirmation (User) column, the attendance confirmation (Admin) column, and the update button are input/output permitted items. .

FIG. 35 is a display example displayed when three items of authority setting item 3121, “guest”, “user”, and “admin” are checked.

Unlike the prototype application screen 3201 of FIG. 32, the prototype application screen 3501 of FIG. 35 additionally displays attendance confirmation (Admin) and attendance confirmation (User) 3503 in the underlined portion 3502, and furthermore, An update button 3504 is additionally displayed.

The above processing has the effect of creating prototype application software that performs screen transitions depending on the role of the user. In other words, if prototype application software that allows only normal screen transitions is generated, it will be a pattern in which only predetermined screen displays and predetermined screen transitions can be performed regardless of user authority. It has panel settings, and can reproduce switching of the displayed screen for each user authority by switching the user authority.

Next, with reference to FIG. 28, the flow of processing for displaying the reproduction of the processing time on the server will be described.

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

The flowchart of FIG. 28 is a flowchart that is started when the user accesses via the web browser 450 of the client device 104 and the SPA of the prototype display screen 440 is downloaded to the web browser 450 .

The processing of steps S2801 and S2802 is the same as the processing of steps S902 and S903 in FIG.

In step S 2803 , the client device 104 activates the prototype operation panel (iFrame) 2503 in the iFrame section of the prototype display screen 2501 . The process up to this point is the same as the process of step S904 in FIG. The details of the processing of S905 in FIG. 9 are described below.

When the user operates the processing time setting item 3131 while the prototype operation panel 3102 is displayed and the processing time setting is changed, the process proceeds to the next step S2804. The processing time setting item 3131 is a setting field for reproducing the screen transition display of the prototype application screen 2502 in consideration of the processing time on the server.

For example, the processing time setting item 3131 of the prototype operation panel 3102 in FIG. 31 is set to "0.2 seconds", but can be changed to "2 seconds" according to the user's operation.

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

In the next step S2805, the client device 104 changes the setting of the prototype application screen 2502 to wait for the processing time stored in step S2804, and changes the prototype application to be reproduced so as to transition to the next screen.

If the processing time setting item 3131 sets the processing time to "2 seconds", for example, pressing the search button 1602 on the prototype application screen 1601 in FIG. Display the display item 1902 for 2 seconds as if it were being processed. The time for displaying the display item 1902 indicating that processing is in progress is the time set by the processing time setting item 3131 . After the display item 1902 is displayed for the set time, the next transition destination screen such as FIG. 32 is displayed.

The above processing has the effect of creating prototype application software that virtually reproduces the waiting time during screen transition. That is, it is possible to reproduce the processing time that occurs on the server side when the application software (product application) in the production environment is operated. For example, when business users and sales representatives demonstrate a prototype application to general users, the processing time with the server that would actually take a long time is reproduced, and what kind of screen is displayed during the processing time with the server. It is possible to reproduce what is done. Since this prototype application is built in SPA, no communication with a real server is required. Therefore, if it is only to execute the prototype application (screen transition), it does not take much processing time, and the prototype application screen transitions one after another according to the user's operation. Since the processing time on the server is not considered in the operation of the application software (product application) in the production environment, general users who are satisfied only by seeing the demonstration that does not take the processing time on the server into consideration will performance discrepancies. In the demonstration of this embodiment, the processing time of the server can be freely set, so the risk of discrepancies in the performance of development deliverables is reduced. Also, by displaying the prototype operation panel, it is possible to change the virtual processing time on the server even while the prototype application is running.

According to this embodiment, even the display screen of the prototype application (for example, the prototype application screen 1601 in FIG. 16) is displayed using the same screen definition information as the application software displayed in the production environment. A similar screen can be displayed.

On the screen of the production environment by the application software, when there is an operation to press (click) the search button, that is, an operation to instruct the search, based on the search keyword ("self-care"), search processing takes time from the database on the Internet. is performed, and display based on the search results is performed after the search process is completed.

On the other hand, on the display screen of the prototype application (for example, FIG. 16), the database on the Internet is searched in response to pressing (clicking) of the search button 1602 corresponding to the search instruction operation in the production environment. Prototype data, which is a predetermined display content as shown in FIG. 32, is displayed without communication with the Internet. The prototype data displayed in FIG. 32 are display contents imitating the display based on the result of the search processing. At this time, if the processing time setting item 3131 sets the processing time to a value greater than zero (if the display item 1902 is set to be displayed), pressing the search button 1602 in FIG. 32, a display item 1902 that virtually indicates the waiting time for search processing is displayed for the set time. After that, the display of FIG. 32 (display of prototype data as predetermined display contents) is performed.

Prototype data is not displayed based on the results of the search process.

Also, the time for displaying the display item 1902 is the time set by the user for the processing time setting item 3131 and is not related to the time required for the search processing.
Also, the time for displaying the display item 1902 is the time for virtually reproducing the time required for the search processing.

If the processing time setting item 3131 sets the processing time to zero, or sets the display item 1902 not to be displayed, the display item 1902 will be displayed when the search button 1602 in FIG. 16 is pressed. 16 to the display of FIG. 32 directly. At this time, it does not wait for a predetermined time.

In the prototype application screen, when an operation (for example, clicking an "image processing button (not shown)") corresponding to an instruction to execute a process (for example, image processing) that takes longer than the search process is performed. , 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 feel that processing takes time (waiting time increases). For example, the display item 1902 is displayed five seconds longer than the time set by the processing time setting item 3131 . After that, predetermined display contents simulating the display of the execution result of the image processing are displayed. Again, since this is a prototype application, no image processing is performed.

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

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

The flowchart of FIG. 29 is a flowchart that is started when the user accesses via the web browser 450 of the client device 104 and the SPA of the prototype display screen 440 is downloaded to the web browser 450 .

The processing of steps S2901 and S2902 is the same as the processing of steps S902 and S903 in FIG.

In step S 2903 , the client device 104 activates the prototype operation panel (iFrame) 2503 in the iFrame section of the prototype display screen 2501 . The process up to this point is the same as the process of step S904 in FIG. The details of the processing of S905 in FIG. 9 are described below.

When the user operates the error setting item 3141 while the prototype operation panel 3102 is displayed, and the virtual error occurrence setting is changed from "off" to "on", the processing of the next step S2904 is performed. transition to

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

In step S2905, the client device 104 obtains the error setting state stored in the prototype application screen 2502 in step S2904.

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

In the next step S2906, the client device 104 divides the processing depending on whether the acquired error setting state is on (valid) or off (invalid). If the error setting state is ON, the process transitions to step S2907, and if the error setting state is OFF, the process transitions to step S2908. When the processing transitions to step S2908, since the error setting state is off, the client device 104 transitions to FIG. 32, which is the normal transition screen of the prototype application.

On the other hand, when the process proceeds to step S2907, the client apparatus 104 proceeds with the process assuming that an error has occurred in the prototype application. Specifically, the screen in FIG. 16 is changed to the screen in FIG.

In FIG. 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 the message "An error has occurred in server processing."

Through the above processing, it is possible to create a prototype application that can virtually reproduce an error screen when screen transition fails. In other words, it is possible to virtually reproduce errors that occur on the server side or during communication during the execution of application software (product applications) in the production environment. Since this prototype application is built in SPA, no communication with a real server is required. Therefore, if you just execute the prototype application (screen transition), no server error or communication error occurs. SPA can meet the demands of developers and general users who want to reproduce the display screen when an error occurs. Also, as a method of reproducing the error display more realistically, in FIG. 28, it is combined with the reproduction of the virtual processing time on the server.

Since the prototype display screen as described above is composed of SPA that can be activated within the browser of various terminals, if a prototype application generated like the prototype display screen 2501 in FIG. 30 is downloaded to a PC or tablet, , the prototype application screen 2502 can be reproduced on each terminal. For example, if a prototype application is downloaded to the tablet 3001, the prototype operation panel 2503 and prototype application screen 2502 can be operated on the tablet. A prototype display screen application can be run on a tablet without the salesperson having to bring a PC. A prototype application that reproduces the processing time on the server can also be operated on the tablet, and the display (3002) on the tablet can reproduce the smartphone-sized display (3003). Therefore, when demonstrating to a customer, if you bring one terminal, you can reproduce the screen displayed on any terminal and the pattern of screen transition.

As described above, a recording medium recording a program for realizing the functions of the above-described embodiments is supplied to a system or device, and the computer (or CPU or MPU) of the system or device reads the program stored in the recording medium. Needless to say, the object of the present invention can also be achieved by reading and executing.

In this case, the program itself read from the recording medium implements the novel functions of the present invention, and the recording medium recording the program constitutes the present invention.

Examples of recording media for supplying programs 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 A disk or the like can be used.

Further, by executing the program read by the computer, not only the functions of the above-described embodiments are realized, but also based on the instructions of the program, the OS (operating system) and the like running on the computer are actually executed. Needless to say, a case where part or all of the processing is performed and the functions of the above-described embodiments are realized by the processing are included.

Furthermore, after the program read from the recording medium is written in the memory provided in the function expansion board inserted into the computer or the function expansion unit connected to the computer, the function expansion board is read according to the instruction of the program code. It goes without saying that a case where a CPU or the like provided in a function expansion unit performs part or all of the actual processing and the functions of the above-described embodiments are realized by the processing.

Moreover, the present invention may be applied to a system composed of a plurality of devices or to an apparatus composed of a single device. Further, it goes without saying that the present invention can be applied to the case where it is achieved by supplying a program to a system or device. In this case, by loading a recording medium storing a program for achieving the present invention into the system or device, the system or device can enjoy the effects of the present invention.

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.

Furthermore, by downloading and reading out the program for achieving the present invention from a server, database, etc. on the network using a communication program, the system or device can enjoy the effects of the present invention. It should be noted that all configurations obtained by combining each of the above-described embodiments and modifications thereof are also included in the present invention.

101 Program development device 102 Execution server 103 Database server 104 Client device 105 Network

Claims (17)

display control means for controlling to display a screen displayed by application software;
Predetermined display content without executing the specific process in response to a specific operation corresponding to an operation for instructing execution of a specific process while the screen is being displayed having control means for controlling to display
In response to the specific operation, the control means displays a predetermined display item indicating a waiting time for processing for a predetermined time before displaying the predetermined display content, and then An information processing apparatus characterized in that the predetermined display content is displayed on the display. Regardless of the processing time required to display the predetermined content, the control means waits for the predetermined time to elapse after the specific operation is performed before performing the predetermined display. 2. The information processing apparatus according to claim 1, wherein control is performed so as to display contents. 3. The information processing apparatus according to claim 1, wherein said predetermined time is a time for virtually reproducing the time required for said specific processing. 4. The information processing apparatus according to any one of claims 1 to 3, wherein the specific operation is an operation for a specific screen component displayed on the screen. The specific process is a process including searching a database,
The predetermined display content is a display content that imitates a display of a result of searching the database,
5. The information processing apparatus according to any one of claims 1 to 4, wherein said control means controls to display said predetermined display content without searching said database. The specific process is a process including communicating with the Internet,
6. The information processing apparatus according to any one of claims 1 to 5, wherein said control means controls to display said predetermined display content without communicating with the Internet. further comprising setting means for setting a setting related to display of the predetermined time or the predetermined item according to a user's operation;
When the predetermined time is set to zero or the predetermined display item is set not to be displayed by the setting means, the control means performs the specific operation while the screen is being displayed. is performed, the predetermined display content is displayed without displaying the predetermined display item and without waiting for the predetermined time to elapse. 7. The information processing apparatus according to any one of claims 1 to 6. 8. The information processing apparatus according to any one of claims 1 to 7, wherein the predetermined time can be set by a user. The screen 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 control means executes the specific processing, and displays a display based on the execution result of the specific processing. 9. The information processing apparatus according to any one of claims 1 to 8, wherein the information processing apparatus controls to perform the processing. without executing the second process in response to a second operation corresponding to an instruction to execute a second process that takes longer than the specific process. displaying a display item indicating that it is waiting time for a process for a second time longer than the predetermined time, and then displaying a predetermined display content simulating a display of the execution result of the second process; 10. The information processing apparatus according to any one of claims 1 to 9, wherein control is performed so as to acquisition means for acquiring definition information defining display items to be displayed on a first screen of an application and a procedure for transitioning from the first screen to the next second screen;
displaying the first screen defined by the definition information obtained by the obtaining means, and displaying a predetermined waiting time indicating a waiting time for processing in response to a specific operation on the first screen; generating means for generating instruction information instructing display items to be displayed for a predetermined period of time, and then to transition to the second screen defined by the procedure of the definition information obtained by the obtaining means; An information processing device comprising: the specific operation is an operation corresponding to an operation instructing execution of a specific process;
The instruction information instructs to display the predetermined display item without performing the specific processing even if the specific operation is performed, and then control to transition to the second screen. 12. The information processing apparatus according to claim 11, wherein the information is information. 13. The information processing apparatus according to claim 12, wherein said predetermined time is a time for virtually reproducing the time required for said specific processing. a display control step for controlling to display a screen displayed by application software;
Predetermined display content without executing the specific process in response to a specific operation corresponding to an operation for instructing execution of a specific process while the screen is being displayed has a control step for controlling to display
In the control step, in response to the specific operation, before displaying the predetermined display content, a predetermined display item indicating a waiting time for processing is displayed for a predetermined time, and then A control method for an information processing apparatus, comprising: controlling to display the predetermined display content on the display. an acquisition step of acquiring definition information that defines a display item to be displayed on a first screen of an application and a procedure for transitioning from the first screen to the next second screen;
displaying the first screen defined by the definition information acquired in the acquiring step, and displaying a predetermined waiting time indicating a waiting time for processing in response to a specific operation being performed on the first screen; A generation step of displaying a display item for a predetermined period of time, and then generating instruction information instructing a transition to the second screen defined by the procedure of the definition information acquired in the acquisition step. A control method for an information processing device, comprising: A program for causing a computer to function as each means of the information processing apparatus according to any one of claims 1 to 13. A computer-readable storage medium storing a program for causing a computer to function as each means of the information processing apparatus according to any one of claims 1 to 13.

Images