Subversion Repositories or1k

/*

 * tkSquare.c --

 *

 *      This module implements "square" widgets.  A "square" is

 *      a widget that displays a single square that can be moved

 *      around and resized.  This file is intended as an example

 *      of how to build a widget;  it isn't included in the

 *      normal wish, but it is included in "tktest".

 *

 * Copyright (c) 1991-1994 The Regents of the University of California.

 * Copyright (c) 1994-1997 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: tkSquare.c,v 1.1.1.1 2002-01-16 10:25:52 markom Exp $

 */

#include "tkPort.h"

#include "tk.h"

/*

 * A data structure of the following type is kept for each square

 * widget managed by this file:

 */

typedef struct {

    Tk_Window tkwin;            /* Window that embodies the square.  NULL

                                 * means window has been deleted but

                                 * widget record hasn't been cleaned up yet. */

    Display *display;           /* X's token for the window's display. */

    Tcl_Interp *interp;         /* Interpreter associated with widget. */

    Tcl_Command widgetCmd;      /* Token for square's widget command. */

    int x, y;                   /* Position of square's upper-left corner

                                 * within widget. */

    int size;                   /* Width and height of square. */

    /*

     * Information used when displaying widget:

     */

    int borderWidth;            /* Width of 3-D border around whole widget. */

    Tk_3DBorder bgBorder;       /* Used for drawing background. */

    Tk_3DBorder fgBorder;       /* For drawing square. */

    int relief;                 /* Indicates whether window as a whole is

                                 * raised, sunken, or flat. */

    GC gc;                      /* Graphics context for copying from

                                 * off-screen pixmap onto screen. */

    int doubleBuffer;           /* Non-zero means double-buffer redisplay

                                 * with pixmap;  zero means draw straight

                                 * onto the display. */

    int updatePending;          /* Non-zero means a call to SquareDisplay

                                 * has already been scheduled. */

} Square;

/*

 * Information used for argv parsing.

 */

static Tk_ConfigSpec configSpecs[] = {

    {TK_CONFIG_BORDER, "-background", "background", "Background",

        "#d9d9d9", Tk_Offset(Square, bgBorder), TK_CONFIG_COLOR_ONLY},

    {TK_CONFIG_BORDER, "-background", "background", "Background",

        "white", Tk_Offset(Square, bgBorder), TK_CONFIG_MONO_ONLY},

    {TK_CONFIG_SYNONYM, "-bd", "borderWidth", (char *) NULL,

        (char *) NULL, 0, 0},

    {TK_CONFIG_SYNONYM, "-bg", "background", (char *) NULL,

        (char *) NULL, 0, 0},

    {TK_CONFIG_PIXELS, "-borderwidth", "borderWidth", "BorderWidth",

        "2", Tk_Offset(Square, borderWidth), 0},

    {TK_CONFIG_INT, "-dbl", "doubleBuffer", "DoubleBuffer",

        "1", Tk_Offset(Square, doubleBuffer), 0},

    {TK_CONFIG_SYNONYM, "-fg", "foreground", (char *) NULL,

        (char *) NULL, 0, 0},

    {TK_CONFIG_BORDER, "-foreground", "foreground", "Foreground",

        "#b03060", Tk_Offset(Square, fgBorder), TK_CONFIG_COLOR_ONLY},

    {TK_CONFIG_BORDER, "-foreground", "foreground", "Foreground",

        "black", Tk_Offset(Square, fgBorder), TK_CONFIG_MONO_ONLY},

    {TK_CONFIG_RELIEF, "-relief", "relief", "Relief",

        "raised", Tk_Offset(Square, relief), 0},

    {TK_CONFIG_END, (char *) NULL, (char *) NULL, (char *) NULL,

        (char *) NULL, 0, 0}

};

/*

 * Forward declarations for procedures defined later in this file:

 */

int                     SquareCmd _ANSI_ARGS_((ClientData clientData,

                            Tcl_Interp *interp, int argc, char **argv));

static void             SquareCmdDeletedProc _ANSI_ARGS_((

                            ClientData clientData));

static int              SquareConfigure _ANSI_ARGS_((Tcl_Interp *interp,

                            Square *squarePtr, int argc, char **argv,

                            int flags));

static void             SquareDestroy _ANSI_ARGS_((char *memPtr));

static void             SquareDisplay _ANSI_ARGS_((ClientData clientData));

static void             KeepInWindow _ANSI_ARGS_((Square *squarePtr));

static void             SquareEventProc _ANSI_ARGS_((ClientData clientData,

                            XEvent *eventPtr));

static int              SquareWidgetCmd _ANSI_ARGS_((ClientData clientData,

                            Tcl_Interp *, int argc, char **argv));

/*

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

 *

 * SquareCmd --

 *

 *      This procedure is invoked to process the "square" Tcl

 *      command.  It creates a new "square" widget.

 *

 * Results:

 *      A standard Tcl result.

 *

 * Side effects:

 *      A new widget is created and configured.

 *

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

 */

int

SquareCmd(clientData, interp, argc, argv)

    ClientData clientData;      /* Main window associated with

                                 * interpreter. */

    Tcl_Interp *interp;         /* Current interpreter. */

    int argc;                   /* Number of arguments. */

    char **argv;                /* Argument strings. */

{

    Tk_Window main = (Tk_Window) clientData;

    Square *squarePtr;

    Tk_Window tkwin;

    if (argc < 2) {

        Tcl_AppendResult(interp, "wrong # args: should be \"",

                argv[0], " pathName ?options?\"", (char *) NULL);

        return TCL_ERROR;

    }

    tkwin = Tk_CreateWindowFromPath(interp, main, argv[1], (char *) NULL);

    if (tkwin == NULL) {

        return TCL_ERROR;

    }

    Tk_SetClass(tkwin, "Square");

    /*

     * Allocate and initialize the widget record.

     */

    squarePtr = (Square *) ckalloc(sizeof(Square));

    squarePtr->tkwin = tkwin;

    squarePtr->display = Tk_Display(tkwin);

    squarePtr->interp = interp;

    squarePtr->widgetCmd = Tcl_CreateCommand(interp,

            Tk_PathName(squarePtr->tkwin), SquareWidgetCmd,

            (ClientData) squarePtr, SquareCmdDeletedProc);

    squarePtr->x = 0;

    squarePtr->y = 0;

    squarePtr->size = 20;

    squarePtr->borderWidth = 0;

    squarePtr->bgBorder = NULL;

    squarePtr->fgBorder = NULL;

    squarePtr->relief = TK_RELIEF_FLAT;

    squarePtr->gc = None;

    squarePtr->doubleBuffer = 1;

    squarePtr->updatePending = 0;

    Tk_CreateEventHandler(squarePtr->tkwin, ExposureMask|StructureNotifyMask,

            SquareEventProc, (ClientData) squarePtr);

    if (SquareConfigure(interp, squarePtr, argc-2, argv+2, 0) != TCL_OK) {

        Tk_DestroyWindow(squarePtr->tkwin);

        return TCL_ERROR;

    }

    interp->result = Tk_PathName(squarePtr->tkwin);

    return TCL_OK;

}

/*

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

 *

 * SquareWidgetCmd --

 *

 *      This procedure is invoked to process the Tcl command

 *      that corresponds to a widget managed by this module.

 *      See the user documentation for details on what it does.

 *

 * Results:

 *      A standard Tcl result.

 *

 * Side effects:

 *      See the user documentation.

 *

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

 */

static int

SquareWidgetCmd(clientData, interp, argc, argv)

    ClientData clientData;              /* Information about square widget. */

    Tcl_Interp *interp;                 /* Current interpreter. */

    int argc;                           /* Number of arguments. */

    char **argv;                        /* Argument strings. */

{

    Square *squarePtr = (Square *) clientData;

    int result = TCL_OK;

    size_t length;

    char c;

    if (argc < 2) {

        Tcl_AppendResult(interp, "wrong # args: should be \"",

                argv[0], " option ?arg arg ...?\"", (char *) NULL);

        return TCL_ERROR;

    }

    Tcl_Preserve((ClientData) squarePtr);

    c = argv[1][0];

    length = strlen(argv[1]);

    if ((c == 'c') && (strncmp(argv[1], "cget", length) == 0)

            && (length >= 2)) {

        if (argc != 3) {

            Tcl_AppendResult(interp, "wrong # args: should be \"",

                    argv[0], " cget option\"",

                    (char *) NULL);

            goto error;

        }

        result = Tk_ConfigureValue(interp, squarePtr->tkwin, configSpecs,

                (char *) squarePtr, argv[2], 0);

    } else if ((c == 'c') && (strncmp(argv[1], "configure", length) == 0)

            && (length >= 2)) {

        if (argc == 2) {

            result = Tk_ConfigureInfo(interp, squarePtr->tkwin, configSpecs,

                    (char *) squarePtr, (char *) NULL, 0);

        } else if (argc == 3) {

            result = Tk_ConfigureInfo(interp, squarePtr->tkwin, configSpecs,

                    (char *) squarePtr, argv[2], 0);

        } else {

            result = SquareConfigure(interp, squarePtr, argc-2, argv+2,

                    TK_CONFIG_ARGV_ONLY);

        }

    } else if ((c == 'p') && (strncmp(argv[1], "position", length) == 0)) {

        if ((argc != 2) && (argc != 4)) {

            Tcl_AppendResult(interp, "wrong # args: should be \"",

                    argv[0], " position ?x y?\"", (char *) NULL);

            goto error;

        }

        if (argc == 4) {

            if ((Tk_GetPixels(interp, squarePtr->tkwin, argv[2],

                    &squarePtr->x) != TCL_OK) || (Tk_GetPixels(interp,

                    squarePtr->tkwin, argv[3], &squarePtr->y) != TCL_OK)) {

                goto error;

            }

            KeepInWindow(squarePtr);

        }

        sprintf(interp->result, "%d %d", squarePtr->x, squarePtr->y);

    } else if ((c == 's') && (strncmp(argv[1], "size", length) == 0)) {

        if ((argc != 2) && (argc != 3)) {

            Tcl_AppendResult(interp, "wrong # args: should be \"",

                    argv[0], " size ?amount?\"", (char *) NULL);

            goto error;

        }

        if (argc == 3) {

            int i;

            if (Tk_GetPixels(interp, squarePtr->tkwin, argv[2], &i) != TCL_OK) {

                goto error;

            }

            if ((i <= 0) || (i > 100)) {

                Tcl_AppendResult(interp, "bad size \"", argv[2],

                        "\"", (char *) NULL);

                goto error;

            }

            squarePtr->size = i;

            KeepInWindow(squarePtr);

        }

        sprintf(interp->result, "%d", squarePtr->size);

    } else {

        Tcl_AppendResult(interp, "bad option \"", argv[1],

                "\": must be cget, configure, position, or size",

                (char *) NULL);

        goto error;

    }

    if (!squarePtr->updatePending) {

        Tcl_DoWhenIdle(SquareDisplay, (ClientData) squarePtr);

        squarePtr->updatePending = 1;

    }

    Tcl_Release((ClientData) squarePtr);

    return result;

    error:

    Tcl_Release((ClientData) squarePtr);

    return TCL_ERROR;

}

/*

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

 *

 * SquareConfigure --

 *

 *      This procedure is called to process an argv/argc list in

 *      conjunction with the Tk option database to configure (or

 *      reconfigure) a square widget.

 *

 * Results:

 *      The return value is a standard Tcl result.  If TCL_ERROR is

 *      returned, then interp->result contains an error message.

 *

 * Side effects:

 *      Configuration information, such as colors, border width,

 *      etc. get set for squarePtr;  old resources get freed,

 *      if there were any.

 *

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

 */

static int

SquareConfigure(interp, squarePtr, argc, argv, flags)

    Tcl_Interp *interp;                 /* Used for error reporting. */

    Square *squarePtr;                  /* Information about widget. */

    int argc;                           /* Number of valid entries in argv. */

    char **argv;                        /* Arguments. */

    int flags;                          /* Flags to pass to

                                         * Tk_ConfigureWidget. */

{

    if (Tk_ConfigureWidget(interp, squarePtr->tkwin, configSpecs,

            argc, argv, (char *) squarePtr, flags) != TCL_OK) {

        return TCL_ERROR;

    }

    /*

     * Set the background for the window and create a graphics context

     * for use during redisplay.

     */

    Tk_SetWindowBackground(squarePtr->tkwin,

            Tk_3DBorderColor(squarePtr->bgBorder)->pixel);

    if ((squarePtr->gc == None) && (squarePtr->doubleBuffer)) {

        XGCValues gcValues;

        gcValues.function = GXcopy;

        gcValues.graphics_exposures = False;

        squarePtr->gc = Tk_GetGC(squarePtr->tkwin,

                GCFunction|GCGraphicsExposures, &gcValues);

    }

    /*

     * Register the desired geometry for the window.  Then arrange for

     * the window to be redisplayed.

     */

    Tk_GeometryRequest(squarePtr->tkwin, 200, 150);

    Tk_SetInternalBorder(squarePtr->tkwin, squarePtr->borderWidth);

    if (!squarePtr->updatePending) {

        Tcl_DoWhenIdle(SquareDisplay, (ClientData) squarePtr);

        squarePtr->updatePending = 1;

    }

    return TCL_OK;

}

/*

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

 *

 * SquareEventProc --

 *

 *      This procedure is invoked by the Tk dispatcher for various

 *      events on squares.

 *

 * Results:

 *      None.

 *

 * Side effects:

 *      When the window gets deleted, internal structures get

 *      cleaned up.  When it gets exposed, it is redisplayed.

 *

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

 */

static void

SquareEventProc(clientData, eventPtr)

    ClientData clientData;      /* Information about window. */

    XEvent *eventPtr;           /* Information about event. */

{

    Square *squarePtr = (Square *) clientData;

    if (eventPtr->type == Expose) {

        if (!squarePtr->updatePending) {

            Tcl_DoWhenIdle(SquareDisplay, (ClientData) squarePtr);

            squarePtr->updatePending = 1;

        }

    } else if (eventPtr->type == ConfigureNotify) {

        KeepInWindow(squarePtr);

        if (!squarePtr->updatePending) {

            Tcl_DoWhenIdle(SquareDisplay, (ClientData) squarePtr);

            squarePtr->updatePending = 1;

        }

    } else if (eventPtr->type == DestroyNotify) {

        if (squarePtr->tkwin != NULL) {

            squarePtr->tkwin = NULL;

            Tcl_DeleteCommandFromToken(squarePtr->interp,

                    squarePtr->widgetCmd);

        }

        if (squarePtr->updatePending) {

            Tcl_CancelIdleCall(SquareDisplay, (ClientData) squarePtr);

        }

        Tcl_EventuallyFree((ClientData) squarePtr, SquareDestroy);

    }

}

/*

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

 *

 * SquareCmdDeletedProc --

 *

 *      This procedure is invoked when a widget command is deleted.  If

 *      the widget isn't already in the process of being destroyed,

 *      this command destroys it.

 *

 * Results:

 *      None.

 *

 * Side effects:

 *      The widget is destroyed.

 *

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

 */

static void

SquareCmdDeletedProc(clientData)

    ClientData clientData;      /* Pointer to widget record for widget. */

{

    Square *squarePtr = (Square *) clientData;

    Tk_Window tkwin = squarePtr->tkwin;

    /*

     * This procedure could be invoked either because the window was

     * destroyed and the command was then deleted (in which case tkwin

     * is NULL) or because the command was deleted, and then this procedure

     * destroys the widget.

     */

    if (tkwin != NULL) {

        squarePtr->tkwin = NULL;

        Tk_DestroyWindow(tkwin);

    }

}

/*

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

 *

 * SquareDisplay --

 *

 *      This procedure redraws the contents of a square 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.

 *

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

 */

static void

SquareDisplay(clientData)

    ClientData clientData;      /* Information about window. */

{

    Square *squarePtr = (Square *) clientData;

    Tk_Window tkwin = squarePtr->tkwin;

    Pixmap pm = None;

    Drawable d;

    squarePtr->updatePending = 0;

    if (!Tk_IsMapped(tkwin)) {

        return;

    }

    /*

     * Create a pixmap for double-buffering, if necessary.

     */

    if (squarePtr->doubleBuffer) {

        pm = Tk_GetPixmap(Tk_Display(tkwin), Tk_WindowId(tkwin),

                Tk_Width(tkwin), Tk_Height(tkwin),

                DefaultDepthOfScreen(Tk_Screen(tkwin)));

        d = pm;

    } else {

        d = Tk_WindowId(tkwin);

    }

    /*

     * Redraw the widget's background and border.

     */

    Tk_Fill3DRectangle(tkwin, d, squarePtr->bgBorder, 0, 0, Tk_Width(tkwin),

            Tk_Height(tkwin), squarePtr->borderWidth, squarePtr->relief);

    /*

     * Display the square.

     */

    Tk_Fill3DRectangle(tkwin, d, squarePtr->fgBorder, squarePtr->x,

            squarePtr->y, squarePtr->size, squarePtr->size,

            squarePtr->borderWidth, TK_RELIEF_RAISED);

    /*

     * If double-buffered, copy to the screen and release the pixmap.

     */

    if (squarePtr->doubleBuffer) {

        XCopyArea(Tk_Display(tkwin), pm, Tk_WindowId(tkwin), squarePtr->gc,

                0, 0, (unsigned) Tk_Width(tkwin), (unsigned) Tk_Height(tkwin),

                0, 0);

        Tk_FreePixmap(Tk_Display(tkwin), pm);

    }

}

/*

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

 *

 * SquareDestroy --

 *

 *      This procedure is invoked by Tcl_EventuallyFree or Tcl_Release

 *      to clean up the internal structure of a square at a safe time

 *      (when no-one is using it anymore).

 *

 * Results:

 *      None.

 *

 * Side effects:

 *      Everything associated with the square is freed up.

 *

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

 */

static void

SquareDestroy(memPtr)

    char *memPtr;               /* Info about square widget. */

{

    Square *squarePtr = (Square *) memPtr;

    Tk_FreeOptions(configSpecs, (char *) squarePtr, squarePtr->display, 0);

    if (squarePtr->gc != None) {

        Tk_FreeGC(squarePtr->display, squarePtr->gc);

    }

    ckfree((char *) squarePtr);

}

/*

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

 *

 * KeepInWindow --

 *

 *      Adjust the position of the square if necessary to keep it in

 *      the widget's window.

 *

 * Results:

 *      None.

 *

 * Side effects:

 *      The x and y position of the square are adjusted if necessary

 *      to keep the square in the window.

 *

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

 */

static void

KeepInWindow(squarePtr)

    register Square *squarePtr;         /* Pointer to widget record. */

{

    int i, bd;

    bd = 0;

    if (squarePtr->relief != TK_RELIEF_FLAT) {

        bd = squarePtr->borderWidth;

    }

    i = (Tk_Width(squarePtr->tkwin) - bd) - (squarePtr->x + squarePtr->size);

    if (i < 0) {

        squarePtr->x += i;

    }

    i = (Tk_Height(squarePtr->tkwin) - bd) - (squarePtr->y + squarePtr->size);

    if (i < 0) {

        squarePtr->y += i;

    }

    if (squarePtr->x < bd) {

        squarePtr->x = bd;

    }

    if (squarePtr->y < bd) {

        squarePtr->y = bd;

    }

}