<*PRAGMA LL*>

INTERFACE ScrnPaintOp;

IMPORT TrestleComm, PaintOp;

If op is a ScrnPaintOp.T valid for screentype st, then op maps a source pixel s and destination pixel d to a result pixel op(d, s). It will be used in a painting operation that sets d := op(d, s). Both d and op(d, s) have type st, and s either has type st or st.bits. (The type st.bits is the screentype for one-bit deep sources that can be used with st.) For example, in a copy operation, s has type st, while in painting a bitmap, s has type st.bits.

A ScrnPaintOp.Oracle is meaningful only as the op field of some screentype st. It provides methods to generate ScreenPaintOp.Ts that are valid for st.

A {\it tint} is a paintop that is independent of s. If op is a tint, we write op(d) instead of op(d, s). (Even in the case of a tint, the type of s must be st.bits; otherwise the result of applying the tint is undefined.)

\subsubsection{Obtaining handles from the oracle}

TYPE
  Pixel = INTEGER;
  Oracle = Private OBJECT
    METHODS
      <* LL.sup <= VBT.mu *>
      opaque(pix: Pixel): T
        RAISES {Failure, TrestleComm.Failure};
      bgfg(bg, fg: T): T
        RAISES {Failure, TrestleComm.Failure};
      swap(p,q: Pixel): T
        RAISES {Failure, TrestleComm.Failure};
      transparent(): T
        RAISES {Failure, TrestleComm.Failure};
      copy(): T
        RAISES {Failure, TrestleComm.Failure};
      builtIn(op: PaintOp.Predefined): T;
    END;
    Private <: ROOT;

EXCEPTION Failure;

The method call

      op := st.op.opaque(pix)

      op := st.op.bgfg(bg, fg)

      op := st.op.swap(p, q)

      op := st.op.transparent()

      op := st.op.copy()

      st.op.builtIn(op)

The exception Failure is raised if the screentype cannot provide the requested painting operation. For all the methods, LL.sup <= VBT.mu.

TYPE
  PlaneWiseOracle = Oracle OBJECT
    METHODS <* LL.sup <= VBT.mu *>
      planewise(
          READONLY mask: ARRAY OF BOOLEAN;
          op1, op2: T): T
        RAISES {Failure, TrestleComm.Failure};
  END;

      op := st.op.planewise(mask, bitOps)

      IF mask[i] THEN
         op(d, s)[i] = op1(d[i], s[i])
      ELSE
         op(d, s)[i] = op2(d[i], s[i])
      END

The convenience procedure ConstructPlanewiseOp can be used to construct a painting operation from an array of boolean functions represented by the enumeration by BitOp:

TYPE
  BitOp = {
    Zero,           (* 0 *)
    And,            (* dest AND src *)
    NotAnd,         (* (NOT dest) AND src *)
    Src,            (* src *)
    AndNot,         (* dest and (NOT src) *)
    Dest,           (* dest *)
    Xor,            (* dest XOR src *)
    Or,             (* dest OR src *)
    Nor,            (* (NOT dest) AND (NOT src) *)
    Equal,          (* dest XOR (NOT src) *)
    Invert,         (* NOT dest *)
    NotOr,          (* (NOT dest) OR src *)
    NotSrc,         (* NOT src *)
    OrNot,          (* dest OR (NOT src) *)
    Nand,           (* (NOT dest) OR (NOT src) *)
    One};           (* 1 *)

PROCEDURE ConstructPlanewiseOp(
  pwo: PlaneWiseOracle;
  READONLY bitOps: ARRAY OF BitOp): T
RAISES {Failure, TrestleComm.Failure};
<* LL.sup <= VBT.mu *>

Return the painting operation that applies bitOp[i] to plane i of the source and destination.

       op(d, s)[i] = bitOps[i](d[i], s[i])

\subsubsection{The handle object}

TYPE
  T <: Public;
  Public = OBJECT id: INTEGER; pix: Pixel := -1 END;

END ScrnPaintOp.