Browse Prior Art Database

Method for Detecting and Freeing Overlayed Graphical User Interface Constructs in a Personal Computer Emulator

IP.com Disclosure Number: IPCOM000115365D
Original Publication Date: 1995-Apr-01
Included in the Prior Art Database: 2005-Mar-30
Document File: 4 page(s) / 119K

Publishing Venue

IBM

Related People

Kiel, HG: AUTHOR [+2]

Abstract

A method for detecting and freeing overlayed graphical constructs in a Personal Computer (PC) emulator which is running a host-based application.

This text was extracted from an ASCII text file.
This is the abbreviated version, containing approximately 52% of the total text.

Method for Detecting and Freeing Overlayed Graphical User Interface
Constructs in a Personal Computer Emulator

      A method for detecting and freeing overlayed graphical
constructs in a Personal Computer (PC) emulator which is running a
host-based application.

      Some PC emulators, running host-based applications, support
graphical constructs.  These graphical constructs are rendered as a
result of commands received in a data stream from a host computer.
At times, graphical constructs that are rendered in this way are
overlayed with new graphical constructs which are rendered as a
result of subsequent data streams.  The overlayed constructs are of
little value, but continue to have memory resources allocated to
them.

      The PC emulator could keep track of all constructs' geometry
and sensitivity (sensitive to user input or insensitive to user
input) in order to detect the complete overlaying of a graphical
construct.  Geometry of a construct typically consists of a
constructs' upper left hand corner position and its height and width
(in x-y or row-column coordinates).  When a new construct is
rendered, its geometry is compared to all of the previously rendered
constructs' geometry to detect a complete overlay.  If the new
construct completely overlays any previously rendered "insensitive"
construct or constructs, the previously rendered construct or
constructs could be removed from the graphical user interface (GUI)
construct table and the construct destroyed.  Destruction of a GUI
construct involves the freeing of memory associated with the
construct.

      Some examples of PC emulator graphical constructs are as
follows: windows, menu bars/pull downs, selection fields, selection
lists, pushbuttons, and scroll bars.

      Windows are always considered insensitive.  The other types of
above graphical constructs are insensitive when a data stream command
is received which makes an existing construct insensitive to user
input.

      An alternative implementation from that described above, could
detect complete overlays that occur due to multiple partial overlays
of a GUI construct.  The PC emulator could use an array that keeps
track of visible portions of all GUI constructs.  To accomplish this,
the array could contain an entry for every possible position that a
GUI construct can occupy.  Since PC emulators typically deal in
row-column coordinates for graphical constructs, the number of
elements in the array would be the number of rows multiplied by the
number of columns on the screen.  Each element of this array could
contain an offset into an array of GUI constructs.  As new GUI
constructs are rendered, corresponding positions in the visible GUI
construct array are filled in with the GUI construct array o...