The Task Group membership was:
This Task Group arose mainly from the Architecture Working Group discussion and the joint session with the Application Program Interface Working Group. We thought it was a good idea to look below windows to see if there are more fundamental objects. We attempted to characterize the common structure properties among all the window systems of which we were aware. We will dodge the issue of overlapping versus tiling. There seem to be good reasons for both styles of use. We will concentrate on what is common between them.
We have to be careful with our terminology here: a conventional window is a Byte reader's idea of a window and is a box on the screen with a name stripe, a border, etc. that you can move about on the screen, change the size of, and so on. A conventional window is shown in Figure 22.1. Windows can also be unconventional as shown in Figure 22.2.
We will not insist on the bits of a window being enclosed in a rectangular border. Fast non-rectangular operations will permit windows with non-rectangular shapes. We want to find a primitive subcomponent of windows to divide the architecture into manageable lumps. We have been through several names for these parts: pads, panes, canvases etc and Colin Prosser has convinced us that we should use a word which is appropriate in graphics terms, namely viewport. A viewport is an area of transparency on the display through which something can be seen.
So the conventional window example is made up of three visible viewports: the name stripe, the scroll bar and the main interaction area, as shown in Figure 22.3. The more complex unconventional window example consists of four viewports, as shown in Figure 22.4.
Viewports are not necessarily limited to being rectangular either. RasterOp leads to rectangular images, ultimately there might be BlobOp graphics primitives leading to blobs . You may have viewports hanging outside a window although the user interface people might say this is bad taste.
Viewports are defined hierarchically with the positions of child viewports being defined relative to the parent viewport. Clipping of the child viewport is independent of the parent.
A window then consists of a family of viewports organized as a subtree. The viewports of a window will usually be contiguous and non-overlapping although this need not be the case. Windows can consist of viewports only in one family. The intention is that the family of viewports in a window are all at Z coordinate levels such that they are either all behind or all in front of another window. Interleaving of viewports from different windows is not allowed. Algorithms determine where input goes according to the viewports. Input control attributes are associated with viewports (echo, ignore mouse hits etc).
When you look through a viewport, you see an image, (the sea!) and we do not really have a satisfactory name for that.
A tentative model of what happens in a window system is shown in Figure 22.5.
Applications draw into viewports. Applications can draw into several viewports, and viewports for a single application can be in different windows. This enables support for icons either as independent windows in their own right, or as elements of a group (the family of windows concept) within a window, in the style of Sapphire. As the substructuring notion is recursive, icons (of either variety) might themselves be composed of subfamilies of viewports. Extending this idea, and recalling that viewports are not necessarily rectangular or constrained to lie within some boundary, it should become apparent that the structuring concept presented also covers items like rubber borders which dynamically echo the new position a window would take were it to be moved or have its size changed.
These ideas were discussed and it was felt that they provided the basis for a sound model for substructuring. However, we did not have time to consider in any depth how well the model would stand up to close analysis, and consequently, this presentation aims to propose the model in overview only. Substantially more work would need to be undertaken before we could be sure that we do indeed have a useful model of substructuring.
A layout manager (which is one component of the window manager) constructs windows out of viewports, moves windows around and constrains them to behave properly.
The viewport manager clips the images and handles overlapping. It also handles input devices, for example, mouse events are directed to whichever viewport the cursor is over.
We looked at the interface between the bottom of the application and the viewport manager. The application passes things we have called pictures or sources to the viewport manager. We are not entirely happy with what we have called them and need a name. These pictures may be bitmaps, display lists or PostScript programs, for example. The viewport manager clips pictures and presents them on the display. This level ought to be device independent but this will usually be too difficult to achieve - although it would be nice if it were.