Information processing device, information processing system, control method, program, and recording medium

Abstract

To provide a mechanism capable of efficiently developing an application using the display and function of an existing component.MEANS FOR SOLVING THE PROBLEM: An information processing device stores both an item to be arranged on a screen and information on display and / or function of a component; arranges the item on the screen; associates the component with the arranged item; and generates a program capable of executing the display and / or function of the associated component.SELECTED DRAWING: Figure 7

Description

[Technical Field]

[0001] Information processing device, information processing system 、 Control Method 、 program and recording media Regarding. [Background technology]

[0002] In recent years, development efficiency has been improved by using application development programs.

[0003] For example, when designing a screen, rather than manually typing in source code, a technology is becoming popular that allows screen design by placing components such as input fields and buttons (items that can be placed on the screen in the application under development) on the screen.

[0004] However, there are limitations to the components and functions that a single application development program provides. Sometimes, you may want to incorporate components created and published (provided) by third parties, as well as the functions realized by those components, into the application you are developing.

[0005] One way to incorporate a component would be to create a component with the same appearance and functionality from scratch, using the appearance (display) and functions of the component as a reference, but this is extremely time-consuming and leads to a decrease in efficiency in the entire application development process. Therefore, it is desirable to reuse the code related to the appearance (display) and function of the component that has already been made public.

[0006] For example, Patent Document 1 describes a technique in which, when developing a program that includes special instructions that are not registered in an editor for program development and editing, a program is created in which identifiers are assigned to existing instructions, and the program is then converted into a program in which the instructions with the identifiers are replaced with special instructions in accordance with conversion rules. It also describes that when an element in a program corresponds to the identifier, the element is converted into a function registered in the conversion rules, making it possible to easily change and set the number and content of arguments of the special instructions. [Prior art documents] [Patent documents]

[0007] [Patent Document 1] Japanese Patent Application Publication No. 11-24905 DISCLOSURE OF THE INVENTION [Problem to be solved by the invention]

[0008] The technology of Patent Document 1 makes it possible to easily call and implement existing functions. However, with the technology of Patent Document 1, it is necessary to add special instruction identifiers directly to the program code.

[0009] For example, if you want to replace the data output processing of a component with different data processing, you need to find the part of the code that corresponds to that data output processing.In other words, to the extent that the user can recognize which output command they want to assign a special command to and add or rewrite the code, they need to be able to read and understand the code created by the program development application and be familiar with programming itself.

[0010] This invention does not involve the use of components created by anyone other than the provider of the application development program. 、 or 、 The purpose is to provide a mechanism that enables easy application development using components provided by parties other than the provider of the application development program. [Means for solving the problem]

[0011] The present invention Program teeth, The information processing device includes a receiving unit for receiving settings relating to the display of a component, and a display unit for displaying the execution result of a process associated with the component on an application screen based on the settings. A program for functioning as a construction means for controlling the construction of the application, The part is Parts created by parties other than the provider of the program 、 or 、 Parts provided by parties other than the provider of the program is It is characterized by: [Effects of the Invention]

[0012] According to the present invention, it is possible to provide a mechanism that allows easy application development using the displays and functions of existing components. [Brief explanation of the drawings]

[0013] [Figure 1] 1 is a diagram illustrating an example of a configuration of an information processing system according to an embodiment of the present invention. [Figure 2] FIG. 2 is a diagram illustrating an example of a hardware configuration of various devices according to an embodiment of the present invention. [Figure 3] FIG. 2 is a diagram illustrating an example of the functional configuration of various devices according to an embodiment of the present invention. [Figure 4] FIG. 2 is a diagram illustrating detailed functional configurations of various devices according to an embodiment of the present invention. [Figure 5] 10 is a flowchart illustrating the flow of a custom part registration process according to an embodiment of the present invention. [Figure 6] 10 is a flowchart showing the flow of an application generation process in the embodiment of the present invention. [Figure 7] 10 is a flowchart showing the flow of a code generation process for a custom part in an embodiment of the present invention. [Figure 8] FIG. 2 is a diagram showing an example of a configuration of a display screen in the embodiment of the present invention. [Figure 9]FIG. 2 is a diagram showing an example of a data configuration in the embodiment of the present invention. [Figure 10] FIG. 2 is a diagram illustrating an example of source code according to an embodiment of the present invention. [Figure 11] FIG. 1 is a diagram illustrating an example of source code according to an embodiment of the present invention. DETAILED DESCRIPTION OF THE INVENTION

[0014] Hereinafter, an example of an embodiment of the present invention will be described with reference to the drawings.

[0015] First, with reference to FIG. 1, an example of the configuration of an information processing system according to an embodiment of the present invention will be described.

[0016] The program development device 100 , the database server 200 , and the application server 300 are communicably connected via a network 101 .

[0017] A program development application is installed in the program development device 100, and the program development device 100 is capable of developing and generating programs (application programs).

[0018] For example, you can edit the screen of the target application. Specifically, you can place components (such as buttons and text input fields displayed by the application) on the screen, and set or change the size, shape, and position of the components.

[0019] It is also possible to set and edit the name of the part, the behavior when an operation is received for the part, the input and output data (also called input and output values / input and output data), the input and output destination screens, tables, etc.

[0020] A search application is installed on the database server 200, and the database server 200 can search for data in a database that can be referenced.

[0021] Application server 300 is a server on which an application generated by program development device 100 runs. Program development device 100 stores the code of the generated application in itself, and then stores the code in application server 300 in accordance with a user operation. This concludes the explanation of FIG. 1.

[0022] Next, with reference to FIG. 2, the hardware configuration of various devices in the embodiment of the present invention will be described.

[0023] 2, reference numeral 201 denotes a CPU, which performs overall control of each device and controller connected to a system bus 204. In addition, a ROM 202 or an external memory 211 stores a BIOS (Basic Input / Output System), which is a control program for the CPU 201, an operating system program (hereinafter referred to as OS), and various programs (described later) required to realize the functions executed by each server or each PC.

[0024] A RAM 203 functions as the main memory, work area, etc. of the CPU 201. The CPU 201 loads programs and the like required for executing processing from the ROM 202 or the external memory 211 into the RAM 203 and executes the loaded programs to realize various operations.

[0025] An input controller 205 controls input from a keyboard (KB) 209 and a pointing device such as a mouse (not shown).

[0026] A video controller 206 controls the display on a display device such as a display 210 (for example, a CRT display). The display device is not limited to a CRT display, and may be other display devices such as a liquid crystal display. These are used by the user as needed.

[0027] Reference numeral 207 denotes a memory controller, which controls access to an external memory 211 such as a hard disk (HD) that stores boot programs, various applications, font data, user files, edited files, various data, etc., a flexible disk (FD), or a CompactFlash (registered trademark) memory connected to a PCMCIA card slot via an adapter.

[0028] A communication I / F controller 208 connects to and communicates with external devices via a network (for example, the network 101 shown in FIG. 1) and executes communication control processing over the network. For example, communication using TCP / IP is possible.

[0029] The CPU 201 enables display on the display 210 by, for example, executing a process of expanding (rasterizing) an outline font into a display information area in the RAM 203. The CPU 201 also enables user instructions using a mouse cursor (not shown) or the like on the display 210.

[0030] Various programs for realizing the present invention, which will be described later, are recorded in the external memory 211 and are executed by the CPU 201 by being loaded into the RAM 203 as needed. Furthermore, definition files and various information tables, etc., used when executing the above programs are also stored in the external memory 211, and these will be described in detail later. This concludes the explanation of FIG. 2.

[0031] Next, with reference to FIG. 3, the functional configuration of various devices in the embodiment of the present invention will be described.

[0032] The component storage unit 311 is a storage unit that stores components (template components) that are stored and managed as templates by a program development application installed in the program development device 100, and other components (non-template components).

[0033] Non-template components are, for example, components created independently by users, or components published by a company other than the provider of the program development application, i.e., a third party from the perspective of the company that developed the program development application.

[0034] The characteristics of non-template parts are as follows: Template parts are optimized for the program development application that provides them, whereas non-template parts are not necessarily optimized for the program development application that provides them.

[0035] For example, the data item names of the non-template components themselves, where information (e.g., text) entered into the component is registered, the data item names of the data output to the component (e.g., output from a database to the component for display in a component such as a graph), the data types and restrictions of these data (maximum number of digits to be displayed, restrictions on full-width and half-width characters), etc., do not necessarily match the data item names, data types, and allowable restrictions handled by the program development application installed in the program development device 100 or the program developed by that application (the application generated by the program development application).

[0036] In order to reliably use non-template parts in the program development application and applications generated by the program development application in the same way as template parts, the non-template parts must be optimized for the application that uses them.

[0037] Returning to the explanation of Figure 3, the custom I / O item storage unit 312 is a functional unit that stores images of custom I / O items, non-template components set as custom I / O items, and data conversion rules used when inputting and outputting data to and from non-template components.

[0038] An I / O item (input / output item) is a component that has the ability to input or output data, or both. Examples of I / O items include text fields and graph objects.

[0039] Custom I / O items (custom input / output items) are input / output items (components) that are set to input and output data for non-template components. Components set as custom I / O items are called custom components.

[0040] The custom I / O item placement processor 313 is a functional unit that places custom I / O items on the screen of the application being developed. For example, by dragging and dropping an image of a custom I / O item displayed beside the screen editor onto the screen, the image of the custom I / O item is placed at the dropped position.

[0041] The specification acceptance screen display unit 314 displays a screen for accepting specification of which non-template component is to be associated with a custom I / O item. The specification acceptance unit 315 is a functional unit that accepts specification of the non-template component to be associated with the custom I / O item.

[0042] The application generation unit 316 is a functional unit that generates application code. For example, it generates source code for the entire application, including code for custom I / O items. For example, it has the functions of the application generation unit 410 and custom component source generation unit 430 shown in FIG. 4, which will be described later. This concludes the explanation of FIG. 3.

[0043] Next, referring to FIG. 4, the detailed functional configuration of various devices in the embodiment of the present invention will be described. explain.

[0044] The program development device 100 includes a repository definition unit 400 that manages definition files (generated by a program development application of the program development device) defined by a developer developing an application by operating the program development device, and an application generation unit 410 that generates application code based on these.

[0045] Furthermore, an extension file management unit 420 is provided for storing and managing extension files.

[0046] Furthermore, a custom component source generator 430 is provided to generate source code for the custom I / O item. That is, this generator generates source code related to the custom component set in the custom I / O item.

[0047] The application server 300 stores applications configured by the codes generated by the various code generation units.

[0048] Each functional unit will be described in detail below. The repository definition unit 400 manages an application definition 401, an input / output definition 402, a data model definition 403, a business process definition 404, and a database definition 405.

[0049] These files are input and created by a developer via a program development application and are stored in the external memory of the program development device 100 .

[0050] The application definition 401 is a definition held for each application developed in the program development application, and is information that defines the settings, data, etc. used in the application. Specifically, it is possible to define input / output definitions used when generating an application, an identification code for the application definition itself, and an application name.

[0051] The input / output definition 402 is definition information that includes input definition information that defines items that are input as arguments to a program, and output definition information that defines items that are output from the program as processing results.

[0052] For example, definitions include the type of definition (item type), the identification code (item code) of the definition itself, its name, the item code of the data item that inputs and outputs data, the identification code of the data model that includes the data item (data model code), a setting (display setting) indicating whether or not to display the component defined by the input / output definition on the display screen, and settings for the number of digits of input / output data and how many decimal places to input / output (number of digits, decimal places, etc.). An example of a definition editing screen (a screen displaying a list of definitions) is shown in Fig. 9.

[0053] The data model definition 403 is a definition defined as schema information. Each data model definition holds an identification code and a name. A data model definition defines multiple data items. Specifically, it defines the item code and item name of each data item, the number of digits and data type (character, numeric, date, etc.) used in the data item, and permission settings such as whether or not null is allowed for the data to be stored.

[0054] The business process definition 404 is information that defines the business logic that runs in an application. For example, it includes the operation type for each business logic ("IN" stores input data to the business process in variables, "CALL" calls the contents of the function code held by the data model code, etc.), data model code, function code indicating the function, etc.

[0055] The database definition 405 is a definition that stores the settings of the server that is accessed by the program (application) generated by the program development application. Specifically, the definitions include the identification code of the server that holds the database to be accessed, the server name, the URL to connect to, the database name, the user name and password required to connect to the database, etc. The repository definition unit 400 is an example of a means for managing these definitions.

[0056] The extension file management unit 420 is a functional unit that manages extension files for extending the functions of a program development application. An extension file is a file of a non-template component. The program development device 100 stores the non-template component file in its external memory 211 in accordance with a user operation or the like. For example, a component that is publicly available on the Internet as commercially available data may be downloaded in accordance with a user operation.

[0057] The extended file management unit 420 will now be described in detail.

[0058] The include file management unit 421 is a management function unit that manages files (CSS files, JS files, etc.) that are included (called) in a JSP file.

[0059] The JS file 422 (JavaScript file) to be included is a script file specified as the target for inclusion. The JS file contains code related to the operation (function) of the non-template component. For example, the code may display the string "Please enter" in the text field of the non-template component until a mouse click is performed on the text field, and then hide the string when a mouse click is performed on the text input field.

[0060] In addition, if the non-template file is a graph, for example, if the non-template component is a graph, the code contains the operation (function) to highlight the graph or display the numerical values ​​of the target graph when the mouse cursor is hovered over the graph.

[0061] The CSS file 423 to be included (Cascading Style Sheets file) is a style sheet specified as a target to be included. For example, if the non-template component is a graph, a CSS file that specifies the style for the graph display area itself and the graph itself is stored.

[0062] The code management unit 424 is a functional unit that manages various codes.

[0063] The component rendering code 425 is the code for rendering components set as custom I / O items in the JSP file. For example, it describes what event to execute when a certain element is focused by hovering the mouse, etc. The content of the event is described in the JS file. An example is shown in 1002 in Figure 10. Note that this explanation is just an example, and for graph components, rendering code different from this explanation may be written.

[0064] The data processing unit / drawing component association code 426 is code that associates the drawing of a non-template component with data managed by a program development application. For example, if the non-template component is a graph, this code describes what data to acquire and draw in the graph, given the settings (parameters) specified in the input / output definition of the non-template component. In an embodiment of the present invention, this association code is a JS file. An example is shown in FIG. 11. Note that the above explanation is an example, and code with content different from the above explanation may be written for a graph component.

[0065] The application generation unit 410 analyzes various definitions in the repository definition unit 400 using a repository definition analysis unit 411, and generates application code 442 consisting of compiled code 443 and HTML / JSP / Javascript (registered trademark) 444 in a source code compilation unit 413 via an application code generation unit 412. For example, a Web application 441 (Web application code) is generated.

[0066] The application code accesses database 445 specified in database definition 405 that the application configured by the code uses when executing its function. In other words, application generation unit 410 is an example of a means for storing rules for generating a program used in an application.

[0067] The custom component source generator 430 is a processing unit that renders a custom component and generates a source that indicates the content of the processing related to the custom component.

[0068] The include part generation unit 431 is a functional unit that writes code that indicates the process of incorporating the CSS and JS files of the non-template parts (custom parts) set for the custom I / O items into the JSP file of the screen on which the custom I / O items are placed. An example of a JSP file generated by the include part generation unit is shown in 1001 in FIG. 10.

[0069] The body part generation unit 432 is a functional unit that writes the drawing code and data processing code for the custom I / O item in the JSP file of the screen on which the custom I / O item is placed. Here, the part where the drawing code and data processing code are written is called the body part. An example is shown as 1003 in Figure 10.

[0070] The data processing unit code generation unit 433 is a functional unit that generates a data processing unit, which is a part that holds data inside a custom I / O item. An example is shown as 1003 in Fig. 10. For example, 1003 is a hidden item "disp" that holds the internal value of the custom I / O item (BAR_VERTICAL) shown in Fig. 9. In other words, this indicates that a data processing unit that holds the internal value of a custom I / O item is generated in a JSP.

[0071] For example, a case will be described in which text entered in a text input field component is registered in data item X on a database (not shown).

[0072] If the "data processing unit and drawing component association code 426" describes that text entered in a text input field component should be written to "disp," the component entered in the text input field component is first written to "disp." After that, the data is written to data item X according to the code "write the data written to 'disp' to data item X," which is separately described in application code 442.

[0073] The rendering code generation unit 434 is a functional unit that generates (writes) a rendering unit, which is code that renders the components (custom components) set in the custom I / O items, in the JSP file of the screen on which the custom I / O items are placed. This concludes the explanation of FIG. 4.

[0074] The processing flow in the embodiment of the present invention will be described below with reference to Figures 5 to 11. Note that the processing of the various flowcharts is executed by the CPU 201 installed in each device using the functions of the functional units provided in each device.

[0075] First, the flow of the custom part registration process in the embodiment of the present invention will be described with reference to FIG.

[0076] In step S501, the program development device 100 starts a program development application in accordance with an operation received from the user.

[0077] In step S502, the program development device 100 activates an application screen editing function (screen editor function) provided by the program development application and displays a screen editing screen (screen editor screen). The editor screen displays objects representing custom I / O items and template parts. In other words, items are displayed on the screen.

[0078] In step S503, the program development application of program development device 100 generates a custom I / O item on the screen. Specifically, as shown in 800 in Fig. 8, by dragging and dropping a custom I / O item object 801 onto the screen being edited, the custom I / O item is placed at the location on the screen where it was dropped.

[0079] At the time of placement, it is still not decided what non-template part the custom I / O item will be displayed as and how it will operate, so a dummy object representing the custom I / O item is displayed at the placement destination (an object containing a dummy image is displayed).

[0080] The default size of the dummy object is stored in the external memory 211 of the program development device 100. The size can be changed by dragging the edge of the dummy object, for example. The program development application generates a program that displays the component (custom component) associated with the custom I / O item at the new size. Specifically, the new size is written to the set style class in the class attribute of the div tag in the body of the JSP file for the screen. For example, in the example of Figure 10, the new size is written to "field_BAR_VERTICAL."

[0081] When an input / output item (template item) corresponding to a template part is placed, an image of the template part corresponding to the input / output item is obtained from the storage device and displayed as an object. The list shown in 802 is an example of such an object.

[0082] In step S504, the program development application of the program development device 100 performs settings to associate the placed custom I / O items with non-template components.

[0083] Specifically, in response to a user operation, a definition editing function provided by the program development application is activated, and a definition list screen (illustrated as 900 in FIG. 9) is displayed. Then, the properties of the custom I / O item placed in step S503 accept input of identification information for the non-template component desired by the user and a setting value for which process to execute among the processes related to that non-template component.

[0084] A specific example is shown in Figure 9. In Figure 9, 900, an input / output item is selected with the default item code "XXX", and with the property "compName" 901, which is the registration destination for the identification information of the non-template component, and the property "compParam" 902, which is the setting destination for the parameters, left blank. The user can edit each item of the selected input / output item. In other words, the user can input and set setting values.

[0085] The screen image after the settings are made is shown in 910 of Fig. 9. In 910 of Fig. 9, the identification information of the non-template part "GRAPH" is set in the item code = "BAR_VERTICAL". In addition, "'type':'PROCEED'" is set as the value (parameter) to be set for the "GRAPH" part.

[0086] The property "compName," which is the registration destination for the non-template part's identification information, and the property "compParam," which is the setting destination for the parameters, are displayed only in the custom I / O item. In reality, these property fields are associated with the custom I / O item and stored in external memory, and when the custom I / O item is placed on the screen, a new custom I / O item with these property fields empty is generated in the list of input / output items.

[0087] In this embodiment, a non-template part is information stored in a folder with the same name as the identification information of the non-template part, and is composed of a CSS file, a JS file, drawing code of the non-template part, and the non-template part itself. An example of a non-template part will be described below.

[0088] The CSS file for a non-template component contains settings (drawing code) related to the display of that non-template component, such as the type, color, size, etc. of the graph.

[0089] In addition, the JS file of a non-template component contains code (Figure 11) that associates the rendering of the non-template component with data processing.

[0090] For example, 1101 describes the code for the following process: "When drawing using the CSS file "GRAPH" (here, drawing a graph), refer to the setting value, and if the setting value is "type":"PROCEED", obtain data from the "year / month" (MONTH_AN...) and "sales" (PROCEEDS) columns in the definition list (Fig. 9) and output it to the graph." Also, 1102 describes the code for the following process: "When drawing using the CSS file "GRAPH" (here, drawing a graph), refer to the setting value, and if the setting value is "type":"EVENT", obtain data from the "year / month" (MONTH_AN...) and "event count" (EVENT) columns in the definition list (Fig. 9) and output it to the graph." This concludes the explanation of non-template components.

[0091] Returning to the explanation of Figure 5, in step S505, the program development application of program development device 100 stores the information input in step S504 in external memory. That is, "GRPH" and "'type':'PROCEED'" are stored in each item of the properties of the custom I / O item called "BAR_VERTICAL." This concludes the explanation of Figure 5.

[0092] Next, the flow of the application generation process will be described with reference to FIG.

[0093] In step S601, the program development application of the program development device 100 accepts, on an application generation execution screen (not shown), the specification of the definition of an application for which code is to be generated (application definition).

[0094] In step S602, the program development application of the program development device 100 receives an instruction to generate application code based on the application definition, for example, by pressing a "Generate" button on the application generation execution screen.

[0095] In step S603, the program development application of the program development device 100 acquires from the external memory 211 the application definition whose specification was accepted in step S601.

[0096] In step S604, the data model definition specified by the application definition is obtained from the external memory 211.

[0097] In step S605, the input / output definition specified by the application definition is obtained from the external memory 211.

[0098] In step S606, the business process definition specified by the application definition is obtained from the external memory 211.

[0099] In step S607, the database definition specified by the application definition is obtained from the external memory 211.

[0100] In step S608, the program development application of the program development device 100 obtains from the external memory 211 the extension file specified by the application definition.

[0101] In step S609, the program development application of program development device 100 generates application code, such as a Java file for the application, a JSP file for each screen, a CSS file, and a JavaScript file (see 444 in FIG. 4, etc.).

[0102] In step S610, the program development application of program development device 100 generates a custom component source. Details of step S610 will be described later in the description of FIG.

[0103] Now, with reference to FIG. 7, the flow of code generation processing for a custom part in an embodiment of the present invention will be described.

[0104] In step S701, the program development application of the program development device 100 acquires a list of input / output definitions, and then repeats the processing of steps S702 to S708 the number of times equal to the number of input / output items.

[0105] In step S702, the program development application of the program development device 100 acquires one unprocessed input / output definition.

[0106] In step S703, the program development application of the program development device 100 determines whether a value is set in the "compName" of the acquired input / output definition. In other words, it determines whether identification information of a non-template component is set in the input / output definition.

[0107] Here, a component determined to have the identification information of a non-template component set is identified as a custom I / O item. That is, the determination process of step S703 is a process of determining whether the input / output definition is a definition of a custom I / O item.

[0108] If it is determined that no value is set in the "compName" of the input / output definition, the process returns to step S702 to acquire an unprocessed input / output definition. If there is no unprocessed input / output definition, the process of FIG. 7 ends.

[0109] If it is determined that a value is set in "compName" of the input / output definition, the process proceeds to step S704.

[0110] In step S704, the program development application of the program development device 100 determines whether a value is set in "compParam" of the acquired input / output definition, that is, whether a parameter is set in the input / output definition.

[0111] If it is determined that no value is set in "compParam," the process proceeds to step S706.

[0112] If it is determined that a value is set in "compParam," the process proceeds to step S705, where the set value is acquired, and the process proceeds to step S706.

[0113] In step S706, the program development application of the program development device 100 generates an include part for the custom part.

[0114] Specifically, code is written to include the CSS and JS files of non-template components in the JSP file of the screen that holds the input / output items (custom I / O items) to which the input / output definition applies. An example is shown in 1001 in Figure 10.

[0115] In step S707, the program development application of program development device 100 generates code for the data processing section of the custom part. The data processing section is a section that holds data inside the custom part. An example is shown as 1003 in FIG. 10.

[0116] In step S708, the program development application of program development device 100 generates code for a drawing section of the custom component. The drawing section is a section that draws the custom component. An example of the drawing section is shown in 1002 in FIG.

[0117] If there are unprocessed input / output definitions, the program development application of program development device 100 returns the process to step S702, acquires one input / output definition, and executes the processes of steps S703 to S708. If there are no unprocessed input / output definitions, the process of Fig. 7 ends. This concludes the explanation of Fig. 7.

[0118] Returning to the description of Fig. 6, in step S611, the program development application of the program development device 100 deploys the code generated in steps S609 and S610. This concludes the description of Fig. 6.

[0119] As described above, according to the present invention, it is possible to provide a mechanism that allows easy and simple application development using the displays and functions of existing components.

[0120] A display example of this part is shown in 810 in Fig. 8. The screen shown in 810 is an example of the case where the application generated in steps S609 and S610 and deployed in step S610 displays the screen shown in 800. 811 in Fig. 8 shows a display example of a non-template part associated with 801 ("GRAPH" associated with the custom I / O item "BAR_VERTICAL" in 920 in Fig. 9). Also, 812 shows a display example of a non-template part associated with a custom I / O item placed separately from 801 ("GRAPH" associated with the custom I / O item "BAR_VERTICAL2" in 920 in Fig. 9).

[0121] These components are displayed in a style that conforms to the CSS of the non-template component "GRAPH" and retain functionality according to the JS file corresponding to "GRAPH" (information included in the JSP file at 1001 in Figure 10).

[0122] 10 and the data processing unit 1003, and the association code in FIG. 11, it is possible to execute drawing and data input / output.

[0123] In the above-described embodiment, an example was given in which both a CSS file (one of the pieces of information related to the display of the component) and a JS file (one of the pieces of information related to the function of the component) of a non-template file set as a custom I / O item are included, but the invention may also be configured to include either one of them.

[0124] Furthermore, in the description of the above-described embodiment, the definition editing function provided by the program development application is activated in accordance with a user operation, and the definition list screen 900 (illustrated in FIG. 9 ) is displayed. However, the definition list screen 900 may be displayed automatically. For example, when the program development application detects that a custom I / O item has been placed (generated) in S503, the definition list screen 900 may be displayed on the display screen. Furthermore, in order to display a screen in which a component to be associated with the custom I / O item can be specified, the custom I / O item generated in S503 may be automatically focused on in the displayed definition list screen 900 (or the definition list screen 900 may be displayed with the focus on the custom I / O item).

[0125] By automatically displaying the definition list screen 900, it is possible to reduce the time and effort required for the user to perform an operation to display the definition list screen.

[0126] Furthermore, by displaying a screen in which a component associated with the custom I / O item can be specified, the user's effort to find the placed custom I / O item from the list can be reduced.

[0127] In the above-described embodiment, it is assumed that the association code between drawing and data processing ( FIG. 11 ) describes that input values ​​from non-template components set as custom I / O items and output values ​​to the non-template components are processed, for example, via the data processing unit 1003. In other words, it is assumed that the association code describes the content of data processing (all or part of it) when an operation on a component is accepted, and the identification information of the items to which values ​​are input and from which values ​​are output.

[0128] However, in non-template components published by third parties, the identification information of the items to which the values ​​are input or output may not necessarily match the item names and data types of the data handled by the program development application.

[0129] This can often occur when a file containing code equivalent to the code relating drawing and data processing, such as which data item data input to a component should be input to, or which data item data should be output from to a component, is created and published not by the user of the program development application but by a third party such as the provider of the non-template component.

[0130] This can also occur if the creator of the association code (Figure 11) specifies an incorrect item name (for example, an item name that is different from the hidden item in the data processing unit 1003), or if they specify an item name that does not exist anywhere in the data model definition.

[0131] For example, the item name of the hidden item that is the data processing unit is "disp", but the item name specified by the association code (Figure 11) (for example, the name of the data item that is the output source of the graph data) does not exist in the data model and is not "disp".

[0132] In this case, data for the part cannot be output from anywhere or input anywhere, meaning the part will not function.

[0133] To avoid this problem and efficiently register working components, that is, to efficiently create application programs constructed with working components, the items may be updated and generated automatically.

[0134] For example, after S610, the program generation application acquires the item name, number of digits, decimal places, and data type of the hidden item of the data processing unit generated by the process in Fig. 7. It also acquires the association code between drawing and data processing (Fig. 11).

[0135] The program generation application analyzes the association code and identifies one or more item names of data input destinations and output sources in the code. It then determines whether each data item name matches either the data model definition or the hidden item name of the data processing unit acquired in S604. In other words, it determines whether a data input destination and output source exist.

[0136] If there is no matching item name (i.e., if there is no data input destination or output source), the item name in the association code is changed or updated to the hidden item name of the data processing unit 1003 of the non-template part that corresponds to that association code. If there is a matching item, the unprocessed item name in that association code is obtained. This is repeated for the item names of the data input destination and output source in the association code. Then, the process proceeds to S611.

[0137] By this change / update process, the data input / output source can be set to the data item name handled by the program development application.

[0138] That is, it is possible to easily create an application program constructed from working components.

[0139] Furthermore, if the settings for data items such as the number of digits, decimal places, and data type differ between the component and the data input or output source, these differences may result in data registration errors.

[0140] Therefore, for example, at step S610, the number of digits, decimal places, and data type of the data item are obtained from the data item name of the data input destination described in the association code. Then, code is automatically generated and inserted into the association code to change the value entered in the component to the number of digits, decimal places, and data type of the data item of the input destination.

[0141] Also, for example, at step S610, the name of the data item that is the output source of the data described in the association code is obtained. The number of digits, decimal places, and data type of the data to be output to the component, which are described in the JS file of the non-template component, are also obtained. Then, code is automatically generated and inserted into the association code to change the value to be output from the data item of the output source to the component to the number of digits, decimal places, and data type of the component.

[0142] By generating and inserting the conversion code, data can be input and output between components and items with different settings such as the number of digits, decimal places, data type, etc. Also, programs that can input and output the data can be created efficiently.

[0143] In other words, it is possible to provide a mechanism that enables efficient application development using the displays and functions of existing components.

[0144] In the above-described embodiment, the code for processing to update the item names in the association code to hidden items in the data processing unit 1003 is written in the association code. However, for example, it is also possible to store in an external memory rules that correspond the item names before the change to the item names after the change, and convert or update the item names in the association code that do not match the data model definition and hidden items according to the rules.

[0145] Furthermore, template components and non-template components may not be stored and managed as files, but may be stored and managed by, for example, having the CSS, JS files, drawing code, etc. for each component written within the code of the program generation application itself.

[0146] It is assumed that template components are stored in pairs with input / output items. In other words, when an input / output item paired with a template component is placed on the screen, there is no need for an instruction (such as CompName) to associate the component with the input / output item. The program generation application will add / generate the input / output item that is already paired (associated) with the template component to the input / output item definition in accordance with the placement.

[0147] Furthermore, the present invention can also be embodied as, for example, a system, an apparatus, a method, a program, or a storage medium, and specifically, it may be applied to a system consisting of multiple devices, or to an apparatus consisting of a single device.

[0148] Specifically, the program development device 100, the database server 200, and the application server 300 may be integrated to execute the processes of the above-described embodiments.

[0149] The extended file management unit 420 may also be configured to be included in the database server 200. That is, the system may be configured so that files (CSS files, JS files) of components to be included as custom components, the rendering code of the components, and the code for associating data processing with rendering are stored in a storage device separate from the program development device 100. In this case, the program development device 100 requests and acquires information about the components specified in the setting values ​​of the specified custom I / O items from the database server 200, stores the information in the RAM of the program development device 100 itself, and sets the path to be included.

[0150] The present invention also includes a case where a software program for realizing the functions of the above-described embodiments is supplied to a system or device directly or remotely, and a computer in the system or device reads and executes the supplied program code to achieve the functions.

[0151] Therefore, the program code installed on a computer to implement the functional processing of the present invention also embodies the present invention, and the present invention also includes the computer program itself for implementing the functional processing of the present invention.

[0152] Recording media for supplying the program include, for example, flexible disks, hard disks, optical disks, magneto-optical disks, MOs, CD-ROMs, CD-Rs, CD-RWs, etc. Also available are magnetic tapes, non-volatile memory cards, ROMs, DVDs (DVD-ROMs, DVD-Rs), etc.

[0153] Another method of supplying the program is to connect to an Internet homepage using the browser of the client computer, and then download the computer program of the present invention itself or a compressed file including an automatic installation function from the homepage to a recording medium such as a hard disk.

[0154] The present invention can also be realized by dividing the program code constituting the program of the present invention into multiple files and downloading each file from a different homepage. In other words, the present invention also includes a WWW server that allows multiple users to download program files for realizing the functional processing of the present invention on a computer.

[0155] Alternatively, the program of the present invention may be encrypted, stored on a storage medium such as a CD-ROM, and distributed to users, and users who meet certain conditions may download key information for decrypting the program from a website via the Internet. The downloaded key information may then be used to execute the encrypted program and install it on a computer, thereby achieving the present invention.

[0156] The functions of the above-described embodiments are realized by the computer executing the read program. Alternatively, the functions of the above-described embodiments can also be realized by an operating system or the like running on the computer performing some or all of the actual processing based on the instructions of the program.

[0157] Furthermore, the program read from the recording medium is written to a memory provided in a function expansion board inserted into a computer or a function expansion unit connected to the computer. Thereafter, based on the instructions of the program, a CPU or the like provided in the function expansion board or the function expansion unit performs part or all of the actual processing, and the functions of the above-mentioned embodiment are also realized by this processing.

[0158] It should be noted that the above-described embodiments are merely examples of specific embodiments for carrying out the present invention, and the technical scope of the present invention should not be construed as being limited by these embodiments. That is, the present invention can be implemented in various forms without departing from the technical idea or main characteristics thereof. [Explanation of symbols]

[0159] 100 Program development device 200 database servers 300 Application Servers

Claims

1. An information processing device a receiving means for receiving settings relating to the display of the component; A construction means for controlling construction of the application that displays the execution result of the process associated with the component on the application screen based on the setting. A program for functioning as The component is a component created by or provided by a party other than the provider of the program. A program characterized by.

2. The setting related to the display of the part is: The setting is related to the display of the execution result of the process associated with the component. The program according to claim 1 .

3. The setting related to the display of the part is: The setting is related to the display position on a screen that displays the execution result of the process associated with the component.

3. The program according to claim 1 or 2,

4. The information processing device, a first screen display control means for controlling the display of a screen for receiving settings relating to the display of the component; 4. The program according to claim 1, further functioning as:

5. The receiving means is Accepting association between the object and the part related to the screen of the application.

5. The program according to claim 1, wherein:

6. The receiving means is Accepting the placement of objects on the editing screen of the application and accepting the association between the objects and the components.

6. The program according to claim 1, wherein:

7. The information processing device, a second screen display control means for controlling the display of a screen for accepting the association between the object and the part; 7. The program according to claim 5 or 6, further functioning as:

8. The information processing device, a third screen display control means for controlling the display of the editing screen; The program according to claim 6, further functioning as:

9. The part is a part that is not stored as a template in the information processing device.

9. The program according to claim 1, wherein:

10. The construction of the application includes at least one of generating source code for the application and constructing an environment in which the application operates.

10. The program according to claim 1, wherein:

11. A receiving means for receiving settings related to the display of parts; A construction means for controlling construction of the application that displays the execution result of the process associated with the component on the application screen based on the setting. A program for functioning as The component is a component created by or provided by a party other than the provider of the program. An information processing device into which a program characterized by the above is loaded.

12. A control method for controlling an information processing device, comprising: a receiving step of receiving settings related to the display of the component; a construction step of controlling construction of the application that displays an execution result of the process associated with the component on a screen of the application based on the setting; A control method comprising: The component is a component created by a party other than the provider of the program that causes a computer to execute the control method, or a component provided by a party other than the provider of the program that causes a computer to execute the control method. A control method characterized by:

13. A receiving means for receiving settings related to the display of parts; A construction means for controlling construction of the application that displays the execution result of the process associated with the component on the application screen based on the setting. A program for functioning as The component is a component created by or provided by a party other than the provider of the program. An information processing system having a program loaded therein.

14. An information processing device a receiving means for receiving settings relating to the display of the component; A construction means for controlling construction of the application that displays the execution result of the process associated with the component on the application screen based on the setting. A program for functioning as The component is a component created by or provided by a party other than the provider of the program. A computer-readable recording medium having a program recorded thereon.

Images