Subversion Repositories or1k_old

/*

 * tkMacScrollbar.c --

 *

 *      This file implements the Macintosh specific portion of the scrollbar

 *      widget.  The Macintosh scrollbar may also draw a windows grow

 *      region under certain cases.

 *

 * Copyright (c) 1996 by Sun Microsystems, Inc.

 *

 * See the file "license.terms" for information on usage and redistribution

 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.

 *

 * RCS: @(#) $Id: tkMacScrlbr.c,v 1.1.1.1 2002-01-16 10:25:57 markom Exp $

 */

#include "tkScrollbar.h"

#include "tkMacInt.h"

#include <Controls.h>

/*

 * The following definitions should really be in MacOS

 * header files.  They are included here as this is the only

 * file that needs the declarations.

 */

typedef pascal void (*ThumbActionFunc)(void);

#if GENERATINGCFM

typedef UniversalProcPtr ThumbActionUPP;

#else

typedef ThumbActionFunc ThumbActionUPP;

#endif

enum {

        uppThumbActionProcInfo = kPascalStackBased

};

#if GENERATINGCFM

#define NewThumbActionProc(userRoutine)         \

                (ThumbActionUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppThumbActionProcInfo, GetCurrentArchitecture())

#else

#define NewThumbActionProc(userRoutine)         \

                ((ThumbActionUPP) (userRoutine))

#endif

/*

 * Minimum slider length, in pixels (designed to make sure that the slider

 * is always easy to grab with the mouse).

 */

#define MIN_SLIDER_LENGTH       5

/*

 * Declaration of Windows specific scrollbar structure.

 */

typedef struct MacScrollbar {

    TkScrollbar info;           /* Generic scrollbar info. */

    ControlRef sbHandle;        /* Handle to the Scrollbar control struct. */

    int macFlags;               /* Various flags; see below. */

} MacScrollbar;

/*

 * Flag bits for scrollbars on the Mac:

 *

 * ALREADY_DEAD:                Non-zero means this scrollbar has been

 *                              destroyed, but has not been cleaned up.

 * IN_MODAL_LOOP:               Non-zero means this scrollbar is in the middle

 *                              of a modal loop.

 * ACTIVE:                      Non-zero means this window is currently

 *                              active (in the foreground).

 * FLUSH_TOP:                   Flush with top of Mac window.

 * FLUSH_BOTTOM:                Flush with bottom of Mac window.

 * FLUSH_RIGHT:                 Flush with right of Mac window.

 * FLUSH_LEFT:                  Flush with left of Mac window.

 * SCROLLBAR_GROW:              Non-zero means this window draws the grow

 *                              region for the toplevel window.

 * AUTO_ADJUST:                 Non-zero means we automatically adjust

 *                              the size of the widget to align correctly

 *                              along a Mac window.

 * DRAW_GROW:                   Non-zero means we draw the grow region.

 */

#define ALREADY_DEAD            1

#define IN_MODAL_LOOP           2

#define ACTIVE                  4

#define FLUSH_TOP               8

#define FLUSH_BOTTOM            16

#define FLUSH_RIGHT             32

#define FLUSH_LEFT              64

#define SCROLLBAR_GROW          128

#define AUTO_ADJUST             256

#define DRAW_GROW               512

/*

 * Globals uses locally in this file.

 */

static ControlActionUPP scrollActionProc = NULL; /* Pointer to func. */

static ThumbActionUPP thumbActionProc = NULL;    /* Pointer to func. */

static TkScrollbar *activeScrollPtr = NULL;        /* Non-null when in thumb */

                                                 /* proc. */

/*

 * Forward declarations for procedures defined later in this file:

 */

static pascal void      ScrollbarActionProc _ANSI_ARGS_((ControlRef theControl,

                            ControlPartCode partCode));

static int              ScrollbarBindProc _ANSI_ARGS_((ClientData clientData,

                            Tcl_Interp *interp, XEvent *eventPtr,

                            Tk_Window tkwin, KeySym keySym));

static void             ScrollbarEventProc _ANSI_ARGS_((

                            ClientData clientData, XEvent *eventPtr));

static pascal void      ThumbActionProc _ANSI_ARGS_((void));

static void             UpdateControlValues _ANSI_ARGS_((MacScrollbar *macScrollPtr));

/*

 * The class procedure table for the scrollbar widget.

 */

TkClassProcs tkpScrollbarProcs = {

    NULL,                       /* createProc. */

    NULL,                       /* geometryProc. */

    NULL                        /* modalProc */

};

/*

 *----------------------------------------------------------------------

 *

 * TkpCreateScrollbar --

 *

 *      Allocate a new TkScrollbar structure.

 *

 * Results:

 *      Returns a newly allocated TkScrollbar structure.

 *

 * Side effects:

 *      None.

 *

 *----------------------------------------------------------------------

 */

TkScrollbar *

TkpCreateScrollbar(

    Tk_Window tkwin)    /* New Tk Window. */

{

    MacScrollbar * macScrollPtr;

    TkWindow *winPtr = (TkWindow *)tkwin;

    if (scrollActionProc == NULL) {

        scrollActionProc = NewControlActionProc(ScrollbarActionProc);

        thumbActionProc = NewThumbActionProc(ThumbActionProc);

    }

    macScrollPtr = (MacScrollbar *) ckalloc(sizeof(MacScrollbar));

    macScrollPtr->sbHandle = NULL;

    macScrollPtr->macFlags = 0;

    Tk_CreateEventHandler(tkwin, ActivateMask|ExposureMask|

            StructureNotifyMask|FocusChangeMask,

            ScrollbarEventProc, (ClientData) macScrollPtr);

    if (!Tcl_GetAssocData(winPtr->mainPtr->interp, "TkScrollbar", NULL)) {

        Tcl_SetAssocData(winPtr->mainPtr->interp, "TkScrollbar", NULL,

                (ClientData)1);

        TkCreateBindingProcedure(winPtr->mainPtr->interp,

                winPtr->mainPtr->bindingTable,

                (ClientData)Tk_GetUid("Scrollbar"), "<ButtonPress>",

                ScrollbarBindProc, NULL, NULL);

    }

    return (TkScrollbar *) macScrollPtr;

}

/*

 *--------------------------------------------------------------

 *

 * TkpDisplayScrollbar --

 *

 *      This procedure redraws the contents of a scrollbar window.

 *      It is invoked as a do-when-idle handler, so it only runs

 *      when there's nothing else for the application to do.

 *

 * Results:

 *      None.

 *

 * Side effects:

 *      Information appears on the screen.

 *

 *--------------------------------------------------------------

 */

void

TkpDisplayScrollbar(

    ClientData clientData)      /* Information about window. */

{

    register TkScrollbar *scrollPtr = (TkScrollbar *) clientData;

    register MacScrollbar *macScrollPtr = (MacScrollbar *) clientData;

    register Tk_Window tkwin = scrollPtr->tkwin;

    MacDrawable *macDraw;

    CGrafPtr saveWorld;

    GDHandle saveDevice;

    GWorldPtr destPort;

    WindowRef windowRef;

    if ((scrollPtr->tkwin == NULL) || !Tk_IsMapped(tkwin)) {

        goto done;

    }

    /*

     * Draw the focus or any 3D relief we may have.

     */

    if (scrollPtr->highlightWidth != 0) {

        GC gc;

        if (scrollPtr->flags & GOT_FOCUS) {

            gc = Tk_GCForColor(scrollPtr->highlightColorPtr,

                    Tk_WindowId(tkwin));

        } else {

            gc = Tk_GCForColor(scrollPtr->highlightBgColorPtr,

                    Tk_WindowId(tkwin));

        }

        Tk_DrawFocusHighlight(tkwin, gc, scrollPtr->highlightWidth,

                Tk_WindowId(tkwin));

    }

    Tk_Draw3DRectangle(tkwin, Tk_WindowId(tkwin), scrollPtr->bgBorder,

            scrollPtr->highlightWidth, scrollPtr->highlightWidth,

            Tk_Width(tkwin) - 2*scrollPtr->highlightWidth,

            Tk_Height(tkwin) - 2*scrollPtr->highlightWidth,

            scrollPtr->borderWidth, scrollPtr->relief);

    /*

     * Set up port for drawing Macintosh control.

     */

    macDraw = (MacDrawable *) Tk_WindowId(tkwin);

    destPort = TkMacGetDrawablePort(Tk_WindowId(tkwin));

    GetGWorld(&saveWorld, &saveDevice);

    SetGWorld(destPort, NULL);

    TkMacSetUpClippingRgn(Tk_WindowId(tkwin));

    if (macScrollPtr->sbHandle == NULL) {

        Rect r;

        r.left = r.top = 0;

        r.right = r.bottom = 1;

        macScrollPtr->sbHandle = NewControl((WindowRef) destPort, &r, "\p",

                false, (short) 500, 0, 1000,

                scrollBarProc, (SInt32) scrollPtr);

        /*

         * If we are foremost than make us active.

         */

        if ((WindowPtr) destPort == FrontWindow()) {

            macScrollPtr->macFlags |= ACTIVE;

        }

    }

    /*

     * Update the control values before we draw.

     */

    windowRef  = (**macScrollPtr->sbHandle).contrlOwner;

    UpdateControlValues(macScrollPtr);

    if (macScrollPtr->macFlags & ACTIVE) {

        Draw1Control(macScrollPtr->sbHandle);

        if (macScrollPtr->macFlags & DRAW_GROW) {

            DrawGrowIcon(windowRef);

        }

    } else {

        (**macScrollPtr->sbHandle).contrlHilite = 255;

        Draw1Control(macScrollPtr->sbHandle);

        if (macScrollPtr->macFlags & DRAW_GROW) {

            DrawGrowIcon(windowRef);

            Tk_Fill3DRectangle(tkwin, Tk_WindowId(tkwin), scrollPtr->bgBorder,

                Tk_Width(tkwin) - 13, Tk_Height(tkwin) - 13,

                Tk_Width(tkwin), Tk_Height(tkwin),

                0, TK_RELIEF_FLAT);

        }

    }

    SetGWorld(saveWorld, saveDevice);

    done:

    scrollPtr->flags &= ~REDRAW_PENDING;

}

/*

 *----------------------------------------------------------------------

 *

 * TkpConfigureScrollbar --

 *

 *      This procedure is called after the generic code has finished

 *      processing configuration options, in order to configure

 *      platform specific options.

 *

 * Results:

 *      None.

 *

 * Side effects:

 *      None.

 *

 *----------------------------------------------------------------------

 */

void

TkpConfigureScrollbar(scrollPtr)

    register TkScrollbar *scrollPtr;    /* Information about widget;  may or

                                         * may not already have values for

                                         * some fields. */

{

}

/*

 *----------------------------------------------------------------------

 *

 * TkpComputeScrollbarGeometry --

 *

 *      After changes in a scrollbar's size or configuration, this

 *      procedure recomputes various geometry information used in

 *      displaying the scrollbar.

 *

 * Results:

 *      None.

 *

 * Side effects:

 *      The scrollbar will be displayed differently.

 *

 *----------------------------------------------------------------------

 */

void

TkpComputeScrollbarGeometry(

    register TkScrollbar *scrollPtr)    /* Scrollbar whose geometry may

                                         * have changed. */

{

    MacScrollbar *macScrollPtr = (MacScrollbar *) scrollPtr;

    int width, fieldLength, adjust = 0;

    if (scrollPtr->highlightWidth < 0) {

        scrollPtr->highlightWidth = 0;

    }

    scrollPtr->inset = scrollPtr->highlightWidth + scrollPtr->borderWidth;

    width = (scrollPtr->vertical) ? Tk_Width(scrollPtr->tkwin)

            : Tk_Height(scrollPtr->tkwin);

    scrollPtr->arrowLength = width - 2*scrollPtr->inset + 1;

    fieldLength = (scrollPtr->vertical ? Tk_Height(scrollPtr->tkwin)

            : Tk_Width(scrollPtr->tkwin))

            - 2*(scrollPtr->arrowLength + scrollPtr->inset);

    if (fieldLength < 0) {

        fieldLength = 0;

    }

    scrollPtr->sliderFirst = fieldLength*scrollPtr->firstFraction;

    scrollPtr->sliderLast = fieldLength*scrollPtr->lastFraction;

    /*

     * Adjust the slider so that some piece of it is always

     * displayed in the scrollbar and so that it has at least

     * a minimal width (so it can be grabbed with the mouse).

     */

    if (scrollPtr->sliderFirst > (fieldLength - 2*scrollPtr->borderWidth)) {

        scrollPtr->sliderFirst = fieldLength - 2*scrollPtr->borderWidth;

    }

    if (scrollPtr->sliderFirst < 0) {

        scrollPtr->sliderFirst = 0;

    }

    if (scrollPtr->sliderLast < (scrollPtr->sliderFirst

            + MIN_SLIDER_LENGTH)) {

        scrollPtr->sliderLast = scrollPtr->sliderFirst + MIN_SLIDER_LENGTH;

    }

    if (scrollPtr->sliderLast > fieldLength) {

        scrollPtr->sliderLast = fieldLength;

    }

    scrollPtr->sliderFirst += scrollPtr->arrowLength + scrollPtr->inset;

    scrollPtr->sliderLast += scrollPtr->arrowLength + scrollPtr->inset;

    /*

     * Register the desired geometry for the window (leave enough space

     * for the two arrows plus a minimum-size slider, plus border around

     * the whole window, if any).  Then arrange for the window to be

     * redisplayed.

     */

    if (scrollPtr->vertical) {

        if ((macScrollPtr->macFlags & AUTO_ADJUST) &&

                (macScrollPtr->macFlags & (FLUSH_RIGHT|FLUSH_LEFT))) {

            adjust--;

        }

        Tk_GeometryRequest(scrollPtr->tkwin,

                scrollPtr->width + 2*scrollPtr->inset + adjust,

                2*(scrollPtr->arrowLength + scrollPtr->borderWidth

                + scrollPtr->inset));

    } else {

        if ((macScrollPtr->macFlags & AUTO_ADJUST) &&

                (macScrollPtr->macFlags & (FLUSH_TOP|FLUSH_BOTTOM))) {

            adjust--;

        }

        Tk_GeometryRequest(scrollPtr->tkwin,

                2*(scrollPtr->arrowLength + scrollPtr->borderWidth

                + scrollPtr->inset), scrollPtr->width + 2*scrollPtr->inset + adjust);

    }

    Tk_SetInternalBorder(scrollPtr->tkwin, scrollPtr->inset);

}

/*

 *----------------------------------------------------------------------

 *

 * TkpDestroyScrollbar --

 *

 *      Free data structures associated with the scrollbar control.

 *

 * Results:

 *      None.

 *

 * Side effects:

 *      None.

 *

 *----------------------------------------------------------------------

 */

void

TkpDestroyScrollbar(

    TkScrollbar *scrollPtr)     /* Scrollbar to destroy. */

{

    MacScrollbar *macScrollPtr = (MacScrollbar *)scrollPtr;

    if (macScrollPtr->sbHandle != NULL) {

        if (!(macScrollPtr->macFlags & IN_MODAL_LOOP)) {

            DisposeControl(macScrollPtr->sbHandle);

            macScrollPtr->sbHandle = NULL;

        }

    }

    macScrollPtr->macFlags |= ALREADY_DEAD;

}

/*

 *--------------------------------------------------------------

 *

 * TkpScrollbarPosition --

 *

 *      Determine the scrollbar element corresponding to a

 *      given position.

 *

 * Results:

 *      One of TOP_ARROW, TOP_GAP, etc., indicating which element

 *      of the scrollbar covers the position given by (x, y).  If

 *      (x,y) is outside the scrollbar entirely, then OUTSIDE is

 *      returned.

 *

 * Side effects:

 *      None.

 *

 *--------------------------------------------------------------

 */

int

TkpScrollbarPosition(

    TkScrollbar *scrollPtr,     /* Scrollbar widget record. */

    int x, int y)               /* Coordinates within scrollPtr's

                                 * window. */

{

    MacScrollbar *macScrollPtr = (MacScrollbar *) scrollPtr;

    GWorldPtr destPort;

    int length, width, tmp, inactive = false;

    ControlPartCode part;

    Point where;

    Rect bounds;

    if (scrollPtr->vertical) {

        length = Tk_Height(scrollPtr->tkwin);

        width = Tk_Width(scrollPtr->tkwin);

    } else {

        tmp = x;

        x = y;

        y = tmp;

        length = Tk_Width(scrollPtr->tkwin);

        width = Tk_Height(scrollPtr->tkwin);

    }

    if ((x < scrollPtr->inset) || (x >= (width - scrollPtr->inset))

            || (y < scrollPtr->inset) || (y >= (length - scrollPtr->inset))) {

        return OUTSIDE;

    }

    /*

     * All of the calculations in this procedure mirror those in

     * DisplayScrollbar.  Be sure to keep the two consistent.  On the

     * Macintosh we use the OS call TestControl to do this mapping.

     * For TestControl to work, the scrollbar must be active and must

     * be in the current port.

     */

    destPort = TkMacGetDrawablePort(Tk_WindowId(scrollPtr->tkwin));

    SetGWorld(destPort, NULL);

    UpdateControlValues(macScrollPtr);

    if ((**macScrollPtr->sbHandle).contrlHilite == 255) {

        inactive = true;

        (**macScrollPtr->sbHandle).contrlHilite = 0;

    }

    TkMacWinBounds((TkWindow *) scrollPtr->tkwin, &bounds);

    where.h = x + bounds.left;

    where.v = y + bounds.top;

    part = TestControl(((MacScrollbar *) scrollPtr)->sbHandle, where);

    if (inactive) {

        (**macScrollPtr->sbHandle).contrlHilite = 255;

    }

    switch (part) {

        case inUpButton:

            return TOP_ARROW;

        case inPageUp:

            return TOP_GAP;

        case inThumb:

            return SLIDER;

        case inPageDown:

            return BOTTOM_GAP;

        case inDownButton:

            return BOTTOM_ARROW;

        default:

            return OUTSIDE;

    }

}

/*

 *--------------------------------------------------------------

 *

 * ThumbActionProc --

 *

 *      Callback procedure used by the Macintosh toolbox call

 *      TrackControl.  This call is used to track the thumb of

 *      the scrollbar.  Unlike the ScrollbarActionProc function

 *      this function is called once and basically takes over

 *      tracking the scrollbar from the control.  This is done

 *      to avoid conflicts with what the control plans to draw.

 *

 * Results:

 *      None.

 *

 * Side effects:

 *      May change the display.

 *

 *--------------------------------------------------------------

 */

static pascal void

ThumbActionProc()

{

    register TkScrollbar *scrollPtr = activeScrollPtr;

    register MacScrollbar *macScrollPtr = (MacScrollbar *) activeScrollPtr;

    Tcl_DString cmdString;

    Rect nullRect = {0,0,0,0};

    int origValue, trackBarPin;

    double thumbWidth, newFirstFraction, trackBarSize;

    char vauleString[40];

    Point currentPoint = { 0, 0 };

    Point lastPoint = { 0, 0 };

    Rect trackRect;

    Tcl_Interp *interp;

    if (scrollPtr == NULL) {

        return;

    }

    Tcl_DStringInit(&cmdString);

    /*

     * First compute values that will remain constant during the tracking

     * of the thumb.  The variable trackBarSize is the length of the scrollbar

     * minus the 2 arrows and half the width of the thumb on both sides

     * (3 * arrowLength).  The variable trackBarPin is the lower starting point

     * of the drag region.

     *

     * Note: the arrowLength is equal to the thumb width of a Mac scrollbar.

     */

    origValue = GetControlValue(macScrollPtr->sbHandle);

    trackRect = (**macScrollPtr->sbHandle).contrlRect;

    if (scrollPtr->vertical == true) {

        trackBarSize = (double) (trackRect.bottom - trackRect.top

                - (scrollPtr->arrowLength * 3));

        trackBarPin = trackRect.top + scrollPtr->arrowLength

            + (scrollPtr->arrowLength / 2);

        InsetRect(&trackRect, -25, -113);

    } else {

        trackBarSize = (double) (trackRect.right - trackRect.left

                - (scrollPtr->arrowLength * 3));

        trackBarPin = trackRect.left + scrollPtr->arrowLength

            + (scrollPtr->arrowLength / 2);

        InsetRect(&trackRect, -113, -25);

    }

    /*

     * Track the mouse while the button is held down.  If the mouse is moved,

     * we calculate the value that should be passed to the "command" part of

     * the scrollbar.

     */

    while (StillDown()) {

        GetMouse(&currentPoint);

        if (EqualPt(currentPoint, lastPoint)) {

            continue;

        }

        lastPoint = currentPoint;

        /*

         * Calculating this value is a little tricky.  We need to calculate a

         * value for where the thumb would be in a Motif widget (variable

         * thumb).  This value is what the "command" expects and is what will

         * be resent to the scrollbar to update its value.

         */

        thumbWidth = scrollPtr->lastFraction - scrollPtr->firstFraction;

        if (PtInRect(currentPoint, &trackRect)) {

            if (scrollPtr->vertical == true) {

                newFirstFraction =  (1.0 - thumbWidth) *

                    ((double) (currentPoint.v - trackBarPin) / trackBarSize);

            } else {

                newFirstFraction =  (1.0 - thumbWidth) *

                    ((double) (currentPoint.h - trackBarPin) / trackBarSize);

            }

        } else {

            newFirstFraction = ((double) origValue / 1000.0)

                * (1.0 - thumbWidth);

        }

        sprintf(vauleString, "%g", newFirstFraction);

        Tcl_DStringSetLength(&cmdString, 0);

        Tcl_DStringAppend(&cmdString, scrollPtr->command,

                scrollPtr->commandSize);

        Tcl_DStringAppendElement(&cmdString, "moveto");

        Tcl_DStringAppendElement(&cmdString, vauleString);

        interp = scrollPtr->interp;

        Tcl_Preserve((ClientData) interp);

        Tcl_GlobalEval(interp, cmdString.string);

        Tcl_Release((ClientData) interp);

        Tcl_DStringSetLength(&cmdString, 0);

        Tcl_DStringAppend(&cmdString, "update idletasks",

                strlen("update idletasks"));

        Tcl_Preserve((ClientData) interp);

        Tcl_GlobalEval(interp, cmdString.string);

        Tcl_Release((ClientData) interp);

    }

    /*

     * This next bit of code is a bit of a hack - but needed.  The problem is

     * that the control wants to draw the drag outline if the control value

     * changes during the drag (which it does).  What we do here is change the

     * clip region to hide this drawing from the user.

     */

    ClipRect(&nullRect);

    Tcl_DStringFree(&cmdString);

    return;

}

/*

 *--------------------------------------------------------------

 *

 * ScrollbarActionProc --

 *

 *      Callback procedure used by the Macintosh toolbox call

 *      TrackControl.  This call will update the display while

 *      the scrollbar is being manipulated by the user.

 *

 * Results:

 *      None.

 *

 * Side effects:

 *      May change the display.

 *

 *--------------------------------------------------------------

 */

static pascal void

ScrollbarActionProc(

    ControlRef theControl,      /* Handle to scrollbat control */

    ControlPartCode partCode)   /* Part of scrollbar that was "hit" */

{

    register TkScrollbar *scrollPtr = (TkScrollbar *) GetCRefCon(theControl);

    Tcl_DString cmdString;

    Tcl_DStringInit(&cmdString);

    Tcl_DStringAppend(&cmdString, scrollPtr->command,

            scrollPtr->commandSize);

    if (partCode == inUpButton || partCode == inDownButton) {

        Tcl_DStringAppendElement(&cmdString, "scroll");

        Tcl_DStringAppendElement(&cmdString,

                (partCode == inUpButton ) ? "-1" : "1");

        Tcl_DStringAppendElement(&cmdString, "unit");

    } else if (partCode == inPageUp || partCode == inPageDown) {

        Tcl_DStringAppendElement(&cmdString, "scroll");

        Tcl_DStringAppendElement(&cmdString,

                (partCode == inPageUp ) ? "-1" : "1");

        Tcl_DStringAppendElement(&cmdString, "page");

    }

    Tcl_Preserve((ClientData) scrollPtr->interp);

    Tcl_DStringAppend(&cmdString, "; update idletasks",

        strlen("; update idletasks"));

    Tcl_GlobalEval(scrollPtr->interp, cmdString.string);

    Tcl_Release((ClientData) scrollPtr->interp);

    Tcl_DStringFree(&cmdString);

}

/*

 *--------------------------------------------------------------

 *

 * ScrollbarBindProc --

 *

 *      This procedure is invoked when the default <ButtonPress>

 *      binding on the Scrollbar bind tag fires.