Raised if X server sends an error reply instead of a normal reply, and, for local reasons.

May be raised dispatched if connection is dead or died while request.

When raised, locks on connection are already released.

Actually an ERROR, not a SIGNAL: proceeding is not allowed except where noted

Raised asynchronously for certain requests.

nil(0), request(1), value(2), window(3), pixmap(4), atom(5), cursor(6), font(7), match(8), drawable(9), access(10), alloc(11), colormap(12), gContext(13), idChoice(14), name(15), length(16), implementation(17),

otherServer(240),

clientError(251), sizeError(252), otherLocal(253), connectionWedged(254), requestFromDeadConnection(255)

};

If an error is < otherServer it is the orginal value generated by the X server.

If an error is > otherServer its value is made up local.

otherServer: The error is generated by the X server but the value conflicts with possible local values. Look at originalCodeByte for the X error value..

clientError: Arguments are bogus.

sizeError: Arguments do not fit the size limitations of the X protocol or connection.

otherLocal: catchall for more.

connectionWedged: never shappen...

requestFromDeadConnection: connection was dead before or while request is handled.

Describes connection with X11, [display* in XLib]

Unless a conection is closed it will never be garbage collected.

nullID: ID ~ 0;

nullDrawable: Drawable ~ [nullID];

nullFontable: Fontable ~ NIL;

nullColorMap: ColorMap ~ [nullID];

ColorMapId: PROC [m: ColorMap] RETURNS [ID] ~ INLINE {

position is upper left corner outside of border

origin is upper left corner inside

size is inside exclusive border

All measured in pixels.

nullWindow: Window ~ [nullDrawable];

WindowId: PROC [w: Window] RETURNS [ID] ~ INLINE {

nullFont: Font ~ NIL;

FontId: PROC [f: Font] RETURNS [ID];

nullVisual: Visual ~ [nullID];

VisualId: PROC [v: Visual] RETURNS [ID] ~ INLINE {

currentTime: TimeStamp ~ RelativeTimes.nullTimeStamp;

Period: PROC [from, to: TimeStamp] RETURNS [INT32] ~ INLINE {

AtomId: PROC [a: XAtom] RETURNS [ID] ~ INLINE {

nullCursor: Cursor ~ [0];

CursorId: PROC [cursor: Cursor] RETURNS [ID] ~ INLINE {

nullPixmap: Pixmap ~ [nullDrawable];

PixmapId: PROC [p: Pixmap] RETURNS [ID] ~ INLINE {

SEQUENCE numberOfScreens: NAT OF Screen

];

root: Window,

defaultColorMap: ColorMap,

whitePixel: Pixel,

blackPixel: Pixel,

currentInputMasks: SetOfEvent,

sizeInPixels: Size,

sizeInMillimeters: Size,

minInstalledMaps: CARD16,

maxInstalledMaps: CARD16,

rootVisual: Visual,

backingStores: MACHINE DEPENDENT {never, whenMapped, always},

saveUnders: BYTE,

rootDepth: BYTE,

nDepths: BYTE,

connection: Connection, --not standard X

screenNumber: INT, --not standard X

properties: PropList.List ¬ NIL, --not standard X

screenDepthL: ScreenDepthL

];

depth: BYTE, --only one Format per depth value

bitsPerPixel: BYTE, --1, 4, 8, 16, 24, 32

scanlinePad: BYTE --8, 16, 32

];

screenDepthIndex: NAT, --not standard X; useful to make pixmap caches

screen: Screen, --not standard X; but handy

properties: PropList.List ¬ NIL, --not standard X

depth: BYTE,

nVisualTypes: CARD16,

visuals: LIST OF READONLY VisualType

];

visual: Visual,

class: VisualClass,

bitsPerRgbValue: BYTE,

colorMapEntries: CARD16,

redMask: CARD32,

greenMask: CARD32,

blueMask: CARD32,

properties: PropList.List ¬ NIL

];

pos: Point ¬ [dontUse, dontUse], --upper left corner (outside of border)

size: Size ¬ [dontUse, dontUse], --inner size (excluding border)

borderWidth: INT ¬ dontUse --all in pixels

];

Layed out such that it can be moved to the X server as whole block.

SEQUENCE numberOfRects: NAT OF PackedRectangle

];

protocolMajorVersion: CARD16,

protocolMinorVersion: CARD16,

releaseNumber: CARD32,

resourceIdBase: CARD32,

resourceIdMask: CARD32,

motionBufferSize: CARD32,

maxRequestLength: INT, -- reduced by 8

maxRequestLengthBytes: INT, -- reduced by 32

numberOfFORMATs: BYTE,

imageByteOrder: MACHINE DEPENDENT {lsbFirst, msbFirst},

bitmapFormatBitOrder: MACHINE DEPENDENT {leastSignificant, mostSignificant},

bitmapFormatScanlineUnit: BYTE, --8, 16, 32 <=bitmapFormatScanlinePad

bitmapFormatScanlinePad: BYTE, --8, 16, 32

minKeycode: KeyCode,

maxKeycode: KeyCode,

vendor: ROPE,

formats: LIST OF READONLY Format,

screens: Screens

];

RETURN [c.info];

};

RETURN [c.properties];

};

RETURN [c.serviceProperties];

};

RETURN [c.info.screens.numberOfScreens];

};

The numbering of screens comes from the server. The first first screen is used for many system properties.

RETURN [c.info.screens[0]];

};

The default screen is the one encoded in the server name used for opening the connection; the server does not know which screen is default for a particular connection.

RETURN [c.info.screens[c.defaultScreenNumber]];

};

RETURN [c.info.screens[i]];

};

The first screens root window

The default screens root window

RETURN [c.name];

};

RETURN [c.screenDepthS.num];

};

RETURN [c.screenDepthS[n]];

};

Returns best guess whether connection is alive [and non NIL]

RETURN [c#NIL AND c.alive];

};

Returns the last time stamp reported from server

RETURN [c.lastTimeStamp];

};

Put local property [NO access to the X server]

Get local property [NO access to the X server]

Initializing utility for local properties.

Atomically executes init exactly when the connection has no key property, then puts the return value as key property.

InitializeProcType: TYPE ~ PROC [c: Connection, key: REF] RETURNS [val: REF ¬ $x];

Put local property [NO access to the X server]

Get local property [NO access to the X server]

Put local property [NO access to the X server]

Get local property [NO access to the X server]

Put local property [NO access to the X server]

Get local property [NO access to the X server]

Query procedure issuing request; presence on server does not imply existence of a Cedar interface. Clients might more efficiently check availability of particular extensions using its interface directly.

QueryExtensionRec: TYPE ~ RECORD [presentOnServer: BOOL, majorOpcode, firstEvent, firstError: BYTE];

Server response; presence on server does not imply existence of a Cedar interface.

Returns valid connection or raises connectionNotCreated [retries if resumed]

server: Name of server including display number.

synchronized: Used in requests with NIL details. Ignored if server=NIL.

applicationKey: Key for default value of server and synchronized fields in case of server=NIL.

errorMatch: Special match used for asynchronous errors. Defaulted fields are filled in to call debugger.

finalMatch: Special match used for notification when reference counts transition to zero for all objects. If reference counts are still zero on return, connection will be closed. Note that a freshly created connection starts with a refcount of 1 on the NIL object. (finalMatch.handles is ignored).

debugHelp: For eventual identification of connection in debugger

connectionNotCreated: SIGNAL [why: REF ConnectionRejectInfo];

ConnectionRejectInfo: TYPE ~ RECORD [

Prevents automatic close of Connection

Might re-enable automatic close of Connection

Does not raise any error (but of course might cause others to do so)

All requests already issued will enter the wire. If ~delayed then right now.

Does not raise any inline errors.

Waits until X server acknowledges having processed the requests

Describes optional more detailed parametrization for execution of requests.

Fields are copied: clients may change fields before replies are returned.

Details may be shared by multiple threads if sequenceNo is ignored.

Errors notified on a per request basis are not forwarded to any per connection error notifier.

--output specifications: set by impl and read by client

sequenceNo: SequenceNo ¬ 0, --set by request (...no locking...).

--input specifications: set by client and read by impl

synchronous: BOOL ¬ FALSE, --makes request synchronous (overwrites other fields)

localErrors: LocalErrorReporting ¬ ignore, --Locally recognized X errors, dead connections, but not programming errors

errorMatch: Match ¬ NIL, --called on XError (ignores EventCodes)

overMatch: Match ¬ NIL, --called on known absence of errors

flush: WhenFlush ¬ default,  --default flushes at least soon if a match is given

--command specific options

specific: REF ¬ NIL,   --NIL is ok for all commands.

--client only fields

props: <<PRIVATE>> REF ¬ NIL, --for eventual implementation of property lists

clientData: REF ¬ NIL   --ignored by Xl and its impl

];

All other connections to this server are delayed; Not reentrant. Heavy weight.

May time out if after some seconds no mouse key is down. Time-out is considered a client error and must be avoided.

This and the other grabs do not protect from events already "on the way"; this and the other grabs without a return result do not take effect until the server actually handles the request; if a grab is made to execute certain uninteruptedness this does not matter, but, should a client depend on knowledge that the server actually has seen the request [absolute time], issuing a RoundTrip request is suggested.

Defaulting details causes a flush

Defaulting details causes a flush

Add event handlers for windows not found

X atoms

returns standard atom; it is an error to use non standard names

An InternAtom query with create=true

X atoms. For all hosts of this server !

X atoms. For all hosts of this server !

X atoms

X properties

data: one of NIL, ROPE, REF TEXT, REF Card16Sequence, REF Card32Sequence

start: index of first unit used for actual request

num: number of units used for actual request; limited by length of data

details: fine tuning of request

Assumes data to be handed to ChangeProperty; returns number of units and unit size in bytes. data must be one of the types allowed by ChangeProperty. This does not involve the X server.

X properties

supposedFormat: speed up some cases

PropertyReturnRec: TYPE ~ RECORD [

X properties

X properties

This brain damaged X request is supported only for the benefit of ICCCM

Think a (TQ) ThreadQueue to be a thread, a queue, and, a lock. The thread ececutes all queued procedures with the lock hold.

Procedures on different TQ's are executed asynchronously.

Creates a ThreadQueue. TQ's are cheap and use process resources only when needed.

createData might be useful to identify tq in the debugger.

order and reverse serve to define a locking order: Clients must get the lock with smaller order before getting lock with larger order. For locks with same order, get the locks in the same order as the create times, unless reverse indicates the opposite.

Enqueues proc on ThreadQueue. Enqueued procedures on TQ are executed in order of enqueueing. Can not cause wedges, but no guarantee for liveness of TQ can be given either.

data typically registered together with proc. proc must not be nested. Certain types of event might cause enqueued procs to be removed from queue.

Executes proc with lock of TQ hold. Might have to wait until lock is free. Order of execution of different calls or with queued procs is undefined.

Lock is PROCESS reentrant.

Might wedge or raise Wedged instead. Not all wedges can be detected.

Watch the order in which locks are acquired! Procedure trusts in caller using correct locking order.

Executes proc with locks of both TQ`s hold in the right order. Caller MUST NOT hold lock of either TQ (otherwise it is too hard to make predictable statements about wedging). Might have to wait until lock is free. Order of execution of different calls or with queued procs is undefined.

Might wedge or raise an ERROR instead. Not all wedges can be detected.

Watch the order of locks acquired otherwise!

Returns whether caller currently holds TQ's lock.

Returns whether it is ok to get first's lock before getting second's lock.

LockOrder: TYPE ~ {ok, reversed, dead};

Returns value used for order. (Some application want a predefined classes for locking order, so they need this procedure to check it.)

The basic type used to decide what handler should be called to handle particular events.

Describes: if event described by "handles" occures, it should be queued on "tq"

"data" is passed throu to event handler procedure

~ INLINE {RETURN [p=illegalPixmap]};

~ INLINE {RETURN [cm=illegalColorMap]};

~ INLINE {RETURN [c=illegalCursor]};

Type describes attributes to be applied; it is not used for querying attributes.

Restriction on event-mask attribute: certain events, necessary for internal consistency can not be excluded from beeing generated

backgroundPixmap: Pixmap ¬ illegalPixmap,

backgroundPixel: Pixel ¬ illegalPixel,

borderPixmap: Pixmap ¬ illegalPixmap,

borderPixel: Pixel ¬ illegalPixel,

bitGravity: BitGravity ¬ illegal,

winGravity: WinGravity ¬ illegal,

backingStore: BackingStore ¬ illegal,

backingPlanes: CARD32 ¬ undefinedBackingPlanes,

backingPixel: Pixel ¬ illegalPixel,

overrideRedirect: BOOL3 ¬ illegal,

saveUnder: BOOL3 ¬ illegal,

eventMask: SetOfEvent ¬ unspecifiedEvents,

doNotPropagateMask: SetOfEvent ¬ unspecifiedEvents,

colorMap: ColorMap ¬ illegalColorMap,

cursor: Cursor ¬ illegalCursor

];

merges attributes; if value in both inputs is defined, the value in "win" will win,

except eventMask which is OR'ed

Creates a window...

matchList: events to be matched and called.

pos: upper left corner (outside of border)

size: inner size excluding border

Caller should enable events [in attributes.eventMask] he wants to handle with matchList. Those events can not be disabled with ChangeWindowAttributes.

Warning:

Be carefull with this procedure, as there is no arbitration what application enables what event.

Add an event handlers for events on window.

match: events to be matched and called.

generate: Events the server ought to generate.

This is not an original X-feature, but it may generate (ChangeWindowAttributes) requests to the server.

Defaulting a values means: don't change current value

CirculateDirection: TYPE ~ MACHINE DEPENDENT {raiseLowest, lowerHighest};

TreeInfoRec: TYPE ~ RECORD [

GeometryRec: TYPE ~ RECORD [

RepliedAttributes: TYPE ~ RECORD [

Finds screen of window; might produce requests to X server or might be cached.

Not an original X request.

Finds screen and depth; might produce requests to X server or might be cached.

Not an original X request.

TranslateRec: TYPE ~ RECORD [sameScreen: BOOL, child: Window, pos: Point];

Get font; might do server request or return cached font.

Details are only useful in case of a server request.

Resource won't be freed up until connection closes down

leftBearing: INT16,

rightBearing: INT16,

charWidth: INT16,

ascent: INT16,

descent: INT16,

attributes: CARD16

];

name: XAtom,

value: CARD32

];

Avoids calling the server if font information is cached

FontInfoRec: TYPE ~ RECORD [

Avoids calling the server if font information is cached

TextExtentsRec: TYPE ~ RECORD [

Gets up to maxNames font names from the server.

data is passed through to each. If each returns quit=TRUE it will not be called anymore with more fonts. This saves doing procedure calls, but the server did already send all the font names.

NameProc: TYPE ~ PROC [name: ROPE, data: REF] RETURNS [quit: BOOL ¬ FALSE];

Enumerates fonts which match pattern, including some information.

each is a callback to return results. If each returns quit=TRUE it will not be called anymore with more fonts. This saves doing procedure calls, but it does NOT prevent the X server from sending information for the remaining fonts.

data is passed through to each.

count is the actual number of font infos returned by the server

FontInfoProc: TYPE ~ PROC [name: Rope.ROPE, info: REF FontInfoRec, data: REF] RETURNS [quit: BOOL ¬ FALSE];

cached

PointerMapping: TYPE ~ REF READONLY PointerMappingSequence;

PointerMappingSequence: TYPE ~ RECORD [SEQUENCE leng: NAT OF BYTE];

Actively grabs control of the pointer.

May time out if after some seconds no mouse key is down. Time-out is considered a client error and must be avoided.

See remarks on "GrabServer" request about timing.

Defaulting details causes a flush

Establishes a passive grab.

PointerReply: TYPE ~ RECORD [

TimeCoord: TYPE ~ RECORD [time: TimeStamp, p: Point];

TimeCoords: TYPE ~ RECORD [SEQUENCE size: NAT OF TimeCoord];

BestSizeClass: TYPE ~ MACHINE DEPENDENT {cursor, tile, stipple};

This is a Cedar convention and not defined by the standard X protocol. Since in Cedar usage connections often are shared between independent applications the original X ownerEvents or OwnerGrabButton mask can not reasonably select what windows should be notified on events. This convention allows to actively establish an ownership of (button) grabs, so events can be ignored if they were ment for an other application.

The (button) grab ownership must be established if a grab is made which does not guarantee exclusive events; e.g when ownerEvents is true or OwnerGrabButton is set. The grab ownership can at any time be taken away by an other application.

The (button) grab ownership must be checked before acting on events. An application has no way to know whether this precaution is necessary or not, because in Cedar this depends on independent other applications.

Cedar convention; not standard X protocol

Returns "owner" of grab or NIL if none; events owned by other clients might be ignored.

Cedar convention; not standard X protocol.

Establishes (button) grab "ownership".

Clients grabbing with ownerEvents true OwnerGrabButton set must establish a grab owner.

SetGrabOwnerSuccess: TYPE ~ {failedFutureTime, failedLaterTime, failedEqualTime, succeeded};

Cedar convention; not standard X protocol.

Removes grab ownership if it was established at timestamp or before.

Noop if grab ownership was established after timeStamp.

RETURN [XlKeyBut.ORSetOfKeyButMask[s1, s2]];

};

RETURN [XlKeyBut.IncludeKeyButInSet[keyBut, mask]]

};

RETURN [XlKeyBut.IsKeyButInSet[keyBut, mask]]

};

A machine [and time] dependent identification of a key.

The X protocol restricts values to [8..255] however Xl does not.

An identification which refers (roughly) to the engravings found on the keycaps of keyboards key engravings.

noSym: KeySym ~ [0];

To make sure a mapping is used which is not to old, clients could get the mapping change notification in the same thread as the key/pointer events [mapping change notification happens on 0 window].

If QueryKeymap is used, no protection against using a mapping which is more recent than a key/pointer event can be given. [Even if a new mapping would be requested immediately [monitored] after each mapping change notification, X would not prevent another connection from changing the mapping and racing ahead before the first map request finishes]

Cached; cache access is fast enough to be used for every keystroke.

The original X request allows to request partial ranges, but for Cedar this seems not necessary and would hinder caching. Use an extras interface if exact protocol behaviour is required. In addition to the protocol, this mapping is also augmented with entries for buttons. (The button entries are are to be applied after the button map is applied; this ensures buttons do not conflict with KeyCodes.)

Use the KeyMapping interface for inpecting the mapping.

Cached

Modifier: TYPE ~ KeyBut[shift..mod5];

ModifierMappingSequence: TYPE ~ RECORD [SEQUENCE num: NAT OF ARRAY Modifier OF KeyCode];

ModifierMapping: TYPE ~ REF READONLY ModifierMappingSequence;

See remarks on "GrabServer" request about timing

Avoid synchrounous pointerMode [wedge protection not yet implemented]

Defaulting details causes a flush

NOT a standard X request; ungrabs keyboard even if grabbed by different Cedar connection

[UngrabKeyboard, faking the identity of the Connection which actually did the grab]

...If that connection is not wedged and allows doing it... [time's out if doesn't come through]

Heavy weight, success highly probable if keyboard was grabbed by a connection from same Cedar world, but not guaranteed.

Installs passive grab on keyboard

anyKey: KeyCode ~ keycode0;

ICCCM Convention: do not use currentTime for time [although X protocol allows]

ICCCM Convention: Use GetSelectionOwner to verify success

ICCCM Convention: do not use currentTime for time [although X protocol allows]

ICCCM Convention: do not use [0] for property [although X protocol allows]

Shortcut for send-event with empty set for event-mask.

window one of regular window, nullWindow or focusPointerRoot

ICCCM Convention: do not use currentTime for timeStamp [although X protocol allows]

window one of regular window, nullWindow or focusPointerRoot

This type matches the X graphical context insofar as it has the same expressiveness. However, it is cached on the client side and actually moved to the server only when needed.

Sharing graphics context among different connections is a bad idea.

Access to GContext is NOT monitored (since it wont be shared anyway).

Delayed until gc is actually used.

If gc is exported or any chance exist that it is used over a different connections [shame on you], it should be flushed explicitely once after creation. This prevents the actual creation of the resource on the server side from using two connection locks.

The gc can be used with any destination drawable having the same root and depth as the specified drawable; for a defaulted drawable the information is taken from first usage [discouraged].

Note that the defaults for foreground and background are counter intuitive [X Protocol].

ok: number of rectangles does not excede maximum request length

if not ok some rectangles are ignored

Ordering: TYPE ~ MACHINE DEPENDENT {unSorted, ySorted, yxSorted, yxBanded};

A simplified PolyFillRectangle request

A simplified PolyLine request

"bit-blit" of area. X PutImage request; generalized to have arbitrary offx, offy.

The area is clipped in the destination drawable, but must fit completely in the source bitmap.

This might generate multiple X requests to draw individual pieces of the area.

dest: dest for area (inside drawable)

offx, offy: source of area (in bitmap coordinates)

size: size of area moved

base: base of bitmap; assume: [slow: down, fast: right]

scanLineBytes: bytes per scanline in bitmap (on X client; NOT X server)

RESTRICTIONS:

Fancy request; read the X Protocol before using

GetImageReplyRef: TYPE ~ REF GetImageReplyRec;

GetImageReplyRec: TYPE ~ RECORD [

Conveniance procedure [like ImageRope]

ImageText8 request

Draws character and background

ImageText8 request

Draws rope and background

ImageText16 request

Draws string16 and background

PolyText8 request. Calls deliver to return textitems or font changes. data is handed to deliver.

Text8DeliverProc: TYPE ~ PROC [data: REF] RETURNS [newFont: Font ¬ NIL, delta: INT ¬ 0, text: Rope.ROPE, startPos: INT ¬ 0, length: INT ¬ LAST[INT], more: BOOL ¬ FALSE];

Simpler PolyText8 request

Draws character without background

Simpler PolyText8 request [1 item]

Draws rope without background

Simple PolyText16 request [1 item]

Draws string16 without background

I'm to lazy to provide PolyText16, but there would be no problem if somebody needs it.

red, green, blue: RGBVal

];

ColorMaps: TYPE ~ RECORD [SEQUENCE count: NAT OF ColorMap];

ColorItem: TYPE ~ RECORD [pixel: Pixel, doRed, doGreen, doBlue: BOOL ¬ TRUE, rgb: RGBRec];

MACHINE DEPENDENT { local(0), errorNotify(1), keyPress(2), keyRelease(3), buttonPress(4), buttonRelease(5), motionNotify(6), enterNotify(7), leaveNotify(8), focusIn(9), focusOut(10), keymapNotify(11), expose(12), graphicsExposure(13), noExposure(14), visibilityNotify(15), createNotify(16), destroyNotify(17), unmapNotify(18), mapNotify(19), mapRequest(20), reparentNotify(21), configureNotify(22), configureRequest(23), gravityNotify(24), resizeRequest(25), circulateNotify(26), circulateRequest(27), propertyNotify(28), selectionClear(29), selectionRequest(30), selectionNotify(31), colorMapNotify(32), clientMessage(33), mappingNotify(34), extension, finalEvent, tipEvent, replyEvent };

keyPress..mappingNotify are core events of the standard X protocol.

All other events are NOT part of the standard X protocol or changed somehow.

local is used for requests not initiated through X.

finalEvent is a notification that the connection died or was closed.

tipEvent is reserved for implementation of tip tables.

replyEvent is reserved.

extension is used instead of ENDCASE branch of variant records for extensions to X.

errorNotify need not be the original error reply of X.

SetEventCodes: PROC [list: LIST OF EventCode] RETURNS [EventCodes];

EventCodeRope: PROC [code: EventCode] RETURNS [r: ROPE];

Type of procedure which handles events.

clientData: is client data of match.

Do not change priority. Process is reused!

The EventFilter type describes the event types some procedure is ready to accept.

EventCodes: TYPE ~ PACKED ARRAY EventCode[EventCode.FIRST..EventCode.LAST] OF BOOL ¬ ALL[FALSE];

Create a simple event filter (filtering basic events only; explicitely no extensions)

Create a complex event filter

originalCodeByte: BYTE ¬ ORD[EventCode[local]],

dispatchDrawable: Drawable ¬ nullDrawable,

connection: Connection ¬ NIL,

props: <<PRIVATE>> REF ¬ NIL,

details: SELECT type: EventCode FROM

];

Debugging aid

This set of event type is used to describe what events an X server generates.

Distinguish generating an events from matching and consuming it!

unspecifiedEvents: SetOfEvent ~ [];

disableEvents: SetOfEvent ~ [reservedforDisableEvents: TRUE];

RETURN [XlSetOfEvent.ORSetOfEvents[s1, s2]]

};

~ INLINE {RETURN [e=unspecifiedEvents]};

Returns: event was generated by other X-client [not by X-server]

RETURN [event.originalCodeByte>127];

};

Ignores originalCodeByte, dispatchDrawable, connection, and, sequence number in eventBody

Short cut for frequent case of SendEvent

--

--buffer for requests

bufNext: CARD ¬ 0, --internal next pointer

bufReady: CARD ¬ 0, --number of bytes ready to be flushed

bufLimit: CARD ¬ 0, --size of buffer

buf: LONG POINTER TO PACKED ARRAY [0..0) OF BYTE ¬ NIL,

bufPrivate: PRIVATE REF ¬ NIL, --real ref in case buf needs header information

bufExpected: PRIVATE CARD ¬ 0, --for self check on bufReady

bufSkipped: PRIVATE CARD ¬ 0, --for self check on bufReady

lastOpCode: PRIVATE CARD ¬ 0, --for debugging XlImpl only

bufDebug: PRIVATE CARD ¬ 0, --for debugging XlImpl only

sequenceNumber: SequenceNo ¬ 0,

bufProblem: REF ¬ NIL, --#NIL means an io error happened

alive: BOOL ¬ FALSE,

--

--various handles protocol relative

info: InfoRef ¬ NIL,

screenDepthS: REF READONLY ScreenDepthTuples ¬ NIL,

name: ROPE ¬ NIL,

displayNumber: INT ¬ 0,

defaultScreenNumber: INT ¬ 0,

lastTimeStamp: TimeStamp ¬ currentTime,

screenDepthTuplesCount: NAT ¬ 0,

synchCount: CARD ¬ 0, -- 0 asynchronous >0 synchronous error event reporting

--

--various handles for impls

cPriv: REF ConnectionPrivate ¬ NIL,

replyStuff: REF ReplyStuffRep ¬ NIL,

resourceStuff: REF ResourceStuffRep ¬ NIL,

dispatchStuff: REF DispatchStuffRep ¬ NIL,

service: REF ServiceRep ¬ NIL,

properties: PRIVATE PropList.List ¬ NIL,

serviceProperties: PRIVATE PropList.List ¬ NIL,

--

--network access

xmit: IO.STREAM ¬ NIL,

recv: IO.STREAM ¬ NIL,

sendSoon: PROC [out: IO.STREAM, when: CARD ¬ 0] ¬ NIL, --like NetworkStream.SendSoon.

errorFromStreamProc: PROC [self: IO.STREAM] RETURNS [ROPE] ¬ NIL,

needFlushing: BOOL ¬ FALSE,

isFlushing: BOOL ¬ FALSE,

--

--grab convention stuff

buttonGrabOwner: REF ¬ NIL,

buttonGrabTimeStamp: TimeStamp ¬ [0],

--

--more

errorMatch: Match ¬ NIL,

applicationKey: ATOM ¬ NIL,

lastError: REF READONLY ANY ¬ NIL, --for debugging

debugHelp: REF ¬ NIL --for debugging

];

activate: EventCodes ¬ ALL[FALSE],

activateExtensions: LIST OF REF ANY ¬ NIL

];