#define _WINMAIN
/* 
 * main.c --
 *
 *	This file contains the main program for "wish", a windowing
 *	shell based on Tk and Tcl.  It also provides a template that
 *	can be used as the basis for main programs for other Tk
 *	applications.
 *
 * Copyright 1990-1992 Regents of the University of California.
 * Permission to use, copy, modify, and distribute this
 * software and its documentation for any purpose and without
 * fee is hereby granted, provided that the above copyright
 * notice appear in all copies.  The University of California
 * makes no representations about the suitability of this
 * software for any purpose.  It is provided "as is" without
 * express or implied warranty.
 *
 * Modifiyed by Peter MacDonald for windows API.
 */

#ifndef lint
static char rcsid[] = "$Header: /user6/ouster/wish/RCS/main.c,v 1.72 93/02/03 10:20:42 ouster Exp $ SPRITE (Berkeley)";
#endif


#include <stdio.h>
#include <stdarg.h>
#include "tkConfig.h"
#include "tkInt.h"

#include "callback.h"

#define dprintf(n,s) dodprintf(s)

void dodprintf(char *str, ... )
{
	va_list va;
	char buf[2000];
	va_start(va, str);
	vsprintf(buf,str,va);
	puts(buf);
	va_end(str);
}

#define TK_EXTENDED
#ifdef TK_EXTENDED
#    include "tclExtend.h"
     extern Tcl_Interp *tk_mainInterp;  /* Need to process signals */
#endif

/*
 * Declarations for library procedures:
 */

extern int isatty();

/*
 * Command used to initialize wish:
 */

#ifdef TK_EXTENDED
static char initCmd[] = "load wishx.tcl";
#else
static char initCmd[] = "source $tk_library/wish.tcl";
#endif

/*
 * Global variables used by the main program:
 */

static Tk_Window w;		/* The main window for the application.  If
				 * NULL then the application no longer
				 * exists. */
static Tcl_Interp *interp;	/* Interpreter for this application. */
static int x, y;		/* Coordinates of last location moved to;
				 * used by "moveto" and "lineto" commands. */
static Tcl_CmdBuf buffer;	/* Used to assemble lines of terminal input
				 * into Tcl commands. */
static int tty;			/* Non-zero means standard input is a
				 * terminal-like device.  Zero means it's
				 * a file. */

/*
 * Command-line options:
 */

int synchronize = 0;
char *fileName = NULL;
char *name = NULL;
char *display = NULL;
char *geometry = NULL;

Tk_ArgvInfo argTable[] = {
    {"-file", TK_ARGV_STRING, (char *) NULL, (char *) &fileName,
	"File from which to read commands"},
    {"-geometry", TK_ARGV_STRING, (char *) NULL, (char *) &geometry,
	"Initial geometry for window"},
    {"-display", TK_ARGV_STRING, (char *) NULL, (char *) &display,
	"Display to use"},
    {"-name", TK_ARGV_STRING, (char *) NULL, (char *) &name,
	"Name to use for application"},
    {"-sync", TK_ARGV_CONSTANT, (char *) 1, (char *) &synchronize,
	"Use synchronous mode for display server"},
    {(char *) NULL, TK_ARGV_END, (char *) NULL, (char *) NULL,
	(char *) NULL}
};

/*
 * Declaration for Tcl command procedure to create demo widget.  This
 * procedure is only invoked if SQUARE_DEMO is defined.
 */

extern int Tk_SquareCmd _ANSI_ARGS_((ClientData clientData,
	Tcl_Interp *interp, int argc, char **argv));

/*
 * Forward declarations for procedures defined later in this file:
 */

static void		DelayedMap _ANSI_ARGS_((ClientData clientData));
static int		LinetoCmd _ANSI_ARGS_((ClientData clientData,
			    Tcl_Interp *interp, int argc, char **argv));
static int		MovetoCmd _ANSI_ARGS_((ClientData clientData,
			    Tcl_Interp *interp, int argc, char **argv));
static void		StdinProc _ANSI_ARGS_((ClientData clientData,
			    int mask));
static void		StructureProc _ANSI_ARGS_((ClientData clientData,
			    XEvent *eventPtr));
static int		_WinCallBack _ANSI_ARGS_((ClientData clientData,
			    Tcl_Interp *interp, int argc, char **argv));
static int		_getStrHandle _ANSI_ARGS_((ClientData clientData,
			    Tcl_Interp *interp, int argc, char **argv));


/*
 *----------------------------------------------------------------------
 *
 * main --
 *
 *	Main program for Wish.
 *
 * Results:
 *	None. This procedure never returns (it exits the process when
 *	it's done
 *
 * Side effects:
 *	This procedure initializes the wish world and then starts
 *	interpreting commands;  almost anything could happen, depending
 *	on the script being interpreted.
 *
 *----------------------------------------------------------------------
 */

int
main( int argc,				/* Number of arguments. */
    char **argv)			/* Array of argument strings. */
{
    char *args, *p, *msg;
    char buf[20];  char bigBuf[300];
    int result;
    Tk_3DBorder border;

#ifdef TK_EXTENDED
    tk_mainInterp = interp = Tcl_CreateExtendedInterp();
#else
    interp = Tcl_CreateInterp();
#endif
#ifdef TCL_MEM_DEBUG
    Tcl_InitMemory(interp);
#endif

    /*
     * Parse command-line arguments.
     */

#if 0
    if (Tk_ParseArgv(interp, (Tk_Window) NULL, &argc, argv, argTable, 0)
	    != TCL_OK) {
	fprintf(stderr, "%s\n", interp->result);
	exit(1);
    }
#endif
    if (name == NULL) {
	if (fileName != NULL) {
	    p = fileName;
	} else {
	    p = argv[0];
	}
	name = strrchr(p, '/');
	if (name != NULL) {
	    name++;
	} else {
	    name = p;
	}
    }

    /*
     * Initialize the Tk application and arrange to map the main window
     * after the startup script has been executed, if any.  This way
     * the script can withdraw the window so it isn't ever mapped
     * at all.
     */

    w = Tk_CreateMainWindow(interp, display, name);
    if (w == NULL) {
	fprintf(stderr, "%s\n", interp->result);
	exit(1);
    }
    Tk_SetClass(w, "Tk");
    Tk_CreateEventHandler(w, StructureNotifyMask, StructureProc,
	    (ClientData) NULL);
    Tk_DoWhenIdle(DelayedMap, (ClientData) NULL);
    if (synchronize) {
	XSynchronize(Tk_Display(w), True);
    }
    Tk_GeometryRequest(w, 200, 200);
    border = Tk_Get3DBorder(interp, w, None, "#ffe4c4");
    if (border == NULL) {
	Tcl_SetResult(interp, (char *) NULL, TCL_STATIC);
	Tk_SetWindowBackground(w, WhitePixelOfScreen(Tk_Screen(w)));
    } else {
	Tk_SetBackgroundFromBorder(w, border);
    }
    XSetForeground(Tk_Display(w), DefaultGCOfScreen(Tk_Screen(w)),
	    BlackPixelOfScreen(Tk_Screen(w)));

    /*
     * Make command-line arguments available in the Tcl variables "argc"
     * and "argv".  Also set the "geometry" variable from the geometry
     * specified on the command line.
     */

#if 0
    args = Tcl_Merge(argc-1, argv+1);
    Tcl_SetVar(interp, "argv", args, TCL_GLOBAL_ONLY);
    ckfree(args);
    sprintf(buf, "%d", argc-1);
    Tcl_SetVar(interp, "argc", buf, TCL_GLOBAL_ONLY);
#endif
    if (geometry != NULL) {
	Tcl_SetVar(interp, "geometry", geometry, TCL_GLOBAL_ONLY);
    }

    /*
     * Add a few application-specific commands to the application's
     * interpreter.
     */

    Tcl_CreateCommand(interp, "lineto", LinetoCmd, (ClientData) w,
	    (void (*)()) NULL);
    Tcl_CreateCommand(interp, "moveto", MovetoCmd, (ClientData) w,
	    (void (*)()) NULL);
#ifdef SQUARE_DEMO
    Tcl_CreateCommand(interp, "square", Tk_SquareCmd, (ClientData) w,
	    (void (*)()) NULL);
#endif
    Tcl_CreateCommand(interp, "wincallback", _WinCallBack, (ClientData) w,
	    (void (*)()) NULL);
    Tcl_CreateCommand(interp, "getstrhandle", _getStrHandle, (ClientData) w,
	    (void (*)()) NULL);

    /*
     * Execute Wish's initialization script, followed by the script specified
     * on the command line, if any.
     */

#ifdef TK_EXTENDED
    tclAppName     = "Wish";
    tclAppLongname = "Wish - Tk Shell";
    tclAppVersion  = TK_VERSION;
    Tcl_ShellEnvInit (interp, TCLSH_ABORT_STARTUP_ERR,
                      name,
                      0, NULL,           /* argv var already set  */
                      fileName == NULL,  /* interactive?          */
                      NULL);             /* Standard default file */
#endif
    result = Tcl_Eval(interp, initCmd, 0, (char **) NULL);
    if (result != TCL_OK) {
	goto error;
    }
    strcpy(bigBuf, Tcl_GetVar(interp, "auto_path", TCL_GLOBAL_ONLY));
    strcat(bigBuf," /usr/local/windows");
    Tcl_SetVar(interp, "auto_path", bigBuf, TCL_GLOBAL_ONLY);
    dprintf(4,("set auto_path \"$auto_path /usr/local/windows\""));
    if (result != TCL_OK) {
	goto error;
    }
#if 0
    tty = isatty(0);
    if (fileName != NULL) {
	result = Tcl_VarEval(interp, "source ", fileName, (char *) NULL);
	if (result != TCL_OK) {
	    goto error;
	}
	tty = 0;
    } else {
	/*
	 * Commands will come from standard input.  Set up a handler
	 * to receive those characters and print a prompt if the input
	 * device is a terminal.
	 */

	Tk_CreateFileHandler(0, TK_READABLE, StdinProc, (ClientData) 0);
	if (tty) {
	    printf("wish: ");
	}
    }
#endif
    fflush(stdout);
    buffer = Tcl_CreateCmdBuf();
    (void) Tcl_Eval(interp, "update", 0, (char **) NULL);

    /*
     * Loop infinitely, waiting for commands to execute.  When there
     * are no windows left, Tk_MainLoop returns and we clean up and
     * exit.
     */
/* Tcl_Eval( interp, "button .hello -text \"Hello, world\" -command {\n puts stdout \"Hello, world\"; destroy .\n\
}\n pack append . .hello {top}\n", 0, (char **)NULL); */
    _WinMain(argc,argv);
    Tcl_DeleteInterp(interp);
    Tcl_DeleteCmdBuf(buffer);
    exit(0);

error:
    msg = Tcl_GetVar(interp, "errorInfo", TCL_GLOBAL_ONLY);
    if (msg == NULL) {
	msg = interp->result;
    }
    fprintf(stderr, "%s\n", msg);
    Tcl_Eval(interp, "destroy .", 0, (char **) NULL);
    exit(1);
    return 0;			/* Needed only to prevent compiler warnings. */
}

/*
 *----------------------------------------------------------------------
 *
 * StdinProc --
 *
 *	This procedure is invoked by the event dispatcher whenever
 *	standard input becomes readable.  It grabs the next line of
 *	input characters, adds them to a command being assembled, and
 *	executes the command if it's complete.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Could be almost arbitrary, depending on the command that's
 *	typed.
 *
 *----------------------------------------------------------------------
 */

    /* ARGSUSED */
static void
StdinProc(clientData, mask)
    ClientData clientData;		/* Not used. */
    int mask;				/* Not used. */
{
#define BUFFER_SIZE 4000
    char input[BUFFER_SIZE+1];
    static int gotPartial = 0;
    char *cmd;
    int result, count;

count=strlen(input);
    if (count <= 0) {
	if (!gotPartial) {
	    if (tty) {
		Tcl_Eval(interp, "destroy .", 0, (char **) NULL);
		exit(0);
	    } else {
		Tk_DeleteFileHandler(0);
	    }
	    return;
	} else {
	    input[0] = 0;
	}
    } else {
	input[count] = 0;
    }
    cmd = Tcl_AssembleCmd(buffer, input);
    if (cmd == NULL) {
	gotPartial = 1;
	return;
    }
    gotPartial = 0;
    result = Tcl_RecordAndEval(interp, cmd, 0);
    if (*interp->result != 0) {
	if ((result != TCL_OK) || (tty)) {
	    printf("%s\n", interp->result);
	}
    }
    if (tty) {
	printf("wish: ");
	fflush(stdout);
    }
}

/*
 *----------------------------------------------------------------------
 *
 * StructureProc --
 *
 *	This procedure is invoked whenever a structure-related event
 *	occurs on the main window.  If the window is deleted, the
 *	procedure modifies "w" to record that fact.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Variable "w" may get set to NULL.
 *
 *----------------------------------------------------------------------
 */

	/* ARGSUSED */
static void
StructureProc(clientData, eventPtr)
    ClientData clientData;	/* Information about window. */
    XEvent *eventPtr;		/* Information about event. */
{
    if (eventPtr->type == DestroyNotify) {
	w = NULL;
    }
}

/*
 *----------------------------------------------------------------------
 *
 * DelayedMap --
 *
 *	This procedure is invoked by the event dispatcher once the
 *	startup script has been processed.  It waits for all other
 *	pending idle handlers to be processed (so that all the
 *	geometry information will be correct), then maps the
 *	application's main window.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The main window gets mapped.
 *
 *----------------------------------------------------------------------
 */

	/* ARGSUSED */
static void
DelayedMap(clientData)
    ClientData clientData;	/* Not used. */
{

    while (Tk_DoOneEvent(TK_IDLE_EVENTS) != 0) {
	/* Empty loop body. */
    }
    if (w == NULL) {
	return;
    }
    Tk_MapWindow(w);
}

/*
 *----------------------------------------------------------------------
 *
 * MoveToCmd and LineToCmd --
 *
 *	This procedures are registered as the command procedures for
 *	"moveto" and "lineto" Tcl commands.  They provide a trivial
 *	drawing facility.  They don't really work right, in that the
 *	drawn information isn't persistent on the screen (it will go
 *	away if the window is iconified and de-iconified again).  The
 *	commands are here partly for testing and partly to illustrate
 *	how to add application-specific commands to Tk.  You probably
 *	shouldn't use these commands in any real scripts.
 *
 * Results:
 *	The procedures return standard Tcl results.
 *
 * Side effects:
 *	The screen gets modified.
 *
 *----------------------------------------------------------------------
 */

	/* ARGSUSED */
static int
MovetoCmd(dummy, interp, argc, argv)
    ClientData dummy;			/* Not used. */
    Tcl_Interp *interp;			/* Current interpreter. */
    int argc;				/* Number of arguments. */
    char **argv;			/* Argument strings. */
{
    if (argc != 3) {
	Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
		" x y\"", (char *) NULL);
	return TCL_ERROR;
    }
    x = strtol(argv[1], (char **) NULL, 0);
    y = strtol(argv[2], (char **) NULL, 0);
    return TCL_OK;
}
	/* ARGSUSED */
static int
LinetoCmd(dummy, interp, argc, argv)
    ClientData dummy;			/* Not used. */
    Tcl_Interp *interp;			/* Current interpreter. */
    int argc;				/* Number of arguments. */
    char **argv;			/* Argument strings. */
{
    int newX, newY;

    if (argc != 3) {
	Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
		" x y\"", (char *) NULL);
	return TCL_ERROR;
    }
    newX = strtol(argv[1], (char **) NULL, 0);
    newY = strtol(argv[2], (char **) NULL, 0);
    Tk_MakeWindowExist(w);
    XDrawLine(Tk_Display(w), Tk_WindowId(w),
	    DefaultGCOfScreen(Tk_Screen(w)), x, y, newX, newY);
    x = newX;
    y = newY;
    return TCL_OK;
}

/*===============================================================*/

#define _WIN_CODE_SECTION
static int dte(char *str,...);
#include <windows.h>
#include <assert.h>


LPWNDCLASS	LpWndClass;

static int tclexec(char *str, ... )
{	int result;
	va_list va;
	char buf[2000];
	va_start(va, str);
	vsprintf(buf,str,va);
	dprintf(32,("tclexec'ing:%s",buf));
	result = Tcl_Eval( interp, buf, 0, (char **)NULL);
	va_end(str);
	if (result != TCL_OK)
	{	printf("error evaluating %s\n", buf);
		fprintf(stderr, "%s\n", interp->result);
		exit(-1);
	}
	return(result);
}

static void str2lower(char *str)
{
	while (*str)
	{	*str = tolower(*str);
		str++;
	}
}

static char *_handles[300];  
static int _handInd=0;

static char* getStrHandle(int hndl)
{	static char buf[20];
	if((hndl<_handInd) && (hndl>=0))
		return(_handles[hndl]);
	sprintf(buf, "%d", hndl);
	return(buf);
}

static int findHandle(char* str)
{	int i;
	for (i=0; i<_handInd; i++)
		if (!strcmp(str,_handles[i]))
			return(i);
	return(-1);
}

typedef enum {enum_win, enum_frame, enum_canvas, enum_button, enum_menu} class_enum;

static int allocStrHandle(char *seed, class_enum class)
{
	static char *classes[]= {"win", "frame", "canvas", "button", "menu"};
	static int classInds[10] = { 0, 0, 0, 0, 0, 0};
	char buf[200];
	assert((class>=0) && (class<=4));
	if (seed && *seed)
		sprintf(buf,"%s.%s%d", seed, classes[class], ++classInds[class]);
	else
		sprintf(buf,"%s%d", classes[class], ++classInds[class]);
	str2lower(buf);
	_handles[_handInd]=strdup(buf);
	return(_handInd++);
}

#if 0
static _WinMain(int argc, char *argv[])
{	int i; char buf[300];

	*buf = 0;
	for (i=1; i<argc; i++)
	{	if (*buf) strcat(buf," ");
		strcat(buf,argv[i]);
	}
	WinMain(getpid(),NULL,buf,SW_SHOWNORMAL); /* or SW_SHOWMINNOACTIVE*/
	exit(0);
}
#endif

static int _WinCallBack( ClientData  clientData, Tcl_Interp *interp,
	int         argc, char      **argv)
{
	int i;
	if (argc>2)
	{	if (!strcmp(argv[1],"menu"))
		{
#if 0
			LpWndClass->lpfnWndProc(findHandle(argv[2]),
				WM_COMMAND,atoi(argv[4]),0); 
#else
			CALLWNDPROC(LpWndClass->lpfnWndProc, 
				    findHandle(argv[2]),
				    WM_COMMAND,
				    atoi(argv[4]),
				    0);
#endif
		}
	}
/*	for (i=0; i<argc; i++)
		printf("%s\n", argv[i]);
	printf("\n"); */
	return(TCL_OK);
}

static int _getStrHandle( ClientData  clientData, Tcl_Interp *interp,
	int         argc, char      **argv)
{
	int i;
	if (argc != 2)
	{	sprintf(interp->result, "%s: invalid arg\n", argv[0]);
		return(TCL_ERROR);
	}
	i = atoi(argv[1]);
	strcpy(interp->result, getStrHandle(i));
	return(TCL_OK);
}

_MsMsg2XvMsg(HWND hwnd, char *event)
{
	WORD message, wParam = 0; LONG lParam = 0;
	if (1) message=WM_PAINT; 
#if 0
	LpWndClass->lpfnWndProc(hwnd,message,wParam,lParam); 
#else
	CALLWNDPROC(LpWndClass->lpfnWndProc, hwnd, message, wParam, lParam);
#endif
}

static short *closed_bits;

HWND  CreateWindow(LPSTR szAppName, LPSTR Label, DWORD ol, int x, int y, int w, int h, HWND d, HMENU e, HANDLE i, LPSTR g)
{	int result, n;
	static int called=0;
	if (x == CW_USEDEFAULT) x=0;
	if (y == CW_USEDEFAULT) y=0;
	if (w == CW_USEDEFAULT) w=500;
	if (h == CW_USEDEFAULT) h=400;
	n=allocStrHandle("",enum_win);
	tclexec( "CreateWindow %s \"%s\" %d %d %d %d", getStrHandle(n), Label, x, y, w, h);
	called=1;
	return((HWND)n);
}

int  DrawText(HDC a, LPSTR str, int c, LPRECT d, WORD flag)
{	int x=d->left, y=d->top, w = d->right, h=d->bottom;
	if (flag&DT_SINGLELINE);
	if (flag&DT_CENTER);
		x=200;
	if (flag&DT_VCENTER);
		y=200;
	/*tclexec(".%s create text 200 200 -text \"%s\" -anchor n\n",getStrHandle(a), str); */
	tclexec("DrawText %s \"%s\" %d %d %d %d\n",getStrHandle(a), str, 
		y,x,h,w);
}

BOOL GetMessage(LPMSG msg,HWND b,WORD c, WORD d)
{	static int called=0;
	if (!called)
		_MsMsg2XvMsg(b, 0);
	called=1;
	return(1);
}

long DispatchMessage(MSG *msg)
{	
	if (tk_NumMainWindows > 0) {
		Tk_DoOneEvent(0); 
		return(0);
	}
	exit(0);
}

BOOL TranslateMessage(LPMSG a){}

void MyEventProc( ClientData clientData, XEvent *eventPtr)
{
}


BOOL  RegisterClass(LPWNDCLASS a) 
{
	/* Tk_CreateEventHandler(win,mask,proc,data); */
	LpWndClass = a; return(1); 
}

BOOL ShowWindow(HWND a, int b) 
{
	if (b != SW_SHOWNORMAL)
	{  assert(b==SW_SHOWMINNOACTIVE);  /* iconize */
	}
	return(TRUE);
}

void UpdateWindow(HWND a)
{
}

HDC  BeginPaint(HWND a, LPPAINTSTRUCT b) 
{	return(a); 
}
void EndPaint(HWND a, LPPAINTSTRUCT b) { }

void GetClientRect(HWND a, LPRECT b)
{	b->top = 0; b->left = 0;
	b->bottom = b->top+0;
	b->right = b->left+0;
}

HMENU CreateMenu(void)
{	static int n, called=0;
	int result;
	if (!called) 
	{	n=allocStrHandle("",enum_frame);
		tclexec( "CreateMenuBar %s\n",getStrHandle(n));
	}
	else
	{	n=allocStrHandle("",enum_menu);
		tclexec( "CreateMenuEntry %s any 0\n",getStrHandle(n));
	}
	called=1;
	return(n);
}

BOOL  AppendMenu(HMENU a, WORD b, WORD c, LPSTR d)
{	char *buf; int dist,n;
	char *cmd = getStrHandle(a);
	if (d)
	{	char *t;
		buf = strdup(d);
		if (t=strchr(buf,'&'))
			strcpy(t,strchr(d,'&')+1);
		dist = t-buf;
	}
	tclexec("AppendMenu %s %d %s {%s} %d", cmd, b, getStrHandle(c),
		buf, dist); 
	return(1);
}

/*   Graphics Primitives */
BOOL  Rectangle(HDC a, int xLeft, int yTop, int xRight, int yBottom)
{
	XDrawRectangle(Tk_Display(w), Tk_WindowId(w), DefaultGCOfScreen(Tk_Screen(w)),
		xLeft, yTop, xRight-xLeft+1, yBottom-yTop+1);
}

int FillRect(HDC a,LPRECT b,HBRUSH c)
{
	XFillRectangle(Tk_Display(w), Tk_WindowId(w), DefaultGCOfScreen(Tk_Screen(w)),
		b->left, b->top, b->right-b->left+1, b->bottom-b->top+1);
}

static int _LineX=0, _LineY=0;

int LineTo(HDC a, int b, int c)
{
	XDrawLine(Tk_Display(w), Tk_WindowId(w), DefaultGCOfScreen(Tk_Screen(w)),
		_LineX,b, _LineY,c);
	_LineX=b;  _LineY=c;
}

int MoveTo(HDC a, int b, int c) { _LineX=b;  _LineY=c; }

BOOL Arc(HDC a, int xLeft, int yTop, int xRight, int yBottom, 
	int xStart, int yStart, int xEnd, int yEnd)
{	int w, h, x, y;
/*	XDrawArc(Tk_Display(w), Tk_WindowId(w), DefaultGCOfScreen(Tk_Screen(w)), x,y,..);*/
}

BOOL Pie(HDC a, int xLeft, int yTop, int xRight, int yBottom, 
	int xStart, int yStart, int xEnd, int yEnd)
{	int w, h, x,y;
}

BOOL Chord(HDC a, int xLeft, int yTop, int xRight, int yBottom, 
	int xStart, int yStart, int xEnd, int yEnd)
{	int w, h, x,y;
}

static int dte(char *str,...)
{       char cmd[300], *ptr, *ptr2;
	int n, i;
	va_list va;
	va_start(va, str);
        strcpy(cmd, str);
	n = va_arg(va,int);
	for (i=0; i<n; i++)
	{	ptr = va_arg(va,char *);
		ptr2 = va_arg(va,char *);
		if (!strncmp("LPSTR",ptr,5))
			sprintf(cmd+strlen(cmd)," \"%s\"", (ptr2?ptr2:""));
		else if (!strncmp("char",ptr,4))
			sprintf(cmd+strlen(cmd)," %c\0", ptr2);
		else if (!strncmp("HANDLE",ptr,6))
			sprintf(cmd+strlen(cmd)," %s", getStrHandle((int)ptr2));
		else
			sprintf(cmd+strlen(cmd)," %d", ptr2);
	}
	strcat(cmd,"\n");
	va_end(va);
	tclexec(cmd);
}

int wsprintf(LPSTR a,LPSTR b,...) {}

BOOL  IsCharAlpha(char ch) { return(isalpha(ch)); }
BOOL  IsCharAlphaNumeric(char ch) { return(isalnum(ch)); }
BOOL  IsCharUpper(char ch) { return(isupper(ch)); }
BOOL  IsCharLower(char ch) { return(islower(ch)); }
int	 lstrcmp( LPSTR a, LPSTR b ) { return(strcmp(a,b)); }
int	 lstrcmpi( LPSTR a, LPSTR b ) { return(strcasecmp(a,b)); }
LPSTR	lstrcpy( LPSTR a, LPSTR b ) { return(strcpy(a,b)); }
LPSTR	lstrcat( LPSTR a, LPSTR b ) { return(strcat(a,b)); }
int	 lstrlen( LPSTR a) { return(strlen(a)); }
int	 _lopen( LPSTR a, int b) { return(open(a,b)); }
int	 _lclose( int a) { return(close(a)); }
int	 _lcreat( LPSTR a, int b) { return(creat(a,b)); }
LONG	_llseek( int a, long b, int c) { return(lseek(a,b,c)); }
WORD	_lread( int a, LPSTR b, int c) { return(read(a,b,c)); }
WORD	_lwrite( int a, LPSTR b, int c) { return(write(a,b,c)); }
BOOL  ExitWindows(DWORD dwReserved, WORD wReturnCode) {exit(0); }