EP0413484A2

EP0413484A2 - Window display system and method

Info

Publication number: EP0413484A2
Application number: EP90308594A
Authority: EP
Inventors: Michael Morris Goldring; Lesley Regina Kalmin; Richard Irving Seidner
Original assignee: International Business Machines Corp
Current assignee: International Business Machines Corp
Priority date: 1989-08-14
Filing date: 1990-08-03
Publication date: 1991-02-20
Anticipated expiration: 2010-08-03
Also published as: JPH0377997A; EP0413484B1; EP0413484A3; CA2021823C; CA2021823A1; DE69018731D1; DE69018731T2

Abstract

A windowing system is provided as an interface between application programs and non-programmable terminal drivers. The system presents logical windows to the applications program, each of which are represented internally by at least two separate parts. The first part includes the border and non-scrollable text for a logical window, while the second part includes scrollable text for the window. Through calls to the display driver, the windowing system manipulates these separate parts so that they are displayed on the screen as a single window.

Description

The present invention relates generally to computer system display windows.
The display of information generated by an application program running on a computer system is often important to the perceived usefulness of the application. Poor displays can render an otherwise good application nearly useless, and good displays can help a user make more efficient use of an application.
Windows are often used to display several items of information on a screen at the same time. Windows are separate regions, often separated by borders, which are treated somewhat independently. Different windows may receive output from different applications running concurrently, and a single application may generate output to several windows.
In general, windows may be displayed as tiled or overlapped. Tiled windows are displayed side-by-side horizontally or vertically, or both, with no overlap of their displayed regions. Overlapped windows appear to be stacked one on top of another, much as individual sheets of paper piled on a desktop, with the covered portions of lower windows not being displayed. This type of display is sometimes referred to as the desktop metaphor for displays, or messy desk windowing. Work stations coming into increasingly common use typically have powerful window display systems to support messy desk windowing.
Many mainframe based applications, typically descendants of applications written before work stations started becoming common, are often written for character based, non-programmable terminals. Some terminals designed for tying into larger, central computer systems support rudimentary graphics or character graphics capabilities, or provide for designating portions of the display screen as active for scrolling purposes. The combination of many available terminals and their software drivers often provides the ability to do an extremely limited form of windowing. This form of windowing, referred to as split screen windowing, typically has full width tiled windows stacked vertically on the screen. These windows often have no borders, and only scrolling of the entire window is allowed. In this case, it would be desirable to provide a high level interface for application programs which hides the details of the window system and provides callable services similar to those available on work stations. It would further be desirable for such a windowing system to be efficient on non-programmable terminals.
Accordingly, the present invention provides a method for displaying a logical window on a character-based non-programmable computer terminal, comprising the steps of:
generating a first region corresponding to a non-scrollable portion of the logical window;
generating a second region corresponding to a scrollable portion of the logical window; and
displaying the first and second regions together to present a single logical window to a user.
The invention also provides a data processing system for displaying a logical window on a character-based, non-programmable computer terminal, comprising:
means for displaying data on the terminal, wherein said displaying means can write data to defined regions on the terminal; and
means for storing a data structure corresponding to the logical window, said data structure containing scrollable and non-scrollable portions of data;
said data processing system being under the control of a window manager having procedures callable by an application program, wherein the procedures communicate with said displaying means to display data on the terminal and wherein the scrollable and non-scrollable portions of data are displayed using different defined regions.
Therefore, according to the present invention, a windowing system is provided as an interface between application programs and non-programmable terminal drivers. The system presents logical windows to the applications program, each of which are represented internally by at least two separate parts. The first part includes the border and non-scrollable text for a logical window, while the second part includes scrollable text for the window. Through calls to the display driver, the windowing system manipulates these separate parts so that they are displayed on the screen as a single window.
Therefore the present invention provides a window system which supports multiple, independent windows on non-programmable display terminals. The windowing system can provide operations on individual windows which manipulate these windows while hiding the operating details from an applications programmer, and can also operate efficiently on non-programmable terminals.
In order that the invention may be fully understood a preferred embodiment thereof will now be described, by way of example only, with reference to the accompanying drawings in which:

FIGURE 1 shows a simplified display illustrating messy desk windowing;
FIGURE 2 illustrates several different portions of a single logical window;
FIGURE 3 illustrates the use of two separate regions displayed together to represent a single logical window;
FIGURE 4 is a block diagram illustrating a system for displaying windows on non-programmable terminals;
FIGURE 5 is a block diagram of a window manager system;
FIGURE 6 illustrates details of a window control block; and
FIGURE 7 illustrates details of a data cluster.

Refer now to Figure 1 which shows a sample computer display screen illustrating the use of overlapping windows. The display 10 can be nearly any CRT display terminal such as known in the art. The border 12 outlines that region of the display on which visual information is presented to the user. Other portions of a typical computer terminal, such as keyboard, housing, and brightness/contrast controls are not shown.
On the display 10 text 14, 16 can be shown, as well as character graphics 18 used to form lines. Within the display area, 4 windows 20, 22, 24, 26 are shown in overlapping fashion. Each window is a rectangular region outlined by a border, and portions of a window which are overlapped by other windows are not displayed. For simplicity of illustration, the windows shown in Figure 1 do not contain text, although text is generally present in windows during actual use.
As shown in Figure 1, window 26 is the uppermost window, followed in decreasing order by windows 24, 22 and 20. Thus, window 20 is on the bottom of the stack, and any portion thereof which is overlaid by any other window is not displayed on the screen 10.
The size and location of the windows 20, 22, 24, 26, as well as their order in the stack, is determined by the user or the applications programs. Preferably, the size and location of the windows can be changed by the user more or less at will, so that any given window's location in the future is indeterminate. The applications programs which write to these windows must be able to do so independently of a windows size or location.
Many windows to be displayed have the property that some of the information therein, including the border, remains relatively static. Figure 2 illustrates a typical window 30 having a border 32 surrounding it and a window title 34 located in the border 32. Header text 36, typically providing informational instructions for the user, is positioned near the top of the window 32. In some window systems, a dividing line 38 may be drawn between the header text 36 and the remainder of the text in the window 30. At the bottom edge of the window 30, bottom text 40 is sometimes used to display further information and instructions to the user. The remainder of the window 30 is a scrollable region 42, consisting of the entire region between the borders 32, below the dividing line 38 and above the bottom text 40. This region 42 is written to by the applications programs, and typically scrolls when it becomes filled with text.
Those portions of the window 30 not in the scrolling region 42, including the border 32, title 34, header text 36, dividing line 38, and bottom text 40, are relatively static. The scrollable region 42 is relatively dynamic, with updated information being written thereto on a fairly regular basis.
The windows described in connection with Figures 1 and 2 can be implemented by an applications programmer in a fairly straightforward manner on most personal work stations and some desktop computers. This is so because many of these machines are designed with built-in support for complex windowing functions. However, non-programmable, character based terminals typically used with mainframe computer systems are not able to support such windowing functions. Figure 3 illustrates a concept according to the present invention which allows an efficient implementation of messy desk windowing with such non-programmable terminals.
Referring to Figure 3, a window 46 is divided into an outer region 48 and an inner region 50. The regions 48, 50 are considered as independent regions for display purposes, but are displayed overlapping as shown in order to present a single logical window to a user. The outer region 48 contains non- scrollable information which changes relatively infrequently, while the inner region 50 contains relatively dynamic text. For example, the outer region 48 will include the window border, title, and header and bottom text. The inner region 50 does not contain a border, and consists primarily of scrollable text information.
The character based, non-programmable terminals typically utilized with the present invention, together with their software drivers, typically provide scrollable placement of text within a defined region. However, they do not provide for scrolling of a part of a region while retaining the remainder of the region intact. Thus, defining a logical window to be two independent regions allows the scrollable portions of the display to be driven independently from the non-scrollable portions. This allows for greatly increased efficiency when writing scrollable text to a window. The terminals and drivers also handle the extended data stream at the region boundaries, so that fonts, color, blinking, and other display attributes are correctly handled within each region. Some terminals are capable of supporting graphics and animation to various degrees.
As will be described in more detail below, a window may have more than two independent regions. For example, a single logical window could have an outer region containing relatively static, non-scrollable text, and two or three separate scrollable regions within its boundaries. The separate scrollable regions are preferably placed adjacent to each other with no overlap. Some logical windows may not include both scrollable and non-scrollable regions. For example, a window could contain only feed information which is not changeable by the user, and such a window would not need an inner, scrollable region 50.
Figure 4 is a high level block diagram illustrating a preferred system for performing windowing. An application program 60 performs output relative to a terminal by making procedure calls to a window manager subsystem 62. The window manager 62 is a collection of procedures and data structures, described below in more detail, which manages the function of the logical windows which the application program 60 expects to see. The window manager is in communication with a display manager 64 which in turn communicates with a display terminal 66 over a data link 68. The display terminal 66 is often located at a site remote from the central computer system, so the data link 68 is typically a serial communications link which may include one or more telephone or satellite links.
The display manager 64 is a software subsystem which resides in the main computer, and drives the display terminal 66. The display manager 64 sends characters to the terminal 66 to be displayed, and also sends control sequences to the terminal 66 to position the cursor, highlight text, and perform other display functions. Information entered into the terminal 66 by a user is received by the display manager 64 and transferred to the application program 60 through the window manager 62. An example of a typical display manager 64 subsystem suitable for use with the present invention is a product known as GRAPHICAL DATA DISPLAY MANAGER (GDDM), a product which is available from IBM and currently in wide use.
Figure 5 illustrates more details of the window manager 62. Communication with the application program 60 and the display manager 64 are made through window services 80. Window services 80 is a collection of procedures, callable by the application program, which in turn make procedure calls to the display manager subsystem. Pseudocode descriptions of the operation of some of the more important procedures within the window services 80 are set forth in the Appendix, and are described in more detail below.
The window services procedures 80 access a plurality of data structures referred to as window control blocks 82, 84, 86. Each window control block corresponds to one logical window, and contains all of the information necessary to generate and control both the scrollable and non-scrollable portions of a logical window. Whenever a new logical window is created by the application program, a new window control block is allocated and made available to the window services 80. When a window is deleted, the corresponding window control block is deal located.
In addition to header information, each window control block 82, 84, 86 contains pointers to one or more data objects 88. These data objects 88, also referred to as clusters, contain the text which is sent to the display manager for display on the terminal. In one embodiment, the application can place data into the data objects 88, from which it is extracted by the window service 80 for transmission to the display manager. As an alternative, using a somewhat more object-oriented approach, the application writes data to a logical window by calling a window service 80, so that the application has no direct access to the data objects 88. Different data objects 88 are used for different portions of a logical window as shown in more detail in Figure 6.
Referring to Figure 6, a preferred internal structure for one window control block 82 is shown. One portion 90 of the window control block 82 contains general information relevant to the logical window. This information 90 includes a window type, such as primary window, pulldown window, or pop-up window. The location of the window is included, which information generally comprises X and Y coordinates for one corner of the window. The size of the window, in terms of number of rows and number of columns is also included, as is various window status information. Miscellaneous information pertaining to the logical window, such as a window title if there is one, and the identity of the application program associated with this window, can also be included here.
A next portion 92 of the window control block 82 includes identifiers for the partitions used to make up the logical window. A partition is a logical region used by the GDDM display manager, and corresponds to the regions 48, 50 described in connection with Figure 3. Thus, in a preferred embodiment, one partition is dedicated to the non-scrollable region 48 of a logical window 46, with the remaining partitions being used for one or more scrollable regions 50. A typical window will have one non-scrollable partition and one scrollable partition. Additional scrollable partitions are normally needed only for complex scrolling operations, such as may occur when row or column headers are to remain static within the scrollable region.
A data portion 94 contains pointers to data clusters 88 which, as described above, contain the text to be placed into the logical window. The data may be organized in any manner convenient for use with the display manager 64, with the arrangement shown in Figure 6 being useful for use with a GDDM display manager 64.
In the data portion 94, several pointers to data located in the non-scrollable partition are first. A border cluster pointer 96 points to a cluster 88 containing the field definitions, described below, containing all information necessary to display the border of the logical window. An action area pointer 98 points to a cluster 88 containing header text 36, and a key legend point 100 points to a cluster 88 containing bottom text 40. Additional pointers (not shown) can point to other data clusters 88 defining other non-scrollable text regions. If a particular window does not have a particular feature such as an action area or key legend, the corresponding pointers are simply set to NULL.
Following the pointers 96, 98, 100 to data contained in the non-scrollable partition, a first body cluster pointer 102 points to a data cluster 88 containing data to be displayed in the scrollable region. A type identifier 104 for the first body cluster indicates whether that region is currently scrollable, and can be used to indicate other information about the associated data cluster 88. Additional body cluster pointers, such as body cluster 2 pointer 106 are used in conjunction with additional scrollable partitions beyond the first scrollable partition. Each of these other body clusters has an associated body cluster type identifier 108 also.
Referring to Figure 7, a preferred organization for a data cluster 88 is shown. Each data cluster 88 has one or more fields, with each field typically corresponding to one line of text to be displayed. The information necessary to display each field is arranged into groups, so that there are formed a flags group 110, a field identifiers group 111, an attributes group 112, and a strings group 114. As shown in Figure 7, each adjacent entry in an attribute group 110, 111, 112, 114 corresponds to one field, so that a first field 116 includes the first entry in each of the groups 110, 111, 112, 114.
The flags entry for each field contains various status flags for that field. The field identifier entry for each field contains a symbolic name for that field, to simplify reference thereto by the application if desired. The attributes entry for a field contains information for the display manager 64 used to display the text of each field, such as size, color, and highlighting information. The strings entry for each field is preferably a pointer to a string containing the text for that field.
The window services 80 are able to easily extract from a window control block the data needed to be sent to the display manager 64. Using the described system allows a relatively straightforward implementation of the functions necessary for high level control of logical windows. These functions include, but are not limited to, functions for creating and destroying windows, writing text to windows and reading input text entered by a user, and sizing, moving, and scrolling windows. Pseudocode for performing these important functions is set forth below:
Henceforth follows a brief description of the functioning of the pseudocode for each of these high level window functions.
The CreateWindow function creates a window from the information passed to it in the Window Control Block (WCB). The contents of the WCB are validity checked (line 100). The outer partition and the contained page are created (lines 101-102). The new window information is recorded in a new MAPREC record at the end of the list of windows (line 103). A MAPREC record simply maps partitions to windows, and a linked list of all such mappings is retained for reference as needed. The window border characters are set according to the device type in use and its capabilities (lines 104-108). The window contents are then created by looping through the WCB contents by cluster (lines 109-112). This completes the creation of the outer partition, and a nearly identical procedure is now used to create the inner partition, which has no border (lines 113-119). A flag is set in the WCB to show that the window has been created and is currently in the open state.
The DestroyWindow function destroys a window, freeing the associated storage and display manager constructs. The validity of the WCB is checked (line 100). Then, looping through each cluster, window contents are deleted, finally freeing the storage for the clusters themselves (lines 101-106). The MAPREC storage and display manager constructs are deleted (partitions and pages), (lines 107-108). Finally, the WCB storage is freed (line 109).
The WriteText function creates new fields and/or places text in existing fields. The WCB is checked for validity (line 100). The outer partition is made current and its first cluster is pointed to (lines 101-102). Then looping through each of the clusters, each cluster is examined to see if any fields need be created or replaced (lines 103-114). One of the optimizations used in this design is the placement of WCB clusters in order, so that the WriteText and related functions can simply fall through the list of clusters, and by doing so, easily handle the switch from outer partition clusters to inner partition clusters (line 105). This is done by looping through each of the fields in each cluster (lines 106-113). A WriteText flag is searched for (having been set by the calling program in order to signal this change in field text), and if it's set (line 107), then the display commands are issued to change the field text and/or create new fields if required (lines 108-109). If these operations succeed, then the WriteText flags are reset in the WCB, else an error code is returned (lines 110-112).
The ReadWindow function causes all of the display changes to be displayed at the device and allows the user to interact with the program. It then notifies the window owners of the changes and/or interactions. Programmed function key information is sent first to the owner of the current window. Windows in which text was changed are also sent messages that a change occurred in their window. WCB fields for which changes occurred are marked with a Modified flag. A Special Input Field designation exists as a convenience for windows which only react to an input string in a designated field.
ReadWindow first looks for the current partition, and if one is not found it returns to the caller (lines 100-101). Otherwise, it issues a display manager command to write any changes to the display and allow the user to interact (line 102). The cursor position is then determined and, if it was not in a defined partition, it is placed in the top partition (lines 103-105). A temporary list of partitions currently on the device screen is created, and matched against the list of all WCBs (lines 106-111). The current partition is placed at the front of the list of WCBs (line 110).
The WCBs are then each handled by the following loop (lines 112-128). Closed or minimized windows are ignored, since no changes will have to appear in them (line 113). The body partition is made current, and a loop determines if any of the fields have been modified, in which case the WCB flag for that field is marked as modified (lines 114-119). The same loop is then repeated for the outer partition (lines 120-125). If the Special Input Field of the WCB has been set, then the field text is obtained for that modified field (line 126). The results of the read operation are passed to the window owner (line 127).
The SizeWindow function resizes the window on the display and pops it to the top of the viewing order. The WCB is checked for validity (line 100). The inner partition is sized first (lines 101-108). This is accomplished by first checking to see if it has a body partition and, if so, sizing it in relation to the outer partition. If the new window is too small for the body to appear at all, the partition is made invisible (lines 104-105).
The outer partition is then resized and recreated (lines 108-115). The WCB is updated with the reguested position and dimensions (lines 108). A display manager command is issued to resize the outer partition (line 109). The partition page is recreated (line 110). The outer partition's contents are recreated according to the new dimensions (line 111-115). Finally the window is made current by making all of its partitions current, if it is not already on top of the viewing order (lines 116-118).
The MoveWindow function moves the window and pops it to the top of the viewing order. The WCB is checked for validity (line 100). The new position of the inner partition is calculated based on the destination and offset from the outer partition (lines 101-103). If the window is not closed, then the display manager command is issued to move the partitions (lines 104-107). The window is placed at the top of the viewing order if it is not already there (lines 109-110).
The ScrollWindow function scrolls the contents of the window and pops it to the top of the viewing order. The WCB is checked for validity (line 100). If there is no body partition for this window, then the function returns, since only window bodies are scrolled (lines 101-102). The inner partition is made current (line 103). Calculations are performed to determine which data will be displayed after the scrolling operation (line 104). The operation then continues by performing the rehired display manager commands that achieve the scrolling result (lines 105-117). The WCB is updated with the new positional information, and the window is placed at the top of the viewing order (lines 118-121).
Other window control functions can be implemented in a straightforward manner using the functions described above or techniques similar to those used in such functions.
As will be appreciated by those skilled in the art, a window manager system has been described which provides high level, fully functional support for messy desk windowing on a non-programmable, character based terminal. Such a system can be used with mainframe computer based applications for which windowing has not heretofore generally been available. The windowing system as described can easily be provided as a package which can be used by numerous application programs. Using the techniques of the present invention, windows may be manipulated efficiently on a terminal which is not normally designed to support their use. Various types of windows, such as pop-up and pulldown windows, can be implemented using the described techniques.
While the invention has been particularly shown and described with reference to a preferred embodiment, it will be understood by those skilled in the art that various changes in form and detail may be made therein without departing from the scope of the invention.

Claims

1. A method for displaying a logical window on a character-based non-programmable computer terminal, comprising the steps of:
generating a first region corresponding to a non-scrollable portion of the logical window;
generating a second region corresponding to a scrollable portion of the logical window; and
displaying the first and second regions together to present a single logical window to a user.

2. A method as claimed in Claim 1, further comprising:
generating at least one additional region corresponding to an additional scrollable portion of the logical window; and
displaying the additional region together with said first and second regions to present a single logical window to the user.

3. A method as claimed in Claim 1 or Claim 2, wherein the first region includes a window border, and wherein the second region is displayed at a location positioned wholly within boundaries of the first region, whereby the window border surrounds the second region.

4. A method as claimed in any preceding Claim, wherein the first region further includes top text and bottom text, and wherein the second region is displayed at a location between the top text and the bottom text.

5. A method as claimed in any preceding Claim, wherein said first region comprises a plurality of subregions, wherein text for display in each subregion is stored as a separate data element.

6. A data processing system for displaying a logical window on a character-based, non-programmable computer terminal, comprising:
means for displaying data on the terminal, wherein said displaying means can write data to defined regions on the terminal; and
means for storing a data structure corresponding to the logical window, said data structure containing scrollable and non-scrollable portions of data;
said data processing system being under the control of a window manager having procedures callable by an application program, wherein the procedures communicate with said displaying means to display data on the terminal and wherein the scrollable and non-scrollable portions of data are displayed using different defined regions.

7. A system as claimed in Claim 6, wherein the scrollable portion of data is displayed in a defined region which is wholly contained within the defined region used to display non-scrollable portions of data.

8. A system as claimed in Claim 7, wherein the non-scrollable portion of data includes a border to be displayed around the periphery of the defined region used to display the non-scrollable portion of data.

9. A system as claimed in Claim 8, wherein the non-scrollable portion of data further includes text to be displayed adjacent to top and bottom borders of the defined region used to display the non-scrollable portion of data, and further wherein the defined region used to display scrollable portions of data is wholly contained within an area between the text displayed adjacent to the top and bottom borders.

10. A system as claimed in any of Claims 6 to 9, in which:
an additional scrollable portion of data is contained within said data structure, said additional scrollable portion of data being displayed in a defined region different from those used to display the scrollable and non-scrollable portions of data.

11. A system as claimed in Claim 10, wherein the defined regions used to display the scrollable portion of data and the additional scrollable portion of data are both wholly contained within the defined region used to display the non-scrollable portion of data.

12. A system as claimed in Claim 11, wherein the defined regions used to display the scrollable portion of data and the additional scrollable portion of data are positioned adjacent to each other with no overlap.

13. A system as claimed in Claim 6, wherein the non-scrollable portion of data is subdivided into sub-portions, each sub-portion being stored separately within said data structure.