DE69018731T2 - Window display setup and method. - Google Patents

Description

The present invention relates generally to the display in windows of computer systems.

The display of information produced by an application program running on a computer system is often important to the perceived usefulness of the application. Bad displays can render an otherwise good application almost useless, and good displays can help a user use an application program more efficiently.

Windows are often used to display multiple items of information on a screen at the same time. Windows are separate areas, often separated by frames, that are manipulated independently in some way. Different windows can receive output from different applications running simultaneously, and a single application can produce output in different windows.

In general, windows can be displayed side by side or cascaded. Side by side windows are displayed side by side, horizontally and/or vertically, with their displayed areas not overlapping. With cascaded windows, the individual windows appear to be stacked on top of each other, like individual sheets of paper stacked on a desk, with the hidden parts of underlying windows not displayed. This type of display is sometimes referred to as the desktop metaphor for displays or as messy desk windowing.

The IBM Technical Disclosure Bulletin, Vol.22, No.10, March 1980, pages 4734-2737, "Local Scrolling with a Multiple Partitioned Display", describes a display system for use in a data processing system. The display system includes a display device on which a plurality of independent scrollable partitions and a plurality of independent non-scrollable partitions can be displayed. A microprocessor assigns a window control block to each non-scrollable partition and a plurality of window control blocks to each scrollable partition. Each window control block contains pointers in a plurality of data groups that define the data to be displayed in the corresponding partition.

Many mainframe-based applications, usually descended from applications written before workstations became commonplace, are often written for character-based, non-programmable terminals. In some terminals designed to interface with larger mainframe systems, primitive graphics or character graphics capabilities are supported, or certain parts of the screen are provided as active for scrolling purposes. The combination of many available terminals and their software drivers often provides the ability to perform an extremely limited form of windowing. This form of windowing, called split-screen windowing, typically has full-width windows stacked vertically on the screen. These windows have no borders, and only scrolling of the entire window is permitted. In this case, it is desirable to provide a higher level interface for application programs which can control the details of the windowing system. and provides callable window calls similar to those available in workstations. In addition, it is desirable for such a windowing system to be effective in non-programmable terminals.

According to the present invention there is now provided a method of displaying overlapping logical windows on a display screen for use in a data processing system including a processor unit and a non-programmable display capable of displaying a plurality of independent scrollable partitions and a plurality of independent non-scrollable partitions, the method comprising: allocating one of a plurality of window control blocks into a logical window generated by an application program executing in the data processing system, the window control block containing pointers in a plurality of data groups; characterized in that the method comprises: filling a plurality of partition identifiers into the window control block including at least a first partition identifier corresponding to a non-scrollable partition to provide a boundary for the logical window and a second identifier corresponding to a scrollable partition for the logical window; setting, for each non-scrollable and scrollable partition, a pointer in the window control block to a data group for the partition defining its attributes for overlapping the scrollable partition on the non-scrollable partition; creating the non-scrollable partition according to the first partition identifier for the logical window on the screen; and creating the scrollable partition according to the second partition label for the logical window on the screen, so that the scrollable partition overlaps the non-scrollable partition to display the logical window on the screen.

Viewed from another aspect of the invention there is now provided a display system for use in a data processing system, the display system comprising: a non-programmable display capable of displaying a plurality of independent scrollable partitions and a plurality of independent non-scrollable partitions of logical windows, and means for associating one of a plurality of window control blocks with a logical window generated by an application program executing in the data processing system, the window control block containing pointers in a plurality of data groups; characterized in that the method includes: filling a plurality of partition identifiers in the window control block containing at least a first partition identifier corresponding to a non-scrollable partition to provide a boundary for the logical window and a second identifier corresponding to a scrollable partition for the logical window; means for setting, for each non-scrollable and scrollable partition, a pointer in the window control block to a data group for the partition defining its attributes for overlapping the scrollable partition on the non-scrollable partition; means for creating the non-rollable partition corresponding to the first partition identifier for the logical window on the screen; and means for creating the rollable partition corresponding to the second partition identifier for the logical window on the screen so that the scrollable partition overlaps the non-scrollable partition to display the logical window on the screen.

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

Thus, the present invention provides a windowing system that supports numerous, independent windows in non-programmable displays. The windowing system can provide functions in individual windows that manipulate those windows while hiding the functional details from an application programmer and can also function more effectively in non-programmable terminals.

In order that the invention may be fully understood, a preferred embodiment will now be described by way of example only with reference to the accompanying drawings in which

FIGURE 1 shows a simplified screen representation illustrating messy desk windowing;

FIGURE 2 shows several different parts of a single logical window;

FIGURE 3 shows the use of two separate panes displayed together to form a single logical window;

FIGURE 4 is a block diagram illustrating a system for displaying windows in non-programmable terminals;

FIGURE 5 shows a block diagram of a window manager system;

FIGURE 6 shows details of a window control block; and

FIGURE 7 shows details of a data group.

Referring now to Figure 1, there is shown a sample screen illustrating the use of overlapping windows. The screen 10 may be virtually any CRT screen known in the art. The frame 12 surrounds the area of the display in which information is visually presented to the user. Other parts of a typical computer terminal, such as keyboard, case, brightness/contrast controls, are not shown.

In the display 10, text 14, 16, it is shown how character graphics 18 are used to form lines. Within the display area, 4 windows 20, 22, 24, 26 are arranged in an overlapping manner. Each window is rectangular and contains a frame. Parts of a window that are overlapped by other windows are not displayed. To simplify the illustration The windows in Figure 1 do not contain any text, although text is generally contained in the windows during normal use.

As Figure 1 shows, window 26 is the topmost window, followed in descending order by windows 24, 22 and 20. Thus, window 20 is at the bottom of the stack, and any part of it that is overlaid by another window is not displayed on the screen 10.

The size and position of the windows 20, 22, 24, 26 and their order in the stack are determined by the user or the application programs. The size and position of the windows can preferably be changed more or less at will by the user, so that in the future any given position of the window is indeterminate. The application programs that are written in these windows must be able to do this for the size or position of a window.

Many display windows have the property that some of the information contained therein, including the frame, remains relatively static. Figure 2 shows a typical window 30 having a frame 32 surrounding it and a window title 34 located within the frame 32. The header text 36, which normally provides informative notices to the user, is positioned near the top of the window 32. In some windowing systems, a dividing line 38 may be drawn between the header text 36 and the rest of the text in window 30. At the bottom of window 30, footer text 40 is sometimes used to provide further information and notices to the user. The remainder of the window is a scrollable area 42 consisting of the entire area between the frame 32, below the dividing line 38 and above the footer text 40. This area 42 is written by the application programs and is normally scrollable when text has been entered.

Parts of the window 30 that are not in the scrollable area 42 include the frame 32, title 34, header text 36, divider line 38 and footer text 40 and are relatively static. The scrollable area 42 is relatively dynamic with updated information written there on a completely regular basis.

The windows described in connection with Figures 1 and 2 can be implemented by an application programmer in a perfectly simple manner in most personal computers and in some desktop computers. This is because some of these devices are designed with built-in support for complex windowing functions. Non-programmable, record-based terminals normally used with mainframe systems cannot support such windowing functions. Figure 3 shows a concept in accordance with the present invention that allows 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 independent regions for display purposes, but are arranged in an overlapping manner as shown to present a single logical window to a user. The outer region 48 contains non-scrollable information that changes relatively infrequently, while the inner Area 50 contains relatively dynamic text. The outer area 48 contains window frames, titles, header text and footer text. The inner area 50 contains no frame and consists primarily of scrollable text information.

The character-based, non-programmable terminals that are typically used with the present invention, along with their software drivers, typically provide scrollable text placement within a defined region. However, these do not provide for scrolling of a subregion, as the rest of the region is retained intact. Thus, by defining a logical window in two independent regions, the scrollable portions of the display can be controlled independently of the non-scrollable portions. This increases the efficiency of writing scrollable text in a window. Terminals and drivers also manipulate the extended data stream in the border regions so that fonts, color, blinking, and other display attributes are properly controlled within each region. Some terminals are capable of supporting graphics and animations at numerous levels.

As described in more detail below, a window may have more than two independent regions. A single logical window may have an outer region of relatively static, non-scrollable text and two or three separate, scrollable regions within its border. The separate, scrollable regions are preferably placed in close proximity to each other without overlapping. Some logical windows contain neither scrollable nor non-scrollable regions. For example, a window may contain only fixed information that cannot be changed by the user. Such a window therefore does not require an inner scrollable area 50.

Figure 4 shows a high level block diagram describing a preferred system for implementing windowing. An application program 60 performs output relative to a terminal by invoking a window manager subsystem 62. The window manager 62 consists of a collection of methods and data structures, described in more detail below, which control the operation of the logical windows that the application program 60 wishes to view. The window manager communicates with a display manager 64, which in turn communicates with a display 66 via a data link 68. The display 66 is often located at a location remote from the host computer system so that the data link 68 is a serial interface which may include one or more telephone or satellite links.

The display manager 64 is a software subsystem located in the main computer that controls the display screen 66. The display manager 44 sends characters to the display screen 66 to be displayed and also sends control sequences to the display screen 66 that are used to position the cursor, highlight text, and perform other display functions. Information entered by a user on the display screen 66 is passed to the display manager 64 and transmitted to the application program 60 via the window manager 62. An example of a typical display manager 64 subsystem suitable for use with the present invention is known as the GRAPHICAL DATA DISPLAY MANAGER (GDDM), available from IBM, and currently in wide use.

Figure 5 describes the window manager 62 in more detail. Communication with the application program 60 and the display manager 64 is via the window calls 80. The window calls 80 consist of a collection of methods that can be called via the application program and which in turn make method calls in the display manager subsystem. Pseudocode descriptions of the execution of some of the most important methods within the window calls 80 are continued in the appendix and described in more detail below.

The window call methods 80 access a variety of data structures called window control blocks 82, 84, 86. Each window control block corresponds to a logical window and contains all the information necessary to create 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 calls 80. When a window is deleted, the corresponding window control block is abandoned.

In addition to the header information, each window control block 82, 84, 86 contains pointers to one or more data objects 88. These data objects 88, also called groups, contain the text that is sent to the display manager for display on the screen. In one embodiment, the application can place data into the data objects 88 from which it can be extracted by the window calls 80 for transmission to the display manager. Alternatively, using a slightly more object-oriented approach, the application writes data to a logical window by making a window call 80 so that the application does not have direct access to the data objects 88. Different data objects 88 are used for different parts of a logical window, as shown in more detail in Figure 6.

Referring to Figure 6, a preferred internal structure for a window control block 82 is shown. A portion 90 of the window control block 82 contains general information relevant to the logical window. This information 90 includes a window type, for example, primary window, pull-down window, or pop-up window. The location of the window is included, with the information generally including X and Y coordinates for a corner of the window. The size of the window, consisting of row and column numbers, is also included, as this is part of the various window status information. Various information pertaining to the logical window, for example, a window title, if any, and the identity of the application program associated with that window, may also be included.

A next part 92 of the window control block 82 contains identifiers for the partitions used to construct the logical window. A partition is a logical area used by the GDDM display manager and corresponds to the areas 48, 50 described in connection with Figure 3. Thus, in a preferred embodiment, one partition is designated for the non-scrollable area 48 of a logical window 46, with the remaining partitions being used for one or more scrollable areas 50. A typical window is constructed from a non- scrollable and a scrollable partition. Additional scrollable partitions are normally only needed for complex scrolling operations, such as when headers of rows or columns within the scrollable area must remain static.

A data portion 94 contains pointers to data groups 88, which, as previously mentioned, contain text to be placed in the logical window. The data may be organized in any manner that is appropriate for use with the display manager 64 in the application shown in Figure 6 and is useful when used with a GDDM display manager 64.

In the data part 94, several pointers to data placed in the non-scrollable partition are first. A boundary group pointer 96 points to a group 88 containing field definitions described below as well as all information required to indicate the boundary of the logical window. An action area pointer 98 points to a group 88 containing header text 36 and a key legend pointer 100 points to a group 88 containing footer text 40. Additional pointers (not shown) may point to other data groups 88 defining other non-scrollable text areas. If a particular window does not contain any special facility, such as an action area or key legend, the corresponding pointers are simply set to NULL.

The reference addresses 96, 98, 100 lead to data that is contained in the non-rollable partition. A first Text group pointer 102 refers to a data group 88 which contains data to be displayed in the scrollable region. A type identifier 104 for the first text group indicates whether this region is currently scrollable and can be used to display other information about the associated data group 88. In addition, text group pointers, for example text group pointer 106, are used in conjunction with additional scrollable partitions after the first scrollable partition. Each of these other text groups also has a type identifier 108 associated with it.

Referring to Figure 7, a preferred organization for a data group 88 is described. Each data group 88 contains one or more fields, each field typically corresponding to a line of text to be displayed. The information required to display each field is arranged in groups to form an indicator group 110, a field label group 111, an attribute group 112, and a chain group 114. As shown in Figure 7, each adjacent entry in an attribute group 110, 111, 112, 114 corresponds to a field, so that a first field 116 contains the first entry in each of the groups 110, 111, 112, 114.

The indicator input for each field contains various status indicators for that field. The field label input for each field contains a symbolic label for that field to facilitate reference to it by the application if necessary. The attribute input for a field contains information for the display manager 64 that is used to display the text of each field, for example Information about size, color and highlighting. The chain input for each field is preferably a reference address in a chain containing the text for that field.

The window calls 80 can be easily extracted from a window control block for the data to be sent to the display manager 64. Use of the system described allows for relatively simple implementation of the functions required for high-level control of logical windows. These functions include, but are not limited to, functions for creating and deleting windows, writing text into windows, reading text entered by a user, and formatting, moving, and scrolling windows. The pseudocode for performing these important functions is described below.

Createwindow /* creates a window on the screen based on the information in the WCB */

100 Check the validity of the WCB that was entered into the function as input /* create outer partition */

101 Display to define outer partition

102 Display to create outer partition page so that it has the same format as outer partition

Create 103 new MAPREC and append it to the end of the chain

104 Replace frame corners and horizontal lines according to device characteristics

105 IF we have symbols

106 THEN Create symbol set attributes for border fields and use programmed symbol corners

107 ELSE use connecting horizontal lines and emulator corner characters

Place 108 correct characters in the corners

109 LOOP over outer partition groups

110 IF group reference address non-zero

111 THEN draw part of the window described by the group

112 END LOOP /* create inner partition */

113 Display to define text (inner) partition

114 Call up display to define underlying page for text partition, format in WCB or specify in partition format

Create 115 new MAPRECs and attach them to the end of the chain

116 LOOP over fields in text group

117 Call display to define field

118 Call display to display text in field

119 END LOOP

120 Set WindowOpen indicator in WCB

Destroywindow /* Delete window and its WCBs, delete associated memory */

100 Check the validity of the WCB that was entered into the function

101 LOOP over every group in the WCB

102 LOOP over each field in the group

103 IF this chain exists, delete it

104 END LOOP

105 Delete group memory

106 END LOOP

107 show total memory MAPREC

108 Remove MAPREC from partitions owned by WCB

109 Clear WCB memory

WriteText /* create new fields and/or place text in existing fields */

100 Check the validity of the WCB that was entered into the function

101 create current outer partition

102 point to first group in partition

103 LOOP over groups in the partition

104 point to first field in group

105 IF pointed to text group, create current inner partition

106 LOOP over fields of the group

107 IF Writetext Set indicator

108 THEN (rewrite the chain, fill with spaces if necessary)

109 Enter display command for text change

110 IF display call successful

111 THEN reset indicator

112 ELSE Return with error code)

113 END LOOP

114 END LOOP

Readwindow /* Read input from screen, update WCB */

100 Query current partition

101 IF no current partition THEN Return

102 Writing/reading on the screen with display manager command

103 Query cursor information

104 IF the cursor is not in a partition

105 THEN place in upper partition

106 TEMP Create a list of WCBs whose partitions are currently on the screen

107 show on total list which partitions are mapped in WCB's (MAPREC's)

/* Create field with reference addresses in WCB's for current windows *1

/* create first current partition in the field */

/* select only outer partitions to get only one WCB per window */

108 LOOP over MAPREC's

109 IF partition is current, place before the field

110 If pointing to outer partition, place corresponding WCB in the field

111 END LOOP

112 LOOP over WCB's in the field

113 IF window is closed or minimized, create next loop in WCB

114 Create current text partition

115 query changed fields, place field identifiers in a list

116 LOOP over modified field of text partition

117 Set WCB field reference address for changed field

118 Set Modified Field Indicator

119 END LOOP

120 create current outer partition

121 query changed fields, place field identifiers in a list

122 LOOP over changed fields of the outer partition

123 Set field reference address WCB for changed field

124 Set Modified Field Indicator

125 END LOOP

126 IF window has special input field, send input string directly to owner and delete input field

127 Window event Send message to window owner

128 END LOOP

SizeWindow /* Reformat the window on the screen and place it at the top of the screen */

100 Check the validity of the WCB that was entered into the function

/* Format inner partition */

101 IF text partition exists

102 THEN (calculate distance from outer partition

103 Update WCB with new text partition, based on destination and distance

104 IF new window format is too small for text display,

105 THEN (it is to be made invisible,

106 slide down on the screen ,

107 reduced indicator)

108 Enter display command to format text partition)

/* Format outer partition */

108 Update WCB with new outer partition position and dimensions

109 Enter display command to format outer partition

110 Delete partition page and recreate with new dimensions

/* recreate outer partition */

111 determine whether title field exists

Save 112 corner characters and one character from each side

113 Update WCB with new outer partition dimensions and new format

114 Recreate frame with saved characters Recreate frame corners with saved characters

/* move up */

116 query current upper partition.

117 IF sliding window is not at the top

118 THEN place text and move outer partition up on the screen

MoveWindow /* Moves the window on the screen and pushes it up on the screen */

100 Check the validity of the WCB that was entered into the function

101 IF text partition exists

102 THEN (calculate distance from outer partition

103 Update WCB with new text partition, based on destination and distance

104 IF window is not minimized

105 THEN enter display command to move text partition)

106 Update WCB with new outer partition position

107 Enter display command to move outer partition

108 query current upper partition.

/* move up */

109 IF Move Window is not at the top

THEN place text and outer partitions at the top of the screen

ScrollWindow /* Scroll window text and move it up on the screen */

100 Check the validity of the WCB that was entered into the function

/* set required variables */-

101 IF text partition does not exist

102 THEN Return /* just scroll text */

103 Update text partition

104 Determine row number of last field in text group

IF scroll type is PAGESCROLLABLE or left/right scrolling is required

106 THEN (query position of the partition relative to the page

107 Determine new page partition

108 Enter display command to move window in relation to the page)

/* Roll windows that are not installed on one side */

109 IF roll type is BIGSCROLLABLE

110 THEN (determine which rows appear at the top of the window

111 Find field row number for first field of this top row

112 determine which row should appear at the bottom of the window

113 LOOP over fields between first and last row

114 Copy field attributes in temporary field

115 Replace row number with window row number

116 Write field text

117 END LOOP

118 Update bodytopline in WCB

119 Query update upper partition

120 IF Move Window is not at the top

121 THEN place text and outer partitions at the top of the screen

From now on, a brief description of the function of the pseudocode for each of these higher window functions follows.

The Createwindow function creates a window based on the information it receives from the Window Control Block (WCB). The contents of the WCB are checked for validity (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 window list (line 103). In a MAPREC record, only the partitions are mapped to the windows and an associated list of all maps is kept for reference if necessary. The window frame characters are set according to the device type used and its capabilities (lines 104-108). The window contents are then created by creating loops over the WCB contents from the group (lines 109-112). This completes the creation of the outer partition, and a nearly identical process is now used to create the inner partition, which has no border (lines 113-119). An indicator is set in the WCB to indicate that the window has been created and is currently in the open state.

The DestroyWindow function deletes a window, its memory and its display manager concepts. The validity of the WCB is checked (line 100). Then, for each group, a loop is created, the contents are deleted, and finally the memory for the groups themselves is deleted (lines 101-106). The MAPREC storage and the display manager concepts are deleted (partitions and pages), (lines 107-108). Finally, the WCB memory is deleted (line 109).

The WriteText function creates new fields and/or places text into existing fields. The WCB is checked for validity (line 100). The outer partition is updated and its first group is displayed (lines 101-102). Then, looping over each of the groups, each group is checked to see if any fields need to be created or replaced (lines 103-114). One of the optimizations used in this design is placing WCB groups in order so that the WriteText function and its associated functions can fall through the list of groups and thereby easily handle switching from the outer partition groups to the inner partition groups (line 105). This is done by looping through each of the fields in each group (lines 106-113). A WriteText indicator is looked for (set by the called program to indicate this change in the field text), and if it is set (line 107), then the command to call the indicator is issued to change the field text and/or create new fields if necessary (lines 108-109). If these operations were successful, then the WriteText indicators in the WCB are reset, otherwise an error code is returned (lines 110-112).

The ReadWindow function causes all display changes to be displayed on the screen and allows the user to intervene with the program. This then informs the window owners of the changes and/or interventions. Programmed function key information is sent first to the owner of the current window. Windows in which text has been changed have also sent messages that a change has been made in their window. WCB fields, for which changes have been made are marked with a Modified indicator. A special field label exists as a convenience for windows that only respond to a string of input in a particular field.

ReadWindow first locks the current partition, and if one is not found, returns to whoever issued this command (lines 100-101). Otherwise, a display manager command is issued to write the changes to the display and allow the user to intervene (line 102). The cursor position is then determined, and if it was not in a defined partition, it is placed in the upper partition (lines 103-105). A temporary list of partitions currently on the screen is created and compared with the list of all WCBs (lines 106-111). The current partition is placed at the front of the list of WCBs (line 110).

Each of the WCBs is then processed by the following loop (lines 112-128). Closed or minimized windows are ignored, as no changes will appear in them (line 113). The text partition is updated, and a loop determines if any of the fields have been changed. If so, the WCB indicator for that field is marked as changed (lines 114-119). The same loop is then repeated for the outer partition (lines 120-125). If the WCB's special input field was set, then the field text for the changed field is obtained (line 126). The results of the read operation are communicated to the window owner (line 127).

The SizeWindow function reformats the window in the display and moves it up the screen. The WCB is checked for validity (line 100). The inner partition is formatted first (lines 101-108). This is done by first checking if it has a text partition and if so, formatting it relative to the outer partition. If the new window is too small for the text it will hold, the partition is made invisible (lines 104-105).

The outer partition is then reformatted and rebuilt (lines 108-115). The WCB is updated with the requested position and dimensions (lines 108). A display manager command is issued to reformat the outer partition (line 109). The partition page is rebuilt (line 110). The contents of the outer partition are rebuilt according to the new dimensions (lines 111-115). Finally, the window is updated, updating all of its partitions if it is not already at the top of the screen (lines 116-118).

The MoveWindow function moves the window and pushes it up on the screen. The WCB is checked for validity (line 100). The new position of the inner partition is calculated based on the destination and distance from the outer partition (lines 101-103). If the window is not closed, the display manager command is issued to move the partitions (lines 104-107). The window is placed at the top of the screen if it is not already there (lines 109-110).

The ScrollWindow function scrolls the contents of the window and moves it up the screen. The WCB is checked for validity (line 100). If there is no text partition for this window, the function returns, since only window text is scrolled (lines 101-102). The inner partition is updated (line 103). Calculations are performed to determine what data is displayed after the scroll operation (line 104). The operation then continues by executing the requested display manager commands that produce the scroll result (105-117). The WCB is updated with the new position information and the window is placed at the top of the screen (lines 118-121).

Additional window control functions can be easily implemented using the functions described previously or techniques similar to those used in such functions.

As will be appreciated by those skilled in the art, a window management system has been described which provides high-level, fully functional support for messy desk windowing in a non-programmable, character-based display. Such a system can be used with mainframe-based applications for which windowing has not been generally available heretofore. The windowing system described here can be readily provided as a package for use in numerous application programs. With the techniques of the present invention, windows can be effectively manipulated in a display which would not normally be is designed to support their use. Numerous types of windows, such as pop-up and pull-down windows, can be implemented using the techniques described.

Claims (11)

1. A method of displaying overlapping logical windows (46) on a non-programmable display (66) for use in a data processing system including a processor unit and the non-programmable display (66) capable of displaying a plurality of independent scrollable partitions (50) and a plurality of independent non-scrollable partitions (48), the method comprising: assigning one of a plurality of window control blocks (82-86) to a logical window (46) generated by an application program executing in the data processing system, the window control block (82) containing pointers (96-108) in a plurality of data groups (88); characterized in that the process comprises: filling a plurality of partition identifiers (92) into the window control block (82) including at least a first partition identifier (ID 1) corresponding to a non-rollable partition (48) to provide a boundary for the logical window (46) and a second identifier (ID 2) corresponding to a rollable partition (50) for the logical window (46); setting, for each non-rollable (48) and rollable (50) partition, a pointer (96-108) in the window control block (82-86) to a data group (88) for the partition (48,50) defining its attributes for overlapping the rollable partition (50) on the non-rollable partition (48); creating the non-rollable partition (48) corresponding to the first partition identifier (ID 1) for the logical window (46) on the screen (66); and creating the scrollable partition (50) corresponding to the second partition identifier (ID 2) for the logical window (46) on the display screen (66) such that the scrollable partition (50) overlaps the non-scrollable partition (48) to display the logical window (46) on the display screen (66). 2. A method as claimed in claim 1, including generating an additional scrollable partition label for the logical window (46) on the display screen (66), the additional partition overlapping the non-scrollable partition (48) to display the logical window (46) on the display screen (66). 3. A method as claimed in claim 1, wherein the non-scrollable partition (48) includes a window boundary, and the scrollable partition (50) is displayed at a location that is entirely within the boundaries of the non-scrollable partition (48), whereby the window boundary surrounds the scrollable partition (50). 4. A method as claimed in claim 3, wherein the non-scrollable partition (48) contains non-scrollable text at the top and bottom, and the scrollable partition (50) is displayed at a location between the top and bottom text. 5. A method as claimed in claim 1, wherein the non-scrollable partition (48) contains a plurality of sub-regions, the text for indicating each sub-region being stored in a separate data group (88). 6. A display device for use in a data processing system, the display device comprising: a non-programmable screen (66) capable of displaying a plurality of independent scrollable partitions (50) and a plurality of independent non-scrollable partitions (48) of the logical windows (46); and means (62) for associating a plurality of window control blocks (82-86) with a logical window (46) generated by an application program executing in the data processing system, the window control block (82) containing pointers (96-108) in a plurality of data groups (88); characterized in that the device contains: means (62) for filling a plurality of partition identifiers (92) into the window control block (82) including at least a first partition identifier (ID 1) corresponding to a non-rollable partition (48) to provide a boundary for the logical window (46) and a second identifier (ID 2) corresponding to a rollable partition (50) for the logical window (46); means (62) for setting, for each non-rollable (48) and rollable (50) partition, a pointer (96-108) in the window control block (82-86) to a data group (88) for the partition (48,50) defining its attributes for overlapping the rollable partition (50) on the non-rollable partition (48); Means (64) for generating the non-scrollable partition (48) corresponding to the first partition identifier (ID 1) for the logical window (46) on the screen (66); and Means (64) for creating the scrollable partition (50) corresponding to the second partition identifier (ID 2) for the logical window (46) on the display screen (66) so that the scrollable partition (50) overlaps the non-scrollable partition (48) to display the logical window (46) on the display screen (66). 7. An apparatus as claimed in claim 6, including means (62) for generating an additional scrollable partition label for the logical window (46) on the display screen (66), the additional partition overlapping the non-scrollable partition (48) to display the logical window (46) on the display screen (66). 8. A device as claimed in claim 1, wherein the non-scrollable partition (48) includes a window boundary, and the scrollable partition (50) is displayed at a location that is entirely within the boundaries of the non-scrollable partition (48), whereby the window boundary surrounds the scrollable partition (50). 9. A device as claimed in claim 8, wherein the non-scrollable partition (48) contains non-scrollable text at the top and bottom, and the scrollable partition (50) is displayed at a location between the top and bottom text. 10. A device as claimed in claim 6, wherein the non-scrollable partition (48) contains a plurality of sub-regions, the text for indicating each sub-region being stored in a separate data group (88). 11. A data processing system comprising a processor unit and a display as claimed in any one of claims 6 to 10.