JP2008287365A - Program generation device, program generation method, program, and recording medium - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To automatically generate a program code which is independent of a screen code for constructing an application by easily connecting it to a separately generated screen code. <P>SOLUTION: An Action program generation part 107, an Meta program generation part 108, and a ValueObject program generation part 109 are constituted so that a program code (Action program 112, Meta program 114, ValueObject program 116) corresponding to processing to be executed according to an event which has occurred on a screen, processing to define the design information of components layout-processed on the screen, and processing to transfer data with the components layout-processed on the screen is formed in the form of being separately independent of codes constituting the screen. <P>COPYRIGHT: (C)2009,JPO&INPIT

Description

  The present invention relates to a program generation device, a program generation method, a program, and a recording medium that generate a program based on design information.

  Conventionally, there is a program generation device that automatically generates a program from design information. However, the automatically generated application screen sufficiently satisfies the various screen layout requirements of the user, such as the layout position of the screen items automatically determined and the prepared screen pattern must be used. It was not a thing.

  In order to solve this problem, a technique in which a user freely customizes a screen when generating an application has been proposed (Patent Document 1).

Patent Document 1 proposes a method of generating a screen as requested by outputting an initial generation screen image on a dedicated program at the time of generating an application and customizing the initial generation screen image on the dedicated program. .
JP 2004-157927 A

  However, the above-mentioned Patent Document 1 has a problem that the initial generation screen image must be changed via a dedicated program, and it takes time to master the dedicated program.

  In particular, in the case of a Web system (divisionalized), designers dedicated to screen creation often change the screen, and designers have high-function editors that are “familiar”. The fact that such an “editor” cannot be used to change the initial generation screen image affects not only the work efficiency but also the quality and function (height and quantity) of the creation screen.

  Furthermore, in the said patent document 1, after producing an application, there is no procedure of changing the produced | generated screen. In recent years, there has also been a need for a development procedure in which only the screen is created first (from the above editor) to confirm the feeling of use and appearance, or the existing screen is reused (to reduce man-hours and a sense of unity). ing. However, the method disclosed in Patent Document 1 has a problem in that a screen created by a user cannot be incorporated into the automatic generation process.

  The present invention has been made to solve the above problems, and the object of the present invention is independent of the screen code that can be easily combined with a separately generated screen code to construct an application. It is to provide a mechanism capable of automatically generating program code.

  The present invention relates to a program corresponding to a process executed in response to an event occurring on a screen, a process for defining design information of a component laid out on the screen, and a process for transferring data with a component laid out on the screen It has a generation means for generating the code in a form that is separated and independent from the code constituting the screen.

  According to the present invention, it is possible to automatically generate a program code independent of the screen code that can be easily combined with a separately generated screen code to construct an application.

  As a result, the screen designer can create a flexible layout screen regardless of the automatically generated program code. Even when the program code or the screen code is modified due to the specification change, it does not affect each other.

  The present invention relates to a technical field for automatically generating a program in a case tool environment for generating software such as programs and screens constituting an application system. For this reason, the description of the case tool environment refers only to the portion directly related to the present invention.

  Hereinafter, it explains in detail using a drawing.

  FIG. 1 is a block diagram showing a configuration of an information processing apparatus (program generation apparatus) showing an embodiment of the present invention.

  In FIG. 1, reference numeral 100 denotes a computer as a program generation apparatus of the present invention. Reference numeral 103 denotes a computer main body. Reference numeral 101 denotes an input device for a keyboard and a pointing device (such as a mouse). Reference numeral 102 denotes a display device such as a CRT display or a liquid crystal display. Reference numeral 104 denotes an external storage device such as a hard disk drive (HDD).

  As shown in FIG. 1, when the user issues an automatic program generation command to the computer main body 103 through the screen displayed on the display device 102 from the input device 101, the computer 103 performs automatic generation processing in the overall control unit 105. Do. Details will be described below.

  First, the screen control unit 106 that has received the program automatic generation command delegates the processing to the Action program generation unit 107, the Meta program generation unit 108, and the ValueObject program generation unit 109.

  The action program generation unit 107 is preliminarily input and stored in the external storage device 104 based on an action template 111 (described later, FIG. 14) created and stored in the external storage device 104. 12 and 13) are applied, an Action program 112 (FIGS. 6 and 15 described later) is generated and stored in the external storage device 104. The Action template 111 is a template (model) for generating the Action program 112. The Action program 112 is a program code corresponding to processing (for example, data transmission / reception processing to the server) executed in response to an event that has occurred on the screen.

  The Meta program generation unit 108 applies user definition information 110 that is input in advance and stored in the external storage device 104 based on a Meta template 113 (FIG. 16 described later) that is generated in advance and stored in the external storage device 104. Then, the Meta program 114 (FIGS. 8 and 17 described later) is generated and stored in the external storage device 104. The Meta template 113 is a template (model) for generating the Meta program 114. The Meta program 114 is a program code corresponding to a process for defining design information (for example, data type and number of digits) of parts laid out on the screen.

  The ValueObject program generation unit 109 is a user definition that is input in advance and stored in the external storage device 104 based on a ValueObject template (VO template) 115 (FIG. 18 described later) that is created in advance and stored in the external storage device 104. By applying the information 110, a ValueObject program (VO program) 115 (FIGS. 10 and 19 described later) is generated and stored in the external storage device 104. The VO template 115 is a template (model) for generating the VO program 116. The VO program 116 is a program code corresponding to a process of transferring data with a component laid out on the screen.

  The server program generation unit 117 applies user-defined information 110 that is input in advance and stored in the external storage device 104 based on a server template 118 (not shown in detail) that is created in advance and stored in the external storage device 104. Then, a server program 119 (details not shown) is generated and stored in the external storage device 104. The server template 118 is a template (model) for generating the server program 119. The server program 119 is a program code corresponding to processing executed on the server side.

  Next, a hardware configuration of the computer 100 as the program generation apparatus shown in FIG. 1 will be described with reference to FIG.

  FIG. 2 is a block diagram showing a hardware configuration of the computer 100 as the program generating apparatus shown in FIG. 1, and the same components as those in FIG. 1 are denoted by the same reference numerals.

  In FIG. 2, reference numeral 201 denotes a CPU (Central Processing Unit) 201, which comprehensively accesses various devices connected to the system bus based on a control program stored in the ROM 203 or the external storage device 104. It is the structure to control.

  Connected to the system bus is a RAM (Random Access Memory) 202 that functions as the main memory, work area, and the like of the CPU 201. The ROM 203 or the external storage device 104 is necessary for realizing a process executed by the computer 103 such as a BIOS (Basic Input / Output System), an operating system (hereinafter referred to as “OS”) program that is a control program of the CPU 201. Various programs are stored.

  The CPU 201 implements the functions and various operations of the overall control unit 105 shown in FIG. 1 by loading various programs necessary for execution of processing into the RAM 202 and executing the programs.

  The external storage device 104 stores a boot program (not shown), various application programs, font data, user files, and the like as the various programs described above.

  For example, the CPU 201 performs WYSIWYG on the display device 102 by executing outline font rasterization processing on a display information area in the RAM 202. Further, the CPU 201 opens various registered windows based on commands instructed by a mouse cursor (not shown) on the display device 102 and executes various data processing.

  Hereinafter, with reference to FIGS. 3 to 10, program generation processing performed by the Action program generation unit 107, the Meta program generation unit 108, the ValueObject program generation unit 109, and the server program generation unit 117 illustrated in FIG. 1 will be described.

  FIG. 3 is a flowchart showing an example of a first control processing procedure according to the present invention. The Action program generation unit 107, Meta program generation unit 108, ValueObject program generation unit 109, and server program generation of the computer 103 shown in FIG. This corresponds to the program generation process performed by the unit 117. Note that the processing of this flowchart is realized by the program generation unit 107 in which the CPU 201 illustrated in FIG. 2 reads the program stored in the external storage device 104 into the RAM 202 and executes the program. In the figure, S301 to S309 indicate each step.

  First, when receiving an instruction of a program automatic generation command input from the input device 101, the screen control unit 106 in the overall control unit 105 delegates the processing to the program generation unit 107, and proceeds to step S301.

  In step S <b> 301, the Action program generation unit 107 first reads the user definition information 110 (FIG. 4) from the external storage device 104 and stores it in the RAM 202.

  In step S <b> 302, the action program generation unit 107 reads the action template 111 (FIG. 5) that is the basis of the program to be generated and stores it in the RAM 202. The Action template 111 has a role as an underlay (template) of the program, and specific data is still variable as shown by 1400 and 1401 in FIG.

  Next, in step S303, the Action program generation unit 107 obtains each of the lines (1211, 1215, etc. in FIG. 4) in which the item type 1206 is “A action” from the user-defined information acquired in S301 and stored in the RAM 202. The value of the item is acquired, the data of the item type 1206 is a variable ioItem.itemType secured in the RAM 202, the data of the item code 1200 is ioItem.code, the data of the name 1201 is ioItem.name, and the data of the display 1202 is ioItem.isVisible The required 1203 data is stored in ioItem.isRequire,..., The number of digits 1204 is stored in ioItem.length, the decimal number 1205 data is stored in ioItem.scale,. Furthermore, the Action program generation unit 107 inserts the value of each item of the acquired user definition information into the variableized locations (1400 and 1401 in FIG. 5) in the Action template 111 acquired in S302 (FIG. 6). 1500, 1501), the Action program 112 is generated and stored in the external storage device 104. Then, this process is performed on the user definition information of all the rows whose item type 1206 is “A action”.

  Hereinafter, S303 will be described more specifically.

  FIG. 5 is a diagram illustrating an example of an Action template.

  In FIG. 5, 1400 and 1400 represent template variables. 1400 corresponds to the “item code” 1200 of the user definition information. 1401 corresponds to the “item name” 1201 of the user definition information.

  FIG. 6 is a diagram illustrating an example of an Action program generation result. This figure is an example corresponding to the user definition information indicated by reference numeral 1215 in FIG.

  In FIG. 6, 1500 represents the result of assigning the value “UPDATE” of the “item code” 1200 of the user-defined information to the template variable “$ {ioItem.name}” 1400. Reference numeral 1501 denotes a result of substituting the value “update” of the “item name” 1201 of the user-defined information into the template variable “$ {ioItem.code}” 1401. This is the end of the description of step S303 in FIG.

  Next, in step S <b> 304 of FIG. 3, the Meta program generation unit 108 reads the Meta template 113 that is the source of the program to be generated and stores it in the RAM 202. The Meta template 113 serves as an underlay (template) for the program, and specific data is still variable as shown in 1600, 1601,... In FIG.

  Next, in step S305, the Meta program generation unit 108 reads the lines (1212 to 1214 in FIG. 4) in which the item type 1206 is “IO input / output” from the user definition information acquired in S301 and stored in the RAM 202. The value of each item is acquired, the data of the item type 1206 is a variable ioItem.itemType secured in the RAM 202, the data of the item code 1200 is ioItem.code, the data of the name 1201 is ioItem.name, and the data of the display 1202 is ioItem. isVisible, essential 1203 data is stored in ioItem.isRequire,..., 1204 digit data is stored in ioItem.length, decimal digit 1205 data is stored in ioItem.scale,. Further, the Meta program generation unit 108 inserts the value of each item of the acquired user definition information into the variableized locations (1600, 1601,... In FIG. 7) in the Meta template 113 acquired in S304. (1700, 1701,... In FIG. 8), the Meta program 114 is generated and stored in the external storage device 104. Then, this process is performed on the user definition information of all the rows whose item type 1206 is “IO input / output”.

  Hereinafter, S305 will be described more specifically.

  FIG. 7 is a diagram illustrating an example of a Meta template.

  In FIG. 7, reference numerals 1600 to 1606 denote template variables.

  1601 corresponds to the “item name” 1201 of the user definition information. 1600 corresponds to “item code” 1200 of the user-defined information. 1602 corresponds to the “display” 1202 of the user definition information. Reference numeral 1606 corresponds to the “item type” 1206 of the user-defined information. 1603 corresponds to “required” 1203 of the user definition information. 1604 corresponds to the “digits” 1204 of the user definition information. 1605 corresponds to the “decimal digit” 1205 of the user definition information.

  FIG. 8 is a diagram illustrating an example of a Meta program generation result. This figure is an example corresponding to the user definition information indicated by 1212 in FIG.

  In FIG. 8, 1701 represents the result of substituting the value “employee ID” of the “name” 1201 of the user-defined information into the template variable “$ {ioItem.code}” 1601. 1700 represents the result of substituting the value “EMP_ID” of the “item code” 1200 of the user-defined information into the template variable “$ {ioItem.name}” 1600.

  1702 represents the result of substituting “true” corresponding to the value “display” of the “display” 1201 of the user-defined information into the template variable “$ {ioItem.isVisible}” 1602. Reference numeral 1706 denotes a result of substituting “IO” corresponding to the value “IO input / output” of the “item type” 1206 of the user-defined information into the variable “$ {ioItem.itemType}” 1606 of the template.

  Reference numeral 1703 denotes the result of substituting “false” corresponding to the value (blank) of the “required” 1203 of the user-defined information into the template variable “$ {ioItem.isRequire}” 1603. Reference numeral 1704 denotes the result of substituting the value “4” of the “digits” 1204 of the user-defined information into the template variable “$ {ioItem.length}” 1604. Reference numeral 1705 represents the result of substituting the value “0” of “decimal digits” 1205 of the user-defined information into the template variable “$ {ioItem.scale}” 1605. This is the end of the description of step S305 in FIG.

  Next, in step S <b> 306 in FIG. 3, the ValueObject program generation unit 109 reads the VO template 115 that is the source of the program to be generated and stores it in the RAM 202. The VO template 115 serves as an underlay (template) for the program, and specific data is still variable as shown in 1800 and 1801 in FIG.

  Next, in step S307, the ValueObject program generation unit 109 reads the lines (items 1212 to 1214 in FIG. 4) in which the item type 1206 is “IO input / output” from the user-defined information acquired in S301 and stored in the RAM 202. The value of each item is acquired, the data of the item type 1206 is a variable ioItem.itemType secured in the RAM 202, the data of the item code 1200 is ioItem.code, the data of the name 1201 is ioItem.name, and the data of the display 1202 is ioItem. isVisible, essential 1203 data is stored in ioItem.isRequire,..., 1204 digit data is stored in ioItem.length, decimal digit 1205 data is stored in ioItem.scale,. Further, the Meta program generation unit 108 inserts the value of each item of the acquired user definition information into the variableized locations (1800 and 1801 in FIG. 9) in the VO template 115 acquired in S306 (FIG. 10). 1900, 1901), the VO program 116 is generated and stored in the external storage device 104. Then, this process is performed on the user definition information of all the rows whose item type 1206 is “IO input / output”.

  Hereinafter, S307 will be described more specifically.

  FIG. 9 is a diagram illustrating an example of a VO template.

  In FIG. 9, reference numerals 1800 and 1801 denote template variables. 1800 corresponds to the “item code” 1200 of the user definition information. Reference numeral 1801 corresponds to the “item name” 1201 of the user definition information.

  FIG. 10 is a diagram illustrating an example of a VO program generation result. This figure is an example corresponding to the user definition information indicated by 1212 in FIG.

  In FIG. 10, 1900 represents the result of substituting the value “EMP_ID” of the “item code” 1200 of the user definition information into the variable “$ {ioItem.name}” 1800 of the template. Reference numeral 1901 represents the result of substituting the value “employee ID” of the “name” 1201 of the user-defined information into the template variable “$ {ioItem.code}” 1601. This is the end of the description of step S307 in FIG.

  In step S <b> 308, the server program generation unit 117 reads the server template 118 that is the source of the generated program and stores it in the RAM 202. The server template 118 serves as an underlay (template) for the program, and specific data is still variable.

  In step S309, the server program generation unit 117 inserts the specific data acquired in step S301 into the variable location in the server template 118 acquired in step S308, generates the server program 119, and stores the external program in the external storage. It is stored in the device 104 (details of this process are omitted). And the process of this flowchart is complete | finished.

  Through the above processing, the Action program 112, the Meta program 114, the VO program 116, and the server program 119 are generated.

  Next, referring to FIG. 11 and FIG. 12, the program generated by the conventional program generation device is compared with the program generated by the program generation device of the present embodiment shown in FIG.

  FIG. 11 is a schematic diagram showing an example of a program generated by a conventional program generation device. A thick frame part is a part generated by a conventional program generation apparatus, and a screen layout 401 and a server generation part 402 are generated.

  FIG. 12 is a schematic diagram showing an example of a program generated by the program generation apparatus of the present embodiment shown in FIG. A thick frame part is a part generated by the program generation apparatus of this embodiment, and a client generation part 404 and a server generation part 405 are generated.

  Note that the screen layout 401 generated by the conventional program generation apparatus includes components laid out on the client side screen and actions executed on the client side.

  On the other hand, as shown in FIG. 12, the program generation apparatus according to the present embodiment has a configuration in which the client generation component 404 is generated separately from the screen layout 403 (in a separate and independent form).

  For example, when developing a large-scale application, a screen is often created by a plurality of people. The members include an “application developer” who implements the business logic of the application and a “designer” who arranges GUI parts on the screen.

  As shown in FIG. 3, the program generation apparatus according to the present embodiment reads the user definition 110 defined by the “application developer”, and programs 112 (for example, FIG. 13) and 114 (for example, FIG. 15) as client generation components 404. , 116 (for example, FIG. 17).

  Further, the “designer” creates a screen layout 403 including GUI parts as shown in FIGS. An example of this screen layout is shown in FIG.

  At the time of creating the screen, the “designer” defines the connection between the GUI component arranged on the screen and the programs 112, 114, and 116 output from the program generation apparatus according to the present embodiment.

  Hereinafter, a method of associating the GUI parts arranged on the screen by the “designer” with the programs 112, 114, and 116 generated by the program generation apparatus of the present embodiment will be described in detail.

  For example, the “designer” describes, in the button definition, a code that links a button in the created screen definition (for example, the update button 2001 in FIG. 19) and the action program 112 generated by the program generation device.

  Specifically, as indicated by reference numeral 701 in FIG. 14, as a click attribute of the Button component, an “action” class in the Action program 112 is instantiated (srv), and a method “UPDATE (indicated by 601 in FIG. 13)” is called. Click = "srv.UPDATE (req)" "is described. Thus, when the update button indicated by 2001 in FIG. 19 is clicked, UPDATE indicated by 601 in FIG. 13 is executed.

  Further, the “designer” uses the static property (EMP_ID.name) of the Meta class (WSEMPMeta) in the Meta program 114 as the text attribute of the Label component in the created screen definition, as indicated by 901 in FIG. Code "text =" {WsEMPMeta.EMP_ID.name} "" that uses the value. As a result, as indicated by 2002 in FIG. 19, the value “employee ID” of EMP_ID.name indicated by 801 in FIG. 15 is displayed on the screen.

  Further, the “designer” uses the value of the property (EMP_ID) that instantiates the VO class (vo) in the VO program 116 generated by the program generation device as the text attribute of the TextInput component in the created screen definition. Write the code (text = "{vo.EMP_ID}"). Accordingly, the value of the text box indicated by 2001 in FIG. 19 is held in vo.EMP_ID that instantiates the VO class (vo) in the VO program 116 indicated by 1001 in FIG.

  As described above, the Action program 112, the Meta program 114, and the VO program 116 output from the program generation apparatus can be easily associated with the screen definition (code for constructing the screen) created separately by the “designer”. The execution screen of the application constructed in such a manner is displayed as shown in FIG.

  When developing large-scale applications, there are often changes in specifications (changes in screen layout, label names, button operations). Even if such a specification change occurs, according to the above method using the program generation apparatus of the present embodiment, the specification change of each person in charge (“developer”, “designer”) does not affect each other. Can be developed.

  For example, when the name “employee ID” of the item “EMP_ID” of the user definition information shown in FIG. 4 becomes “employee number” due to the specification change, the “developer” defines the definition “EMP_ID” of the user definition information of FIG. Is changed to “employee ID”, and the program generation device only needs to generate the program code again. That is, the code (1101 in FIG. 18) created by the “designer” does not need to be changed at all, and the specification can be changed (“EMP_ID” is changed to “employee ID”).

  When the position or type of the screen component is changed in specification, for example, when the position of the button is changed in specification, the “designer” displays the screen coordinates “x =“ 293 ”y =” shown at 701 in FIG. Just change the 127 "" part. That is, there is no need to regenerate the program code with the program generation device or change the connection between the program and the screen definition.

  Also, when the processing content of the update processing (UPDATE) is changed in specification, the “developer” only changes the processing content of the definition “UPDATE” in FIG. 4 and generates the program code again by the program generation device. It's okay. That is, the specification can be changed without changing the code of FIG. 18 created by the “designer”.

  As described above, a program can be generated flexibly with respect to specification changes by generating a program using the program generation apparatus of the present embodiment and linking it with the screen definition generated by the “designer”.

  On the other hand, in the program generated by the conventional program generating apparatus as shown in FIG. 11, the name “employee ID” of the item “EMP_ID” of the user-defined information shown in FIG. In the case of “employee number”, it is necessary to generate both the screen layout 401 and the server generation component 402 again.

  In addition, when the position or type of the screen component is changed in specification, for example, even when the button position is changed in specification, the program generated by the conventional program generation device uses the screen layout 401 and the server generation component 402. Both had to be generated again.

  Even when the processing content of the update process (UPDATE) is changed in specification, it is necessary to generate both the screen layout 401 and the server generation component 402 again in the program generated by the conventional program generation apparatus.

  In the conventional method shown in FIG. 11, since the screen layout is generated using the program generation device, there are many cases where there are restrictions on the parts that can be specified on the screen. For example, it is not an exaggeration to say that there are as many specifications as the number of users, such as wanting to use a slider bar or pull-down menu for parts that input numerical values, and it is difficult to cover them all with a program generation device Met.

  However, in the present invention, since a program is generated by a program generation device and a “designer” generates a screen and connects both, a flexible screen design can be performed.

  Note that the program generation apparatus of the present embodiment does not simply generate a program separated from a screen, but has a configuration for generating a program in a form that can be easily associated with a separately created screen definition.

  First, a program is generated for each function. For example, the Action program 112 is generated as a client-side request processing program (that is, a program corresponding to a process executed in response to an event generated on the screen) corresponding to the server-side logic in general and the server action. Also, as a program having design definition information (including name, type, number of digits of items, etc.) of GUI parts on the screen (that is, a program corresponding to a process for defining design information of parts laid out on the screen) A program 114 is generated. Further, the VO program 116 is generated as a data processing program for transferring GUI component values (that is, a program corresponding to processing for transferring data with components laid out on the screen).

  In the Action program 112, as shown at 602 in FIG. 13, comment information indicating which operation corresponds to the program is embedded. Therefore, the designer can easily embed the description shown in 701 in FIG. 14 in the screen definition by determining the corresponding Action program with reference to 602 in FIG.

  In the Meta program 114, as shown by 802 in FIG. 15, comment information indicating which part corresponds to the design definition information is embedded. Therefore, the designer can easily embed the description shown in 901 of FIG. 16 in the screen definition by determining the corresponding Meta program with reference to 802 of FIG.

  In the VO program 116, as shown by 1001 in FIG. 17, comment information indicating which component value is handled is embedded. Therefore, the designer can easily embed the description shown in 1101 of FIG. 18 in the screen definition by determining the corresponding VO program with reference to 1001 of FIG.

  Thus, in each program code generated by the program generation apparatus of the present embodiment, comment information indicating processing realized by the program code is embedded. Therefore, the designer can easily associate the screen code generated separately and each program code generated by the program generation apparatus of the present embodiment.

  It has been extremely difficult and unrealistic to separate a program created by a conventional program generation device from a screen and use the separated program by incorporating it into a screen created separately by a designer.

  As described above, by generating a program that can be easily combined with a separately generated screen, it is possible to freely perform layout and design using a GUI component of a screen that does not depend on the program generation device.

  For this reason, when a newly created GUI component is introduced, the newly introduced GUI component can be used without changing the program generation device itself.

  In addition, since the server component is freely connected, not only the newly introduced GUI component can be laid out but also an appropriate operation is possible.

  Furthermore, the designer can create a screen with a more flexible layout regardless of the generation of the program generation device. The developer can easily modify the application by changing user-defined information (for example, name and number of digits).

  In other words, it becomes easy for designers and developers to develop in parallel without affecting each other's modification even if the specification changes.

  Furthermore, the program generation device of the present invention is a development procedure in which a designer creates only a screen first, or reuses an existing screen for man-hour reduction or a sense of unity, in order to check the feeling of use and appearance. It is possible to provide a mechanism that can be executed easily.

  Therefore, it is possible to easily enjoy both the good-looking screen created by the designer and the operation logic automatically generated by the program generation device.

  In addition, although the program generation apparatus of this embodiment is a structure which does not generate | occur | produce the code which comprises a screen, you may comprise so that the code which comprises a default screen may be produced | generated. This makes it possible to execute an application using the automatically generated default screen even when the designer creates a delay in screen creation. It should be noted that when a designer creates a screen, the default screen can be replaced by the created screen.

  It should be noted that the configuration and contents of the various data described above are not limited to this, and it goes without saying that the various data and configurations are configured according to the application and purpose.

  Although one embodiment has been described above, the present invention can take an embodiment as, for example, a system, apparatus, method, program, or recording medium, and specifically includes a plurality of devices. The present invention may be applied to a system including a single device.

  The configuration of a data processing program that can be read by the program generation device according to the present invention will be described below with reference to the memory map shown in FIG.

  FIG. 20 is a diagram for explaining a memory map of a recording medium (storage medium) that stores various data processing programs readable by the program generation apparatus according to the present invention.

  Although not specifically shown, information for managing a program group stored in the recording medium, for example, version information, creator, etc. is also stored, and information depending on the OS on the program reading side, for example, a program is identified and displayed. Icons may also be stored.

  Further, data depending on various programs is also managed in the directory. In addition, when a program or data to be installed is compressed, a program to be decompressed may be stored.

  The functions shown in FIG. 3 in this embodiment may be performed by the host computer by a program installed from the outside. In this case, the present invention is applied even when an information group including a program is supplied to the output device from a recording medium such as a CD-ROM, a flash memory, or an FD, or from an external recording medium via a network. Is.

  As described above, a recording medium recording software program codes for realizing the functions of the above-described embodiments is supplied to a system or apparatus, and a computer (or CPU or MPU) of the system or apparatus stores the recording medium in the recording medium. It goes without saying that the object of the present invention can also be achieved by reading and executing the programmed program code.

  In this case, the program code itself read from the recording medium realizes the novel function of the present invention, and the recording medium storing the program code constitutes the present invention.

  As a recording medium for supplying the program code, for example, a flexible disk, hard disk, optical disk, magneto-optical disk, CD-ROM, CD-R, DVD-ROM, magnetic tape, nonvolatile memory card, ROM, EEPROM, A silicon disk or the like can be used.

  Further, by executing the program code read by the computer, not only the functions of the above-described embodiments are realized, but also an OS (operating system) or the like running on the computer based on the instruction of the program code. It goes without saying that a case where the function of the above-described embodiment is realized by performing part or all of the actual processing and the processing is included.

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

  Further, the present invention may be applied to a system composed of a plurality of devices or an apparatus composed of a single device. Needless to say, the present invention can be applied to a case where the present invention is achieved by supplying a program to a system or apparatus. In this case, by reading a recording medium storing a program represented by software for achieving the present invention into the system or apparatus, the system or apparatus can enjoy the effects of the present invention. .

  Furthermore, by downloading and reading out a program represented by software for achieving the present invention from a server, database, etc. on a network using a communication program, the system or apparatus can enjoy the effects of the present invention. It becomes.

  In addition, all the structures which combined each embodiment mentioned above and its modification are also included in this invention.

It is a block diagram which shows the structure of the information processing apparatus (program production | generation apparatus) which shows one Embodiment of this invention. It is a block diagram which shows the hardware constitutions of the computer as a program production | generation apparatus shown in FIG. It is a flowchart which shows an example of the 1st control processing procedure in this invention. It is a figure which shows an example of the user definition information shown in FIG. It is a figure which shows an example of the Action template shown in FIG. It is a figure which shows an example of the Action program shown in FIG. It is a figure which shows an example of the Meta template shown in FIG. It is a figure which shows an example of the Meta program shown in FIG. It is a figure which shows an example of the VO template shown in FIG. It is a figure which shows an example of the VO program shown in FIG. It is a schematic diagram which shows an example of the program produced | generated with the conventional program production | generation apparatus. It is a schematic diagram which shows an example of the program produced | generated by the program production | generation apparatus of this embodiment shown in FIG. It is a figure which shows an example of an Action program. It is a figure which shows the example which used the Action program shown in FIG. 13 as an attribute of the components laid out on a screen. It is a figure which shows an example of a Meta program. It is a figure which shows the example which used the Meta program shown in FIG. 15 as an attribute of the components laid out on a screen. It is a figure which shows an example of VO program. It is a figure which shows the example which used the VO program shown in FIG. 17 as an attribute of the components laid out on a screen. It is a figure which shows an example of the screen of the executed application. It is a figure explaining the memory map of the recording medium (storage medium) which stores the various data processing program which can be read with the program generator which concerns on this invention.

Explanation of symbols

DESCRIPTION OF SYMBOLS 100 Computer 101 Input device 102 Display apparatus 103 Computer main body 104 External storage device 105 Overall control part 106 Screen control part 107 Action program generation part 108 Meta program generation part 109 ValueObject program generation part 110 User definition information 111 Action template 112 Action program 113 Meta Template 114 Meta program 115 ValueObject template 116 ValueObject program

Claims (7)

  Program code corresponding to the processing executed in response to the event that occurred on the screen, the processing to define the design information of the components laid out on the screen, and the processing to transfer data to the components laid out on the screen A program generation apparatus comprising generation means for generating the code in a form that is separated and independent from the code constituting the program.   The program generation apparatus according to claim 1, wherein the generation unit does not generate a code constituting the screen.   The program generation apparatus according to claim 1, wherein the generation unit generates program codes corresponding to the processes in a form separated from each other.   The program generation apparatus according to claim 3, wherein the generation unit includes comment information indicating processing realized by the program code in each program code.   A program corresponding to the processing executed by the generation unit in response to an event that has occurred on the screen, the processing for defining the design information of a component laid out on the screen, and the processing for transferring data with a component laid out on the screen What is claimed is: 1. A program generating method comprising: generating means for generating code in a form that is separated and independent from code constituting a screen.   Program code corresponding to the processing that is executed by the computer in response to an event that occurs on the screen, the processing that defines the design information for the components that are laid out on the screen, and the processing that passes data to the components that are laid out on the screen For functioning as a generation means for generating the program in a form that is separated and independent from the code constituting the screen.   Program code corresponding to the processing that is executed by the computer in response to an event that occurs on the screen, the processing that defines the design information for the components that are laid out on the screen, and the processing that passes data to the components that are laid out on the screen Is a computer-readable recording medium on which is recorded a program for functioning as a generating means for generating the image in a form that is separated and independent from the code constituting the screen.

Images