KR20050057822A - Method for realization gui using xml - Google Patents

Abstract

Commonly applicable in the field of implementing Graphic User Interface (GUI) using XML. In implementing a server / client model or a client only model. In order to achieve maximum effect with minimum cost, a GUI implementation method using XML is presented. According to the present invention, it is possible to reduce the time and cost used when implementing the GUI by independent of the repetitive development part when implementing the GUI as an XML document and by providing the elements required for the GUI development through generalization. .

Description

Method for realizing GUI using WLML {method for realization GUI using XML}

The present invention relates to a GUI implementation method using XML. In particular, the present invention is commonly applicable in the field of implementing a graphic user interface (GUI) using XML. The present invention relates to a GUI implementation method using XML in order to achieve the maximum effect at the minimum cost in implementing a model or a client-only model.

In general, the way to implement the GUI is to design the screen and implement the functions according to the design. Here, the screen is a unit having components necessary for a user to input or query a value. The GUI is a collection of these screens. Therefore, the developer of the GUI implements functions based on the data input and output from the user and the function based on the screen configuration task that adds and arranges elements for each screen and the components arranged through the screen configuration task. Tasks must be performed for each screen. For example, if the number of screens that the developer wants to implement is 10, the screen composition, data input / output, and function implementation should be repeated for the 10 screens.

However, since the GUI has three components in common: a screen component, an input / output processing component for a user, and a user requirement processing component, an implementation of an arbitrary function requires only those three components. If you add coding according to the matter, it can be implemented. When the GUI performs the same function in development, but the requirements, that is, the screen configuration is different, the developer has to repeat the screen configuration work, data input / output work, and the function implementation work for the screen, so the development cost of the GUI is high. Not only is it excessively consumed, but there is a problem that repetitive development occurs due to a decrease in the efficiency of work, that is, the reuse of already-coded code is hardly made.

The present invention has been invented to solve the above problems, in the development of the GUI, based on the implementation of the above three elements generalized to derive a part that can be repeatedly developed according to the requirements of the user Independence using XML data format can save time and cost in GUI development. In addition, it avoids the developer's manual work on the independent XML document, which can be a huge amount, and creates and modifies the XML document in a form similar to that provided by the existing GUI development tool for the user's intuitive use. Its purpose is to provide a GUI implementation method using XML that enhances the convenience of GUI development by providing XML Builder Application so that XML document can be created and modified easily, conveniently and accurately.

The present invention for achieving the above object

Creating a control document in which property information of all kinds of components provided by Java Swing is provided in an XML data format using an XML builder application;

By using XML Builder application, Java Swing element for specific screen layout and specific action processing according to user's input / output request are written in XML data format to compose a specific screen. Creating a GUI startup document for performing the above;

After generating the GUI startup document, parsing the contents of the created XML document and converting the converted XML document into a predefined loading class to make it usable in a Java application. Performing);

And a screen configuration step of constructing a GUI screen according to the content of the XML document by using the information loaded through XML parsing in a Java application.

In addition, in the GUI implementation method using the XML according to the present invention, the input and output processing step for the user to process the input value from the screen when the user inputs a specific value through the screen to execute a specific function It delivers to the requirement processing component of and also outputs the result value to the screen when processing is completed.

The input / output processing stage for the user is a Java application as opposed to a function that converts the user's input value from the Java Swing screen system that the user can understand to the Java variable system that the Java application can understand. This function converts the output value from the understandable Java variable system to the Java Swing that the user can understand. This step is equivalent to the concept of a loading class used when parsing XML, which means conversion to a predefined interface class.

In the GUI implementation method using XML according to the preferred embodiment of the present invention, the user actually performs a desired function according to an input value input through an input / output processing element for a user, that is, a value contained in an interface class. It stores the result back to the interface class, and includes a component that implements the user's requirements entered through the input and output processing elements for the user.

In conclusion, in the GUI implementation method using XML according to the present invention, in the implementation of the GUI, the steps of first writing a control document, creating a GUI startup document, and performing XML parsing are performed. Create the XML data required for the implementation of the GUI and parse the created XML data to store basic data, and then configure the GUI screen based on the stored data, process the input / output for the user, It is to repeat the user's requirement processing step.

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

1 is a view for explaining an example of creating a GUI startup document in the GUI implementation method using XML according to the present invention, Figure 2 is an operation of the GUI implementation method using XML according to the present invention This is a conceptual diagram for explaining.

In the GUI implementation method using XML according to the present invention, assuming that there is XML generated by a component that processes XML, the following elements are implemented. Module that draws GUI screen, that is, screen component, module that receives values from screen components or outputs values to screen, i.e. user I / O processing component, received from user A module that processes data, that is, a module is classified into a function performing element, and the divided module is implemented as a Java component.

In addition, the contents that are the subjects of execution of screen components and user input / output processing elements are implemented using the XML data format, and an XML builder application is provided to automatically generate XML data. The XML Builder application is used to solve complex XML document creation, modification, and grammar problems.

The present invention saves development time and costs by developing a GUI using three components and an XML builder, which are screen components, user input and output processing elements, and function performing elements. To provide.

<XML Data Format-Control Document>

In the present invention, a control document which is a configuration document for all Java Swing elements written in XML data format, and a GUI startup document which is a document about a GUI screen implementation, a user input, output processing, and a function implementation configuration, etc. Have different kinds of documents The dual control document is a document in which property information of all kinds of components provided by Java Swing is written in XML data format.

The content written in the control document is the default value for each Java Swing Component specified in the screen composition part when implementing the screen function in the GUI startup document which is the screen composition, user I / O processing, and function implementation configuration document. Can be.

In general, in the GUI implementation method according to the present invention, when defining the properties of Java Swing components required for the screen configuration of the GUI in a GUI startup document written in XML data format, Since it is inefficient to specify all the properties that the Component must provide, only the items necessary for the composition of the GUI screen are defined. In this case, values not defined in GUI startup document written in XML data format have already written property information of all kinds of components provided by Java Swing in XML data format. Reference it in the control document you placed. In other words, the control document is a property of all selectable options for GUI screen composition provided by various components required in Java Swing, such as Button, Table, Label, Tree, Radio Button, and Check Box. Since the values of properties are defined by each element, the values of properties that are not provided in the GUI startup document are referred to in the control document.

Java Swing components include JButton, JCheckBox, JComboBox, JComponent, JDialog, JFrame, JLabel, JList, JMenu, JPanel, JPopupMenu, JProgressBar, JRadioButton, JScrollBar, JSlider, JSpinner, JSplitPane, JTable, JTextArea, JTextField There are items such as, JTextPane, JToolBar, and JTree. The following is an example of the list and value of properties defined for JButton item among Java Swing elements in control document.

<JButton>

<name> JButton1 </ name>

<action> </ action>

<actionCommand> </ actionCommand>

<actionMap> </ actionMap>

<alignmentX> </ alignmentX>

<alignmentY> </ alignmentY>

<background> </ background>

<border>

<type> </ type> <!-Empty, Line, Etched, Bevel, Matte (Color), Matte (Icon)->

<color> </ color> <!-RGB Style->

<width> </ width>

<highlight> </ highlight>

<shadow> </ shadow>

<highlightOuter> </ highlightOuter> <!-RGB->

<highlightInner> </ highlightInner> <!-RGB->

<shadowOuter> </ shadowOuter> <!-RGB->

<shadowInner> </ shadowInner> <!-RGB->

<icon> </ icon>

<title> </ title>

<innerBorder> </ innerBorder>

<insets>

<top> </ top>

<bottom> </ bottom>

<right> </ right>

<left> </ left>

</ insets>

</ border>

<borderPainted> </ borderPainted> <!-true, false->

<contentAreaFilled> </ contentAreaFilled> <!-true, false->

<!-LOG_OPTION, FLASH_OPTION, BUFFERED_OPTION, NONE_OPTION->

<debugGraphicsOptions> </ debugGraphicsOptions>

<disabledIcon> </ disabledIcon>

<disabledSelectedIcon> </ disabledSelectedIcon>

<doubleBuffered> </ doubleBuffered> <!-true, false->

<enabled> </ enabled> <!-true, false->

<focusPainted> </ focusPainted> <!-true, false->

<font>

<type> </ type> <!-MS Sans Serif->

<size> </ size>

<italic> </ italic> <!-true, false->

<bold> </ bold> <!-true, false->

</ font>

<foreground> </ foreground>

<!-LEFT, CENTER, RIGHT, LEADING, TRAILING->

<horizontalAlignment> </ horizontalAlignment>

<!-LEFT, CENTER, RIGHT, LEADING, TRAILING->

<horizontalTextPosition> </ horizontalTextPosition>

<icon> </ icon>

<inputVerifier> </ inputVerifier>

<margin> </ margin>

<maximumSize> </ maximumSize>

<minimumSize> </ minimumSize>

<mnenomic> </ mnenomic>

<model> </ model>

<nextFocuableComponent> </ nextFocuableComponent>

<opaque> </ opaque> <!-true, false->

<preferredSize> </ preferredSize>

<pressedIcon> </ pressedIcon>

<requestFocusEnabled> </ requestFocusEnabled> <!-true, false->

<rolloverEnabled> </ rolloverEnabled> <!-true, false->

<rolloverSelectedIcon> </ rolloverSelectedIcon>

<selected> </ selected> <!-true, false->

<text> </ text>

<toolTipText> </ toolTipText>

<verifyInputWhenFocusTarget> </ verifyInputWhenFocusTarget> <!-true, false->

<verticalAlignment> </ verticalAlignment> <!-TOP, CENTER, BOTTOM->

<verticalTextPosition> </ verticalTextPosition> <!-TOP, CENTER, BOTTOM->

</ JButton>

As described above, in the control document, items for all Java Swing components are defined for each element using the XML data format. This control document is directly related to screen design, especially in GUI startup documents, and serves as ancillary data for the Java Swing components used in screen design.

<XML Data Format-GUI Startup Document>

GUI Startup document, also defined in XML data format, embodies the contents of screen design, user I / O processing, and functional design for the functions to be implemented as GUI. That is, in the implementation of a general GUI, the screen design, the user I / O processing, and the functional design should all be implemented by Java Coding. In the present invention, the GUI startup document may be changed according to a user's request. Among them, screen design, user I / O processing, and function processing parts are created using XML data format, and the functions are generalized and developed as components, screen design elements and user I / O processing components. In other words, the function processing components are called from the Java application and executed as specified in the XML data format, thereby completing the GUI application.

In other words, how to organize the screen using XML data format in GUI startup document, how to arrange Java Swing elements, user input and output processing on GUI screen, and how to implement functions on GUI screen. Specify the contents of (specific functions such as whether to save in the database or print out the contents of the database). The XML document created as described above becomes input values of the generalized and implemented screen component, user input / output processing component, and component implementation component, so that the user can draw the desired screen and perform the desired function. Will be.

In the GUI implementation method using XML according to the present invention, when the GUI is implemented, the control document and the GUI startup document, which are written in XML data format, are loaded to configure a screen and perform a function as instructed by XML. Each time a feature is added, there is no need to add new coding. In other words, you only need to work with XML documents for functions added or changed.

The GUI Startup document contains Java Swing components for screen composition according to the user's request, and Java Swing components for implementing specific functions according to the user's request. It is written in XML data format about how Java application will take for user input / output processing of user input values from screen.

The GUI startup document defines Java Swing elements using XML data format only those items necessary for the composition of a specific screen. 1 shows a specific screen for inquiring system information and storing and printing the information. The screen shown in FIG. 1 includes a JLabel element (Component) for outputting system information, three JButtons for the user to select a function of inquiry, storage, and printing, and an element of JTable for outputting contents ( Component) is used. In order to compose such a specific screen, the GUI startup document sets an independent item called <System Information> in XML data format and describes it as follows.

First, what kind of Java Swing Component to use for the screen design part, what is the characteristic value of the selected Java Swing Component, and the Java Swing Component ), Where the location information of where to place it is described. Next, for the user I / O processing part, perform the function opposite to the Java Swing component that receives input from the user among the Java Swing components, and then view the result. For Java Swing component that should be outputted so that the value can be converted into a form that can be processed in Java Application, it is defined as Interface Class. Data is stored in this interface class, and the user input / output part and the function processing part exchange data with each other.

Finally, for the function processing part, we describe the processing procedure of the button (here, JButton) in the Java Swing Component that allows the user to pass his or her requirements to the Computer.

The following example is an XML example to illustrate this.

<ITEM ID = "System Info">

<Control>

<Type = "JLabel" Depth = "1" Identity = "1" Name "System Information" Value = "label1" Position = "3,3,29,9" />

<Type = "JButton" Depth = "1" Identity = 7 "Name =" Save "Value =" button1 "Position =" 76,13,85,18 ">

<Command>

<Identification> GetSystemInfo </ Identification>

<Component> SystemInfoTable </ Component>

</ Command>

</ Type>

<Type = "JTable" Depth = "1" Identity = "9" Name "" Value = "table1" Position = "3,27,49,57" Col = "Proc, User, Pid, Memory, CPU" />

</ Control>

</ ITEM>

The JLabel element to display the system information text on the screen should be defined as "System information" in the X, Y coordinate information on the screen where the JLabel is to be located, and in the Java Swing Component Property. Part, variable name to be used in actual Java Code.

In addition, Java swing elements for specific processing are also written in XML data format for the items that have input / output processing from the user among Java Swing components. Referring to FIG. 1, a Java Swing element in which an input and output of a user occurs is a JButton called inquiry, storage, and printing. In other words, when the user operates the input button, a Java application is to write a method to perform the corresponding operation. In the example above, the operation is described in a tag called <Command>, which is a function called GetSystemInfo and means to output a value to a Java Swing component called SystemInfoTable. If the data received according to this information is passed to the component, it is described in XML and the component is executed according to the defined function.

In this way, the GUI startup document is a screen component that displays a Java Swing component for a specific screen design, and receives the user's data from the screen and outputs the data to the screen again. The main component is a user input / output component, a component for implementing a specific function according to a request from a user, and the three elements are implemented in an XML data format instead of Java code.

That is, in the configuration of the conventional GUI, when a new requirement arises and a specific screen needs to be implemented, the screen is designed for a new screen and additionally developed Java Coding for function implementation, and then compiled and debugged. After executing (Debugging), an executable file is created.

However, in the GUI implementation method according to the present invention, the part about screen design is replaced by the Java Swing Component definition technology part of the screen configuration in the GUI startup document written in XML data format. The part responsible for I / O of the system is described, and it is replaced by the action processing definition description part of the function implementation described in XML based on the data received from the user.

<GUI Implementation Example>

Hereinafter, a specific embodiment of the GUI implementation method according to the present invention will be described in detail by timely referring to FIG.

First, in the GUI implementation method according to the present invention, Java Swing for a control document and a specific screen configuration for writing property information of all kinds of components provided in Java Swing in XML data format. GUI startup document for creating (Java Swing) element (screen configuration) and specific action processing according to user's request and Java Swing element (User In / Out configuration) for it in XML data format You will write

In this case, when the control document and the GUI startup document are generated manually, a large amount of time is required, and a consistency check process is required. It's also not easy to do it manually when you need to make corrections or when something needs to be done. Therefore, when creating the control document and the GUI startup document, the XML builder application is used to implement the automation of the XML document generation.

In addition, the XML Builder application adds functionality for constructing GUI screens, for example, the positioning of Java Swing elements, the property values of positioned Java Swing elements, etc. Implement the function. The ultimate goal of the XML Builder application is to quickly and easily generate control documents and GUI startup documents in XML data format.

The XML Builder application, a separate tool for effectively creating and managing XML documents, is similar to JBuilder. The developer selects Java Swing elements on the screen by dragging and dropping. And specify the values of the properties. In addition, necessary actions for user input and output requests are provided through the screen. Therefore, the GUI developer should define all the screens and functions required by the Java application when generating the control document and the GUI startup document through the XML Builder application and then generate the XML document. Selecting a feature generates an XML document. In addition, XML Builder applications can modify XML documents that have already been created.

Referring to FIG. 2, the developer of the GUI may determine which components of Java Swing are to be positioned where and where the properties of the Java Swing are to be designed for the GUI screen design. Builder application is used to create or modify control documents and startup documents in XML data format.

XML Parsing Performs XML Parsing to make two XML data format documents created by calling Component to be usable in Java Application. XML parsing is a function that converts XML document contents into a predefined loading class so that each component can be used in a unified way in a Java application.

Passing the loading class to the screen component, that is, the screen component receives the loading class as input, and the loading class is an array of classes. Steps to configure the GUI screen are performed in the order of. In other words, the screen implemented in the form desired by the user is drawn. This screen is ready to receive input from the user.

When the GUI is implemented as described above, when the user selects a desired function, the user input / output processing component is called and the screen is written as written in the loading class defined using the XML parsing function. It reads the value from and converts it to the type used in Java Application.

This means a transformation from a system that can be understood by a user to a system that can be understood by a Java application, which, like a loading class, is converted into a predefined interface class.

The user input / output processing component converts the input of the screen into an interface class and calls a component implementing component using the interface class.

The function implementation element understands the user's desired function in the Interface Class and performs the defined function using the value entered by the user. In this case, the function performed may be executable on the computer where the GUI is executed, or may be a case where a result must be received by transmitting a message to a server. The result of the function performed is put in the interface class to call the user I / O processing component.

The user I / O processing component will output the contents of the interface class to the GUI screen so that the user can check it again.

In this way, it executes the functions of the GUI program, and the screen generation component, user input / output processing component, and function implementation component are called independently based on the content of XML. It is called repeatedly to perform a GUI function.

If you want to implement a new function GUI, regenerate the XML Startup document as you want it to be implemented using the XML Builder application, and then parse the XML Parsing Component, screen. You only need to regenerate the code that calls the generation component, the user input / output processing component, and the function implementation component. At this point, the control XML document is generic to Java Swing and can be reused over and over again. It also changes only the XML Startup documents and reuses the code for each Java component.

As described above, in the GUI implementation method of the present invention, when the GUI is implemented, the repetitive development part is separated into an XML document and the functions required for the GUI development are provided by generalizing the elements. It enables code reuse that saves time and money. In addition, an independent XML document part can be easily created and modified through an XML builder application, thus improving the ease of development through this method.

Although the preferred embodiments of the present invention have been described in detail with reference to the accompanying drawings, the present invention is not limited thereto and may be improved or modified by those skilled in the art within the scope of the technical idea of the present invention.

1 is a view for explaining an example of the creation of a GUI startup document in the GUI implementation method using XML according to the present invention.

2 is a conceptual diagram illustrating the operation of a GUI implementation method using XML according to the present invention.

Claims (4)

Creating a control document in which property information of all kinds of Java Swing components for screen design is arranged in an XML data format when a GUI is implemented; Referring to the control document, a screen component for displaying a Java Swing component for a specific screen design is created, and a user's input on the designed screen is transferred to an interface class. A user input / output component for storing the output value (processing result of the input value) stored in the interface class on the screen, and a user input / output component Creating a GUI startup document for composing a specific screen by creating a function implementation component in an XML data format for implementing a specific function according to a request; After generating the GUI startup document, parsing the contents of the created XML document and converting the content into a predefined loading class to make it usable in a Java application. Performing parsing; And, And constructing a GUI screen according to the content of the XML document by using the information loaded through XML parsing in a Java application. According to claim 1, The GUI startup document written in XML data format (Drag & Drop) Drag and drop (Java Swing) element selected on the screen and placed on the screen (Property) GUI implementation method using XML, characterized in that it is written using an XML Builder application that performs the function of specifying the. The method of claim 1, wherein the function implementation component is input through an input / output processing element for the user to perform a specific function according to an input value stored in the interface class, and the result is performed on the interface. GUI implementation method using XML, characterized in that to perform the function of handling the user's requirements by storing in the Interface (Interface Class). According to claim 1, The function implementation element and the user input, output processing element is a Java (Java) variable system that can execute a Java application when the input value in the Java Swing (Java Swing) screen for the user of the user GUI implementation using XML, which converts an input value and converts an output value from a Java variable system in which the Java application is executed to a Java Swing screen for a user Way.