CN1202077A - Method and device for generating graphical interface system components in batches - Google Patents

Abstract

Apparatus and methods for batch generation of motif components are provided. A method for batch generation of motif components according to an illustrative embodiment of the present invention includes compiling component generation data files for generating batches of components, and defining batch generation structures for reading out in corresponding component group units The compiled components generate data. The corresponding data files requested by the command to batch generate structure definition units are read out, and composite components are generated in batches by using a component generating function.

Description

Method and device for generating graphical interface system components in batches

The present invention relates to a graphical user interface (GUI) implemented in a mobile communication system, and more particularly to a method and device for realizing an alarm display for displaying a fault alarm of a base station manager (BSM) in a digital cellular system.

Since cellular communication services became commercially available in the early 1980's, the demand for cellular communication services has continued to grow because of the mobility, speed, wide area coverage, and convenience it provides cellular service users. To meet this growing demand, the following advances have occurred: microcells with increased radio channel capacity; the use of digital techniques; narrowband voice signals; high-efficiency frequency modulators; and multiple-access systems.

The current digital cellular mobile communication system is divided into TDMA (Time Division Multiple Access) and CDMA (Code Division Multiple Access) systems. The TDMA system utilizes a technique whereby predetermined time slots are allocated for transmitting and receiving signals. By adjusting the transmission time of the signals, multiple signals can be sent to different stations, whereby the signals overlap in the space domain but do not interfere with each other in the time domain. The TDMA scheme is currently being used in Europe, the United States, and Japan, which have established TDMA standards. CDMA systems on the other hand are divided into two groups according to frequency hopping and direct sequence. Qualcomm Corporation proposes a direct-sequence CDMA system.

Alarm displays for cellular BSM failure alarms have been implemented by commercial programs such as SL-GMS. SL-GMS is a software graphics tool that is very expensive to install and requires a lot of memory in order to drive the associated system resources. The use of SL-GMS increases the load involved in changing the alarm display, thus increasing the total time required for changing the display. Moreover, such use increases the display update time, thereby reducing the efficiency of GUI alarm display that requires real-time processing. Efforts have therefore been continuously made to use widgets of the graphical interface system (motif) instead of the alarm display of the SL-GMS.

Advantageously, the use of motifs facilitates display generation. It is also economical because it is basically provided with most UNIX systems. Moreover, the motif puts little load on the driving system during the driving process, and can run faster than SL-GMS. Despite these advantages, the generation of basic motif elements (called artifacts) requires a large amount of code to be entered one by one. And it is very difficult to change the characteristics and structure of the components. For example, since a code must be modified and compiled to change the color of one component, the process of changing the displayed color of a motif including many components becomes very complicated and requires a large amount of time.

Therefore, it is an object of the present invention to provide an apparatus and method for generating motif components in batches in a digital cellular system in order to efficiently perform alarm display for a base station manager. The generation of the motif components includes the use of a data file that includes a collection of motif component generation data.

Another object of the present invention is to provide a device and method for generating motif components in batches by means of data files.

Another object of the present invention is to provide an apparatus and method for easily generating motif components in order to complete alarm display.

To achieve the above and other objects, a device and method for generating motif components in batches are provided. The method for generating motif components in batches according to an embodiment of the present invention includes the following steps, such as compiling component generation data files for generating components in batches, and defining a batch generation structure for use in corresponding component group units Read out the compiled component generation data in . Next, corresponding data files requested by an instruction to batch generate structure definition units are read out, and composite components are batch-generated by using component generating functions.

Objects and advantages of the present invention will become more apparent by describing in detail embodiments of the present invention with reference to the accompanying drawings, in which:

Figure 1 is a block diagram of a digital cellular communication system associated with a BSM to which embodiments of the present invention are applied;

Figure 2 shows an example motif display for a better understanding of component groups, group IDs and

child ID;

Figure 3 shows the structure of the components of the motif displayed by the motif shown in Figure 2;

Figure 4 is an algorithm for component batch generation according to an embodiment of the present invention; and

FIG. 5 is a block diagram of a motif batch generation device according to an embodiment of the present invention.

Detailed description of the preferred embodiment

In the digital cellular system, BSM operates as a workstation, and its task is to manage, repair and maintain the entire mobile communication system. The BSM transmits the working status of the mobile communication system through the motif alarm display implemented according to the embodiment of the present invention.

Figure 1 is a block diagram of a CDMA digital cellular communication system associated with a BSM. The system includes mobile stations (MS) 10-1 through 10-n, base transceiver station subsystem (BTS) 12, base station controller (BSC) 14, base station manager (BSM) 16, and base switching center (MSC) 18 . Mobile stations 10-1 to 10-n are mobile communication terminals that carry out wireless communication under the control of BTS12. BTS 12 is a base station that performs wireless communication with mobile stations 10-1 to 10-n within its own cell radius. BSC14 is connected between BTS12 and MSC18 and controls all communications related to BTS12. BSM 16 is connected to BSC 14 and interfaces to operators in BTS 12 . MSC 18 is connected to BSC 14, and handovers mobile stations 10-1 to 10-n.

The first illustrative embodiment of the present invention is directed to an efficient implementation of an alarm display for displaying fault alarms of the base station manager 16 to users and operators. For this purpose there is provided a method for batch generation of motif components using a data file comprising a collection of motif component generation data. By using this method, components are easily mass-generated by putting only the data required to generate the components into files. The component structure is corrected through the data file without compiling operation, which reduces the working time and improves the working efficiency.

A motif is a collection of user interface objects called widgets. The motif widget set includes all objects related to the GUI that a programmer or user may need, such as drop-down menus, dialog boxes, scroll bars, buttons, etc. When a programmer intends to build an application using motifs, he simply selects the component set for making the GUI and includes the component set in code. The results of the coded components are shown on the display screen. However, in order to make a plurality of components with the same properties by means of motifs, it should be inconvenient to repeat the same coding. The code parts of widgets with the same properties change according to the widget's position, color and string. Therefore, if the data required for generating components is independently managed, components can be mass-produced easily and quickly. Coding can be simplified by programming component generation data into data files, reading data files, and generating functions for automatic component generation. Furthermore, coding efficiency can be improved simply by modifying data files to change component properties.

Although there are many kinds of manager components necessary for generating components, a form component may be used instead of the manager component due to the convenience of arranging components according to positions, as will be explained below. The data file includes the location of the parent widget, the type of widget generated, the widget's location within the parent widget, and the widget's colors and strings. For the widget's position, the relative coordinates used in the form widget's XmATTACH POSITION resource are used. Components are grouped according to their respective types, and components in the same group have the same parent component. In order to indicate the component type, a string representing the batch generation function of the motif component is used instead of the original motif component name. Although the function can be established whenever necessary according to the use of the component, basic required functions are established in advance.

When generating motif components, data files are used in the same way as in User Interface Language, where precompilation is utilized. Therefore the UIL should have the same structure as the component expressed in the motif code, and thus needs to be compiled. However, the use of data files according to the present invention enables component structures to be determined regardless of source files, thus requiring no compilation. Also, component generating functions can be created whenever necessary, improving coding efficiency by removing unnecessary component generating functions from sources. Conventional methods are not feasible when coding, especially in the case of alarm displays, since the structure of the alarm display should be modified whenever the requirements for the alarm status change. However, according to the component batch generation method of the present invention, the alarm display can be changed simply by changing the data file, thereby simplifying the coding. The component structure for batch generation of components according to the embodiment of the present invention will be defined below.

(1) Definition of component structures for batch generation

Components are grouped to generate components in batches. Each component group has exactly the same parent component, and the same nature of the sub-components. The parent component refers to the manager component in the motif, and the child component refers to the component generated on the parent component. The component structure is defined as:

           
  struct Page{

         int*N;

           Widget**Buttons;

           Pos**POSPTR;

           Col**COLPTR;

           Str**STRPTR;

           Prt*PRTPTR;

           Knd*KNDPTR;

          int *MAXLEN;

    };

        

The field 'N' here indicates the number of components required for memory allocation (hereinafter referred to as "malloc"). N[0] represents the total number of component groups forming the display. N[n] (n>0) represents the number of sub-components in the nth group. The field 'Buttons' represents the address of each sub-widget in a group. Subwidgets are defined by double pointers containing the group id and subid assigned to the subwidget. The fields 'POSPTR', 'COLPTR' and 'STRPTR' represent the widget's position, color and string, respectively. The structures 'Pos', 'Col' and 'Str' store the data needed to change the widget's position, color and string, respectively. The fields 'PRTPTR' and 'KNDPTR' indicate the position of the parent component and the type of component group. 'PRTPTR' and 'KNDPTR' are defined by a pointer since the child components in a group are of the same type and share the same parent component. The field 'MAXLEN' stores data corresponding to the length of the longest character string in a group, which is used to assign appropriate fonts to components. 'MAXLEN' differs from other fields in that its value is set after comparing strings during program execution, whereas the initial values of other fields are set in the data file. That is, the initial value of 'MAXLEN' may not have been set in the data file. The structures 'Pos', 'Col', 'Str' and 'Knd' are defined as:

           
    typedef struct_Pos{

          int Nth,Sth,Wst,Est;

    } Pos;

    typedef struct_Col{

          char Tsh[20], Bsh[20], Bgd[20];

    }Col;

    typedef struct_Str{

          char str[100];

          char fore[20];

    }Str;

    typedef struct_Prt{

          int i,j;

    }Prt;

    typedef struct_Knd{

          char knd[20];

    }Knd;

        

The 'Pos' field represents the top, bottom, left and right position coordinates of the child widget relative to the parent widget. The 'Col' field represents the widget's top shadow, bottom shadow and background. The 'Str' field represents the string and the color of the string, respectively. Here, the 'fore' field may be omitted, in which case black is specified. The two fields of 'Prt' represent the group id and child id of the parent component respectively. The 'Knd' field indicates the type or kind of member. The concept of component generation according to the present invention will be described below.

(2) The concept of component generation

A component group is a collection of components of the same type on the same parent component. The group id indicates the group number in the group defined in the data file, and it increases sequentially from 1. The sub-id represents the component number in a group, starting from 1 and increasing sequentially. Each component defined in the data file has a group id and a sub id. Figure 2 shows a simple motif display to better understand component groups, group ids and sub-ids.

To generate the motif display structure shown in Figure 2, 4 component groups and 5 subcomponents were used. The 4 groups have one, one, one and two subcomponents respectively. Although the background widget 20 at the bottom (ie the form widget) does not belong to any group, it is used as a parent widget to other widgets in the data file and thus has a group id and a child id. The background component 20 is thus given group id 0 and child id 0. Figure 3 shows the structure shown by the motif shown in Figure 2. For simplicity in describing components, if the bth sub-component in group a is defined as component {a, b}, the background component 20 is component {0, 0}. Groups 1-4 have components {0,0}, {1,1}, {2,1} and {3,1} respectively, as do their parent components. Components of the same type under the same parent component are usually included in the same group, but in some cases may be in different groups, for example to assign different fonts to components in the same group, or to conveniently When managing artifacts. Next, the component generation function will be described.

(3) Component generation function

The widget creation function performs the following functions: builds subwidgets on a parent widget by allocating (malloc) as many subwidgets as needed in memory; changes subwidget properties, such as position and color; and returns subwidget pointers. The returned pointer value is marshaled and used to identify sub-components by group id and sub-id. The data of the parent component as well as the number, position and color of the child components can be derived from the component structure in the data file. Composite members with complex structures can be formed when necessary. For example, to generate a manager widget with a 3D visual effect, 3 malloced widgets are assigned different colors and slightly offset to overlap. While the position of the child widget relative to the parent is determined by the form widget at the bottom of the parent, the address of the form widget at the top of the parent is returned as the address of the widget group. There are no specific restrictions on the component generator functions, they can be defined by the user, as long as the pointer of the window component is returned in the composite manager component generator function. This is because other widgets can only be positioned on the Composite Manager widget that includes the Form widget. If the character string representing each function is utilized in an if-statement, the desired component generating function can be realized by reading only one function without including the generating functions of several components expressed in separate codes. The establishment of data files for batch generation of components according to the embodiment of the present invention will be described below.

(4) Establish data files for batch generation of components

The data files for a simple motif display in a digital cellular system implemented by a component generation function and used in an alarm display of a base station manager will now be analyzed. It should be noted that this data file is not ideal and it can be freely defined by the programmer. The data file corresponding to Figure 2 is given as:

           
    4:1112

    KND01{BigButtons}
    KND02{BigButtons}

    KND03{BigButtons}

    KND04{verticaldrawn}

    PRT01{0,0}

    PRT02{1,1}

    PRT03{2,1}

    PRT04{3,1}

    POS01{25, 76, 3, 97}

    POS02{5, 95, 5, 95}

    POS03{5, 93, 5, 95}

    POS04{7, 93, 15, 43} {7, 95, 57, 85}

    COL01{whitesmoke, grey50, lightgrey}

    COL02 {grey50, whitesmoke, gray70}

    COL03{whitesmoke, grey50, lightgrey}
    COL04{NULL, NULL, limegreen} {NULL, NULL, limegreen}

    STR01{NULL}

    STR02{NULL}

    STR03{NULL}

    STR04{A}{B}

        

The first row indicates that there are four component groups with one, one, one and two subcomponents respectively. These numbers are used for component memory allocation required by component generation functions, and they should be placed in a fixed order on the first line. 'KND' indicates the type or kind of component, and it should be placed at the beginning of a line, because it is usually used as a mark indicating the position of the desired data in the data file. A character string (character sequence) representing a component type is enclosed in {}, and other character sequences are not considered. A string can be defined to represent a user-initialized component generation function.

'PRT' means the parent widget, with the parent widget's group id and child id separated by commas. When specifying a parent component, the order of the parent component and subsequent components should be maintained. Otherwise the parent widget will not be recognized, resulting in unexpected display.

'POS' represents the top, bottom, left and right position of the child widget relative to the parent widget, expressed as a percentage. Assuming that the component completely occupies the parent component, the relative position of the component is {0, 100, 0, 100}. Typically, the relative minimum position is 1, with no decimal point. In the case where the desired position requires a coordinate below 1, an empty widget is generated on the parent widget, and then a widget is placed on the empty widget.

'COL' provides color information for widgets such as top shadow, bottom shadow and background. 'NULL' means an unused color, and the color item should be consistent with the definition in the text file rgb.txt.

'STR' includes string information attached to the component. In order to get sub-components without strings, the color information of the sub-components in the data file should be blank. To remove a string from all subcomponents in a group, 'NULL' should be marked in the subcomponent's color information.

Fig. 5 is a block diagram of a motif component batch generation device according to an embodiment of the present invention. This device has a data preparation unit 50 , a batch generation structure definition unit 52 and a composite component batch generation control unit 54 . The data creation unit 50 compiles component generation data necessary for batch generation of components as GUI objects. The batch generation structure definition unit 52 defines a batch generation structure for reading the compiled component generation data in the corresponding component group unit. Composite component batch generation control unit 54 reads out the corresponding data file requested by the instruction of the batch generation structure definition unit 52 from the data compilation unit 50, and generates the desired Composite components.

An algorithm for batch generation of components according to an embodiment of the present invention is shown in FIG. 4 . The data file in the data compilation unit 50 is opened (step 100). Then the number PAGE.N[0] of the component group and the number PAGE.N[n] of the subcomponent in the nth group are read from the data file (step 102). 2 and 3, PAGE.N[0] is 4, and PAGE.N[1] to PAGE.N[4] are 1, 1, 1 and 2, respectively.

At step 104, the component structure is allocated to memory by using malloc (memory allocation). Structure PAGE stores component structure information read from data files.

In step 106, i and j represent the group id and sub-id respectively, both of which are set to 1. Then, i is incremented from 1 to PAGE.N[0], and j is incremented from 1 to PAGE.N[n], where n represents any number between 1 and PAGE.N[PAGE.N[0]] The group id. Next, it is determined whether i is less than or equal to PAGE.N[0] (step 108). Referring to FIGS. 2 and 3, PAGE.N[0] is 4, which is greater than 1(i), so the program goes to step 110.

In step 110 it is determined whether j is less than or equal to PAGE.N[i]. Since j is equal to 1 at this moment, it is also equal to PAGE.N[i], so the program goes to step 112.

In step 112, the type or category KNDPTR[i] of the component is read from the data file, the parent component PRTPTR[i][j], the position POSPTR[i][j] of the component relative to the parent component, and the color COLPTR[i] of the component ][j] and the string STRPTR[i][j]. The current values of i and j are 1, respectively. The data read out at step 112 is used to generate components. In step 114, a composite component corresponding to PAGE.KNDPTR[group id] is generated by using the component generation function. Referring to Figures 2 and 3, by using the corresponding component generation function PAGE.KNDPTR[1], the composite components of Group 1 are generated. Component generation functions include functions for generating desired composite components, which are implemented by typing PAGE.KNDPTR[group id].

At step 116, j is incremented by 1, and the program returns to step 110. Now j is 2, and j is greater than PAGE.N[1]. Thus, the program jumps to step 118 . In step 118, i is incremented by 1, and j is set to 1, and the program returns to step 108.

Through the above procedure, the composite components of group 1 are generated in batches, and then steps 108-118 are repeated, while i and j are incremented by 1 sequentially. Thus composite members of groups 2-4 are generated in one batch. If all subcomponents of all groups are generated, the program proceeds to step 120, and the data file is closed.

As described above, in the component batch generation method using the motif function according to the present invention, components are easily generated in batches by programming component generation functions. And the work time is reduced by modifying the component structure in the data file, which does not require compilation. In addition, using functions for automatically reading out data files and generating components makes coding easier and improves work efficiency.

While illustrative embodiments of the present invention are described herein with reference to the drawings, it is to be understood that the invention is not limited to those precise embodiments, and that various other changes and modifications may be made by those skilled in the art without departing from scope and spirit of the invention.

Claims (16)

1. be used for generating in batch the method for motif member, may further comprise the steps:

Establishment is used for producing in batch the member generation data file of member;

Define one batch of generating structure, be used for reading the member of being worked out and generate data in corresponding component sets unit;

Read the corresponding data file of asking by the instruction of one batch of generating structure definition unit; And

By using the member generating function, generate composite component in batch.

2. the method for claim 1 is characterized in that, wherein member is used for member by marshalling and generates in batch in the step of definition this batch generating structure.

3. the method for claim 2 is characterized in that, wherein each component sets has the member of same father's member and same nature.

4. the method for claim 3 is characterized in that, the member of wherein being worked out generates data and comprises father's member, and element type, member are with respect to the position of father's member, and the color of member and character string.

5. the method for claim 4 is characterized in that, the member of wherein being worked out generates a plurality of sub-member in every group that uses when data also comprise the sum of component sets and distribute for the needed member of this member generating function in memory.

6. the method for claim 4 is characterized in that, wherein the data of being worked out corresponding to father's member comprise group id and sub-id.

7. the method for claim 4 is characterized in that, wherein the data of being worked out corresponding to the member color comprise top shadow, the color of bottom shadow and background etc.

8. the method for claim 1 is characterized in that, wherein the composite component generating function is concentrated in the member generating function.

9. be used for generating in batch the equipment of motif member, may further comprise the steps:

Be used to work out the data organization unit that the member that is utilized to produce member in batch generates data file;

Be used for reading one batch of generating structure definition unit of the member generation data of being worked out in corresponding component sets unit; And

Composite component generates control unit in batch, is used for reading from the data organization unit corresponding data file of being asked by the instruction of this batch generating structure definition unit and by the member generating function, generates needed composite component in batch.

10. the equipment of claim 9 is characterized in that, wherein when this batch of definition generating structure, member is used for member by marshalling and generates in batch.

11. the equipment of claim 10 is characterized in that, wherein each component sets has the member of same father's member and same nature.

12. the equipment of claim 11 is characterized in that, the member of wherein being worked out generates data and comprises father's member, and element type, member are with respect to the position of father's member, and the color of member and character string.

13. the equipment of claim 12 is characterized in that, the member of wherein being worked out generates a plurality of sub-member in every group that uses when data also comprise the sum of component sets and distribute for the needed member of member generating function in memory.

14. the equipment of claim 13 is characterized in that, wherein the institute's organized data corresponding to father's member comprises group id and sub-id.

15. the equipment of claim 13 is characterized in that, wherein the data of being worked out corresponding to the member color comprise top shadow, the color of bottom shadow and background etc.

16. the equipment of claim 9 is characterized in that, wherein the composite component generating function is concentrated in the member generating function.

Images