<*PRAGMA LL*>

INTERFACE VBTRep;

IMPORT Batch, Cursor, PropertyV, Rect, Region,
  ScreenType, ScrnPaintOp, ScrnCursor, ScrnPixmap,
  ScrnFont, VBT, VBTClass, Word, PaintPrivate, Axis, Palette,
  PaintOp, Font, Pixmap;

CONST EmptyCage = VBT.EmptyCage;

TYPE
  MiscRef = REF MiscRec;
  MiscRec = RECORD
    cage := EmptyCage;
    badRgn := Region.Empty;
    rpseqno: Word.T;
    oldDomain := Rect.Empty;
    link: MiscRef := NIL
  END;

The rpseqno field is the {\it repainting sequence number}. It is incremented whenever the badRgn is expanded and recorded before activating a repaint method. Thus when the repaint method returns, the current value can be compared with the recorded value to determine whether the current badRgn is the one that the repaint method responded to, or whether a new bad region arrived while the client was responding to the old one.

TYPE
  Prop =
    {EscapePending, Reshaping, RepaintPending, OnQ,
     Covered, Combiner, ShortCircuit, CageCovered,
     Marked, ExcessBegins, HasNewShape, BlockNewShape,
     EscapeCovered};
  Props = SET OF Prop;

CONST
  AllProps = Props{FIRST(Prop)..LAST(Prop)};
  NoProps = Props{};

EscapePending: Set when a thread of control is forked to deliver a cage escape to gone. Set to FALSE when any position is delivered.

Reshaping: set when the VBT has a non-empty old domain.

RepaintPending: Set when a thread of control exists that will deliver the bad region.

OnQ: Set when the VBT is on the Metermaid's to-be-serviced queue.

Covered: Ordinarily painting into an empty batch will put the VBT on the Metermaid's queue and set onQ. If the covered bit is set, this will not happen. For example, PutPosition sets covered before passing the position to child, and clears it and forces the batch before it returns. Only set during event delivery, so any action that could be deferred until after event delivery can check covered and clean up on method exit.

Combiner: Set to indicate that this VBT is a good place to pile up small paint batches, even if it is not covered. Trestle sets this bit in one VBT near the root of a client address space to avoid shipping many small batches across RPC.

ShortCircuit: Set on a VBT when painting on the VBT can be implemented by clipping to the VBT's domain and painting on its parent.

Marked: set by VBT.Mark.

CageCovered: VBTClass.PutPosition sets this bit on a VBT before calling its position method; after calling the position method, the procedure relays the child's cage to the parent and clears the bit. VBTClass.SetCage notices the bit and omits relaying the cage to the parent.

ExcessBegins: Set when excessBegins > 0.

HasNewShape is set when VBT.NewShape is called, and cleared by a call to VBTClass.HasNewShape or VBTClass.GetShape.

If BlockNewShape is set, VBT.NewShape calls will not be relayed to the parent of the VBT.

REVEAL VBT.Prefix =
  VBTClass.Prefix BRANDED OBJECT
    <* LL >= {SELF} *>
    cursor := Cursor.DontCare;
    cageType: (*BITS 16 FOR*) VBTClass.VBTCageType
      := VBTClass.VBTCageType.Gone;
    props: (*BITS 16 FOR*) Props := NoProps;
    batch: Batch.T := NIL;
    remaining: INTEGER := 0;
    propset: PropertyV.Set := NIL;
    miscRef: MiscRef := NIL;
  OVERRIDES
    getcursor := GetcursorDefault;
    axisOrder := AxisOrderDefault;
  END;

REVEAL VBT.ScreenType <: STPub;

TYPE STPub =
  ScreenType.Public OBJECT
    ops: REF ARRAY OF ScrnPaintOp.T;
    cursors: REF ARRAY OF ScrnCursor.T;
    pixmaps: REF ARRAY OF ScrnPixmap.T;
    fonts: REF ARRAY OF ScrnFont.T
  METHODS
    opApply(cl: Palette.OpClosure; op: PaintOp.T): ScrnPaintOp.T;
    cursorApply(cl: Palette.CursorClosure; cs: Cursor.T): ScrnCursor.T;
    pixmapApply(cl: Palette.PixmapClosure; pm: Pixmap.T): ScrnPixmap.T;
    fontApply(cl: Palette.FontClosure; ft: Font.T): ScrnFont.T
  END;

TYPE OffscreenType = VBT.ScreenType OBJECT st: VBT.ScreenType END;

PROCEDURE CheckMisc(v: VBT.T); <* LL >= {v} *>

Set v.misc := NIL if v's badRgn and oldDomain are empty and its cage type is not Rect.

PROCEDURE CreateMisc(v: VBT.T); <* LL >= {v} *>

If v.misc = NIL, then create a misc for v with empty badRgn and oldDomain, and with appropriate cage. Otherwise, do nothing.

PROCEDURE DestroyMisc(v: VBT.T);
<* LL >= {v, v.parent} *>

Set v's misc to NIL, clearing Reshaping from v.props.

PROCEDURE NewBatch(v: VBT.T; len: INTEGER := -1);
<* LL.sup = v *>

Force v's batch if it is non-nil and allocate a new batch for it of size at least len, or of size VBTTuning.BatchSize if len=-1.

PROCEDURE ForceBatch(v: VBT.T); <* LL.sup = v *>

Force v's batch if it is non-nil, and leave it nil.

PROCEDURE CancelBatch(v: VBT.T); <* LL.sup = v *>

Free v's batch and set it to NIL.

PROCEDURE Enqueue(v: VBT.T); <* LL.sup = v *>

Place v on the list of VBTs scheduled to be serviced by the MeterMaid.

PROCEDURE GetcursorDefault(v: VBT.Prefix): ScrnCursor.T;

Return the result of resolving cursor(v) using v's screentype.

PROCEDURE AxisOrderDefault(v: VBT.Prefix): Axis.T;

Return Axis.T.Hor.

PROCEDURE ExpandBadRect(w: VBT.T;
  READONLY clp: Rect.T; ba: Batch.T);
<* LL.sup = w *>

Expand w's bad region for ba.

PROCEDURE ExtendBatch(v: VBT.T; VAR ba: Batch.T);

Extend v's batch to include the painting operations in ba, and free ba. It is assumed that v has a non-empty batch which has room for the extension.

PROCEDURE MaxRepeat(v: VBT.T): CARDINAL;
<* LL.sup = v *>

Return the number of RepeatRec's that can fit in v's current batch.

PROCEDURE PaintRepeat(v: VBT.T;
  READONLY clip: ARRAY OF Rect.T);
<* LL.sup = v *>

Add a RepeatRec to v's batch for each rectangle in clip.

PROCEDURE PaintSingle(v: VBT.T; READONLY clip: Rect.T;
  com: PaintPrivate.CommandPtr); <* LL.sup = v *>

Add the paint operation referenced by com to v's batch, but use the clipping rectangle clip instead of the one in com.

PROCEDURE Scroll(v: VBT.T; READONLY clip: Rect.T;
  com: PaintPrivate.ScrollPtr); <* LL.sup = v *>

Like PaintSingle, but com must be a scroll command.

PROCEDURE Mark(v: VBT.T); <* LL >= {v} *>

Identical to VBT.Mark except for the locking level.

PROCEDURE Redisplay(); <* LL.sup = VBT.mu *>

Redisplay and unmark all marked windows whose screentype is non-NIL.

      LOOP
        WITH m = an array containing all marked windows DO
          IF NUMBER(m) = 0 THEN EXIT END;
          Sort m in order of non-decreasing depth;
          FOR i := 0 TO LAST(m) DO
            IF IsMarked(m[i]) AND m[i].st # NIL THEN
               Unmark(m[i]);
               m[i].redisplay()
            END
          END
        END
      END

Ordinarily when a window is marked, a thread is forked that will call Redisplay. This is wasteful if Redisplay will be called soon anyway. Therefore, if you know that Redisplay will be called soon, you can call CoverRedisplay, which increments a ``coverage counter''. If the coverage counter is non-zero, marking a VBT does not fork a thread. Of course by calling CoverRedisplay you acquire the obligation to ensure that Redisplay will be called soon. Calling UncoverRedisplay decrements the counter and calls Redisplay if the result is zero.

PROCEDURE CoverRedisplay(); <* LL.sup = VBT.mu *>

Increment the redisplay coverage counter.

PROCEDURE UncoverRedisplay(); <* LL.sup = VBT.mu *>

Decrement the redisplay coverage counter and call Redisplay if the result is zero.

END VBTRep.