path: root/generic/tkIntStubs.c

/* 
 * tkIntStubs.c --
 *
 *	This file contains the wrapper functions for the platform independent
 *	unsupported Tk API.
 *
 * Copyright (c) 1998-1999 by Scriptics Corporation.
 * All rights reserved.
 *
 * RCS: @(#) $Id: tkIntStubs.c,v 1.2 1999/03/10 07:04:41 stanton Exp $
 */

#include "tkInt.h"

/*
 * WARNING: This file is automatically generated by the tools/genStubs.tcl
 * script.  Any modifications to the function declarations below should be made
 * in the generic/tkInt.decls script.
 */

/* !BEGIN!: Do not edit below this line. */

/*
 * Exported stub functions:
 */

/* Slot 0 */
TkWindow *
TkAllocWindow(dispPtr, screenNum, parentPtr)
    TkDisplay * dispPtr;
    int screenNum;
    TkWindow * parentPtr;
{
    return (tkIntStubsPtr->tkAllocWindow)(dispPtr, screenNum, parentPtr);
}

/* Slot 1 */
void
TkBezierPoints(control, numSteps, coordPtr)
    double control[];
    int numSteps;
    double * coordPtr;
{
    (tkIntStubsPtr->tkBezierPoints)(control, numSteps, coordPtr);
}

/* Slot 2 */
void
TkBezierScreenPoints(canvas, control, numSteps, xPointPtr)
    Tk_Canvas canvas;
    double control[];
    int numSteps;
    XPoint * xPointPtr;
{
    (tkIntStubsPtr->tkBezierScreenPoints)(canvas, control, numSteps, xPointPtr);
}

/* Slot 3 */
void
TkBindDeadWindow(winPtr)
    TkWindow * winPtr;
{
    (tkIntStubsPtr->tkBindDeadWindow)(winPtr);
}

/* Slot 4 */
void
TkBindEventProc(winPtr, eventPtr)
    TkWindow * winPtr;
    XEvent * eventPtr;
{
    (tkIntStubsPtr->tkBindEventProc)(winPtr, eventPtr);
}

/* Slot 5 */
void
TkBindFree(mainPtr)
    TkMainInfo * mainPtr;
{
    (tkIntStubsPtr->tkBindFree)(mainPtr);
}

/* Slot 6 */
void
TkBindInit(mainPtr)
    TkMainInfo * mainPtr;
{
    (tkIntStubsPtr->tkBindInit)(mainPtr);
}

/* Slot 7 */
void
TkChangeEventWindow(eventPtr, winPtr)
    XEvent * eventPtr;
    TkWindow * winPtr;
{
    (tkIntStubsPtr->tkChangeEventWindow)(eventPtr, winPtr);
}

/* Slot 8 */
int
TkClipInit(interp, dispPtr)
    Tcl_Interp * interp;
    TkDisplay * dispPtr;
{
    return (tkIntStubsPtr->tkClipInit)(interp, dispPtr);
}

/* Slot 9 */
void
TkComputeAnchor(anchor, tkwin, padX, padY, innerWidth, innerHeight, xPtr, yPtr)
    Tk_Anchor anchor;
    Tk_Window tkwin;
    int padX;
    int padY;
    int innerWidth;
    int innerHeight;
    int * xPtr;
    int * yPtr;
{
    (tkIntStubsPtr->tkComputeAnchor)(anchor, tkwin, padX, padY, innerWidth, innerHeight, xPtr, yPtr);
}

/* Slot 10 */
int
TkCopyAndGlobalEval(interp, script)
    Tcl_Interp * interp;
    char * script;
{
    return (tkIntStubsPtr->tkCopyAndGlobalEval)(interp, script);
}

/* Slot 11 */
unsigned long
TkCreateBindingProcedure(interp, bindingTable, object, eventString, evalProc, freeProc, clientData)
    Tcl_Interp * interp;
    Tk_BindingTable bindingTable;
    ClientData object;
    char * eventString;
    TkBindEvalProc * evalProc;
    TkBindFreeProc * freeProc;
    ClientData clientData;
{
    return (tkIntStubsPtr->tkCreateBindingProcedure)(interp, bindingTable, object, eventString, evalProc, freeProc, clientData);
}

/* Slot 12 */
TkCursor *
TkCreateCursorFromData(tkwin, source, mask, width, height, xHot, yHot, fg, bg)
    Tk_Window tkwin;
    char * source;
    char * mask;
    int width;
    int height;
    int xHot;
    int yHot;
    XColor fg;
    XColor bg;
{
    return (tkIntStubsPtr->tkCreateCursorFromData)(tkwin, source, mask, width, height, xHot, yHot, fg, bg);
}

/* Slot 13 */
int
TkCreateFrame(clientData, interp, argc, argv, toplevel, appName)
    ClientData clientData;
    Tcl_Interp * interp;
    int argc;
    char ** argv;
    int toplevel;
    char * appName;
{
    return (tkIntStubsPtr->tkCreateFrame)(clientData, interp, argc, argv, toplevel, appName);
}

/* Slot 14 */
Tk_Window
TkCreateMainWindow(interp, screenName, baseName)
    Tcl_Interp * interp;
    char * screenName;
    char * baseName;
{
    return (tkIntStubsPtr->tkCreateMainWindow)(interp, screenName, baseName);
}

/* Slot 15 */
Time
TkCurrentTime(dispPtr)
    TkDisplay * dispPtr;
{
    return (tkIntStubsPtr->tkCurrentTime)(dispPtr);
}

/* Slot 16 */
void
TkDeleteAllImages(mainPtr)
    TkMainInfo * mainPtr;
{
    (tkIntStubsPtr->tkDeleteAllImages)(mainPtr);
}

/* Slot 17 */
void
TkDoConfigureNotify(winPtr)
    TkWindow * winPtr;
{
    (tkIntStubsPtr->tkDoConfigureNotify)(winPtr);
}

/* Slot 18 */
void
TkDrawInsetFocusHighlight(tkwin, gc, width, drawable, padding)
    Tk_Window tkwin;
    GC gc;
    int width;
    Drawable drawable;
    int padding;
{
    (tkIntStubsPtr->tkDrawInsetFocusHighlight)(tkwin, gc, width, drawable, padding);
}

/* Slot 19 */
void
TkEventDeadWindow(winPtr)
    TkWindow * winPtr;
{
    (tkIntStubsPtr->tkEventDeadWindow)(winPtr);
}

/* Slot 20 */
void
TkFillPolygon(canvas, coordPtr, numPoints, display, drawable, gc, outlineGC)
    Tk_Canvas canvas;
    double * coordPtr;
    int numPoints;
    Display * display;
    Drawable drawable;
    GC gc;
    GC outlineGC;
{
    (tkIntStubsPtr->tkFillPolygon)(canvas, coordPtr, numPoints, display, drawable, gc, outlineGC);
}

/* Slot 21 */
int
TkFindStateNum(interp, option, mapPtr, strKey)
    Tcl_Interp * interp;
    CONST char * option;
    CONST TkStateMap * mapPtr;
    CONST char * strKey;
{
    return (tkIntStubsPtr->tkFindStateNum)(interp, option, mapPtr, strKey);
}

/* Slot 22 */
char *
TkFindStateString(mapPtr, numKey)
    CONST TkStateMap * mapPtr;
    int numKey;
{
    return (tkIntStubsPtr->tkFindStateString)(mapPtr, numKey);
}

/* Slot 23 */
void
TkFocusDeadWindow(winPtr)
    TkWindow * winPtr;
{
    (tkIntStubsPtr->tkFocusDeadWindow)(winPtr);
}

/* Slot 24 */
int
TkFocusFilterEvent(winPtr, eventPtr)
    TkWindow * winPtr;
    XEvent * eventPtr;
{
    return (tkIntStubsPtr->tkFocusFilterEvent)(winPtr, eventPtr);
}

/* Slot 25 */
TkWindow *
TkFocusKeyEvent(winPtr, eventPtr)
    TkWindow * winPtr;
    XEvent * eventPtr;
{
    return (tkIntStubsPtr->tkFocusKeyEvent)(winPtr, eventPtr);
}

/* Slot 26 */
void
TkFontPkgInit(mainPtr)
    TkMainInfo * mainPtr;
{
    (tkIntStubsPtr->tkFontPkgInit)(mainPtr);
}

/* Slot 27 */
void
TkFontPkgFree(mainPtr)
    TkMainInfo * mainPtr;
{
    (tkIntStubsPtr->tkFontPkgFree)(mainPtr);
}

/* Slot 28 */
void
TkFreeBindingTags(winPtr)
    TkWindow * winPtr;
{
    (tkIntStubsPtr->tkFreeBindingTags)(winPtr);
}

/* Slot 29 */
void
TkFreeCursor(cursorPtr)
    TkCursor * cursorPtr;
{
    (tkIntStubsPtr->tkFreeCursor)(cursorPtr);
}

/* Slot 30 */
char *
TkGetBitmapData(interp, string, fileName, widthPtr, heightPtr, hotXPtr, hotYPtr)
    Tcl_Interp * interp;
    char * string;
    char * fileName;
    int * widthPtr;
    int * heightPtr;
    int * hotXPtr;
    int * hotYPtr;
{
    return (tkIntStubsPtr->tkGetBitmapData)(interp, string, fileName, widthPtr, heightPtr, hotXPtr, hotYPtr);
}

/* Slot 31 */
void
TkGetButtPoints(p1, p2, width, project, m1, m2)
    double p1[];
    double p2[];
    double width;
    int project;
    double m1[];
    double m2[];
{
    (tkIntStubsPtr->tkGetButtPoints)(p1, p2, width, project, m1, m2);
}

/* Slot 32 */
TkCursor *
TkGetCursorByName(interp, tkwin, string)
    Tcl_Interp * interp;
    Tk_Window tkwin;
    Tk_Uid string;
{
    return (tkIntStubsPtr->tkGetCursorByName)(interp, tkwin, string);
}

/* Slot 33 */
char *
TkGetDefaultScreenName(interp, screenName)
    Tcl_Interp * interp;
    char * screenName;
{
    return (tkIntStubsPtr->tkGetDefaultScreenName)(interp, screenName);
}

/* Slot 34 */
TkDisplay *
TkGetDisplay(display)
    Display * display;
{
    return (tkIntStubsPtr->tkGetDisplay)(display);
}

/* Slot 35 */
int
TkGetDisplayOf(interp, objc, objv, tkwinPtr)
    Tcl_Interp * interp;
    int objc;
    Tcl_Obj *CONST objv[];
    Tk_Window * tkwinPtr;
{
    return (tkIntStubsPtr->tkGetDisplayOf)(interp, objc, objv, tkwinPtr);
}

/* Slot 36 */
TkWindow *
TkGetFocusWin(winPtr)
    TkWindow * winPtr;
{
    return (tkIntStubsPtr->tkGetFocusWin)(winPtr);
}

/* Slot 37 */
int
TkGetInterpNames(interp, tkwin)
    Tcl_Interp * interp;
    Tk_Window tkwin;
{
    return (tkIntStubsPtr->tkGetInterpNames)(interp, tkwin);
}

/* Slot 38 */
int
TkGetMiterPoints(p1, p2, p3, width, m1, m2)
    double p1[];
    double p2[];
    double p3[];
    double width;
    double m1[];
    double m2[];
{
    return (tkIntStubsPtr->tkGetMiterPoints)(p1, p2, p3, width, m1, m2);
}

/* Slot 39 */
void
TkGetPointerCoords(tkwin, xPtr, yPtr)
    Tk_Window tkwin;
    int * xPtr;
    int * yPtr;
{
    (tkIntStubsPtr->tkGetPointerCoords)(tkwin, xPtr, yPtr);
}

/* Slot 40 */
void
TkGetServerInfo(interp, tkwin)
    Tcl_Interp * interp;
    Tk_Window tkwin;
{
    (tkIntStubsPtr->tkGetServerInfo)(interp, tkwin);
}

/* Slot 41 */
void
TkGrabDeadWindow(winPtr)
    TkWindow * winPtr;
{
    (tkIntStubsPtr->tkGrabDeadWindow)(winPtr);
}

/* Slot 42 */
int
TkGrabState(winPtr)
    TkWindow * winPtr;
{
    return (tkIntStubsPtr->tkGrabState)(winPtr);
}

/* Slot 43 */
void
TkIncludePoint(itemPtr, pointPtr)
    Tk_Item * itemPtr;
    double * pointPtr;
{
    (tkIntStubsPtr->tkIncludePoint)(itemPtr, pointPtr);
}

/* Slot 44 */
void
TkInOutEvents(eventPtr, sourcePtr, destPtr, leaveType, enterType, position)
    XEvent * eventPtr;
    TkWindow * sourcePtr;
    TkWindow * destPtr;
    int leaveType;
    int enterType;
    Tcl_QueuePosition position;
{
    (tkIntStubsPtr->tkInOutEvents)(eventPtr, sourcePtr, destPtr, leaveType, enterType, position);
}

/* Slot 45 */
void
TkInstallFrameMenu(tkwin)
    Tk_Window tkwin;
{
    (tkIntStubsPtr->tkInstallFrameMenu)(tkwin);
}

/* Slot 46 */
char *
TkKeysymToString(keysym)
    KeySym keysym;
{
    return (tkIntStubsPtr->tkKeysymToString)(keysym);
}

/* Slot 47 */
int
TkLineToArea(end1Ptr, end2Ptr, rectPtr)
    TkDouble2 end1Ptr;
    TkDouble2 end2Ptr;
    TkDouble4 rectPtr;
{
    return (tkIntStubsPtr->tkLineToArea)(end1Ptr, end2Ptr, rectPtr);
}

/* Slot 48 */
double
TkLineToPoint(end1Ptr, end2Ptr, pointPtr)
    double end1Ptr[];
    TkDouble2 end2Ptr;
    TkDouble2 pointPtr;
{
    return (tkIntStubsPtr->tkLineToPoint)(end1Ptr, end2Ptr, pointPtr);
}

/* Slot 49 */
int
TkMakeBezierCurve(canvas, pointPtr, numPoints, numSteps, xPoints, dblPoints)
    Tk_Canvas canvas;
    double * pointPtr;
    int numPoints;
    int numSteps;
    XPoint xPoints[];
    double dblPoints[];
{
    return (tkIntStubsPtr->tkMakeBezierCurve)(canvas, pointPtr, numPoints, numSteps, xPoints, dblPoints);
}

/* Slot 50 */
void
TkMakeBezierPostscript(interp, canvas, pointPtr, numPoints)
    Tcl_Interp * interp;
    Tk_Canvas canvas;
    double * pointPtr;
    int numPoints;
{
    (tkIntStubsPtr->tkMakeBezierPostscript)(interp, canvas, pointPtr, numPoints);
}

/* Slot 51 */
void
TkOptionClassChanged(winPtr)
    TkWindow * winPtr;
{
    (tkIntStubsPtr->tkOptionClassChanged)(winPtr);
}

/* Slot 52 */
void
TkOptionDeadWindow(winPtr)
    TkWindow * winPtr;
{
    (tkIntStubsPtr->tkOptionDeadWindow)(winPtr);
}

/* Slot 53 */
int
TkOvalToArea(ovalPtr, rectPtr)
    double * ovalPtr;
    double * rectPtr;
{
    return (tkIntStubsPtr->tkOvalToArea)(ovalPtr, rectPtr);
}

/* Slot 54 */
double
TkOvalToPoint(ovalPtr, width, filled, pointPtr)
    TkDouble4 ovalPtr;
    double width;
    int filled;
    TkDouble2 pointPtr;
{
    return (tkIntStubsPtr->tkOvalToPoint)(ovalPtr, width, filled, pointPtr);
}

/* Slot 55 */
int
TkpChangeFocus(winPtr, force)
    TkWindow * winPtr;
    int force;
{
    return (tkIntStubsPtr->tkpChangeFocus)(winPtr, force);
}

/* Slot 56 */
void
TkpCloseDisplay(dispPtr)
    TkDisplay * dispPtr;
{
    (tkIntStubsPtr->tkpCloseDisplay)(dispPtr);
}

/* Slot 57 */
void
TkpClaimFocus(topLevelPtr, force)
    TkWindow * topLevelPtr;
    int force;
{
    (tkIntStubsPtr->tkpClaimFocus)(topLevelPtr, force);
}

/* Slot 58 */
void
TkpDisplayWarning(msg, title)
    char * msg;
    char * title;
{
    (tkIntStubsPtr->tkpDisplayWarning)(msg, title);
}

/* Slot 59 */
void
TkpGetAppName(interp, name)
    Tcl_Interp * interp;
    Tcl_DString * name;
{
    (tkIntStubsPtr->tkpGetAppName)(interp, name);
}

/* Slot 60 */
TkWindow *
TkpGetOtherWindow(winPtr)
    TkWindow * winPtr;
{
    return (tkIntStubsPtr->tkpGetOtherWindow)(winPtr);
}

/* Slot 61 */
TkWindow *
TkpGetWrapperWindow(winPtr)
    TkWindow * winPtr;
{
    return (tkIntStubsPtr->tkpGetWrapperWindow)(winPtr);
}

/* Slot 62 */
int
TkpInit(interp)
    Tcl_Interp * interp;
{
    return (tkIntStubsPtr->tkpInit)(interp);
}

/* Slot 63 */
void
TkpInitializeMenuBindings(interp, bindingTable)
    Tcl_Interp * interp;
    Tk_BindingTable bindingTable;
{
    (tkIntStubsPtr->tkpInitializeMenuBindings)(interp, bindingTable);
}

/* Slot 64 */
void
TkpMakeContainer(tkwin)
    Tk_Window tkwin;
{
    (tkIntStubsPtr->tkpMakeContainer)(tkwin);
}

/* Slot 65 */
void
TkpMakeMenuWindow(tkwin, transient)
    Tk_Window tkwin;
    int transient;
{
    (tkIntStubsPtr->tkpMakeMenuWindow)(tkwin, transient);
}

/* Slot 66 */
Window
TkpMakeWindow(winPtr, parent)
    TkWindow * winPtr;
    Window parent;
{
    return (tkIntStubsPtr->tkpMakeWindow)(winPtr, parent);
}

/* Slot 67 */
void
TkpMenuNotifyToplevelCreate(interp1, menuName)
    Tcl_Interp * interp1;
    char * menuName;
{
    (tkIntStubsPtr->tkpMenuNotifyToplevelCreate)(interp1, menuName);
}

/* Slot 68 */
TkDisplay *
TkpOpenDisplay(display_name)
    char * display_name;
{
    return (tkIntStubsPtr->tkpOpenDisplay)(display_name);
}

/* Slot 69 */
int
TkPointerEvent(eventPtr, winPtr)
    XEvent * eventPtr;
    TkWindow * winPtr;
{
    return (tkIntStubsPtr->tkPointerEvent)(eventPtr, winPtr);
}

/* Slot 70 */
int
TkPolygonToArea(polyPtr, numPoints, rectPtr)
    double * polyPtr;
    int numPoints;
    double * rectPtr;
{
    return (tkIntStubsPtr->tkPolygonToArea)(polyPtr, numPoints, rectPtr);
}

/* Slot 71 */
double
TkPolygonToPoint(polyPtr, numPoints, pointPtr)
    double * polyPtr;
    int numPoints;
    double * pointPtr;
{
    return (tkIntStubsPtr->tkPolygonToPoint)(polyPtr, numPoints, pointPtr);
}

/* Slot 72 */
int
TkPositionInTree(winPtr, treePtr)
    TkWindow * winPtr;
    TkWindow * treePtr;
{
    return (tkIntStubsPtr->tkPositionInTree)(winPtr, treePtr);
}

/* Slot 73 */
void
TkpRedirectKeyEvent(winPtr, eventPtr)
    TkWindow * winPtr;
    XEvent * eventPtr;
{
    (tkIntStubsPtr->tkpRedirectKeyEvent)(winPtr, eventPtr);
}

/* Slot 74 */
void
TkpSetMainMenubar(interp, tkwin, menuName)
    Tcl_Interp * interp;
    Tk_Window tkwin;
    char * menuName;
{
    (tkIntStubsPtr->tkpSetMainMenubar)(interp, tkwin, menuName);
}

/* Slot 75 */
int
TkpUseWindow(interp, tkwin, string)
    Tcl_Interp * interp;
    Tk_Window tkwin;
    char * string;
{
    return (tkIntStubsPtr->tkpUseWindow)(interp, tkwin, string);
}

/* Slot 76 */
int
TkpWindowWasRecentlyDeleted(win, dispPtr)
    Window win;
    TkDisplay * dispPtr;
{
    return (tkIntStubsPtr->tkpWindowWasRecentlyDeleted)(win, dispPtr);
}

/* Slot 77 */
void
TkQueueEventForAllChildren(winPtr, eventPtr)
    TkWindow * winPtr;
    XEvent * eventPtr;
{
    (tkIntStubsPtr->tkQueueEventForAllChildren)(winPtr, eventPtr);
}

/* Slot 78 */
int
TkReadBitmapFile(display, d, filename, width_return, height_return, bitmap_return, x_hot_return, y_hot_return)
    Display* display;
    Drawable d;
    CONST char* filename;
    unsigned int* width_return;
    unsigned int* height_return;
    Pixmap* bitmap_return;
    int* x_hot_return;
    int* y_hot_return;
{
    return (tkIntStubsPtr->tkReadBitmapFile)(display, d, filename, width_return, height_return, bitmap_return, x_hot_return, y_hot_return);
}

/* Slot 79 */
int
TkScrollWindow(tkwin, gc, x, y, width, height, dx, dy, damageRgn)
    Tk_Window tkwin;
    GC gc;
    int x;
    int y;
    int width;
    int height;
    int dx;
    int dy;
    TkRegion damageRgn;
{
    return (tkIntStubsPtr->tkScrollWindow)(tkwin, gc, x, y, width, height, dx, dy, damageRgn);
}

/* Slot 80 */
void
TkSelDeadWindow(winPtr)
    TkWindow * winPtr;
{
    (tkIntStubsPtr->tkSelDeadWindow)(winPtr);
}

/* Slot 81 */
void
TkSelEventProc(tkwin, eventPtr)
    Tk_Window tkwin;
    XEvent * eventPtr;
{
    (tkIntStubsPtr->tkSelEventProc)(tkwin, eventPtr);
}

/* Slot 82 */
void
TkSelInit(tkwin)
    Tk_Window tkwin;
{
    (tkIntStubsPtr->tkSelInit)(tkwin);
}

/* Slot 83 */
void
TkSelPropProc(eventPtr)
    XEvent * eventPtr;
{
    (tkIntStubsPtr->tkSelPropProc)(eventPtr);
}

/* Slot 84 */
void
TkSetClassProcs(tkwin, procs, instanceData)
    Tk_Window tkwin;
    TkClassProcs * procs;
    ClientData instanceData;
{
    (tkIntStubsPtr->tkSetClassProcs)(tkwin, procs, instanceData);
}

/* Slot 85 */
void
TkSetWindowMenuBar(interp, tkwin, oldMenuName, menuName)
    Tcl_Interp * interp;
    Tk_Window tkwin;
    char * oldMenuName;
    char * menuName;
{
    (tkIntStubsPtr->tkSetWindowMenuBar)(interp, tkwin, oldMenuName, menuName);
}

/* Slot 86 */
KeySym
TkStringToKeysym(name)
    char * name;
{
    return (tkIntStubsPtr->tkStringToKeysym)(name);
}

/* Slot 87 */
int
TkThickPolyLineToArea(coordPtr, numPoints, width, capStyle, joinStyle, rectPtr)
    double * coordPtr;
    int numPoints;
    double width;
    int capStyle;
    int joinStyle;
    double * rectPtr;
{
    return (tkIntStubsPtr->tkThickPolyLineToArea)(coordPtr, numPoints, width, capStyle, joinStyle, rectPtr);
}

/* Slot 88 */
void
TkWmAddToColormapWindows(winPtr)
    TkWindow * winPtr;
{
    (tkIntStubsPtr->tkWmAddToColormapWindows)(winPtr);
}

/* Slot 89 */
void
TkWmDeadWindow(winPtr)
    TkWindow * winPtr;
{
    (tkIntStubsPtr->tkWmDeadWindow)(winPtr);
}

/* Slot 90 */
TkWindow *
TkWmFocusToplevel(winPtr)
    TkWindow * winPtr;
{
    return (tkIntStubsPtr->tkWmFocusToplevel)(winPtr);
}

/* Slot 91 */
void
TkWmMapWindow(winPtr)
    TkWindow * winPtr;
{
    (tkIntStubsPtr->tkWmMapWindow)(winPtr);
}

/* Slot 92 */
void
TkWmNewWindow(winPtr)
    TkWindow * winPtr;
{
    (tkIntStubsPtr->tkWmNewWindow)(winPtr);
}

/* Slot 93 */
void
TkWmProtocolEventProc(winPtr, evenvPtr)
    TkWindow * winPtr;
    XEvent * evenvPtr;
{
    (tkIntStubsPtr->tkWmProtocolEventProc)(winPtr, evenvPtr);
}

/* Slot 94 */
void
TkWmRemoveFromColormapWindows(winPtr)
    TkWindow * winPtr;
{
    (tkIntStubsPtr->tkWmRemoveFromColormapWindows)(winPtr);
}

/* Slot 95 */
void
TkWmRestackToplevel(winPtr, aboveBelow, otherPtr)
    TkWindow * winPtr;
    int aboveBelow;
    TkWindow * otherPtr;
{
    (tkIntStubsPtr->tkWmRestackToplevel)(winPtr, aboveBelow, otherPtr);
}

/* Slot 96 */
void
TkWmSetClass(winPtr)
    TkWindow * winPtr;
{
    (tkIntStubsPtr->tkWmSetClass)(winPtr);
}

/* Slot 97 */
void
TkWmUnmapWindow(winPtr)
    TkWindow * winPtr;
{
    (tkIntStubsPtr->tkWmUnmapWindow)(winPtr);
}


/* !END!: Do not edit above this line. */