2004-01-06  Joe English  <jenglish@users.sourceforge.net>
	* generic/track.c: New utility, TrackElementState
	* generic/scrollbar.c, library/scrollbar.tcl:
	Updated TScrollbar to use TrackElementState; 
	[$scrollbar elementstate] widget method no longer needed.
	* Scrollbar finally displays "active" state properly!

2004-01-06  Pat Thoyts  <patthoyts@users.sourceforge.net>

	* generic/tkTheme.c:     Fix element lookup to look over multiple
	dot-separated names. eg: Z.x.y -> x.y -> y then lookup the same in
	the parent theme.
	
	* generic/scale.c:       Improved the scale implementation.

CLEANFILES	= *.$(OBJEXT) $(tile_LIB_FILE)

GENERIC_OBJECTS	= tkstate.$(OBJEXT) \
		  tile.$(OBJEXT) \
		  scrollbar.$(OBJEXT) \
		  layout.$(OBJEXT) \
		  widget.$(OBJEXT) \
		  track.$(OBJEXT) \
		  altTheme.$(OBJEXT) \
		  stepTheme.$(OBJEXT) \
		  tkElements.$(OBJEXT) \
		  tkTheme.$(OBJEXT) \

UNIX_OBJECTS	=
WIN_OBJECTS	= xpTheme.$(OBJEXT)

tile_OBJECTS 	= \
    tkstate.$(OBJEXT) \
    tile.$(OBJEXT) \
    scrollbar.$(OBJEXT) \
    scale.$(OBJEXT) \
    layout.$(OBJEXT) \
    widget.$(OBJEXT) \
    track.$(OBJEXT) \
    altTheme.$(OBJEXT) \
    tkElements.$(OBJEXT) \
    tkTheme.$(OBJEXT) \
    stepTheme.$(OBJEXT) \
    @EXTRA_OBJS@

WIN_OBJS	= xpTheme.$(OBJEXT)

	must be the sole children of their parent node, otherwise
	reqsize calculation is wrong.  (probable cause of problem: 
	INSIDE/BORDER flags lack a packing specification).

@@@ TTK_LayoutFindNode, [$sb identify], &c -- need a way to identify
    nodes by name instead of class.


VERY IMPORTANT: error-checking in AllocateResources(), DeallocateResources().
This is a sure-fire way to crash.

~~ Layout engine:
    + Reimplement; the current design is subtly but fatally flawed.
    + Change ElementSpec draw procedure to take a TTK_Box * instead
      of separate x, y, width, height arguments.

~~ General:
    + add fallback fallback "null" element 
    + Need per-engine cleanup procedures.
    + Rethink resource allocation (AllocateResource,DeallocateResources)
    + Provide for drawing by parent style engine. In the XP theme, if 
      themeing is disabled then we need to revert to win32 compatible
      drawing (eg: alt theme).
    + [style configure] should schedule a WorldChanged call
    + WorldChanged handler should reload all elements
    + Need: windows-native theme (use native (non-XP-theme) widgets)
    + Need: MacOSX-native theme (ditto).
    + Need to support both "native/default" L&F and highly-customized L&F
      (Ex: http://www.iit.demokritos.gr/~petasis/Tcl/PeculiarButtons.gif)


~~ Buttons, checkbuttons, radiobuttons:
    + rename 'compound' element to 'label', 'label' => 'text'
    + add -width resource to text element; negative -width => minimum.
    + [$checkbutton configure -variable foo] does not set state
    + [$label configure -textvariable foo] does not update -text
    + alt theme: focus ring should go around text (in check/radio buttons)
      (maybe we can get away with not doing this...)

~~ Scrollbars:
    + Need a way to specify per-element state, so arrows press, etc&
      (@@@ done; need a _different_ way)
      (@@@ found a different way, still doesn't work right)
      (@@@ 6 Jan 2004 Think this finally works now).
    + minimum width/height for thumb element.
      (Problem: this should really be determined by the theme,
      but the scrollbar widget itself needs to know this value).
      (Finally fixed, 4 Jan 2004)
    + classic theme: scrollbar arrows don't look quite right.
    + alt theme: scrollbar arrows don't look quite right.
    + scrollbar elements don't activate/prelight on hover.

/*
 * layout.c --
 *
 * Generic layout processing.
 *
 * Copyright (c) 2003 Joe English.  Freely redistributable.
 *
 * $Id: layout.c,v 1.11 2004/01/05 01:24:31 jenglish Exp $
 */

#include <string.h>
#include <tk.h>
#include "tkTheme.h"

#define MAX(a,b) (a > b ? a : b)

}

void TTK_ModifyElementState(TTK_LayoutNode *node, TTK_WidgetStateSpec *spec)
{
    node->state = TTK_ModifyWidgetState(node->state, spec);
}

void TTK_ChangeElementState(TTK_LayoutNode *node,unsigned set,unsigned clr)
{
    node->state = (node->state | set) & ~clr;
}

static TTK_Box makeBox(int x, int y, int w, int h)
{
    TTK_Box b;
    b.x = x; b.y = y; b.w = w; b.h = h;
    return b;
}

/* $Id: scrollbar.c,v 1.12 2004/01/06 01:26:00 jenglish Exp $
 *
 * Copyright (c) 2003, Joe English
 *
 * Scrollbar widget implementation.
 *
 */

static int 
ScrollbarInitialize(Tcl_Interp *interp, void *recordPtr)
{
    Scrollbar *sb = recordPtr;
    sb->scrollbar.first = 0.0;
    sb->scrollbar.last = 1.0;

    TrackElementState(&sb->core);

    return TCL_OK;
}

static void 
ScrollbarCleanup(void *recordPtr)
{
    /* no-op for now */

	    fraction = (double)(x - b.x) / (double)(b.w - minSize);
    }

    Tcl_SetObjResult(interp, Tcl_NewDoubleObj(fraction));
    return TCL_OK;
}
















































static WidgetCommandSpec ScrollbarCommands[] =
{
    { "configure",	WidgetConfigureCommand },
    { "cget",		WidgetCgetCommand },
    { "delta",    	ScrollbarDeltaCommand },

    { "fraction",    	ScrollbarFractionCommand },
    { "get",    	ScrollbarGetCommand },
    { "identify",	ScrollbarIdentifyCommand },
    { "instate",	WidgetInstateCommand },
    { "set",  		ScrollbarSetCommand },
    { "state",  	WidgetStateCommand },
    { 0,0 }

/*
 * tkTheme.h --
 *      Declarations for Tk style engine.
 *
 * Copyright (c) 2003 Joe English.  Freely redistributable.
 *
 * $Id: tkTheme.h,v 1.15 2004/01/05 21:57:04 patthoyts Exp $
 */

#ifndef TKTHEME_H
#define TKTHEME_H 1

#ifndef WIN32
#define NO_PRIVATE_HEADERS 1

extern const char *TTK_LayoutNodeName(TTK_LayoutNode *);
extern TTK_Box TTK_LayoutNodeParcel(TTK_LayoutNode *);
extern TTK_Element TTK_LayoutNodeElement(TTK_LayoutNode *);

extern void TTK_LayoutNodeSetParcel(TTK_LayoutNode *node, TTK_Box parcel);
extern void TTK_ModifyElementState(TTK_LayoutNode *, TTK_WidgetStateSpec *);
extern void TTK_ChangeElementState(TTK_LayoutNode *,unsigned set,unsigned clr);

extern TTK_Style TTK_RegisterLayout(
    TTK_Theme theme, const char *className, TTK_LayoutSpec layoutSpec);

extern TTK_LayoutSpec TTK_FindLayout(TTK_Theme theme, const char *className);

extern TTK_Layout TTK_CreateLayout(

/* $Id$
 * Copyright (c) 2004, Joe English
 *
 * TrackElementState() -- helper routine for widgets
 * like scrollbars in which individual elements may
 * be active or pressed instead of the widget as a whole.
 *
 * Usage:
 * 	TrackElementState(&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;

/* ReleaseElement --
 * 	Releases the currently pressed element, if any.
 */
void ReleaseElement(ElementStateTracker *es)
{
    if (!es->pressedElement)
	return;

    TTK_ChangeElementState(es->pressedElement, 0,TK_WIDGET_STATE_PRESSED);
    es->pressedElement = 0;

    /* Reactivate element under the mouse cursor:
     */
    if (es->activeElement)
	TTK_ChangeElementState(es->activeElement, TK_WIDGET_STATE_ACTIVE, 0);

    WidgetChanged(es->corePtr, REDISPLAY_REQUIRED);
}

/* PressElement --
 * 	Presses the specified element.
 */
static void PressElement(ElementStateTracker *es, TTK_LayoutNode *node)
{
    if (es->pressedElement)
	ReleaseElement(es);

    if (node)
	TTK_ChangeElementState(node, TK_WIDGET_STATE_PRESSED, 0);

    es->pressedElement = node;
    WidgetChanged(es->corePtr, REDISPLAY_REQUIRED);
}

/*
 * ActivateElement(es, node) --
 * 	Make 'node' the active element if non-NULL.
 * 	Deactivates the currently active element if different.
 *
 * 	The active element has TTK_WIDGET_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)
	    TTK_ChangeElementState(es->activeElement, 0,TK_WIDGET_STATE_ACTIVE);
	if (node)
	    TTK_ChangeElementState(node, TK_WIDGET_STATE_ACTIVE,0);
	WidgetChanged(es->corePtr, REDISPLAY_REQUIRED);
    }

    es->activeElement = node;
}

/* 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);
	    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)es);
	    break;
    }
}

/*
 * TrackElementState --
 * 	Register an event handler to manage the 'pressed'
 * 	and 'active' states of individual widget elements.
 */

void TrackElementState(WidgetCore *corePtr)
{
    ElementStateTracker *es = (ElementStateTracker*)ckalloc(sizeof(*es));
    es->corePtr = corePtr;
    es->activeElement = es->pressedElement = 0;
    Tk_CreateEventHandler(corePtr->tkwin,
	    ElementStateMask,ElementStateEventProc,es);
}

/* $Id: widget.h,v 1.11 2004/01/05 21:57:04 patthoyts Exp $
 * Copyright (c) 2003, Joe English
 *
 * Helper routines for widget implementations.
 *
 * Require: tkTheme.h, layout.h
 */

extern void WidgetChangeState(WidgetCore *,
	unsigned int setBits, unsigned int clearBits);

extern void WidgetChanged(WidgetCore *, unsigned flags);

extern void WidgetSetLayout(Tcl_Interp *,WidgetCore *, const char *layoutName);

extern void TrackElementState(WidgetCore *);

/*
 * Useful widget base classes:
 */
extern Tk_OptionSpec CoreOptionSpecs[];

typedef struct 	/* Common resources for nearly every widget. */

#
# $Id: scrollbar.tcl,v 1.9 2004/01/06 01:26:00 jenglish Exp $
#
# Bindings for TScrollbar widget
#

namespace eval Tile { 
    namespace eval Scrollbar { 
    	variable State

}

proc Scrollbar::Press {w x y} {
    variable State

    set State(xPress) $x
    set State(yPress) $y


    switch -glob -- [$w identify $x $y] {
    	*uparrow -
	*leftarrow {
	    Tile::Repeatedly Scroll $w -1 unit
	}
	*downarrow -

    set xDelta [expr {$x - $State(xPress)}]
    set yDelta [expr {$y - $State(yPress)}]
    Moveto $w [expr {$State(first) + [$w delta $xDelta $yDelta]}]
}

proc Scrollbar::Release {w x y} {
    variable State








    unset -nocomplain State(xPress) State(yPress) State(first)
    Tile::CancelRepeat
}

# Scrollbar::Jump -- ButtonPress-2 binding for scrollbars.
# 	Behaves exactly like Scrollbar::Press, except that
#	clicking in the trough jumps to the the selected position.
#
proc Scrollbar::Jump {w x y} {
    variable State

    switch -glob -- [$w identify $x $y] {
	*hthumb -
	*vthumb -
	*trough {
	    set State(first) [$w fraction $x $y]
	    Moveto $w $State(first)
	    set State(xPress) $x
	    set State(yPress) $y

	}
	default {
	    Press $w $x $y
	}
    }
}

}; # namespace eval Tile

#
# $Id: tile.tcl,v 1.24 2004/01/06 16:43:23 patthoyts Exp $
#
# Widget bindings and default appearance for Tile widget set.
#

if {![info exists tile_library]} {
    set tile_library [file dirname [info script]]
}

	{}		$defaultBG
    "
    style elementconfigure "alt" background -background "
	disabled	$defaultBG
	active 		$activeBG
	{}		$defaultBG
    "
    foreach class {
    	TRadiobutton TCheckbutton
	TScrollbarHorizontal TScrollbarVertical
    } {
	foreach theme {"" "alt"} {
	    style configure $theme $class -background "
		disabled	$defaultBG
		active 		$activeBG
		{}		$defaultBG
	    "
	}
    }

    style configure "" TButton -relief {
	{pressed !disabled} 	sunken
	{active !disabled} 	raised
    }

        "
    }

    foreach theme {{} alt step} {
	style configure $theme TScrollbarHorizontal -relief {
	    pressed sunken
	    {} raised 
	} \
	-troughcolor [list {} $troughColor]  \

	style configure $theme TScrollbarVertical -relief {
	    pressed sunken
	    {} raised 
	} -troughcolor [list {} $troughColor]
	# @@@ Sort out scrollbar "background" vs. "trough"
	style elementconfigure $theme Scrollbar.background \
	    -background [list {} $troughColor]

# Copyright (c) 1995-1996 Sun Microsystems, Inc.
# Copyright (c) 1998-2000 Ajuba Solutions.
# Copyright (c) 2001 ActiveState Corporation.
# Copyright (c) 2001-2002 David Gravereaux.
# Copyright (c) 2003 Pat Thoyts
#
#-------------------------------------------------------------------------
# RCS: @(#)$Id: makefile.vc,v 1.7 2004/01/05 21:57:04 patthoyts Exp $
#-------------------------------------------------------------------------

!if "$(MSVCDIR)" == ""
MSG = ^
You will need to run vcvars32.bat from Developer Studio, first, to setup^
the environment.  Jump to this line to read the new instructions.
!error $(MSG)

DLLOBJS = \
	$(TMP_DIR)\tile.obj \
	$(TMP_DIR)\tkElements.obj \
	$(TMP_DIR)\layout.obj \
	$(TMP_DIR)\scrollbar.obj \
	$(TMP_DIR)\scale.obj \
	$(TMP_DIR)\widget.obj \
	$(TMP_DIR)\track.obj \
	$(TMP_DIR)\tkstate.obj \
	$(TMP_DIR)\altTheme.obj \
	$(TMP_DIR)\tkTheme.obj \
	$(TMP_DIR)\stepTheme.obj \
	$(TMP_DIR)\xpTheme.obj

#-------------------------------------------------------------------------