#charset "us-ascii"
/*
* Copyright (c) 2000, 2006 Michael J. Roberts. All Rights Reserved.
*
* TADS 3 Library: banner manager
*
* This module defines the banner manager, which provides high-level
* services to create and manipulate banner windows.
*
* A "banner" is an independent window shown within the interpreter's
* main application display frame (which might be the entire screen on a
* character-mode terminal, or could be a window in a GUI system). The
* game can control the creation and destruction of banner windows, and
* can control their placement and size.
*
* This implementation is based in part on Steve Breslin's banner
* manager, used by permission.
*/
#include "adv3.h"
/* ------------------------------------------------------------------------ */
/*
* A BannerWindow corresponds to an on-screen banner. For each banner
* window a game wants to display, the game must create an object of this
* class.
*
* Note that merely creating a BannerWindow object doesn't actually
* display a banner window. Once a BannerWindow is created, the game
* must call the object's showBanner() method to create the on-screen
* window for the banner.
*
* BannerWindow instances are intended to be persistent (not transient).
* The banner manager keeps track of each banner window that's actually
* being displayed separately via an internal transient object; the game
* doesn't need to worry about these tracking objects, since the banner
* manager automatically handles them.
*/
class BannerWindow: OutputStreamWindow
/*
* Construct the object.
*
* 'id' is a globally unique identifying string for the banner. When
* we dynamically create a banner object, we have to provide a unique
* identifying string, so that we can correlate transient on-screen
* banners with the banners in a saved state when restoring the saved
* state.
*
* Note that no ID string is needed for BannerWindow objects defined
* statically at compile-time, because the object itself ('self') is
* a suitably unique and stable identifier.
*/
construct(id)
{
/* remember my unique identifier */
id_ = id;
}
/*
* Show the banner. The game should call this method when it first
* wants to display the banner.
*
* 'parent' is the parent banner; this is an existing BannerWindow
* object. If 'parent' is nil, then the parent is the main game
* text window. The new window's display space is obtained by
* carving space out of the parent's area, according to the
* alignment and size values specified.
*
* 'where' and 'other' give the position of the banner among the
* children of the given parent. 'where' is one of the constants
* BannerFirst, BannerLast, BannerBefore, or BannerAfter. If
* 'where' is BannerBefore or BannerAfter, 'other' gives the
* BannerWindow object to be used as the reference point in the
* parent's child list; 'other' is ignored in other cases. Note
* that 'other' must always be another child of the same parent; if
* it's not, then we act as though 'where' were given as BannerLast.
*
* 'windowType' is a BannerTypeXxx constant giving the new window's
* type.
*
* 'align' is a BannerAlignXxx constant giving the alignment of the
* new window. 'size' is an integer giving the size of the banner,
* in units specified by 'sizeUnits', which is a BannerSizeXxx
* constant. If 'size' is nil, it indicates that the caller doesn't
* care about the size, usually because the caller will be resizing
* the banner soon anyway; the banner will initially have zero size
* in this case if we create a new window, or will retain the
* existing size if there's already a system window.
*
* 'styleFlags' is a combination of BannerStyleXxx constants
* (combined with the bitwise OR operator, '|'), giving the requested
* display style of the new banner window.
*
* Note that if we already have a system banner window, and the
* existing banner window has the same characteristics as the new
* creation parameters, we'll simply re-use the existing window
* rather than closing and re-creating it; this reduces unnecessary
* redrawing in cases where the window isn't changing. If the caller
* explicitly wants to create a new window even if we already have a
* window, the caller should simply call removeBanner() before
* calling this routine.
*/
showBanner(parent, where, other, windowType,
align, size, sizeUnits, styleFlags)
{
local parentID;
local otherID;
/* note the ID's of the parent window and the insertion point */
parentID = (parent != nil ? parent.getBannerID() : nil);
otherID = (other != nil ? other.getBannerID() : nil);
/*
* if we have an 'other' specified, its parent must match our
* proposed parent; otherwise, ignore 'other' and insert at the
* end of the parent list
*/
if (other != nil && other.parentID_ != parentID)
{
other = nil;
where = BannerLast;
}
/* if we already have an existing banner window, check for a match */
if (handle_ != nil)
{
local t;
local match;
/* presume we won't find an exact match */
match = nil;
/* we already have a window - get the UI tracker object */
if ((t = bannerUITracker.getTracker(self)) != nil)
{
/* check the placement, window type, alignment, and style */
match = (t.windowType_ == windowType
&& t.parentID_ == parentID
&& t.align_ == align
&& t.styleFlags_ == styleFlags
&& bannerUITracker.orderMatches(t, where, otherID));
}
/*
* if it doesn't match the existing window, close it, so that
* we will open a brand new window with the new
* characteristics
*/
if (!match)
removeBanner();
}
/* if the system-level banner doesn't already exist, create it */
if (handle_ == nil)
{
/* create my system-level banner window */
if (!createSystemBanner(parent, where, other, windowType, align,
size, sizeUnits, styleFlags))
{
/* we couldn't create the system banner - give up */
return nil;
}
/* create our output stream */
createOutputStream();
/* add myself to the UI tracker's active banner list */
bannerUITracker.addBanner(handle_, outputStream_, getBannerID(),
parentID, where, other, windowType,
align, styleFlags);
}
else
{
/*
* Our system-level window already exists, so we don't need
* to create a new one. However, our size could be
* different, so explicitly set the requested size if it
* doesn't match our recorded size. If the size is given as
* nil, leave the size as it is; a nil size indicates that
* the caller doesn't care about the size (probably because
* the caller is going to change the size shortly anyway),
* so we can avoid unnecessary redrawing by leaving the size
* as it is for now.
*/
if (size != nil && (size != size_ || sizeUnits != sizeUnits_))
bannerSetSize(handle_, size, sizeUnits, nil);
}
/*
* remember the creation parameters, so that we can re-create the
* banner with the same characteristics in the future if we
* should need to restore the banner from a saved position
*/
parentID_ = parentID;
windowType_ = windowType;
align_ = align;
size_ = size;
sizeUnits_ = sizeUnits;
styleFlags_ = styleFlags;
/*
* Add myself to the persistent banner tracker's active list. Do
* this even if we already had a system handle, since we might be
* initializing the window as part of a persistent restore
* operation, in which case the persistent tracking object might
* not yet exist. (This seems backwards: if we're restoring a
* persistent state, surely the persistent tracker would already
* exist. In fact, the case we're really handling is where the
* window is open in the transient UI, because it was already
* open in the ongoing session; but the persistent state we're
* restoring doesn't include the window. This is most likely to
* occur after a RESTART, since we could have a window that is
* always opened immediately at start-up and thus will be in the
* transient state up to and through the RESTART, but is only
* created as part of the initialization process.)
*/
bannerTracker.addBanner(self, parent, where, other);
/* indicate success */
return true;
}
/*
* Remove the banner. This removes the banner's on-screen window.
* The BannerWindow object itself remains valid, but after this
* method returns, the BannerWindow no longer has an associated
* display window.
*
* Note that any child banners of ours will become undisplayable
* after we're gone. A child banner depends upon its parent to
* obtain display space, so once the parent is gone, its children no
* longer have any way to obtain any display space. Our children
* remain valid objects even after we're closed, but they won't be
* visible on the display.
*/
removeBanner()
{
/* if I don't have a system-level handle, there's nothing to do */
if (handle_ == nil)
return;
/* remove my system-level banner window */
bannerDelete(handle_);
/* our system-level window is gone, so forget its handle */
handle_ = nil;
/* we only need an output stream when we're active */
outputStream_ = nil;
/* remove myself from the UI trackers's active list */
bannerUITracker.removeBanner(getBannerID());
/* remove myself from the persistent banner tracker's active list */
bannerTracker.removeBanner(self);
}
/* write the given text to the banner */
writeToBanner(txt)
{
/* write the text to our underlying output stream */
outputStream_.writeToStream(txt);
}
/* flush any pending output to the banner */
flushBanner() { bannerFlush(handle_); }
/*
* Set the banner window to a specific size. 'size' is the new
* size, in units given by 'sizeUnits', which is a BannerSizeXxx
* constant.
*
* 'isAdvisory' is true or nil; if true, it indicates that the size
* setting is purely advisory, and that a sizeToContents() call will
* eventually follow to set the actual size. When 'isAdvisory is
* true, the interpreter is free to ignore the request if
* sizeToContents()
*/
setSize(size, sizeUnits, isAdvisory)
{
/* set the underlying system window size */
bannerSetSize(handle_, size, sizeUnits, isAdvisory);
/*
* remember my new size in case we have to re-create the banner
* from a saved state
*/
size_ = size;
sizeUnits_ = sizeUnits;
}
/*
* Size the banner to its current contents. Note that some systems
* do not support this operation, so callers should always make an
* advisory call to setSize() first to set a size based on the
* expected content size.
*/
sizeToContents()
{
/* size our system-level window to our contents */
bannerSizeToContents(handle_);
}
/*
* Clear my banner window. This clears out all of the contents of
* our on-screen display area.
*/
clearWindow()
{
/* clear our system-level window */
bannerClear(handle_);
}
/* set the text color in the banner */
setTextColor(fg, bg) { bannerSetTextColor(handle_, fg, bg); }
/* set the screen color in the banner window */
setScreenColor(color) { bannerSetScreenColor(handle_, color); }
/*
* Move the cursor to the given row/column position. This can only
* be used with text-grid banners; for ordinary text banners, this
* has no effect.
*/
cursorTo(row, col) { bannerGoTo(handle_, row, col); }
/*
* Get the banner identifier. If our 'id_' property is set to nil,
* we'll assume that we're a statically-defined object, in which case
* 'self' is a suitable identifier. Otherwise, we'll return the
* identifier string.
*/
getBannerID() { return id_ != nil ? id_ : self; }
/*
* Restore this banner. This is called after a RESTORE or UNDO
* operation that finds that this banner was being displayed at the
* time the state was saved but is not currently displayed in the
* active UI. We'll show the banner using the characteristics saved
* persistently.
*/
showForRestore(parent, where, other)
{
/* show myself, using my saved characteristics */
showBanner(parent, where, other, windowType_, align_,
size_, sizeUnits_, styleFlags_);
/* update my contents */
updateForRestore();
}
/*
* Create the system-level banner window. This can be customized as
* needed, although this default implementation should be suitable
* for most instances.
*
* Returns true if we are successful in creating the system window,
* nil if we fail.
*/
createSystemBanner(parent, where, other, windowType, align,
size, sizeUnits, styleFlags)
{
/* create the system-level window */
handle_ = bannerCreate(parent != nil ? parent.handle_ : nil,
where, other != nil ? other.handle_ : nil,
windowType, align, size, sizeUnits,
styleFlags);
/* if we got a valid handle, we succeeded */
return (handle_ != nil);
}
/* create our banner output stream */
createOutputStreamObj()
{
return new transient BannerOutputStream(handle_);
}
/*
* Update my contents after being restored. By default, this does
* nothing; instances might want to override this to refresh the
* contents of the banner if the banner is normally updated only in
* response to specific events. Note that it's not necessary to do
* anything here if the banner will soon be updated automatically as
* part of normal processing; for example, the status line banner is
* updated at each new command line via a prompt-daemon, so there's
* no need for the status line banner to do anything here.
*/
updateForRestore()
{
/* do nothing by default; subclasses can override as needed */
}
/*
* Initialize the banner window. This is called during
* initialization (when first starting the game, or when resetting
* with RESTART). If the banner is to be displayed from the start of
* the game, this can set up the on-screen display.
*
* Note that we might already have an on-screen handle when this is
* called. This indicates that we're restarting an ongoing session,
* and that this banner already existed in the session before the
* RESTART operation. If desired, we can attach ourselves to the
* existing on-screen banner, avoiding the redrawing that would occur
* if we created a new window.
*
* If this window depends upon another window for its layout order
* placement (i.e., we'll call showBanner() with another BannerWindow
* given as the 'other' parameter), then this routine should call the
* other window's initBannerWindow() method before creating its own
* window, to ensure that the other window has a system window and
* thus will be meaningful to establish the layout order.
*
* Overriding implementations should check the 'inited_' property.
* If this property is true, then it can be assumed that we've
* already been initialized and don't require further initialization.
* This routine can be called multiple times because dependent
* windows might call us directly, before we're called for our
* regular initialization.
*/
initBannerWindow()
{
/* by default, simply note that we've been initialized */
inited_ = true;
}
/* flag: this banner has been initialized with initBannerWindow() */
inited_ = nil
/*
* The creator-assigned ID string to identify the banner
* persistently. This is only needed for banners created
* dynamically; for BannerWindow objects defined statically at
* compile time, simply leave this value as nil, and we'll use the
* object itself as the identifier.
*/
id_ = nil
/* the handle to my system-level banner window */
handle_ = nil
/*
* Creation parameters. We store these when we create the banner,
* and update them as needed when the banner's display attributes
* are changed.
*/
parentID_ = nil
windowType_ = nil
align_ = nil
size_ = nil
sizeUnits_ = nil
styleFlags_ = nil
;
/* ------------------------------------------------------------------------ */
/*
* Banner Output Stream. This is a specialization of OutputStream that
* writes to a banner window.
*/
class BannerOutputStream: OutputStream
/* construct */
construct(handle)
{
/* inherit base class constructor */
inherited();
/* remember my banner window handle */
handle_ = handle;
}
/* execute preinitialization */
execute()
{
/*
* We shouldn't need to do anything during pre-initialization,
* since we should always be constructed dynamically by a
* BannerWindow. Don't even inherit the base class
* initialization, since it could clear out state that we want to
* keep through a restart, restore, etc.
*/
}
/* write text from the stream to the interpreter I/O system */
writeFromStream(txt)
{
/* write the text to the underlying system banner window */
bannerSay(handle_, txt);
}
/* our system-level banner window handle */
handle_ = nil
;
/* ------------------------------------------------------------------------ */
/*
* The banner UI tracker. This object keeps track of the current user
* interface display state; this object is transient because the
* interpreter's user interface is not part of the persistence
* mechanism.
*/
transient bannerUITracker: object
/* add a banner to the active display list */
addBanner(handle, ostr, id, parentID, where, other,
windowType, align, styleFlags)
{
local uiWin;
local parIdx;
local idx;
/* create a transient BannerUIWindow object to track the banner */
uiWin = new transient BannerUIWindow(handle, ostr, id, parentID,
windowType, align, styleFlags);
/*
* Find the parent in the list. If there's no parent, the
* parent is the main window; consider it to be at imaginary
* index zero in the list.
*/
parIdx = (parentID == nil
? 0 : activeBanners_.indexWhich({x: x.id_ == parentID}));
/* insert the banner at the proper point in our list */
switch(where)
{
case BannerFirst:
/*
* insert as the first child of the parent - put it
* immediately after the parent in the list
*/
activeBanners_.insertAt(parIdx + 1, uiWin);
break;
case BannerLast:
ins_last:
/*
* Insert as the last child of the parent: insert
* immediately after the last window that descends from the
* parent.
*/
activeBanners_.insertAt(skipDescendants(parIdx), uiWin);
break;
case BannerBefore:
case BannerAfter:
/* find the reference point ID in our list */
idx = activeBanners_.indexWhich(
{x: x.id_ == other.getBannerID()});
/*
* if we didn't find the reference point, or the reference
* point item doesn't have the same parent as the new item,
* then ignore the reference point and instead insert at the
* end of the parent's child list
*/
if (idx == nil || activeBanners_[idx].parentID_ != parentID)
goto ins_last;
/*
* if inserting after, skip the reference item and all
* of its descendants
*/
if (where == BannerAfter)
idx = skipDescendants(idx);
/* insert at the position we found */
activeBanners_.insertAt(idx, uiWin);
break;
}
}
/*
* Given an index in our list of active windows, skip the given item
* and all items whose windows are descended from this window.
* We'll leave the index positioned on the next entry in the list
* that isn't a descendant of the window at the given index. Note
* that this skips not only children but grandchildren (and so on)
* as well.
*/
skipDescendants(idx)
{
local parentID;
/*
* if the index is zero, it's the main window; all windows are
* children of the root window, so return the next index after
* the last item
*/
if (idx == 0)
return activeBanners_.length() + 1;
/* note ID of the parent item */
parentID = activeBanners_[idx].id_;
/* skip the parent item */
++idx;
/* keep going as long as we see children of the parent */
while (idx <= activeBanners_.length()
&& activeBanners_[idx].parentID_ == parentID)
{
/*
* This is a child of the given parent, so we must skip it;
* we must also skip its descendants, since they're all
* indirectly descendants of the original parent. So,
* simply skip this item and its descendants with a
* recursive call to this routine.
*/
idx = skipDescendants(idx);
}
/* return the new index */
return idx;
}
/* remove a banner from the active display list */
removeBanner(id)
{
local idx;
/* find the entry with the given ID, and remove it */
if ((idx = activeBanners_.indexWhich({x: x.id_ == id})) != nil)
{
local lastIdx;
/*
* After removing an item, its children are no longer
* displayable, because a child obtains display space from
* its parent. So, we must remove any children of this item
* at the same time we remove the item itself. Find the
* index of the next item after all of our descendants, so
* that we can remove the item and its children all at once.
* An item and its descendants are always contiguous in our
* list, since we store children immediately after their
* parents, so we can simply remove the range of items from
* the specified item to its last descendant.
*
* Note that skipDescendants() returns the index of the
* first item that is NOT a descendant; so, decrement the
* result so that we end up with the index of the last
* descendant.
*/
lastIdx = skipDescendants(idx) - 1;
/* remove the item and all of its children */
activeBanners_.removeRange(idx, lastIdx);
}
}
/* get the BannerUIWindow tracker object for a given BannerWindow */
getTracker(win)
{
local id;
/* get the window's ID */
id = win.getBannerID();
/* return the tracker with the same ID as the given BannerWindow */
return activeBanners_.valWhich({x: x.id_ == id});
}
/* check a BannerUIWindow to see if it matches the given layout order */
orderMatches(uiWin, where, otherID)
{
local idx;
local otherIdx;
local parentID;
local parIdx;
/* get the list index of the given window */
idx = activeBanners_.indexOf(uiWin);
/* get the list index of the reference point window */
otherIdx = (otherID != nil
? activeBanners_.indexWhich({x: x.id_ == otherID}) : nil);
/*
* find the parent item (using imaginary index zero for the
* root, which we can think of as being just before the first
* item in the list)
*/
parentID = uiWin.parentID_;
parIdx = (parentID == nil
? 0 : activeBanners_.indexWhich({x: x.id_ == parentID}));
/*
* if 'other' is specified, it has to have our same parent; if
* it has a different parent, it's not a match
*/
if (otherID != nil && parentID != activeBanners_[otherIdx].parentID_)
return nil;
/*
* if there's no such window in the list, it can't match the
* given placement no matter what the given placement is, as it
* has no placement
*/
if (idx == nil)
return nil;
/* check the requested layout order */
switch (where)
{
case BannerFirst:
/* make sure it's immediately after the parent */
return idx == parIdx + 1;
case BannerLast:
/*
* Make sure it's the last child of the parent. To do this,
* make sure that the next item after this item's last
* descendant is the same as the next item after the
* parent's last descendant.
*/
return skipDescendants(idx) == skipDescendants(parIdx);
case BannerBefore:
/*
* we want this item to come before 'other', so make sure
* the next item after all of this item's descendants is
* 'other'
*/
return skipDescendants(idx) == otherIdx;
case BannerAfter:
/*
* we want this item to come just after 'other', so make
* sure that the next item after all of the descendants of
* 'other' is this item
*/
return skipDescendants(otherIdx) == idx;
default:
/* other layout orders are invalid */
return nil;
}
}
/*
* The vector of banners currently on the screen. This is a list of
* transient BannerUIWindow objects, stored in the same order as the
* banner layout list.
*/
activeBanners_ = static new transient Vector(32)
;
/*
* A BannerUIWindow object. This keeps track of the transient UI state
* of a banner window while it appears on the screen. We create only
* transient instances of this class, since it tracks what's actually
* displayed at any given time.
*/
class BannerUIWindow: object
/* construct */
construct(handle, ostr, id, parentID, windowType, align, styleFlags)
{
/* remember the banner's data */
handle_ = handle;
outputStream_ = ostr;
id_ = id;
parentID_ = parentID;
windowType_ = windowType;
align_ = align;
styleFlags_ = styleFlags;
}
/* the system-level banner handle */
handle_ = nil
/* the banner's ID */
id_ = nil
/* the parent banner's ID (nil if this is a top-level banner) */
parentID_ = nil
/*
* The banner's output stream. Output streams are always transient,
* so hang on to each active banner's stream so that we can plug it
* back in on restore.
*/
outputStream_ = nil
/* creation parameters of the banner */
windowType_ = nil
align_ = nil
styleFlags_ = nil
/*
* Scratch-pad for our association to our BannerWindow object. We
* only use this during the RESTORE process, to tie the transient
* object back to the proper persistent object.
*/
win_ = nil
;
/*
* The persistent banner tracker. This keeps track of the active banner
* windows persistently. Whenever we save or restore the game's state,
* this object will be saved or restored along with the state. When we
* restore a previously saved state, we can look at this object to
* determine which banners were active at the time the state was saved,
* and use this information to restore the same active banners in the
* user interface.
*
* This is a post-restore and post-undo object, so we're notified via our
* execute() method whenever we restore a saved state using RESTORE or
* UNDO. When we restore a saved state, we'll restore the banner display
* conditions as they existed in the saved state.
*/
bannerTracker: PostRestoreObject, PostUndoObject
/* add a banner to the active display list */
addBanner(win, parent, where, other)
{
local parIdx;
local otherIdx;
/*
* Don't add it if it's already in the list. If we're restoring
* the banner from persistent state, it'll already be in the
* active list, since the active list is the set of windows
* we're restoring in the first place.
*/
if (activeBanners_.indexOf(win) != nil)
return;
/* find the parent among the existing windows */
parIdx = (parent == nil ? 0 : activeBanners_.indexOf(parent));
/* note the index of 'other' */
otherIdx = (other == nil ? nil : activeBanners_.indexOf(other));
/* insert the banner at the proper point in our list */
switch(where)
{
case BannerFirst:
/* insert immediately after the parent */
activeBanners_.insertAt(parIdx + 1, win);
break;
case BannerLast:
ins_last:
/* insert after the parent's last descendant */
activeBanners_.insertAt(skipDescendants(parIdx), win);
break;
case BannerBefore:
case BannerAfter:
/*
* if we didn't find the reference point, insert at the end
* of the parent's child list
*/
if (otherIdx == nil)
goto ins_last;
/*
* if inserting after, skip the reference item and all of
* its descendants
*/
if (where == BannerAfter)
otherIdx = skipDescendants(otherIdx);
/* insert at the position we found */
activeBanners_.insertAt(otherIdx, win);
break;
}
}
/*
* Skip all descendants of the window at the given index.
*/
skipDescendants(idx)
{
local parentID;
/* index zero is the root item, so skip the entire list */
if (idx == 0)
return activeBanners_.length() + 1;
/* note the parent item */
parentID = activeBanners_[idx].getBannerID();
/* skip the parent item */
++idx;
/* keep going as long as we see children of the parent */
while (idx < activeBanners_.length()
&& activeBanners_[idx].parentID_ == parentID)
{
/* this is a child, so skip it and all of its descendants */
idx = skipDescendants(idx);
}
/* return the new index */
return idx;
}
/* remove a banner from the active list */
removeBanner(win)
{
local idx;
local lastIdx;
/* get the index of the item to remove */
idx = activeBanners_.indexOf(win);
/* if we didn't find it, ignore the request */
if (idx == nil)
return;
/* find the index of its last descendant */
lastIdx = skipDescendants(idx) - 1;
/*
* remove the item and all of its descendants - child items
* cannot be displayed once their parents are gone, so we can
* remove all of this item's children, all of their children,
* and so on, as they are becoming undisplayable
*/
activeBanners_.removeRange(idx, lastIdx);
}
/*
* The list of active banners. This is a list of BannerWindow
* objects, stored in banner layout list order.
*/
activeBanners_ = static new Vector(32)
/* receive RESTORE/UNDO notification */
execute()
{
/* restore the display state for a non-initial state */
restoreDisplayState(nil);
}
/*
* Restore the saved banner display state, so that the banner layout
* looks the same as it did when we saved the persistent state. This
* should be called after restoring a saved state, undoing to a
* savepoint, or initializing (when first starting the game or when
* restarting).
*/
restoreDisplayState(initing)
{
local uiVec;
local uiIdx;
local origActive;
/* get the list of banners active in the UI */
uiVec = bannerUITracker.activeBanners_;
/*
* First, go through all of the persistent BannerWindow objects.
* For each one whose ID shows up in the active UI display list,
* tell the BannerWindow object its current UI handle.
*/
forEachInstance(BannerWindow, function(cur)
{
local uiCur;
/* find this banner in the active UI list */
uiCur = uiVec.valWhich({x: x.id_ == cur.getBannerID()});
/*
* if the window exists in the active UI list, note the
* current system handle for the window; otherwise, we have
* no system window, so set the handle to nil
*/
if (uiCur != nil)
{
/* note the current system banner handle */
cur.handle_ = uiCur.handle_;
/* re-establish the banner's active output stream */
cur.outputStream_ = uiCur.outputStream_;
/* tie the transient record to the current 'cur' */
uiCur.win_ = cur;
}
else
{
/* it's not shown, so it has no system banner handle */
cur.handle_ = nil;
/* it has no output stream */
cur.outputStream_ = nil;
}
});
/*
*
* 'initing' indicates whether we're initializing (startup or
* RESTART) or doing something else (RESTORE, UNDO). When
* initializing, if there are any banners on-screen, we'll give
* their associated BannerWindow objects (if any) a chance to set
* up their initial conditions; this allows us to avoid
* unnecessary redrawing if we have banners that we'd immediately
* set up to the same conditions anyway, since we can just keep
* the existing banners rather than removing and re-creating
* them.
*
* So, if we're initializing, tell each banner that it's time to
* set up its initial display.
*/
if (initing)
forEachInstance(BannerWindow, {cur: cur.initBannerWindow()});
/*
* scan the active UI list, and close each window that isn't
* still open in the saved state
*/
foreach (local uiCur in uiVec)
{
/* if this window isn't in the active list, close it */
if (activeBanners_.indexWhich(
{x: x.getBannerID() == uiCur.id_}) == nil)
{
/*
* There's no banner in the persistent list with this
* ID, so this window is not part of the state we're
* restoring. Close the window. If we have an
* associated BannerWindow object, close through the
* window object; otherwise, close the system handle
* directly.
*/
if (uiCur.win_ != nil)
{
/* we have a BannerWindow - close it */
uiCur.win_.removeBanner();
}
else
{
/* there's no BannerWindow - close the system window */
bannerDelete(uiCur.handle_);
/* remove the UI tracker object */
uiVec.removeElement(uiCur);
}
}
}
/* start at the first banner actually displayed right now */
uiIdx = 1;
/*
* make a copy of the original active list - we might modify the
* actual active list in the course of restoring things, so make
* a copy that we can refer to as we reconstruct the original
* list
*/
origActive = activeBanners_.toList();
/*
* Scan the saved list of banners, and restore each one. Note
* that by restoring windows in the order in which they appear
* in the list, we ensure that we always restore a parent before
* restoring any of its children, since a child always follows
* its parent in the list.
*/
for (local curIdx = 1, local aLen = origActive.length() ;
curIdx <= aLen ; ++curIdx)
{
local redisp;
local cur;
/* get the current item */
cur = origActive[curIdx];
/* presume we will have to redisplay this banner */
redisp = true;
/*
* If this banner matches the current banner in the active
* UI display list, and the characteristics match, we need
* do nothing, as we're already displaying this banner
* properly. If the current active UI banner doesn't match,
* then we need to insert this saved banner at the current
* active UI position.
*/
if (uiVec.length() >= uiIdx)
{
local uiCur;
/* get this current UI display item (a BannerUIWindow) */
uiCur = uiVec[uiIdx];
/* check for a match to 'cur' */
if (uiCur.id_ == cur.getBannerID()
&& uiCur.parentID_ == cur.parentID_
&& uiCur.windowType_ == cur.windowType_
&& uiCur.align_ == cur.align_
&& uiCur.styleFlags_ == cur.styleFlags_)
{
/*
* This saved banner ('cur') exactly matches the
* active UI banner ('uiCur') at the same position
* in the layout list. Therefore, we do not need to
* redisplay 'cur'.
*/
redisp = nil;
}
}
/* if we need to redisplay 'cur', do so */
if (redisp)
{
local prvIdx;
local where;
local other;
local parent;
/*
* If 'cur' is already being displayed, we must remove
* it before showing it anew. This is the only way to
* ensure that we display it with the proper
* characteristics, since the characteristics of the
* current instance of its window don't match up to what
* we want to restore.
*/
if (cur.handle_ != nil)
cur.removeBanner();
/*
* Figure out how to specify this window's display list
* position. A display list position is always
* specified relative to the parent's child list, so
* figure out where we go in our parent's list. Scan
* backwards in the active list for the nearest previous
* window with the same parent. If we find one, insert
* the new window after that prior sibling; otherwise,
* insert as the first child of our parent. Presume
* that we'll fail to find a prior sibling, then search
* for it and search for our parent.
*/
where = BannerFirst;
other = nil;
for (prvIdx = curIdx - 1 ; prvIdx > 0 ; --prvIdx)
{
local prv;
/* note this item */
prv = origActive[prvIdx];
/*
* If this item has our same parent, and we haven't
* already found a prior sibling, this is our most
* recent prior sibling, so note it.
*/
if (where == BannerFirst
&& prv.parentID_ == cur.parentID_)
{
/* insert after this prior sibling */
where = BannerAfter;
other = prv;
}
/* if this is our parent, note it */
if (prv.getBannerID() == cur.parentID_)
{
/*
* note the parent BannerWindow object - we'll
* need it to specify our window display
* position
*/
parent = prv;
/*
* Children of a given parent always come after
* the parent in the display list, so there's no
* possibility of finding another sibling.
* There's also obviously no possibility of
* finding another parent. So, our work here is
* done; we can stop scanning.
*/
break;
}
}
/* show the window */
cur.showForRestore(parent, where, other);
}
else
{
/*
* the banner is already showing, so we don't need to
* redisplay it; simply notify it that a Restore
* operation has taken place so that it can do any
* necessary updates
*/
cur.updateForRestore();
}
/*
* 'cur' should now be displayed, but we might have failed
* to re-create it. If we did show the window, we can
* advance to the next slot in the UI list, since this
* window will necessarily be at the current spot in the UI
* list.
*/
if (cur.handle_ != nil)
{
/*
* We know that this window is now the entry in the
* active UI list at the current index we're looking at.
* Move on to the next position in the active list for
* the next saved window.
*/
++uiIdx;
}
}
}
;
/*
* Initialization object - this will be called when we start the game the
* first time or RESTART within a session. We'll restore the display
* state to the initial conditions.
*/
bannerInit: InitObject
execute()
{
/* restore banner displays to their initial conditions */
bannerTracker.restoreDisplayState(true);
}
;
TADS 3 Library Manual
Generated on 5/16/2013 from TADS version 3.1.3