Pratt 1.5.6

data/pkgs/tile-0.8.2/generic/tkstate.c

@@ -0,0 +1,268 @@
+/*
+ * tkstate.c,v 1.11 2005/04/06 00:03:09 jenglish Exp
+ *
+ * Tk widget state utilities.
+ *
+ * Copyright (c) 2003 Joe English.  Freely redistributable.
+ *
+ */
+
+#include <string.h>
+
+#include <tk.h>
+#include "tkTheme.h"
+
+/*
+ * Table of state names.  Must be kept in sync with TTK_STATE_*
+ * #defines in tkTheme.h.
+ */
+static const char *stateNames[] =
+{
+    "active",		/* Mouse cursor is over widget or element */
+    "disabled",		/* Widget is disabled */
+    "focus",		/* Widget has keyboard focus */
+    "pressed",		/* Pressed or "armed" */
+    "selected",		/* "on", "true", "current", etc. */
+    "background",	/* Top-level window lost focus (Mac,Win "inactive") */
+    "alternate",	/* Widget-specific alternate display style */
+    "invalid",		/* Bad value */
+    "readonly",		/* Editing/modification disabled */
+    NULL
+};
+
+/*------------------------------------------------------------------------
+ * +++ StateSpec object type:
+ *
+ * The string representation consists of a list of state names,
+ * each optionally prefixed by an exclamation point (!).
+ *
+ * The internal representation uses the upper half of the longValue
+ * to store the on bits and the lower half to store the off bits.
+ * If we ever get more than 16 states, this will need to be reconsidered...
+ */
+
+static int  StateSpecSetFromAny(Tcl_Interp *interp, Tcl_Obj *obj);
+/* static void StateSpecFreeIntRep(Tcl_Obj *); */
+#define StateSpecFreeIntRep 0		/* not needed */
+static void StateSpecDupIntRep(Tcl_Obj *, Tcl_Obj *);
+static void StateSpecUpdateString(Tcl_Obj *);
+
+static
+struct Tcl_ObjType StateSpecObjType =
+{
+    "StateSpec",
+    StateSpecFreeIntRep,
+    StateSpecDupIntRep,
+    StateSpecUpdateString,
+    StateSpecSetFromAny
+};
+
+static void StateSpecDupIntRep(Tcl_Obj *srcPtr, Tcl_Obj *copyPtr)
+{
+    copyPtr->internalRep.longValue = srcPtr->internalRep.longValue;
+    copyPtr->typePtr = &StateSpecObjType;
+}
+
+static int StateSpecSetFromAny(Tcl_Interp *interp, Tcl_Obj *objPtr)
+{
+    int status;
+    int objc;
+    Tcl_Obj **objv;
+    int i;
+    unsigned int onbits = 0, offbits = 0;
+
+    status = Tcl_ListObjGetElements(interp, objPtr, &objc, &objv);
+    if (status != TCL_OK)
+	return status;
+
+    for (i = 0; i < objc; ++i) {
+	char *stateName = Tcl_GetString(objv[i]);
+	int on, j;
+
+	if (*stateName == '!') {
+	    ++stateName;
+	    on = 0;
+	} else {
+	    on = 1;
+	}
+
+	for (j = 0; stateNames[j] != 0; ++j) {
+	    if (strcmp(stateName, stateNames[j]) == 0)
+		break;
+	}
+
+    	if (stateNames[j] == 0) {
+	    if (interp) {
+		Tcl_ResetResult(interp);
+		Tcl_AppendResult(interp, "Invalid state name ", stateName,NULL);
+	    }
+	    return TCL_ERROR;
+	}
+
+	if (on) {
+	    onbits |= (1<<j);
+	} else {
+	    offbits |= (1<<j);
+	}
+    }
+
+    /* Invalidate old intrep:
+     */
+    if (objPtr->typePtr && objPtr->typePtr->freeIntRepProc) {
+	objPtr->typePtr->freeIntRepProc(objPtr);
+    }
+
+    objPtr->typePtr = &StateSpecObjType;
+    objPtr->internalRep.longValue = (onbits << 16) | offbits;
+
+    return TCL_OK;
+}
+
+static void StateSpecUpdateString(Tcl_Obj *objPtr)
+{
+    unsigned int onbits = (objPtr->internalRep.longValue & 0xFFFF0000) >> 16;
+    unsigned int offbits = objPtr->internalRep.longValue & 0x0000FFFF;
+    unsigned int mask = onbits | offbits;
+    Tcl_DString result;
+    int i, len;
+
+    Tcl_DStringInit(&result);
+
+    for (i=0; stateNames[i] != NULL; ++i) {
+	if (mask & (1<<i)) {
+	    if (offbits & (1<<i))
+		Tcl_DStringAppend(&result, "!", 1);
+	    Tcl_DStringAppend(&result, stateNames[i], -1);
+	    Tcl_DStringAppend(&result, " ", 1);
+	}
+    }
+
+    len = Tcl_DStringLength(&result);
+    if (len) {
+	/* 'len' includes extra trailing ' ' */
+	objPtr->bytes = Tcl_Alloc((unsigned)len);
+	objPtr->length = len-1;
+	strncpy(objPtr->bytes, Tcl_DStringValue(&result), (size_t)len-1);
+	objPtr->bytes[len-1] = '\0';
+    } else {
+	/* empty string */
+	objPtr->length = 0;
+	objPtr->bytes = Tcl_Alloc(1);
+	*objPtr->bytes = '\0';
+    }
+
+    Tcl_DStringFree(&result);
+}
+
+Tcl_Obj *Ttk_NewStateSpecObj(unsigned int onbits, unsigned int offbits)
+{
+    Tcl_Obj *objPtr = Tcl_NewObj();
+
+    Tcl_InvalidateStringRep(objPtr);
+    objPtr->typePtr = &StateSpecObjType;
+    objPtr->internalRep.longValue = (onbits << 16) | offbits;
+
+    return objPtr;
+}
+
+int Ttk_GetStateSpecFromObj(
+    Tcl_Interp *interp,
+    Tcl_Obj *objPtr,
+    Ttk_StateSpec *spec)
+{
+    if (objPtr->typePtr != &StateSpecObjType) {
+	int status = StateSpecSetFromAny(interp, objPtr);
+	if (status != TCL_OK)
+	    return status;
+    }
+
+    spec->onbits = (objPtr->internalRep.longValue & 0xFFFF0000) >> 16;
+    spec->offbits = objPtr->internalRep.longValue & 0x0000FFFF;
+    return TCL_OK;
+}
+
+
+/*
+ * Tk_StateMapLookup --
+ *
+ * 	A state map is a paired list of StateSpec / value pairs.
+ *	Returns the value corresponding to the first matching state
+ *	specification, or NULL if not found or an error occurs.
+ */
+Tcl_Obj *Ttk_StateMapLookup(
+    Tcl_Interp *interp,		/* Where to leave error messages; may be NULL */
+    Ttk_StateMap map,		/* State map */
+    Ttk_State state)    	/* State to look up */
+{
+    Tcl_Obj **specs;
+    int nSpecs;
+    int j, status;
+
+    status = Tcl_ListObjGetElements(interp, map, &nSpecs, &specs);
+    if (status != TCL_OK)
+	return NULL;
+
+    for (j = 0; j < nSpecs; j += 2) {
+	Ttk_StateSpec spec;
+	status = Ttk_GetStateSpecFromObj(interp, specs[j], &spec);
+	if (status != TCL_OK)
+	    return NULL;
+	if (Ttk_StateMatches(state, &spec))
+	    return specs[j+1];
+    }
+    if (interp) {
+	Tcl_ResetResult(interp);
+	Tcl_AppendResult(interp, "No match in state map", NULL);
+    }
+    return NULL;
+}
+
+/* Ttk_GetStateMapFromObj --
+ * 	Returns a Ttk_StateMap from a Tcl_Obj*.
+ * 	Since a Ttk_StateMap is just a specially-formatted Tcl_Obj, 
+ * 	this basically just checks for errors.
+ */
+Ttk_StateMap Ttk_GetStateMapFromObj(
+    Tcl_Interp *interp,		/* Where to leave error messages; may be NULL */
+    Tcl_Obj *mapObj)		/* State map */
+{
+    Tcl_Obj **specs;
+    int nSpecs;
+    int j, status;
+
+    status = Tcl_ListObjGetElements(interp, mapObj, &nSpecs, &specs);
+    if (status != TCL_OK)
+	return NULL;
+
+    if (nSpecs % 2 != 0) {
+	if (interp)
+	    Tcl_SetResult(interp,
+		    "State map must have an even number of elements",
+		    TCL_STATIC);
+	return 0;
+    }
+
+    for (j = 0; j < nSpecs; j += 2) {
+	Ttk_StateSpec spec;
+	if (Ttk_GetStateSpecFromObj(interp, specs[j], &spec) != TCL_OK)
+	    return NULL;
+    }
+
+    return mapObj;
+}
+
+/*
+ * Ttk_StateTableLooup --
+ * 	Look up an index from a statically allocated state table.
+ */
+int Ttk_StateTableLookup(Ttk_StateTable *map, unsigned int state)
+{
+    while ((state & map->onBits) != map->onBits
+	    || (~state & map->offBits) != map->offBits)
+    {
+	++map;
+    }
+    return map->index;
+}
+
+/*EOF*/

data/pkgs/tile-0.8.2/generic/trace.c

@@ -0,0 +1,145 @@
+/* trace.c,v 1.4 2005/09/12 03:11:01 jenglish Exp
+ *
+ * Copyright 2003, Joe English
+ *
+ * Simplified interface to Tcl_TraceVariable.
+ *
+ * PROBLEM: Can't distinguish "variable does not exist" (which is OK) 
+ * from other errors (which are not).
+ */
+
+#include <tk.h>
+#include "tkTheme.h"
+#include "widget.h"
+
+struct TtkTraceHandle_
+{
+    Tcl_Interp		*interp;	/* Containing interpreter */
+    Tcl_Obj 		*varnameObj;	/* Name of variable being traced */
+    Ttk_TraceProc	callback;	/* Callback procedure */
+    void		*clientData;	/* Data to pass to callback */
+};
+
+/*
+ * Tcl_VarTraceProc for trace handles.
+ */
+static char *
+VarTraceProc(
+    ClientData clientData,	/* Widget record pointer */
+    Tcl_Interp *interp, 	/* Interpreter containing variable. */
+    CONST char *name1,		/* (unused) */
+    CONST char *name2,		/* (unused) */
+    int flags)			/* Information about what happened. */
+{
+    Ttk_TraceHandle *tracePtr = clientData;
+    const char *name, *value;
+    Tcl_Obj *valuePtr;
+
+    if (flags & TCL_INTERP_DESTROYED) {
+	return NULL;
+    }
+
+    name = Tcl_GetString(tracePtr->varnameObj);
+
+    /*
+     * If the variable is being unset, then re-establish the trace:
+     */
+    if (flags & TCL_TRACE_DESTROYED) {
+	Tcl_TraceVar(interp, name,
+		TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS,
+		VarTraceProc, clientData);
+	tracePtr->callback(tracePtr->clientData, NULL);
+	return NULL;
+    }
+
+    /*
+     * Call the callback:
+     */
+    valuePtr = Tcl_GetVar2Ex(interp, name, NULL, TCL_GLOBAL_ONLY);
+    value = valuePtr ?  Tcl_GetString(valuePtr) : NULL;
+    tracePtr->callback(tracePtr->clientData, value);
+
+    return NULL;
+}
+
+/* Ttk_TraceVariable(interp, varNameObj, callback, clientdata) --
+ * 	Attach a write trace to the specified variable,
+ * 	which will pass the variable's value to 'callback'
+ * 	whenever the variable is set.
+ *
+ * 	When the variable is unset, passes NULL to the callback
+ * 	and reattaches the trace.
+ */
+Ttk_TraceHandle *Ttk_TraceVariable(
+    Tcl_Interp *interp,
+    Tcl_Obj *varnameObj,
+    Ttk_TraceProc callback,
+    void *clientData)
+{
+    Ttk_TraceHandle *h = (Ttk_TraceHandle*)ckalloc(sizeof(*h));
+    int status;
+
+    h->interp = interp;
+    h->varnameObj = Tcl_DuplicateObj(varnameObj);
+    Tcl_IncrRefCount(h->varnameObj);
+    h->clientData = clientData;
+    h->callback = callback;
+
+    status = Tcl_TraceVar(interp, Tcl_GetString(varnameObj),
+	    TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS,
+	    VarTraceProc, (ClientData)h);
+
+    if (status != TCL_OK) {
+	Tcl_DecrRefCount(h->varnameObj);
+	ckfree((ClientData)h);
+	return NULL;
+    }
+
+    return h;
+}
+
+/*
+ * Ttk_UntraceVariable --
+ * 	Remove previously-registered trace and free the handle.
+ */
+void Ttk_UntraceVariable(Ttk_TraceHandle *h)
+{
+    if (h) {
+	Tcl_UntraceVar(h->interp, Tcl_GetString(h->varnameObj),
+		TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS,
+		VarTraceProc, (ClientData)h);
+	Tcl_DecrRefCount(h->varnameObj);
+	ckfree((ClientData)h);
+    }
+}
+
+/*
+ * Ttk_FireTrace --
+ * 	Executes a trace handle as if the variable has been written.
+ *
+ * 	Note: may reenter the interpreter.
+ */
+int Ttk_FireTrace(Ttk_TraceHandle *tracePtr)
+{
+    Tcl_Interp *interp = tracePtr->interp;
+    void *clientData = tracePtr->clientData;
+    const char *name = Tcl_GetString(tracePtr->varnameObj);
+    Ttk_TraceProc callback = tracePtr->callback;
+    Tcl_Obj *valuePtr;
+    const char *value;
+
+    /* Read the variable.
+     * Note that this can reenter the interpreter, and anything can happen --
+     * including the current trace handle being freed!
+     */
+    valuePtr = Tcl_GetVar2Ex(interp, name, NULL, TCL_GLOBAL_ONLY);
+    value = valuePtr ? Tcl_GetString(valuePtr) : NULL;
+
+    /* Call callback.
+     */
+    callback(clientData, value);
+
+    return TCL_OK;
+}
+
+/*EOF*/

data/pkgs/tile-0.8.2/generic/track.c

@@ -0,0 +1,174 @@
+/* track.c,v 1.9 2007/10/22 03:13:34 jenglish Exp
+ * Copyright (c) 2004, Joe English
+ *
+ * TtkTrackElementState() -- helper routine for widgets
+ * like scrollbars in which individual elements may
+ * be active or pressed instead of the widget as a whole.
+ *
+ * Usage:
+ * 	TtkTrackElementState(&recordPtr->core);
+ *
+ * Registers an event handler on the widget that tracks pointer
+ * events and updates the state of the element under the
+ * mouse cursor.
+ *
+ * The "active" element is the one under the mouse cursor,
+ * and is normally set to the ACTIVE state unless another element
+ * is currently being pressed.
+ *
+ * The active element becomes "pressed" on <ButtonPress> events,
+ * and remains "active" and "pressed" until the corresponding
+ * <ButtonRelease> event.
+ *
+ * TODO: Handle "chords" properly (e.g., <B1-ButtonPress-2>)
+ */
+
+#include <tk.h>
+#include "tkTheme.h"
+#include "widget.h"
+
+typedef struct 
+{
+    WidgetCore		*corePtr;	/* Widget to track */
+    Ttk_LayoutNode	*activeElement;	/* element under the mouse cursor */
+    Ttk_LayoutNode	*pressedElement; /* currently pressed element */
+} ElementStateTracker;
+
+/*
+ * ActivateElement(es, node) --
+ * 	Make 'node' the active element if non-NULL.
+ * 	Deactivates the currently active element if different.
+ *
+ * 	The active element has TTK_STATE_ACTIVE set _unless_
+ * 	another element is 'pressed'
+ */
+static void ActivateElement(ElementStateTracker *es, Ttk_LayoutNode *node)
+{
+    if (es->activeElement == node) {
+	/* No change */
+	return;
+    }
+
+    if (!es->pressedElement) {
+	if (es->activeElement) {
+	    /* Deactivate old element */
+	    Ttk_ChangeElementState(es->activeElement, 0,TTK_STATE_ACTIVE);
+	} 
+	if (node) {
+	    /* Activate new element */
+	    Ttk_ChangeElementState(node, TTK_STATE_ACTIVE,0);
+	}
+	TtkRedisplayWidget(es->corePtr);
+    }
+
+    es->activeElement = node;
+}
+
+/* ReleaseElement --
+ * 	Releases the currently pressed element, if any.
+ */
+static void ReleaseElement(ElementStateTracker *es)
+{
+    if (!es->pressedElement)
+	return;
+
+    Ttk_ChangeElementState(
+	es->pressedElement, 0,TTK_STATE_PRESSED|TTK_STATE_ACTIVE);
+    es->pressedElement = 0;
+
+    /* Reactivate element under the mouse cursor:
+     */
+    if (es->activeElement)
+	Ttk_ChangeElementState(es->activeElement, TTK_STATE_ACTIVE,0);
+
+    TtkRedisplayWidget(es->corePtr);
+}
+
+/* PressElement --
+ * 	Presses the specified element.
+ */
+static void PressElement(ElementStateTracker *es, Ttk_LayoutNode *node)
+{
+    if (es->pressedElement) {
+	ReleaseElement(es);
+    }
+
+    if (node) {
+	Ttk_ChangeElementState(
+	    node, TTK_STATE_PRESSED|TTK_STATE_ACTIVE, 0);
+    }
+
+    es->pressedElement = node;
+    TtkRedisplayWidget(es->corePtr);
+}
+
+/* ElementStateEventProc --
+ * 	Event handler for tracking element states.
+ */
+
+static const unsigned ElementStateMask =
+      ButtonPressMask 
+    | ButtonReleaseMask 
+    | PointerMotionMask 
+    | LeaveWindowMask 
+    | EnterWindowMask
+    | StructureNotifyMask
+    ;
+
+static void
+ElementStateEventProc(ClientData clientData, XEvent *ev)
+{
+    ElementStateTracker *es = (ElementStateTracker *)clientData;
+    Ttk_LayoutNode *node;
+
+    switch (ev->type)
+    {
+	case MotionNotify :
+	    node = Ttk_LayoutIdentify(
+		es->corePtr->layout,ev->xmotion.x,ev->xmotion.y);
+	    ActivateElement(es, node);
+	    break;
+	case LeaveNotify:
+	    ActivateElement(es, 0);
+	    if (ev->xcrossing.mode == NotifyGrab)
+		PressElement(es, 0);
+	    break;
+	case EnterNotify:
+	    node = Ttk_LayoutIdentify(
+		es->corePtr->layout,ev->xcrossing.x,ev->xcrossing.y);
+	    ActivateElement(es, node);
+	    break;
+	case ButtonPress:
+	    node = Ttk_LayoutIdentify(
+		es->corePtr->layout, ev->xbutton.x, ev->xbutton.y);
+	    if (node) 
+		PressElement(es, node);
+	    break;
+	case ButtonRelease:
+	    ReleaseElement(es);
+	    break;
+	case DestroyNotify:
+	    /* Unregister this event handler and free client data. 
+	     */
+	    Tk_DeleteEventHandler(es->corePtr->tkwin,
+		    ElementStateMask, ElementStateEventProc, es);
+	    ckfree(clientData);
+	    break;
+    }
+}
+
+/*
+ * TtkTrackElementState --
+ * 	Register an event handler to manage the 'pressed'
+ * 	and 'active' states of individual widget elements.
+ */
+
+void TtkTrackElementState(WidgetCore *corePtr)
+{
+    ElementStateTracker *es = (ElementStateTracker*)ckalloc(sizeof(*es));
+    es->corePtr = corePtr;
+    es->activeElement = es->pressedElement = 0;
+    Tk_CreateEventHandler(corePtr->tkwin,
+	    ElementStateMask,ElementStateEventProc,es);
+}
+