JP5511704B2 - Apparatus, method, and program for supporting creation of software - Google Patents

Description

  The present invention relates to a technique for supporting creation of software.

  In recent years, GUI (Graphical User Interface) such as car navigation (hereinafter referred to as “car navigation”) emphasizes dynamic visual effects using animation (hereinafter referred to as “animation”). Therefore, animation is used to switch between components displayed on the GUI or the screen. For example, when the user presses a button displayed on the screen, the state in which the button is pressed is continuously expressed using animation.

  Designers often design GUIs including animation. However, designers often cannot write script programs. Thus, for example, Patent Document 1 discloses a method that allows a designer to easily edit a GUI design by displaying an animation state of a component displayed on a screen along a timeline.

  However, in the car navigation system, various interruption processes occur according to the user's operation or the driving situation of the car. For example, removal of a CD (Compact Disk), reroute of a guidance route, and the like occur. Therefore, in the development of a car navigation GUI, these interrupt processes must be taken into account, and design and development are difficult. Therefore, various development support tools have been proposed in order to reduce the design and development load of designers and software creators (hereinafter “developers”). For example, when displaying an interrupt screen, Patent Literature 2 generates display control information for displaying a screen without contradiction based on a screen group in which the screens are combined, a plurality of interrupt display rules, and exception display data thereof. Is disclosed.

JP 2003-169290 A JP 2008-40666 Gazette

  According to Patent Document 1, when designing a GUI on a screen, a designer who designs a GUI specifies a specific time on the timeline in the timeline type editing tool, so that the screen within the specified time can be displayed. You can visually check the state of the animation. However, since the timeline expresses a plurality of animation screens continuously, it is difficult for a developer who writes a script in units of screens to specify a position where the script is embedded. Further, since it is difficult for the developer to grasp the screen configuration and screen transition of the entire application, development and debugging become difficult.

  Patent Literature 2 discloses a method for creating a rule for displaying an interrupt screen when an interrupt event occurs, correcting the rule, and checking the rule. However, in Patent Document 2, the state of the car navigation device (for example, the CPU usage rate, the memory usage rate, etc.) or the information received by the car navigation system from an external device (for example, the vehicle speed, the brake status, etc.) Based on this, it is difficult to create software (for example, design and / or development) in which GUI operation is limited.

  The above problems are not limited to the creation of software executed by a car navigation system, but may also be related to creation of other types of software that display a GUI whose screen changes with the passage of time.

  Accordingly, an object of the present invention is to facilitate creation of software for displaying a GUI.

  Based on the screen data including a frame section consisting of a plurality of continuous frames that transition with time, it generates transition management information that defines a frame section that transitions according to an event that occurred during the display of the frame section. The creation of software is supported based on the transition management information. Specifically, for example, the user creates software based on the transition management information. Each frame section is composed of one or more consecutive frames. The plurality of frames in the screen data include one or more frames in which display components that are objects displayed in the GUI are arranged. The screen data includes definition information including information indicating which frame the display transitions to when the display component arranged in which frame is executed. Information representing an event identified based on the screen data is included in the transition management information.

  According to the present invention, creation of software for displaying a GUI is facilitated.

The example of a screen display of the software creation assistance apparatus which concerns on one Embodiment of this invention is shown. An example of a process in which a display target frame jumps is shown. 2 shows an example of functional blocks of a software creation support apparatus according to an embodiment of the present invention. An example of a screen transition table is shown. An example of an event constraint definition table is shown. An example of a code template for screen transition processing is shown. An example of a code template table 700 and a code template is shown. It is an example of the flowchart of the process which produces | generates a screen transition table from screen data. It is an example of the flowchart of step S812 of FIG. It is an example of the flowchart of the process which produces | generates a screen model from a screen transition table.

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

  In the following description, various types of information may be described using the expression “xxx table”, but the various types of information may be expressed using a data structure other than the table. In order to show that it does not depend on the data structure, the “xxx table” can be referred to as “xxx information”.

  In the following description, a name or number is used to identify an element, but other types of identification information may be used instead of or in addition to the name or number.

  Further, in the following description, the process may be described using a “function” (or program) that is exhibited when the program is executed by a processor (for example, a CPU (Central Processing Unit)) as a subject. “Function” is a process in which the processor determines a process appropriately using a storage resource (for example, a memory) and / or a communication interface device (for example, a communication port). Therefore, the subject of the process is “processor”. Also good. The “processor” is not limited to one physical processor, and may include a hardware circuit different from the processor that performs part or all of the processing of functions. The computer program may be installed on each computer from a program source. The program source may be, for example, a program distribution server or a storage medium.

  FIG. 1 shows a screen display example of a software creation support apparatus according to an embodiment of the present invention.

  The screen 100 of the timeline type screen design tool has a component arrangement area 130, a component menu area 110, a component editing area 120, and a timeline description area 140.

  The component arrangement area 130 is an area in which display components are arranged to configure a screen. In the description of this embodiment, a “display component” is an object displayed on a screen provided by development target software. Examples of the display component include a “return” button 131, a “data update” button 132, a “display switching” button 133, and a balloon 134. A button press event occurs regardless of which of the buttons 131 to 133 is designated. Various messages are displayed in the balloon 134.

  In the parts menu area 110, a processing menu for display parts arranged in the parts arrangement area 130 is displayed. For example, when the “enlarge / reduce” menu is selected, the size of the display component can be changed.

  In the component editing area 120, attribute information related to the display component selected in the component arrangement area 130 is displayed. When the attribute information displayed in this area 120 is changed, the operation and function of the display component can be changed. For example, as shown in the figure, when the “data update” button 132 is selected in the component arrangement area 130, the attribute information of the “data update” button 132 is displayed in the component edit area 120. Here, “ID” is an identifier for uniquely identifying a display component, and an identifier “Update” is given. “Type” indicates the function of the display component, and the type “button” is given. Therefore, when the “data update” button 132 is selected, a process associated with the identifier “Update” is executed.

  In the timeline description area 140, an association between a frame and a program executed in the frame is arranged along the time axis 142. Here, the “frame” is data of one screen. In addition, the time axis 142 is assumed to have elapsed time from the left to the right. The frames arranged along the time axis 142 and various data corresponding to the frames are collectively referred to as a “timeline”. In principle, one animation is composed of multiple frames. Therefore, the animation is executed by advancing the time in the frame.

  The frame number 144 is a number for identifying a frame. A consecutive number is assigned to each frame as a frame number 144 in ascending order from the first frame arranged on the time axis 142.

  A display time 143 is displayed on the time axis 142. The display time 143 is located at a position on the time axis 142 corresponding to the frame number displayed in the component placement area 130. The display time 143 may be a slider that moves on the time axis 142 in response to an operation from a user (for example, a designer).

  The label name 145 is a character string for identifying the frame section. The label name 145 is used when jumping to a specific frame in the program. Note that the “frame section” means a frame number range of one or more frames (a range from the number of the first frame to the number of the rearmost frame) that are sequentially displayed as time passes. . Further, in the description of the present embodiment, “jump” is typically a number that is displayed next to a frame that is displayed next to the number of the frame that is being displayed. This means that the frame number being displayed is not a consecutive frame but a frame with a non-consecutive number. However, even if the number of the frame displayed next to the frame being displayed may be the next number that is consecutive to the number of the frame being displayed or a number that is not continuous with the number of the frame being displayed, Is sometimes used.

  The script presence / absence mark 146 is a symbol indicating whether or not a script program (hereinafter “script”) corresponding to the frame exists. The script is used when controlling display components in the frame. Examples of script languages include ActionScript, Python, Ruby, JavaScript (registered trademark), and the like.

  A layer 141 indicates the front-rear relationship in the screen display when the display components overlap. When the display parts overlap, the display parts described in the upper part of the column are displayed on the front.

  The display component list 147 is a list of names of all display components used in the software under development.

  For each display component name displayed in the display component list 147, there is at least one of a component display section 148 and a component non-display section 149. The component display section 148 is a section in which broken arrows are marked in the figure, and indicates a time section in which the display component is displayed in the component arrangement area 130. On the other hand, the component non-display section 149 is a section in which black diagonal lines are marked in the drawing, and indicates a section in which display components are not displayed in the component arrangement area 130. For example, the balloon 134 shown in the figure is included in each of the frame “1” (frame number “1”) to frame “17”. Therefore, when a plurality of frames are displayed in ascending order of the frame number from frame “1”, balloon 134 is displayed from frame “17”, and the displayed frame changes from frame “17” to frame “18”. In addition, it can be seen that the balloon 134 is not displayed.

  FIG. 2 shows an example of a process in which the display target frame jumps from the frame “17” to the frame “45” when the “display switching” button 133 in FIG. 1 is pressed.

  In the figure, a screen switching script is embedded in frame “15”. The script 202 is an example of a script that jumps to “menu_list” that is a frame of the frame number “45” when the button is pressed. When the “display switch” button 133 is pressed in the script 202, a button press event occurs, the function “pressChangeViewButton” is called, and “goto (“ menu_list ”)” described in the function is executed. Is stated. Therefore, when the script 202 is executed, the program jumps to the frame “45” to which the label name “menu_list” is assigned, and the destination menu 201 (frame “menu_list”) is displayed in the component placement area 130. When the “return” button 131 is pressed in the script 202, the function “pressReturnButton” is called, and “goto (“ anim2 ”)” described in the function is executed.

  FIG. 3 shows an example of functional blocks of the software creation support apparatus according to the present embodiment.

  The software creation support apparatus 300 includes a screen design program 340 that is mainly used by a designer to design a screen, and a screen transition generation program 350 that is mainly used by a developer when developing the program. Note that the screen design program 340 and the screen transition generation program 350 may be provided in one device or in separate devices. The software creation support apparatus 300 includes a CPU (Central Processing Unit), a storage resource, an input device, and a display device. Programs 340 and 350 included in the apparatus 300 are stored in a storage resource (for example, a memory) and executed by the CPU. By executing the program 340, the functions of the transition table generation unit 302 and the screen template generation unit 304 are exhibited. By executing the program 350, the functions of the complexity determination unit 317, the code template generation unit 318, the code combination unit 319, and the module generation unit 323 are exhibited. The storage unit 316 is realized by storage resources.

  The software creation support apparatus 300 does not necessarily include a display device and an input device. For example, the device 300 may be a server of a server client system, and the display device and the input device may be in a client of the server client system.

  The target device 330 is an electronic device that executes software developed by the software creation support apparatus 300. For example, the target device 330 is a device that executes the screen display program 331, and includes an OS 334, a native module 333, and a screen display program 331. The target device 330 includes a CPU, a storage resource (for example, a memory), an input device, and a display device. Various programs such as the OS 334 and the screen display program 331 are stored in the storage resource and executed by the CPU. . Thereby, the screen is displayed on the display device by the screen display program 331. The displayed screen is a screen designed using a timeline type screen design tool. The target device 330 is, for example, a car navigation device (car navigation system). There are several types of car navigation systems. According to the software creation support apparatus 300 according to the present embodiment, it is possible to develop software suitable for the model of the car navigation system (for example, software that performs GUI display according to the model of the car navigation system). The target device 330 may be another type of electronic device (for example, a mobile information processing terminal) instead of or in addition to the car navigation system.

  In FIG. 3, at least one of the screen data 301, the event constraint definition table 500, the document 314, the code template table 700, the code-added screen data 320, and the module 324 is stored in a storage resource of the software creation support apparatus 300. Good. In addition, at least one of the screen data 301, the event constraint definition table 500, the document 314, the code template table 700, the screen data with code 320, and the module 324 is information input to the software creation support apparatus 300 through the input device. It's okay.

  Next, an overview of each function and process will be described.

First, a user (for example, a designer) creates screen data 301 using a screen design design tool (see FIG. 1) provided by the screen design program 340. The screen data 301 is data related to a screen (GUI) displayed on the target device 330. The screen data 301 includes, for example, the following information:
(*) Information about a plurality of frames (for example, information including information about display components included in the frame and definition information (for example, script) for controlling the operation of the display components in the frame)
(*) Frame section information (for example, information including the label name for each frame section and the number of the first frame and the number of the end frame for each frame section),
(*) Information representing a timeline (for example, information representing a sequence of frames),
Is included. For example, as described above, the script related to the display component arranged in the frame may include information indicating to which frame the display jumps from the frame when the display component is executed.

  Next, the transition table generation unit 302 analyzes the screen data 301 and specifies a label name for each frame section. In addition, the transition table generation unit 302 identifies an event that may occur for each frame section, and assigns an event name that can identify the identified event to the event. For example, the transition table generation unit 302 identifies what display component is arranged in which frame, identifies an event based on the type (for example, ID) of the identified display component, and identifies the event as the identified event. An event name that can be identified is assigned. Then, the transition table generating unit 302 generates a screen transition table that is a table (matrix) of the identified label name and the assigned event name. In addition, the transition table generation unit 302 describes a constraint condition that restricts the operation of the event corresponding to the event name in a cell that is uniquely determined from the combination of the frame name and the event name in the generated screen transition table. The transition table generation unit 302 stores the generated screen transition table in the storage unit 316. Note that the constraint conditions differ for each target device on which the software is executed. There is an event constraint definition table 500 showing constraint conditions for each combination of target device and event. A target device ID may be input from a user (for example, an operator), and a constraint condition corresponding to the input target device ID may be specified.

Here, if the screen display program 331 to be executed by the target device 330 is described by a script, the execution speed becomes slow when the screen transition is complicated. Therefore, the complexity determination unit 317 refers to the screen transition table, and at least one of the following:
(*) Number of cells constituting the screen transition table,
(*) Number of events that cause a jump from a frame to that frame and a non-contiguous frame,
(*) Number of constraints described in each cell,
The complexity (for example, the complexity of the screen data 301) is calculated based on the above, and an appropriate code is determined according to the complexity. Specifically, the complexity determination unit 317 analyzes the screen transition table stored in the storage unit 316 and determines whether the complexity of the screen transition is equal to or less than a predetermined threshold.

  Here, if the determination result of the complexity determination unit 317 is affirmative (if the complexity is equal to or less than the threshold value), the code template generation unit 318 generates a code template that is a code template related to screen transition by a script. Next, the code combining unit 319 generates code-added screen data 320 from the screen data 301 and the code template table 700. Here, the code-added screen data 320 is obtained by rewriting the screen data 301 so that a code template can be called (the code template table 700 and the code template will be described later). Next, the user (for example, a developer) adds a necessary code to the code-added screen data 320. Finally, the screen display program generation unit 322 generates the screen display program 331 from the screen data with code 320. The generated screen display program 331 can be executed by the target device 330.

  On the other hand, if the determination result of the complexity determination unit 317 is negative (if the complexity exceeds the threshold value), the module generation unit 323 performs a module (native code) 324 that performs screen (frame) transition in the GUI. Is generated. Next, the code combining unit 319 generates code-added screen data that can call the module 324. Next, the screen display program generation unit 322 generates a screen display program 331. As a result of this processing, a module 324 that can be executed by a native code and a screen display program 331 that can be executed by a script are generated. Next, the module 324 and the screen display program 331 are incorporated into the target device 330. Thereby, in the target device 330, the module 324 and the screen display program 331 operate in cooperation. At least one of the module 324 and the screen display program 331 may be created. Each of the module 324 and the screen display program 331 may be created software itself or may be an element of created software.

  In the document generation unit 313, a document (for example, a screen transition diagram obtained by editing the screen transition table into a format that is easy for the user to read) 314 from the data of the screen transition table stored in the storage unit 316 is displayed. It may be generated. Further, in the generation of the document 314, the color of the portion where the processing load of the animation is high may be changed, or the color of the portion where the hierarchy where the screen transitions is deeper than a predetermined value may be changed.

  Each cell of the screen transition table in the storage unit 316 has an animation flag. The screen template generation unit 304 refers to the screen transition table in the storage unit 316, and sets a frame section in which the animation flag is longer than the frame section corresponding to false as the frame section corresponding to true. Then, when the cell holds the constraint condition, the screen template generation unit 304 indicates that the constraint condition exists in the event having the event name corresponding to the cell (see FIG. 1). Can be explicitly displayed. This process will be described later with reference to FIG.

  FIG. 4 shows an example of the screen transition table. In this table, one cell uniquely determined when a specific row and column is selected is referred to as a “cell”. Each “cell” can hold information.

  Here, the cell holds an animation flag indicating whether or not the frame corresponding to the cell is an animation frame (a frame including an animation operation). A cell whose animation flag is “true” holds a constraint condition related to the animation operation, and a cell whose animation flag is “false” holds a constraint condition related to the screen transition destination.

  Set whether or not to omit the animation operation of the frame corresponding to the cell based on the past operation of the user (operator or developer), for example, as a constraint condition for the animation operation in the cell having the animation flag “true” can do.

  In addition, in a cell having the animation flag “false”, as a restriction condition regarding the transition destination of the screen (frame), whether to omit the animation operation at the transition destination based on the state of the target device on which the software is executed is set. Can do.

  Hereinafter, the above-described operation will be described in detail with reference to FIG.

  An event name 403 is a list of event names that trigger screen transition. Examples of the event type include “finish (frame reproduction completed)”, “pressMapButton (map button pressed)”, and the like.

  The label name 404 is a list of label names assigned to each frame.

  In the screen transition table 400, a cell is uniquely determined from a label name and an event name. The cell describes a process of jumping to a predetermined frame when an event described in the event name corresponding to the cell occurs in a frame to which the label name corresponding to the cell is assigned. Further, in the cell, various conditions for executing the jump process, a jump destination label name, and the like are described.

  As the cell, there are an animation cell that is a cell having an animation flag “true” and a normal cell that is a cell having an animation flag “false”.

  The animation cell is a cell corresponding to the animation frame, and has information indicating processing when the event described in the event name 403 occurs. For example, the animation cell has information (parameters) such as a jump destination 422 and animation omission 423 in addition to the animation flag 411. In the animation flag 421, whether or not the animation frame is an animation cell is set. In the figure, since the cell 401 is an animation cell, the animation flag 411 is “true”. The jump destination 422 is a label name of the jump destination. Since “menu_list” is set as the jump destination 422 in the cell 401, after the execution of the animation frame corresponding to the cell 401, the displayed animation frame is changed from the completed animation frame to the frame with the label name “menu_list”. Jump. The animation abbreviation 423 represents whether or not the animation is to be omitted thereafter when the user performs a specific key operation (for example, button hitting) while executing the animation. In the cell 401, since the animation omission 423 is “true”, the animation omission function is enabled.

  A normal cell is a cell corresponding to a frame that does not include animation, and has information indicating processing when an event described in the event name 403 occurs. In addition to the animation flag 411, the normal cell includes information (parameters) such as an after-transition animation limit 412, a jump destination (animation permission) 413, and a jump destination (animation prohibition) 414, for example. In the figure, since the cell 402 is a frame that does not include animation, the animation flag 411 is “false”. The post-transition animation restriction 412 is information representing a condition for permitting the execution of the animation and / or a condition for prohibiting the execution of the animation. In the cell 402, “prohibition of animation with a CPU load of 50% or more” is set as the post-transition animation limit 412. Therefore, animation is prohibited when the CPU load of the target device 330 is 50% or more. The jump destination (animation permission) 413 is a label name of the jump destination when the animation is permitted in the post-transition animation restriction 412. In the cell 402, “Aim1” is set as the jump destination (animation permission) 413. Therefore, in the cell 402, when a “pressMapButton” event occurs during execution of the frame with the label name “init”, the display jumps to the frame with the label name “Aim1”. The jump destination (animation prohibited) 414 is a label name of the jump destination when the animation is prohibited in the post-transition animation restriction 412. In the cell 402, “menu_map” is set as the jump destination (animation prohibited) 414. Therefore, when the “pressMapButton” event occurs during the execution of the frame with the label name “init”, the display jumps to the frame with the label name “menu_map”.

  FIG. 5 shows an example of the event constraint definition table.

  The event constraint definition table 500 describes the constraint conditions when a screen transition event occurs for each target device. The plurality of target devices have different specifications. For example, some target devices have high performance CPUs, and some target devices have low performance CPUs.

  The event constraint definition table 500 has a target device ID 502 for each target device. The target device ID 502 is an identifier that can uniquely identify each target device.

  Each column of the event constraint definition table 500 corresponds to a target device ID, and each row corresponds to an event name. A constraint condition 510 is described in a cell that is uniquely determined from the target device ID and the event name.

  In the event constraint definition table 500, different constraint conditions 510 can be set for each combination of the target device ID 502 and the event name 503. In the constraint condition 510, a static constraint condition 511 and a dynamic constraint condition 512 can be set.

The static constraint condition 510 is information representing the static constraint condition. The “static constraint condition” is uniquely determined when the use of the target device (for example, the software and / or hardware specifications of the target device) is determined, and the operation state of the target device (for example, the operation state at the time of event execution). It is a type of constraint that does not depend on The condition 510 is used to determine whether the animation cell violates the static constraint condition when generating the screen transition table. The static constraint 510 is, for example, the following information:
(*) Number of animation elements 513 representing the maximum number of display parts that can be animated simultaneously,
(*) Animation element size 514 representing the maximum size of display parts that can be animated,
(*) An animation period 515 that represents the maximum time during which animation can be continuously played,
including.

The dynamic constraint condition 512 is information representing the dynamic constraint condition. The “dynamic constraint condition” is a constraint condition applied according to the operation status of the target device (for example, the operation status at the time of event execution). The condition 512 is used to describe the dynamic constraint condition in a normal cell when generating the screen transition table. The dynamic constraint condition 512 is used as a constraint condition when the screen display program 331 is executed in the target device. The dynamic constraint condition 512 includes, for example, the following information:
(*) Animation prohibition CPU load factor 516 which is a threshold of CPU load factor prohibiting animation,
(*) Animation prohibition memory usage rate 517, which is a threshold of memory usage rate that prohibits animation.
(*) A vehicle travel operation 518 indicating whether or not to permit an operation during vehicle travel;
including. The determination of which dynamic constraint condition should be described in which normal cell depends on the data content of the frame corresponding to the cell, the attribute of the display component existing in the frame, and the like. For example, when there is a button on the frame that is prohibited from being operated during traveling, a dynamic constraint condition in which the vehicle traveling operation 518 is “No” is described in the normal cell. Note that the threshold value of the CPU load factor may be determined after actually executing the test content on the target device. In addition, various constraint conditions may be automatically generated by analyzing various regulations related to car navigation from definition sentences such as the road traffic law.

  FIG. 6 shows an example of a code template for screen transition processing.

  The code template 600 for screen transition is described in a predetermined language, for example, the javascript language. The code description area 601 can describe a process that the user wants to execute independently.

  FIG. 7 shows an example of a code template table 700 of events related to screen transitions and a code template.

  The code template table 700 describes a code template that is executed when a screen transition event occurs for each target device. The code template is combined with the screen data 301 in the code combining unit 319.

  The code template table 700 has a target device ID 703 for each target device. Each column corresponds to a target device ID, and each row corresponds to an event name. A code template is described in a cell that is uniquely determined from the target device ID and the event name.

  A certain code template 710 describes a process of calling a screen transition method “onEvent” when a “pressListButton” event occurs. In the code template 710, a line starting with “//” is a comment sentence, which describes information to be referred to when the user independently describes the process. As a result of the determination in the complexity determination unit 317, when it is determined that the module is a native module 333, the code template 710 describes a code “onNativeEvent” 711 for calling the native module instead of the screen transition method “onEvent”. .

  Another code template 720 is a processing template when “finish” which is a frame transition completion event occurs. The code template 720 describes a process of calling a data reading method “dataLoad” and a screen transition method “onEvent”.

  FIG. 8 is an example of a flowchart of processing for generating a screen transition table from screen data.

  First, the transition table generating unit 302 newly creates an empty screen transition table (S801).

  Next, the transition table generation unit 302 searches the frames of the screen data in the order of the frame numbers, extracts the label names, and sets the label names as the titles of the columns of the screen transition table (S802).

  Next, the transition table generation unit 302 determines whether or not the label name includes the character string “anime”. If the determination result is “YES”, the frame of the label name is determined to be an animation frame, The animation flag of the cell belonging to the label name column is set to “true” (S803). In this embodiment, as a method for identifying an animation frame, a method of determining whether or not the character string “anime” is included in the label name is employed. However, the identification of the animation frame may be performed by other methods. For example, it may be adopted to determine whether or not a character string other than “anime” is included in the label name. Further, a method of determining whether or not a character string indicating an animation frame is described as a comment in the script in the frame may be adopted.

  Next, the transition table generation unit 302 determines whether or not the label name includes the character string “menu”. If the determination result is “YES”, the frame with the label name is set as a normal frame (animation does not work). The animation flag of the cell belonging to the label name column is set to “false” (S804). In the present embodiment, the identification of the normal frame may be performed by other methods. For example, it may be employed to determine whether or not a character string other than “menu” is included in the label name. A method of determining whether or not a character string indicating a normal frame is described as a comment in the script in the frame may be employed.

  Next, the transition table generating unit 302 sets a frame counter for determining a frame number to 0 (S805).

  Next, the transition table generation unit 302 determines whether there is a script description in a frame to which a frame number that matches the value represented by the frame counter is assigned (S806). If there is a script description in the frame (S806: Yes), the process proceeds to step S807. On the other hand, if there is no script description in the frame (S806: No), the process proceeds to step S810. Hereinafter, the processing from step S807 will be described.

  Next, the transition table generation unit 302 determines whether or not a jump instruction (goto statement) exists in the script (S807). If there is a jump instruction (S807: Yes), the process proceeds to step S808. On the other hand, if there is no jump instruction (S807: No), the process proceeds to step S810. Hereinafter, processing from step S808 will be described.

  Next, the transition table generating unit 302 extracts the method name in which the jump instruction is described and the jump destination label name described in the jump instruction (S808).

  Next, the transition table generation unit 302 sets the method name extracted in step S808 as the event name in the title of the screen transition table row. The transition table generation unit 302 then jumps to the jump destinations 413, 414, and 422 held by the cell in the cell where the row of the method name and the column of the frame determined in step S806 intersect in step S808. The previous label name is described (S809).

  Next, the transition table generating unit 302 adds 1 to the frame counter (S810).

  Next, the transition table generating unit 302 determines whether or not the frame number that matches the value of the frame counter is the last frame number (S811). Here, in the case of the last frame number (S811: Yes), the process proceeds to step 812. On the other hand, if it is not the last frame number (S811: No), the process returns to step 806. Hereinafter, the processing from step S812 will be described.

  Next, the transition table generation unit 302 corrects the screen transition table based on the constraint condition (S812).

  FIG. 9 is an example of a flowchart of step S812 in FIG.

  First, the transition table generation unit 302 searches the screen transition table for cells whose “anime flag” is “true” (hereinafter sometimes referred to as “anime cell”) in order from the beginning of the table, and matches first. A cell is extracted (S901). The extracted cell is referred to as “cell A” in the description of FIG.

  Next, the transition table generation unit 302 searches the screen transition table for cells that specify the frame section corresponding to the cell A extracted in step S901 as a jump destination in order from the beginning of the table, and extracts the matched cells. (S902). The extracted cell is referred to as “cell B” in the description of FIG. When there are a plurality of cells B, all the cells B are extracted, and the subsequent processes related to the cells B are executed for all the cells B.

  Next, the transition table generating unit 302 extracts a static constraint condition corresponding to the search key from the event constraint definition table 500 using the target device ID and the event name as a search key. Then, the transition table generating unit 302 sets the static constraint condition to “animation restriction after transition” of the cell B (S903). That is, in S903, the animation limit for cell A after transition from cell B to cell A is set. Note that the event name in the search key is the event name of the event that occurs because the transition to the cell A.

  Next, based on the label name corresponding to the cell A, the transition table generation unit 302 checks the frame to which the label name is assigned (S904).

  Next, the transition table generation unit 302 determines that the frame checked in step S904 includes a plurality of constraint conditions described in the static constraint conditions (for example, “number of animation elements”, “animation element size”, and “animation playback period”). It is determined whether or not at least one constraint condition in “)” is violated (S905). If the constraint condition is violated (S905: Yes), the process proceeds to step S906. On the other hand, if the constraint condition is not violated (S905: No), the process proceeds to step S910. Hereinafter, the processing from step S906 will be described.

  Next, the transition table generation unit 302 extracts the label name of the jump-destination frame section described in the cell A after completion of frame reproduction (S906).

  Next, the transition table generating unit 302 replaces the label name of the jump destination 414 described in the cell B with the label name of the jump destination frame section extracted in step S906 after completion of frame reproduction (S907). ). That is, when the normal frame corresponding to the cell B violates the static constraint condition, a setting is made so that the normal frame does not jump to the animation frame.

  Next, the transition table generating unit 302 displays a warning that the animation is omitted on the screen of the tool (S908). If the jump destination label name is not found in step S906, the screen transition itself is interrupted there, and a warning to that effect is displayed on the tool screen (the tool described with reference to FIG. 1). May be displayed.

  Next, the transition table generation unit 302 determines whether there is an unprocessed animation cell (S909). If there is an unprocessed anime cell (S909: Yes), the process returns to step S901. On the other hand, if there is no unprocessed anime cell (S909: No), the process proceeds to step S910. Hereinafter, the processing from step S910 will be described.

  Next, the transition table generation unit 302 is a cell corresponding to a normal frame in which a transition from the screen transition table to the animation frame corresponding to the animation cell A is described (hereinafter sometimes referred to as “normal cell”). B is extracted again (S910).

  Next, the transition table generation unit 302 extracts an event name from the row to which the normal cell B belongs (S911).

  Next, in step S912, the transition table generation unit 302 extracts dynamic constraint conditions from the event constraint definition table 500 using the event name extracted in step S911 as a search key, and changes the dynamic constraint conditions after the transition. It adds to cell B as animation restriction 412 (S912).

  Next, the transition table generating unit 302 determines whether there is an unprocessed cell (S913). If there is an unprocessed cell (S913: Yes), the process returns to step S910. On the other hand, when there is no unprocessed cell (S913: No), a process is complete | finished.

  FIG. 10 is an example of a flowchart of processing for generating a screen template from the screen transition table.

  First, the screen template generation unit 304 sets the frame counter to 0 (S1001).

  Next, the screen template generation unit 304 extracts a label name from the title of the column of the screen transition table (S1002). In the description of FIG. 10, the column is referred to as “target column”.

  Next, the screen template generation unit 304 generates a frame number from the frame counter. The generated frame number is, for example, a number that matches the value indicated by the frame counter. The screen template generation unit 304 generates an empty new frame, and assigns the generated frame number and the label name extracted in step S1002 to the new frame (S1003).

  Next, the screen template generation unit 304 extracts all event names from the target column (the column of the assigned label name) (S1004). S1005 described later is performed for each extracted event name. Hereinafter, an event name (referred to as “target event name” in the description of FIG. 10) is taken as an example.

  Next, the screen template generation unit 304 determines whether or not the extracted target event name is an event name representing a button press event (S1005). If the event is a button press event (S1005: Yes), the process proceeds to step S1006. On the other hand, if it is not a button press event (S1005: No), the process proceeds to step S1011. Hereinafter, the processing from step 1006 will be described.

  Next, the screen template generation unit 304 arranges a button template as a display component in this new frame so that a button press event can be generated (S1006).

  Next, the screen template generation unit 304 generates and generates a code template of the target event (event identified from the target event name) corresponding to the button template arranged in step S1006 with reference to the code template table 700. The code template is described in the script description area of the new frame (S1007).

  Next, the screen template generation unit 304 determines whether the target event has a constraint condition (S1008). If there is a constraint condition (S1008), the process proceeds to step S1009. On the other hand, if there is no constraint condition (S1008: No), the process proceeds to step S1013. Hereinafter, processing from step S1009 will be described.

  Next, the screen template generation unit 304 changes the color of the button template arranged in the new frame (S1009). As a result, in the generated screen data, the restricted display component is displayed in a different color, so that it can be visually discriminated. A display mode change (highlighted display) of a type other than the color change may be employed. The display mode is, for example, line thickness, font, or the like.

  Next, the screen template generation unit 304 adds the constraint condition described in the cell (cell in the screen transition table) corresponding to the target event name to the code as a comment (S1010).

  Next, the screen template generation unit 304 determines whether or not there is an event name unprocessed in step S1005 in one or more event names extracted in step S1004 (S1013). If there is an unprocessed event name (S1013: Yes), the process returns to step S1005. On the other hand, when there is no unprocessed event (S1013: No), it progresses to step S1014. Hereinafter, processing from step S1014 will be described.

  Next, the screen template generation unit 304 determines whether or not the “animation flag” is “true” in all cells belonging to the target column (S1014). If the “animation flag” is “true” (S1014: Yes), the process proceeds to step S1015. On the other hand, if the “animation flag” is “false” (S1014: No), the process proceeds to step S1016. Hereinafter, processing from step S1015 will be described.

  When the “animation flag” is “true” (S1014: Yes), the screen template generation unit 304 adds 5 to the frame counter (S1015). The reason for adding 5 to the frame counter is to insert an animation frame in this frame section. On the other hand, when the “animation flag” is “false” (S1014: No), the screen template generation unit 304 adds 1 to the frame counter.

  Next, the screen template generation unit 304 determines whether or not an unprocessed column remains in the screen transition table (S1017). If an unprocessed column remains (S1017: Yes), the process returns to step S1002. On the other hand, if no unprocessed column remains (S1017: No), the process ends.

  In step S1005, if the event is not a button press event (S1005: No), the screen template generation unit 304 inserts the code template into the script description area (S1011).

  Next, the screen template generation unit 304 adds the restriction condition described in the cell corresponding to the target event name (cell in the screen transition table) to the code as a comment (S1012), and proceeds to step S1013. The subsequent processing is the same as described above.

  A screen data template 303 is generated by a series of processes shown in FIG.

  The above is the description of the present embodiment.

  According to this embodiment, the developer can easily grasp the flow of frame transition in the GUI based on the screen transition table.

  Further, according to the present embodiment, appropriate constraint conditions (static constraint conditions and dynamic constraint conditions) according to the specifications of the target device are reflected in the software (for example, code). For this reason, the development load by the developer is reduced.

  Further, according to the present embodiment, the constraint condition that restricts the operation of animation or the like is reflected in the software (for example, code) according to the CPU usage rate of the target device. For this reason, the developer can develop user-friendly software.

  Further, according to the present embodiment, a script code is generated when the complexity of the screen data 301 is low, and a native code is generated when the complexity of the screen data 301 is high. This makes it possible to create software that balances extensibility and execution speed.

  In addition, embodiment of this invention mentioned above is an illustration for description of this invention, and is not the meaning which limits the scope of the present invention only to those embodiment. Those skilled in the art can implement the present invention in various other modes without departing from the gist of the present invention.

  For example, when it is necessary to make a sound when a button is operated, a restriction condition for sound may be determined and described as a restriction condition in the screen transition table. In the present embodiment, the function is built in the timeline type screen design tool itself, but the function may be added to an existing tool as a plug-in.

  Further, the above-described software creation support apparatus 300 is effective for cooperation between a designer and a developer. For this reason, for example, the device 300 manages authentication information for designers (for example, login ID) and authentication information for developers (for example, login ID), and the authentication information input by the user is for the designer. Depending on whether it is for a developer or a developer, a service (program to be executed) provided to the user may be selected. For example, if the input authentication information is the designer authentication information, the program 340 is executed and the program 350 is not executed. On the other hand, if the input authentication information is the developer authentication information, the program 350 is Once executed, the program 340 may not be executed.

  Further, for example, the target device ID may be an ID of the target device type.

100 Screen display example of software creation support apparatus 300 Software creation support apparatus 302 Transition table generation unit 313 Document generation unit 316 Storage unit 317 Complexity determination unit 318 Code template generation unit 319 Code combination unit 322 Screen display program generation unit 323 Module generation unit 340 Screen design program 350 Screen transition generation program 400 Screen transition table 500 Event constraint definition table 700 Code template

Claims (10)

A software creation support apparatus that supports creation of software for displaying a GUI (Graphical User Interface) on an electronic device,
A screen data storage unit for storing screen data including a frame section composed of a plurality of continuous frames that transition with the passage of time;
Event constraint definition information, which is information representing an operation restriction of the electronic device in an event, and a frame that transitions according to an event that occurs during display of the frame section based on the event constraint definition information and the screen data A transition management information generation unit for generating transition management information defining a section;
A management information storage unit for storing the event constraint definition information and the transition management information;
A software creation support apparatus characterized by comprising: The software creation support apparatus according to claim 1 ,
The plurality of frame sections include one or more animation frame sections that are frames including a frame in which the animation operates, and one or more normal frame sections that are frame sections configured by a frame in which the animation does not operate,
The event constraint definition information includes information representing a static constraint that is a constraint that does not depend on an operation state of the electronic device for at least one event,
The transition management information generation unit
(A) Specify the first animation frame section,
(B) specifying a second frame section in which the first animation frame section is a transition destination by the occurrence of an event;
(C) determine whether a static constraint corresponding to the event in the second frame interval is satisfied;
(D) If the result of the determination in (c) is negative, specify the third frame section that is the transition destination of the first animation frame section;
The transition management information is
(X) If the result of the determination in (c) is affirmative, it has information representing the first animation frame section as a transition destination of the second frame section;
(Y) If the result of the determination in (c) is negative, information representing the first animation frame section and information representing the third frame section as the transition destination of the second frame section And
The software created based on the transition management information in which the first animation frame section and the third frame section are designated as the transition destination of the second frame section is the second software in the GUI. Preferentially select the first animation frame section as a transition destination from the frame section of
Software creation support device. A software creation support apparatus according to claim 2 ,
The event constraint definition information further includes information representing a dynamic constraint that is a constraint related to an operation state of the electronic device with respect to the at least one event.
The transition management information generation unit identifies a dynamic constraint corresponding to the event in the second frame section,
The transition management information includes information representing the identified dynamic constraint as a constraint on the second frame section,
Created based on the transition management information that includes the first animation frame section and the third frame section as transition destinations of the second frame section and includes information representing the dynamic constraint When the operation state of the electronic device does not satisfy the operation constraint, the software that has been selected selects the third frame section as a transition destination from the second frame section in the GUI.
Software creation support device. A software creation support apparatus according to claim 3 ,
The third frame section is the normal frame section.
Software creation support device. The software creation support apparatus according to claim 1 ,
The event constraint definition information has information indicating whether there is a restriction on the operation of the electronic device in an event for each electronic device or each type of electronic device,
The transition management information generation unit generates the transition management information based on the constraint corresponding to the input electronic device identification information in the event constraint definition information,
The electronic device identification information is identification information of the type of electronic device or electronic device.
Software creation support device. The software creation support apparatus according to claim 1 ,
The constraint is a constraint that represents whether or not the execution of the transition destination animation can be omitted when the operation status of the electronic device is a predetermined status.
Software creation support device. The software creation support apparatus according to claim 1 ,
The constraint is a constraint indicating whether or not the execution of the animation can be omitted when the user performs a predetermined operation.
Software creation support device. The software creation support apparatus according to claim 1 ,
The plurality of frame sections include one or more animation frame sections that are frames including a frame in which the animation operates, and one or more normal frame sections that are frame sections configured by a frame in which the animation does not operate,
The constraint on the animation frame section is different from the constraint on the normal frame section.
Software creation support device. A software creation support method for supporting creation of software for displaying a GUI (Graphical User Interface) on an electronic device,
Obtaining from a predetermined storage unit screen data including a frame section composed of a plurality of continuous frames that transition with the passage of time, and event constraint definition information, which is information representing the constraint of the operation of the electronic device in an event,
Based on the event constraint definition information and the screen data, generate transition management information that defines a frame section that transitions according to an event that occurred during display of the frame section,
A software creation support method, wherein the transition management information is stored in a predetermined storage unit . A computer program for supporting creation of software executed on an electronic device and displaying a GUI (Graphical User Interface),
Obtaining from a predetermined storage unit screen data including a frame section composed of a plurality of continuous frames that transition with the passage of time, and event constraint definition information, which is information representing a constraint on the operation of the electronic device in an event,
Based on the event constraint definition information and the screen data, generate transition management information that defines a frame section that transitions according to an event that occurred during display of the frame section ,
A computer program storing the transition management information in a predetermined storage unit .

Images