source: trunk/vizservers/pymolproxy/pymolproxy.c @ 951

/*
 * ----------------------------------------------------------------------
 * proxypymol.c
 *
 *      This module creates the Tcl interface to the pymol server.  It acts as
 *      a go-between establishing communication between a molvisviewer widget
 *      and the pymol server. The communication protocol from the molvisviewer
 *      widget is the Tcl language.  Commands are then relayed to the pymol
 *      server.  Responses from the pymol server are translated into Tcl
 *      commands * and send to the molvisviewer widget. For example, resulting
 *      image rendered offscreen is returned as BMP-formatted image data.
 *
 *  Copyright (c) 2004-2006  Purdue Research Foundation
 *
 *  See the file "license.terms" for information on usage and
 *  redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 * ======================================================================
 */

#include <stdio.h>
#include <assert.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <sys/select.h>
#include <poll.h>
#include <sys/time.h>
#include <fcntl.h>
#include <netinet/in.h>
#include <getopt.h>
#include <errno.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <tcl.h>

#undef INLINE
#ifdef __GNUC__
#  define INLINE __inline__
#else
#  define INLINE
#endif

#define IO_TIMEOUT (30000)

static FILE *flog;
static int debug = 1;

static void
trace TCL_VARARGS_DEF(char *, arg1)
{
    if (debug) {
        char *format;
        va_list args;

        format = TCL_VARARGS_START(char *, arg1, args);
        vfprintf(flog, format, args);
        fprintf(flog, "\n");
        fflush(flog);
    }
}

typedef struct {
    char *data;
    int   used;
    int   allocated;
} DyBuffer;

typedef struct {
    int p_stdin;
    int p_stdout;
    int p_stderr;
    int c_stdin;
    int c_stdout;
    DyBuffer image;
    int need_update;
    int can_update;
    int immediate_update;
    int sync;
    int labels;
    int frame;
    int rock_offset;
    int cacheid;
    int invalidate_cache;
    int error;
    int status;
} PymolProxy;

INLINE static void
dyBufferInit(DyBuffer *buffer)
{
    buffer->data = NULL;
    buffer->used = 0;
    buffer->allocated = 0;
}

INLINE static void
dyBufferFree(DyBuffer *buffer)
{
    assert(buffer != NULL);
    free(buffer->data);
    dyBufferInit(buffer);
}

void
dyBufferSetLength(DyBuffer *buffer, int length)
{
    assert(buffer != NULL);
    if (length == 0) {
        dyBufferFree(buffer);
    } else if (length > buffer->used) {
        char *newdata;
        
        newdata = realloc(buffer->data, length);
        if (newdata != NULL) {
            buffer->data = newdata;
            buffer->used = length;
            buffer->allocated = length;
        }
    } else {
        buffer->used = length;
    }
}

static void
dyBufferAppend(DyBuffer *buffer, const char *data, int length)
{
    int offset;

    assert(buffer != NULL);
    offset = buffer->used;
    dyBufferSetLength(buffer, offset + length);
    memcpy(buffer->data + offset, data, length);
}

static int
bwrite(int sock, char *buffer, int size)
{
    int result;
    int total = 0;
    int left = size;

    trace("bwrite: want to write %d bytes\n", size);
    while(1) {
        result = write(sock,buffer+total,left);

        if (result <= 0)
            break;

        total += result;
        left -= result;

        if (total == size)
            break;
    }
    trace("bwrite: wrote %d bytes\n", total);
    return(total);
}

static int
bread(int sock, char *buffer, int size)
{
    int result, total, left;

    for( total = 0, left = size; left > 0; left -= result) {
        result = read(sock,buffer+total,left);
        
        if (result > 0) {
            total += result;
            continue;
        }
        
        if ((result < 0) && (errno != EAGAIN) && (errno != EINTR)) { 
            trace("pymolproxy: Error reading sock(%d), %d/%s\n", 
                  sock, errno,strerror(errno));
            break;
        }
        
        result = 0;
    }
    return(total);
}

#ifdef notdef

static int 
bflush(int sock, char *buffer, int size, int bytes)
{
    int bsize;

    while(bytes) {
        if (bytes > size)
            bsize = size;
        else
            bsize = bytes;
        
        bsize = bread(sock,buffer,bsize);
        
        bytes -= bsize;     
    }
}

#undef timersub
static void
timersub(struct timeval *a, struct timeval *b, struct timeval *result)
{
    result->tv_sec = a->tv_sec - b->tv_sec;
    result->tv_usec = a->tv_usec - b->tv_usec;

    while(result->tv_usec < 0) {
        result->tv_sec -= 1;
        result->tv_usec += 1000000;
    }
}

#endif

static void
timersub_ms(struct timeval *a, struct timeval *b, int *result)
{
    struct timeval tmp;

    tmp.tv_sec = a->tv_sec - b->tv_sec;
    tmp.tv_usec = a->tv_usec - b->tv_usec;

    while(tmp.tv_usec < 0) {
        tmp.tv_sec -= 1;
        tmp.tv_usec += 1000000;
    }

    *result = (tmp.tv_sec * 1000) + (tmp.tv_usec / 1000);
}

#undef timeradd
static void
timeradd (struct timeval *a, struct timeval *b, struct timeval *result)
{
    result->tv_sec = a->tv_sec + b->tv_sec;
    result->tv_usec = a->tv_usec + b->tv_usec;

    while (result->tv_usec >= 1000000) {
        result->tv_sec += 1;
        result->tv_usec -= 1000000;
    }
}

static void
timerset_ms(struct timeval *result, int timeout)
{
    result->tv_sec = timeout / 1000;
    result->tv_usec = (timeout % 1000) * 1000;
}

static int
getline(int sock, char *buffer, int size, long timeout)
{
    int pos = 0, status, timeo;
    struct timeval now, end, tmo;
    struct pollfd ufd;

    gettimeofday(&now,NULL);
    timerset_ms(&tmo, timeout);
    timeradd(&now,&tmo,&end);

    ufd.fd = sock;
    ufd.events = POLLIN;

    size--;

    while(pos < size) {
        if (timeout > 0) {
            gettimeofday(&now,NULL);
            timersub_ms(&now,&end,&timeo);
        } 
        else
            timeo = -1;

        status = poll(&ufd, 1, timeo);

        if (status > 0)
            status = read(sock,&buffer[pos],1);

        if ( (status < 0) && ( (errno == EINTR) || (errno == EAGAIN) ) )
            continue; /* try again, if interrupted/blocking */

        if (status <= 0)
            break;
                        
        if (buffer[pos] == '\n') {
            pos++;
            break;
        }
        pos++;
    }

    buffer[pos]=0;

    return(pos);
}

static int
waitForString(PymolProxy *pymol, char *string, char *buffer, int length)
{
    int sock;

    assert(buffer != NULL);
    if (pymol->status != TCL_OK)
        return pymol->status;

    sock = pymol->p_stdout;
    trace("want to match (%s)\n", string);
    while(1) {
        if (getline(sock,buffer,length,IO_TIMEOUT) == 0) {
            pymol->error = 2;
            pymol->status = TCL_ERROR;
            break;
        }
        trace("stdout-u>read(%s)", buffer);
        if (strncmp(buffer, string, strlen(string)) == 0) {
            trace("stdout-e> %s",buffer);
            pymol->error = 0;
            pymol->status = TCL_OK;
            break;
        }
    }

    return pymol->status;
}

INLINE static int
clear_error(PymolProxy *pymol)
{
    pymol->error = 0;
    pymol->status = TCL_OK;
    return pymol->status;
}

static int
send_expect(PymolProxy *pymol, char *expect, char *cmd)
{
    if (pymol->error) {
        return(TCL_ERROR);
    }
    trace("to-pymol>(%s)", cmd);
    write(pymol->p_stdin, cmd, strlen(cmd));
    if (waitForString(pymol, expect, cmd, 800)) {
        trace("pymolproxy: Timeout reading data [%s]\n",cmd);
        pymol->error = 1;
        pymol->status = TCL_ERROR;
        return pymol->status;
    }
    return( pymol->status );
}

static int
sendf(PymolProxy *pymol, char *format, ...)
{
    va_list ap;
    char buffer[800];

    if (pymol->error)
        return(TCL_ERROR);

    va_start(ap, format);
    vsnprintf(buffer, 800, format, ap);
    va_end(ap);
    trace("to-pymol>(%s)", buffer);
    write(pymol->p_stdin, buffer, strlen(buffer));

    if (waitForString(pymol, "PyMOL>", buffer, 800)) {
        trace("pymolproxy: Timeout reading data [%s]\n",buffer);
        pymol->error = 1;
        pymol->status = TCL_ERROR;
        return pymol->status;
    }

    return( pymol->status );
}

static int
BallNStickCmd(ClientData cdata, Tcl_Interp *interp, int argc, const char *argv[])
{
    int ghost = 0, defer = 0, push = 0, arg;
    const char *model = "all";
    PymolProxy *pymol = (PymolProxy *) cdata;

    clear_error(pymol);

    for(arg = 1; arg < argc; arg++) {
        if ( strcmp(argv[arg],"-defer") == 0 )
            defer = 1;
        else if (strcmp(argv[arg],"-push") == 0)
            push = 1;
        else if (strcmp(argv[arg],"-ghost") == 0)
            ghost = 1;
        else if (strcmp(argv[arg],"-normal") == 0)
            ghost = 0;
        else if (strcmp(argv[arg],"-model") == 0) {
            if (++arg < argc)
                model = argv[arg];
        }
        else
            model = argv[arg];
    }

    pymol->invalidate_cache = 1;
    pymol->need_update = !defer || push;
    pymol->immediate_update |= push;

    sendf(pymol, "hide everything,%s\n",model);
    sendf(pymol, "set stick_color,white,%s\n",model);
        
    if (ghost)
        sendf(pymol, "set stick_radius,0.1,%s\n",model);
    else
        sendf(pymol, "set stick_radius,0.14,%s\n",model);

    sendf(pymol, "set sphere_scale=0.25,%s\n", model);

    if (ghost) {
        sendf(pymol, "set sphere_transparency,0.75,%s\n", model);
        sendf(pymol, "set stick_transparency,0.75,%s\n", model);
    }
    else {
        sendf(pymol, "set sphere_transparency,0,%s\n", model);
        sendf(pymol, "set stick_transparency,0,%s\n", model);
    }

    sendf(pymol, "show sticks,%s\n",model);
    sendf(pymol, "show spheres,%s\n",model);

    if (pymol->labels)
        sendf(pymol, "show labels,%s\n", model);

    return( pymol->status );
}

static int
SpheresCmd(ClientData cdata, Tcl_Interp *interp, int argc, const char *argv[])
{
    int defer = 0, ghost = 0, push = 0, arg;
    const char *model = "all";
    PymolProxy *pymol = (PymolProxy *) cdata;

    clear_error(pymol);

    for(arg = 1; arg < argc; arg++) {
        if ( strcmp(argv[arg],"-defer") == 0 )
            defer = 1;
        else if (strcmp(argv[arg],"-push") == 0)
            push = 1;
        else if (strcmp(argv[arg],"-ghost") == 0)
            ghost = 1;
        else if (strcmp(argv[arg],"-normal") == 0)
            ghost = 0;
        else if (strcmp(argv[arg],"-model") == 0) {
            if (++arg < argc)
                model = argv[arg];
        }
        else
            model = argv[arg];
    }

    pymol->invalidate_cache = 1;
    pymol->need_update = !defer || push;
    pymol->immediate_update |= push;

    sendf(pymol, "hide everything, %s\n", model);
    sendf(pymol, "set sphere_scale,0.41,%s\n", model);
    //sendf(pymol, "set sphere_quality,2,%s\n", model);
    sendf(pymol, "set ambient,.2,%s\n", model);

    if (ghost)
        sendf(pymol, "set sphere_transparency,.75,%s\n", model);
    else
        sendf(pymol, "set sphere_transparency,0,%s\n", model);

    sendf(pymol, "show spheres,%s\n", model);

    if (pymol->labels)
        sendf(pymol, "show labels,%s\n", model);

    return pymol->status;
}

static int
LinesCmd(ClientData cdata, Tcl_Interp *interp, int argc, const char *argv[])
{
    int ghost = 0, defer = 0, push = 0, arg;
    const char *model = "all";
    PymolProxy *pymol = (PymolProxy *) cdata;

    clear_error(pymol);

    for(arg = 1; arg < argc; arg++) {
        if ( strcmp(argv[arg],"-defer") == 0 )
            defer = 1;
        else if (strcmp(argv[arg],"-push") == 0)
            push = 1;
        else if (strcmp(argv[arg],"-ghost") == 0)
            ghost = 1;
        else if (strcmp(argv[arg],"-normal") == 0)
            ghost = 0;
        else if (strcmp(argv[arg],"-model") == 0) {
            if (++arg < argc)
                model = argv[arg];
        }
        else
            model = argv[arg];
    }

    pymol->invalidate_cache = 1;
    pymol->need_update = !defer || push;
    pymol->immediate_update |= push;

    sendf(pymol, "hide everything,%s\n",model);

    if (ghost)
        sendf(pymol, "set line_width,.25,%s\n",model);
    else
        sendf(pymol, "set line_width,1,%s\n",model);

    sendf(pymol, "show lines,%s\n",model);

    if (pymol->labels)
        sendf(pymol, "show labels,%s\n",model);

    return pymol->status;
}

static int
DisableCmd(ClientData cdata, Tcl_Interp *interp, int argc, const char *argv[])
{
    PymolProxy *pymol = (PymolProxy *) cdata;
    const char *model = "all";
    int arg, defer = 0, push = 0;

    clear_error(pymol);

    for(arg = 1; arg < argc; arg++) {

        if (strcmp(argv[arg], "-defer") == 0 )
            defer = 1;
        else if (strcmp(argv[arg], "-push") == 0 )
            push = 1;
        else
            model = argv[arg];
        
    }

    pymol->need_update = !defer || push;
    pymol->immediate_update |= push;
    pymol->invalidate_cache = 1;

    sendf( pymol, "disable %s\n", model);

    return pymol->status;
}

static int
EnableCmd(ClientData cdata, Tcl_Interp *interp, int argc, const char *argv[])
{
    PymolProxy *pymol = (PymolProxy *) cdata;
    const char *model = "all";
    int arg, defer = 0, push = 0;

    clear_error(pymol);

    for(arg = 1; arg < argc; arg++) {
                
        if (strcmp(argv[arg],"-defer") == 0)
            defer = 1;
        else if (strcmp(argv[arg], "-push") == 0 )
            push = 1;
        else
            model = argv[arg];

    }

    pymol->need_update = !defer || push;
    pymol->immediate_update |= push;
    pymol->invalidate_cache = 1;

    sendf( pymol, "enable %s\n", model);

    return pymol->status;
}

static int
VMouseCmd(ClientData cdata, Tcl_Interp *interp, int argc, const char *argv[])
{
    PymolProxy *pymol = (PymolProxy *) cdata;
    int arg, defer = 0, push = 0, varg = 1;
    int arg1 = 0, arg2 = 0, arg3 = 0, arg4 = 0, arg5 = 0;

    clear_error(pymol);

    for(arg = 1; arg < argc; arg++) {
        if (strcmp(argv[arg], "-defer") == 0)
            defer = 1;
        else if (strcmp(argv[arg], "-push") == 0)
            push = 1;
        else if (varg == 1) {
            arg1 = atoi(argv[arg]);
            varg++;
        }
        else if (varg == 2) {
            arg2 = atoi(argv[arg]);
            varg++;
        }
        else if (varg == 3) {
            arg3 = atoi(argv[arg]);
            varg++;
        }
        else if (varg == 4) {
            arg4 = atoi(argv[arg]);
            varg++;
        }
        else if (varg == 5) {
            arg5 = atoi(argv[arg]);
            varg++;
        }
    }

    pymol->need_update = !defer || push;
    pymol->immediate_update |= push;
    pymol->invalidate_cache = 1;

    sendf(pymol, "vmouse %d,%d,%d,%d,%d\n", arg1,arg2,arg3,arg4,arg5);

    return pymol->status;
}

static int
RawCmd(ClientData cdata, Tcl_Interp *interp, int argc, const char *argv[])
{
    PymolProxy *pymol = (PymolProxy *) cdata;
    DyBuffer buffer;
    int arg, defer = 0, push = 0;
    const char *cmd;
    clear_error(pymol);

    dyBufferInit(&buffer);

    cmd = NULL;
    for(arg = 1; arg < argc; arg++) {
        if (strcmp(argv[arg], "-defer") == 0)
            defer = 1;
        else if (strcmp(argv[arg], "-push") == 0)
            push = 1;
        else {
            cmd = argv[arg];
        }
    }

    pymol->need_update = !defer || push;
    pymol->immediate_update |= push;
    pymol->invalidate_cache = 1;

    sendf(pymol,"%s\n", cmd);
    dyBufferFree(&buffer);

    return pymol->status;
}

static int
LabelCmd(ClientData cdata, Tcl_Interp *interp, int argc, const char *argv[])
{
    PymolProxy *pymol = (PymolProxy *) cdata;
    int state = 1;
    int arg, push = 0, defer = 0;

    clear_error(pymol);

    for(arg = 1; arg < argc; arg++) {
        if ( strcmp(argv[arg],"-defer") == 0 )
            defer = 1;
        else if (strcmp(argv[arg],"-push") == 0 )
            push = 1;
        else if (strcmp(argv[arg],"on") == 0 )
            state = 1;
        else if (strcmp(argv[arg],"off") == 0 )
            state = 0;
        else if (strcmp(argv[arg],"toggle") == 0 )
            state =  !pymol->labels;
    }

    pymol->need_update = !defer || push;
    pymol->immediate_update |= push;
    pymol->invalidate_cache = 1;

    if (state) {
        sendf(pymol, "set label_color,white,all\n");
        sendf(pymol, "set label_size,14,all\n");
        sendf(pymol, "label all,\"%%s%%s\" %% (ID,name)\n");
    }
    else
        sendf(pymol, "label all\n");

    pymol->labels = state;

    return pymol->status;
}

static int
FrameCmd(ClientData cdata, Tcl_Interp *interp, int argc, const char *argv[])
{
    PymolProxy *pymol = (PymolProxy *) cdata;
    int frame = 0;
    int arg, push = 0, defer = 0;

    clear_error(pymol);

    for(arg = 1; arg < argc; arg++) {
        if ( strcmp(argv[arg],"-defer") == 0 )
            defer = 1;
        else if (strcmp(argv[arg],"-push") == 0 )
            push = 1;
        else
            frame = atoi(argv[arg]);
    }
                
    pymol->need_update = !defer || push;
    pymol->immediate_update |= push;

    pymol->frame = frame;

    sendf(pymol,"frame %d\n", frame);
        
    return pymol->status;
}

static int
ResetCmd(ClientData cdata, Tcl_Interp *interp, int argc, const char *argv[])
{
    PymolProxy *pymol = (PymolProxy *) cdata;
    int arg, push = 0, defer = 0;

    clear_error(pymol);

    for(arg = 1; arg < argc; arg++) {
        if ( strcmp(argv[arg],"-defer") == 0 )
            defer = 1;
        else if (strcmp(argv[arg],"-push") == 0 )
            push = 1;
    }
                
    pymol->need_update = !defer || push;
    pymol->immediate_update |= push;
    pymol->invalidate_cache = 1;
        
    sendf(pymol, "reset\n");
    sendf(pymol, "zoom buffer=2\n");

    return pymol->status;
}

static int
RockCmd(ClientData cdata, Tcl_Interp *interp, int argc, const char *argv[])
{
    PymolProxy *pymol = (PymolProxy *) cdata;
    float y = 0.0;
    int arg, push = 0, defer = 0;

    clear_error(pymol);

    for(arg = 1; arg < argc; arg++) {
        if ( strcmp(argv[arg],"-defer") == 0 )
            defer = 1;
        else if (strcmp(argv[arg],"-push") == 0 )
            push = 1;
        else
            y = atof( argv[arg] );
    }
                
    pymol->need_update = !defer || push;
    pymol->immediate_update |= push;

    sendf(pymol,"turn y, %f\n", y - pymol->rock_offset);

    pymol->rock_offset = y;

    return pymol->status;
}

static int
ViewportCmd(ClientData cdata, Tcl_Interp *interp, int argc, const char *argv[])
{
    PymolProxy *pymol = (PymolProxy *) cdata;
    int width = 640, height = 480;
    int defer = 0, push = 0, arg, varg = 1;

    clear_error(pymol);

    for(arg = 1; arg < argc; arg++) {
        if ( strcmp(argv[arg],"-defer") == 0 ) 
            defer = 1;
        else if ( strcmp(argv[arg], "-push") == 0 )
            push = 1;
        else if (varg == 1) {
            width = atoi(argv[arg]);
            height = width;
            varg++;
        }
        else if (varg == 2) {
            height = atoi(argv[arg]);
            varg++;
        }
    }

    pymol->need_update = !defer || push;
    pymol->immediate_update |= push;
    pymol->invalidate_cache = 1;

    sendf(pymol, "viewport %d,%d\n", width, height);

    //usleep(205000); // .2s delay for pymol to update its geometry *HACK ALERT*
        
    return pymol->status;
}

static int
LoadPDBCmd(ClientData cdata, Tcl_Interp *interp, int argc, const char *argv[])
{
    const char *pdbdata, *name;
    PymolProxy *pymol = (PymolProxy *) cdata;
    int state = 1;
    int arg, defer = 0, push = 0, varg = 1;

    clear_error(pymol);

    pdbdata = name = NULL;      /* Suppress compiler warning. */
    for(arg = 1; arg < argc; arg++) {
        if ( strcmp(argv[arg],"-defer") == 0 )
            defer = 1;
        else if (strcmp(argv[arg],"-push") == 0)
            push = 1;
        else if (varg == 1) {
            pdbdata = argv[arg];
            varg++;
        }
        else if (varg == 2) {
            name = argv[arg];
            varg++;
        }
        else if (varg == 3) {
            state = atoi( argv[arg] );
            varg++;
        }
    }

    pymol->need_update = !defer || push;
    pymol->immediate_update |= push;

    {
        int count;
        const char *p;
        char *q, *newdata;

        count = 0;
        for (p = pdbdata; *p != '\0'; p++) {
            if (*p == '\n') {
                count++;
            }
            count++;
        }
        
        q = newdata = malloc(count + 100);
        strcpy(newdata, "cmd.read_pdbstr(\"\"\"\\\n");
        q = newdata + strlen(newdata);
        for (p = pdbdata; *p != '\0'; p++, q++) {
            if (*p == '\n') {
                *q++ = '\\';
            } 
            *q = *p;
        }
        sprintf(q, "\\\n\"\"\",\"%s\",%d)\n", name, state);
        {
            char expect[800];

            sprintf(expect, "PyMOL>\"\"\",\"%s\",%d)\n", name, state);
            send_expect(pymol, expect, newdata);
        }
        free(newdata);
    }
    sendf(pymol, "zoom buffer=2\n");

    return pymol->status;
}

static int
RotateCmd(ClientData cdata, Tcl_Interp *interp, int argc, const char *argv[])
{
    double turnx = 0.0;
    double turny = 0.0;
    double turnz = 0.0;
    PymolProxy *pymol = (PymolProxy *) cdata;
    int defer = 0, push = 0, arg, varg = 1;

    clear_error(pymol);

    for(arg = 1; arg < argc; arg++)
        {
            if (strcmp(argv[arg],"-defer") == 0)
                defer = 1;
            else if (strcmp(argv[arg],"-push") == 0)
                push = 1;
            else  if (varg == 1) {
                turnx = atof(argv[arg]);
                varg++;
            }
            else if (varg == 2) {
                turny = atof(argv[arg]);
                varg++;
            }
            else if (varg == 3) {
                turnz = atof(argv[arg]);
                varg++;
            }
        } 
 
    pymol->need_update = !defer || push;
    pymol->immediate_update  |= push;
    pymol->invalidate_cache = 1;

    if (turnx != 0.0)
        sendf(pymol,"turn x, %f\n", turnx);
        
    if (turny != 0.0)
        sendf(pymol,"turn y, %f\n", turny);
        
    if (turnz != 0.0) 
        sendf(pymol,"turn z, %f\n", turnz);

    return pymol->status;
}

static int
ZoomCmd(ClientData cdata, Tcl_Interp *interp, int argc, const char *argv[])
{
    double factor = 0.0;
    double zmove = 0.0;
    PymolProxy *pymol = (PymolProxy *) cdata;
    int defer = 0, push = 0, arg, varg = 1;

    clear_error(pymol);

    for(arg = 1; arg < argc; arg++)
        {
            if (strcmp(argv[arg],"-defer") == 0)
                defer = 1;
            else if (strcmp(argv[arg],"-push") == 0)
                push = 1;
            else if (varg == 1) {
                factor = atof(argv[arg]);
                varg++;
            }
        }

    zmove = factor * -75;
 
    pymol->need_update = !defer || push;
    pymol->immediate_update  |= push;
    pymol->invalidate_cache = 1;

    if (zmove != 0.0)
        sendf(pymol,"move z, %f\n", factor);

    return pymol->status;
}

static int
PNGCmd(ClientData cdata, Tcl_Interp *interp, int argc, const char *argv[])
{
    char buffer[800];
    unsigned int bytes=0;
    float samples = 0.0;
    PymolProxy *pymol = (PymolProxy *) cdata;

    clear_error(pymol);

    if (pymol->invalidate_cache)
        pymol->cacheid++;

    pymol->need_update = 0;
    pymol->immediate_update = 0;
    pymol->invalidate_cache = 0;

    sendf(pymol,"png -\n");

    waitForString(pymol, "image follows: ", buffer, 800);

    sscanf(buffer, "image follows: %d %f\n", &bytes, &samples);
 
    write(3,&samples,sizeof(samples));
  
    dyBufferSetLength(&pymol->image, bytes);

    bread(pymol->p_stdout, pymol->image.data, pymol->image.used);

    waitForString(pymol, " ScenePNG", buffer,800);

    if (bytes && (pymol->image.used == bytes)) {
        sprintf(buffer, "nv>image %d %d %d %d\n", 
                bytes, pymol->cacheid, pymol->frame, pymol->rock_offset);
        trace("to-molvis> %s", buffer);
        write(pymol->c_stdin, buffer, strlen(buffer));
        bwrite(pymol->c_stdin, pymol->image.data, bytes);
    }
    return pymol->status;
}

static int
BMPCmd(ClientData cdata, Tcl_Interp *interp, int argc, const char *argv[])
{
    char buffer[800];
    unsigned int bytes=0;
    float samples = 0.0;
    PymolProxy *pymol = (PymolProxy *) cdata;

    clear_error(pymol);

    if (pymol->invalidate_cache)
        pymol->cacheid++;

    pymol->need_update = 0;
    pymol->immediate_update = 0;
    pymol->invalidate_cache = 0;

    sendf(pymol,"bmp -\n");

    waitForString(pymol, "image follows: ", buffer, 800);

    sscanf(buffer, "image follows: %d %f\n", &bytes, &samples);
    write(3,&samples,sizeof(samples));

    dyBufferSetLength(&pymol->image, bytes);

    bread(pymol->p_stdout, pymol->image.data, pymol->image.used);

    if (bytes && (pymol->image.used == bytes)) {
        sprintf(buffer, "nv>image %d %d %d %d\n", 
                bytes, pymol->cacheid, pymol->frame, pymol->rock_offset);
        write(pymol->c_stdin, buffer, strlen(buffer));
        trace("to-molvis buffer=%s\n", buffer);
        bwrite(pymol->c_stdin, pymol->image.data, bytes);
    }
    return pymol->status;
}
        
static int 
ProxyInit(int c_in, int c_out, char *const *argv)
{
    int flags, status, result = 0;
    int pairIn[2];
    int pairOut[2];
    int pairErr[2];
    Tcl_Interp *interp;
    Tcl_DString cmdbuffer;
    DyBuffer dybuffer, dybuffer2;
    struct pollfd ufd[3];
    int pid;
    PymolProxy pymol;
    struct timeval now,end;
    int timeout;

    /* Create three pipes for communication with the external application. One
     * each for the applications's: stdin, stdout, and stderr  */

    if (pipe(pairIn) == -1)
        return(-1);

    if (pipe(pairOut) == -1) {
        close(pairIn[0]);
        close(pairIn[1]);
        return(-1);
    }

    if (pipe(pairErr) == -1) {
        close(pairIn[0]);
        close(pairIn[1]);
        close(pairOut[0]);
        close(pairOut[1]);
        return(-1);
    }

    /* Fork the new process.  Connect i/o to the new socket.  */

    pid = fork();
        
    if (pid < 0) {
        fprintf(stderr, "can't fork process: %s\n", strerror(errno));
        return(-3);
    }
    if (pid == 0) {
        int fd;

        /* Child process */
        
        /* 
         * Create a new process group, so we can later kill this process and
         * all its children without affecting the process that created this
         * one.
         */
        setpgid(pid, 0); 
        
        /* Redirect stdin, stdout, and stderr to pipes before execing */ 
        dup2(pairIn[0] ,0);  // stdin
        dup2(pairOut[1],1);  // stdout
        dup2(pairErr[1],2);  // stderr
        
        for(fd = 3; fd < FD_SETSIZE; fd++)  /* close all other descriptors  */
            close(fd);
        
        execvp(argv[0], argv);
        trace("pymolproxy: Failed to start pyMol %s\n", argv[0]);
        exit(-1);
    }
       
    /* close opposite end of pipe, these now belong to the child process        */
    close(pairIn[0]);
    close(pairOut[1]);
    close(pairErr[1]);

    signal(SIGPIPE, SIG_IGN); // ignore SIGPIPE (ie if nanoscale terminates)

    pymol.p_stdin = pairIn[1];
    pymol.p_stdout = pairOut[0];
    pymol.p_stderr = pairErr[0];
    pymol.c_stdin  = c_in;
    pymol.c_stdout = c_out;
    pymol.labels = 0;
    pymol.need_update = 0;
    pymol.can_update = 1;
    pymol.immediate_update = 0;
    pymol.sync = 0;
    pymol.frame = 1;
    pymol.rock_offset = 0;
    pymol.cacheid = 0;
    pymol.invalidate_cache = 0;

    ufd[0].fd = pymol.c_stdout;
    ufd[0].events = POLLIN | POLLHUP; /* ensure catching EOF */
    ufd[1].fd = pymol.p_stdout;
    ufd[1].events = POLLIN | POLLHUP;
    ufd[2].fd = pymol.p_stderr;
    ufd[2].events = POLLIN | POLLHUP;

    flags = fcntl(pymol.p_stdout, F_GETFL);
    fcntl(pymol.p_stdout, F_SETFL, flags|O_NONBLOCK);

    interp = Tcl_CreateInterp();
    Tcl_MakeSafe(interp);

    Tcl_DStringInit(&cmdbuffer);
    dyBufferInit(&pymol.image);
    dyBufferInit(&dybuffer);
    dyBufferInit(&dybuffer2);

    Tcl_CreateCommand(interp, "bmp",     BMPCmd,        &pymol, NULL);
    Tcl_CreateCommand(interp, "png",     PNGCmd,        &pymol, NULL);
    Tcl_CreateCommand(interp, "screen",  ViewportCmd,   &pymol, NULL);
    Tcl_CreateCommand(interp, "viewport",ViewportCmd,   &pymol, NULL);
    Tcl_CreateCommand(interp, "rotate",  RotateCmd,     &pymol, NULL);
    Tcl_CreateCommand(interp, "zoom",    ZoomCmd,       &pymol, NULL);
    Tcl_CreateCommand(interp, "loadpdb", LoadPDBCmd,    &pymol, NULL);
    Tcl_CreateCommand(interp, "ballnstick",BallNStickCmd, &pymol, NULL);
    Tcl_CreateCommand(interp, "spheres", SpheresCmd,    &pymol, NULL);
    Tcl_CreateCommand(interp, "lines",   LinesCmd,      &pymol, NULL);
    Tcl_CreateCommand(interp, "raw",     RawCmd,        &pymol, NULL);
    Tcl_CreateCommand(interp, "label",   LabelCmd,      &pymol, NULL);
    Tcl_CreateCommand(interp, "reset",   ResetCmd,      &pymol, NULL);
    Tcl_CreateCommand(interp, "rock",    RockCmd,       &pymol, NULL);
    Tcl_CreateCommand(interp, "frame",   FrameCmd,      &pymol, NULL);
    Tcl_CreateCommand(interp, "vmouse",  VMouseCmd,     &pymol, NULL);
    Tcl_CreateCommand(interp, "disable", DisableCmd,    &pymol, NULL);
    Tcl_CreateCommand(interp, "enable",  EnableCmd,     &pymol, NULL);

    // Main Proxy Loop
    //  accept tcl commands from socket
    //  translate them into pyMol commands, and issue them to child proccess
    //  send images back

    gettimeofday(&end, NULL);

    while(1) 
        {
            char ch;

            gettimeofday(&now,NULL);

            if ( (!pymol.need_update) )
                timeout = -1;
            else if ((now.tv_sec > end.tv_sec) || ( (now.tv_sec == end.tv_sec) && (now.tv_usec >= end.tv_usec)) )
                timeout = 0; 
            else
                {
                    timeout = (end.tv_sec - now.tv_sec) * 1000;

                    if (end.tv_usec > now.tv_usec)
                        timeout += (end.tv_usec - now.tv_usec) / 1000;
                    else
                        timeout += (((1000000 + end.tv_usec) - now.tv_usec) / 1000) - 1000;

                }

            if (!pymol.immediate_update)
                status = poll(ufd, 3, timeout);
            else
                status = 0;

            if ( status < 0 )
                {
                    trace("pymolproxy: POLL ERROR: status = %d, errno = %d, %s \n", status,errno,strerror(errno));
                }
            else if (status > 0)
                {
                    gettimeofday(&now,NULL);

                    if (ufd[0].revents) { /* Client Stdout Connection: command input */
                        if (read(ufd[0].fd,&ch,1) <= 0) 
                            {
                                if (errno != EINTR)
                                    {
                                        trace("pymolproxy: lost client connection (%d).\n", errno);
                                        break;
                                    }
                            }
                        else
                            {
                                Tcl_DStringAppend(&cmdbuffer, &ch, 1);

                                if (ch == '\n' && Tcl_CommandComplete(Tcl_DStringValue(&cmdbuffer))) {
                                    Tcl_Eval(interp, Tcl_DStringValue(&cmdbuffer));
                                    trace("Executed(%d,%d): %s", pymol.need_update, pymol.immediate_update, Tcl_DStringValue(&cmdbuffer));
                                    Tcl_DStringSetLength(&cmdbuffer, 0);

                                    if (timeout == 0) status = 0; // send update
                                }
                            }
                    }

                    if (ufd[1].revents ) { /* pyMol Stdout Connection: pymol (unexpected) output */
                        if (read(ufd[1].fd, &ch, 1) <= 0)
                            {
                                if (errno != EINTR) {
                                    trace("pymolproxy: lost connection (stdout) to pymol server\n");
                                    break;
                                }
                            }
                        else
                            {
                                dyBufferAppend(&dybuffer, &ch, 1);

                                if (ch == '\n') {
                                    ch = 0;
                                    dyBufferAppend(&dybuffer, &ch, 1);
                                    trace("STDOUT>%s",dybuffer.data);
                                    dyBufferSetLength(&dybuffer,0);
                                }
                            }
                    }

                    if (ufd[2].revents) { /* pyMol Stderr Connection: pymol standard error output */
                        if (read(ufd[2].fd, &ch, 1) <= 0)
                            {
                                if (errno != EINTR) { 
                                    trace("pymolproxy: lost connection (stderr) to pymol server\n");
                                    break;
                                }
                            }
                        else {
                            dyBufferAppend(&dybuffer2, &ch, 1);

                            if (ch == '\n') {
                                ch = 0;
                                dyBufferAppend(&dybuffer2, &ch, 1);
                                trace("stderr>%s", dybuffer2.data);
                                dyBufferSetLength(&dybuffer2,0);
                            }
                        }
                    }
                }

            if (status == 0) 
                {
                    gettimeofday(&now,NULL);

                    if (pymol.need_update && pymol.can_update)
                        Tcl_Eval(interp, "bmp -\n");

                    end.tv_sec = now.tv_sec;
                    end.tv_usec = now.tv_usec + 150000;

                    if (end.tv_usec >= 1000000)
                        {
                            end.tv_sec++;
                            end.tv_usec -= 1000000;
                        }

                }

        }

    status = waitpid(pid, &result, WNOHANG);

    if (status == -1) {
        trace("pymolproxy: error waiting on pymol server to exit (%d)\n", errno);
    } else if (status == 0) {
        trace("pymolproxy: attempting to SIGTERM pymol server\n");
        kill(-pid, SIGTERM); // kill process group
        alarm(5);
        status = waitpid(pid, &result, 0);
        alarm(0);

        while ((status == -1) && (errno == EINTR))
            {
                trace("pymolproxy: Attempting to SIGKILL process.\n");
                kill(-pid, SIGKILL); // kill process group
                alarm(10);
                status = waitpid(pid, &result, 0);
                alarm(0); 
            }
    }

    trace("pymolproxy: pymol server process ended (%d)\n", result);

    dyBufferFree(&pymol.image);

    Tcl_DeleteInterp(interp);

    return( (status == pid) ? 0 : 1);
}

#ifdef STANDALONE

int
main(int argc, char *argv[])
{
    if (debug) {
        flog = stderr;
        flog = fopen("/tmp/pymolproxy.log", "w");
    }    
    ProxyInit(fileno(stdout), fileno(stdin), argv + 1);
    return 0;
}

#endif