path: root/nx-X11/lib/dps/cslibext.c

/*
 *  cslibext.c -- DPSCAP client Xlib extension hookup
 *
 * (c) Copyright 1991-1994 Adobe Systems Incorporated.
 * All rights reserved.
 *
 * Permission to use, copy, modify, distribute, and sublicense this software
 * and its documentation for any purpose and without fee is hereby granted,
 * provided that the above copyright notices appear in all copies and that
 * both those copyright notices and this permission notice appear in
 * supporting documentation and that the name of Adobe Systems Incorporated
 * not be used in advertising or publicity pertaining to distribution of the
 * software without specific, written prior permission.  No trademark license
 * to use the Adobe trademarks is hereby granted.  If the Adobe trademark
 * "Display PostScript"(tm) is used to describe this software, its
 * functionality or for any other purpose, such use shall be limited to a
 * statement that this software works in conjunction with the Display
 * PostScript system.  Proper trademark attribution to reflect Adobe's
 * ownership of the trademark shall be given whenever any such reference to
 * the Display PostScript system is made.
 *
 * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR
 * ANY PURPOSE.  IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY.
 * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
 * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NON- INFRINGEMENT OF THIRD PARTY RIGHTS.  IN NO EVENT SHALL ADOBE BE LIABLE
 * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL
 * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT,
 * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN
 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.  ADOBE WILL NOT
 * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE.
 *
 * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems
 * Incorporated which may be registered in certain jurisdictions
 *
 * Author:  Adobe Systems Incorporated
 */
/* $XFree86: xc/lib/dps/cslibext.c,v 1.4tsi Exp $ */

#include <stdio.h>
#include <stdlib.h>

#include <sys/param.h>		/* for MAXHOSTNAMELEN */
#include <X11/X.h>
#include <X11/Xlib.h>
#include <X11/Xlibint.h>
#include "cslibint.h"
#include <DPS/XDPS.h>
#include <DPS/XDPSproto.h>
#include <DPS/dpsXclient.h>
#include <DPS/dpsNXargs.h>
#include "DPSCAPClient.h"
#include "dpsassert.h"
#include <DPS/XDPSlib.h>

#include "publictypes.h"
#include "dpsXpriv.h"

/* === DEFINES === */

#define DPSNXSYNCGCMODE_FLUSH	0
#define DPSNXSYNCGCMODE_SYNC	1
#define DPSNXSYNCGCMODE_DELAYED	2
#define DPSNXSYNCGCMODE_DEFAULT	DPSNXSYNCGCMODE_DELAYED

/* === GLOBALS === */

DPSCAPGlobals gCSDPS = NULL;

#ifdef DPSLNKL
#define ANXCYAN
#define ANXMAGENTA
#define ANXYELLOW
#define ANXBLACK
#define ANXSPOT
#include "dpslnkl.inc"
#endif /* DPSLNKL */

int gNXSyncGCMode = DPSNXSYNCGCMODE_DEFAULT;

/* === PUBLIC PROCS === */

#ifdef MAHALO
static int
DPSCAPFlushAfterProc(Display *agent)
{
    LockDisplay(agent);
    N_XFlush(agent);
    UnlockDisplay(agent);
}
#endif

int
CSDPSInit(
    Display *dpy,
    int *numberType,		/* RETURN */
    char **floatingName)	/* RETURN */
{
    register Display *agent;
    register xCAPConnReplyPrefix *p;
    register char *c;
    DPSCAPData my;
    xCAPConnSetupReq setup;
    union {
        xCAPConnSuccess good;
        xCAPConnFailed bad;
    } reply;
    XExtData *extData;
    XExtCodes *codes;
    int indian;
    int rest;
    Window clientWindow;
    char fullDisplayName[MAXHOSTNAMELEN+10];

    if (gCSDPS == NULL)
        DPSCAPStartUp();

    /* To fix dps-nx #68, Motif too slow on HP */
    if ((c = getenv("DPSNXGCMODE")) != 0)
        {
	gNXSyncGCMode = atoi(c);
	if (gNXSyncGCMode < DPSNXSYNCGCMODE_FLUSH
	  || gNXSyncGCMode > DPSNXSYNCGCMODE_DELAYED)
	    gNXSyncGCMode = DPSNXSYNCGCMODE_DEFAULT;
	}

    /* We may have already called this routine via XDPSExtensionPresent,
       so don't do it again! */

    if ((codes = XDPSLGetCodes(dpy))
        && (agent = XDPSLGetShunt(dpy))
        && agent != dpy
	&& codes->major_opcode == DPSXOPCODEBASE)
        return(DPSCAPSUCCESS);

    /* Try to create a window for ClientMessage communication */

    clientWindow = XCreateSimpleWindow(
      dpy,
      DefaultRootWindow(dpy),
      0, 0,
      1, 1,
      0,
      BlackPixel(dpy, DefaultScreen(dpy)),
      WhitePixel(dpy, DefaultScreen(dpy)));
    if (clientWindow == None)
        return(DPSCAPFAILED);

    /* Try to open a connection to an agent */

    if ((extData = DPSCAPOpenAgent(dpy, fullDisplayName)) == NULL)
        {
        XDestroyWindow(dpy, clientWindow);
        return(DPSCAPFAILED);
        }

    /* DPSCAPOpenAgent only partially fills in extData, so finish it */

    codes = XAddExtension(dpy);
    codes->major_opcode = DPSXOPCODEBASE;
    codes->first_event = 0;  /* REQUIRED */
    codes->first_error = FirstExtensionError;
    extData->number = codes->extension;
    extData->free_private = DPSCAPDestroy;
    my = (DPSCAPData) extData->private_data;
    my->codes = codes;
    agent = my->agent;
    /* +++ Is this all we have to do here? */

    /* Send opening handshake */

    indian = 1;
    if (*(char *) &indian)
        setup.byteorder = 'l';
    else
    	setup.byteorder = 'B';
    setup.dpscapVersion = DPSCAPPROTOVERSION;
    setup.flags = DPSCAPNONEFLAG;
    setup.libraryversion = DPSPROTOCOLVERSION;
    setup.authProtoNameLength = 0;
    setup.authProtoDataLength = 0;
    setup.displayStringLength = strlen(fullDisplayName);
    setup.nodeStringLength = 0;
    setup.transportStringLength = 0;
    setup.display = 0;
    setup.screen = 0;
    setup.reserved = 0;
    setup.clientWindow = clientWindow;

#ifndef DPSLNKL
    DPSCAPWrite(agent, (char *)&setup, sizeof(xCAPConnSetupReq), dpscap_nopad,dpscap_insert);
    DPSCAPWrite(agent, fullDisplayName, setup.displayStringLength, dpscap_pad, dpscap_append);
    N_XFlush(agent);
#else /* DPSLNKL */
    if (CSDPSConfirmDisplay(agent, dpy, &setup, &reply, fullDisplayName) == 1)
        {
	p = (xCAPConnReplyPrefix *)&reply.good;
        goto skip_read;
	}
    /* Read normal reply */
#endif /* DPSLNKL */

    /* Read common reply prefix */

    p = (xCAPConnReplyPrefix *)&reply.good;
    N_XRead(agent, (char *)p, (long)sizeof(xCAPConnReplyPrefix));
#ifdef DPSLNKL
skip_read:
#endif
    if (!p->success)
        {
	char mbuf[512];
        /* read the rest */
        c = (char *)&reply.bad.serverVersion;
        N_XRead(agent, c, sz_xCAPConnFailed - sz_xCAPConnReplyPrefix);
	sprintf(mbuf, "DPS NX: connection to \"%s\" refused by agent.", DisplayString(agent));
	DPSWarnProc(NULL, mbuf);
        c = (char *)Xmalloc(reply.bad.reasonLength);
        if (!c) return(DPSCAPFAILED);
        N_XReadPad(agent, c, (long)reply.bad.reasonLength);
	if (!reply.bad.reasonLength)
	    sprintf(mbuf, "DPS NX: (no reason given)\n");
	else
            {
	    strcpy(mbuf, "DPS NX: ");
	    strncat(mbuf, c, reply.bad.reasonLength);
	    mbuf[reply.bad.reasonLength+7] = '\0';
	    }
	DPSWarnProc(NULL, mbuf);
        Xfree(c);
        DPSCAPDestroy(extData);
        Xfree(extData);
        XDestroyWindow(dpy, clientWindow);
        return(DPSCAPFAILED);
        }

    /* read the rest of the fixed length reply */
    c = (char *)&reply.good.serverVersion;
    rest = sizeof(xCAPConnSuccess) - sizeof(xCAPConnReplyPrefix);
    N_XRead(agent, c, rest);

    /* verify */

    if (reply.good.serverVersion < DPSPROTOCOLVERSION)
        {
	/* Fine, we downgrade the client */
	char qbuf[256];
	sprintf(qbuf, "NX: server version %ld older than expected %d, client will downgrade", (long)reply.good.serverVersion, DPSPROTOCOLVERSION);
	DPSWarnProc(NULL, qbuf);
	}
    my->dpscapVersion = reply.good.dpscapVersion;
    if (my->dpscapVersion < DPSCAPPROTOVERSION)
        {
	/* Fine, we downgrade the client */
	char kbuf[256];
	sprintf(kbuf, "NX: agent version %d older than expected %d, client will downgrade", my->dpscapVersion, DPSCAPPROTOVERSION);
	DPSWarnProc(NULL, kbuf);
#ifdef XXX
        /* Saving this code as a reminder about what needs to be
	   cleaned up if we exit here */
        DPSCAPDestroy(extData);
        Xfree(extData);
        XDestroyWindow(clientWindow);
        return(DPSCAPFAILED);
#endif
	}

    if (numberType)
        *numberType = reply.good.preferredNumberFormat;

    /* read additional data */

    c = (char *)Xmalloc(reply.good.floatingNameLength + 1);
    N_XReadPad(agent, c, reply.good.floatingNameLength);
    c[reply.good.floatingNameLength] = 0;
    if (floatingName)
	*floatingName = c;
    else
	Xfree(c);

    /* set library extension data */

    XDPSLSetVersion(agent, reply.good.serverVersion);
    XDPSLSetVersion(dpy, reply.good.serverVersion);
    XDPSLSetShunt(dpy, agent);
    XDPSLSetCodes(dpy, codes);
    if (XDPSLGetSyncMask(dpy) == DPSCAP_SYNCMASK_NONE)
        XDPSLSetSyncMask(dpy, DPSCAP_SYNCMASK_DFLT);
    my->agentWindow = reply.good.agentWindow;
    XDPSLSetGCFlushMode(dpy, XDPSNX_GC_UPDATES_SLOW); /* default */

    /* Hook my extension data on the dpy */

    my->extData = extData;
    XAddToExtensionList(CSDPSHeadOfDpyExt(dpy), extData);
    (void) XESetCloseDisplay(dpy, codes->extension, DPSCAPCloseDisplayProc);
    (void) XESetCopyGC(dpy, codes->extension, DPSCAPCopyGCProc);
    (void) XESetFreeGC(dpy, codes->extension, DPSCAPFreeGCProc);
    (void) XESetFlushGC(dpy, codes->extension, DPSCAPFlushGCProc);
    XDPSLSetClientMessageHandler(dpy);

    /* Chain my data on global list */

    my->next = gCSDPS->head;
    gCSDPS->head = my;

#ifdef MAHALO
    /* Set function that is called after every Xlib protocol proc */
    XDPSLSetAfterProc(dpy);

    /* All CSDPS protocol is auto-flushed */
    (void) XSetAfterFunction(agent, DPSCAPFlushAfterProc);
#endif /* MAHALO */

    /* set agent arguments, if needed */
    /* must follow setting of ShuntMap at least, so safest to
       do here when everything has been setup */
    XDPSLUpdateAgentArgs(dpy);

    return(DPSCAPSUCCESS);
}


XExtData **
CSDPSHeadOfDpyExt(
   Display *dpy)
{
   XEDataObject object;

   object.display = dpy;
   return(XEHeadOfExtensionList(object));
}

void
XDPSSyncGCClip(
    register Display *dpy,
    register GC gc)
{
    /* The primary utility of this function is for DPS NX correctness,
       but it also helps DPS/X do less work in tracking GC changes. */
    XDPSLSyncGCClip(dpy, gc);
}

void
XDPSReconcileRequests(
    register DPSContext ctxt)
{
    Display *dpy;
    register ContextXID cxid;
    register DPSContext curCtxt;

    for (curCtxt = ctxt; curCtxt; curCtxt = curCtxt->chainChild)
        {
	cxid = XDPSXIDFromContext(&dpy, curCtxt);
	if (dpy == (Display *)NULL || cxid == None)
	    break;  /* Skip text contexts */
	XDPSLReconcileRequests(dpy, cxid);
        }
}

Status
XDPSNXSetAgentArg(
    Display *dpy,
    int arg, int val)
{
    if (!dpy || arg >= 0 || arg < AGENTLASTARG)
        return(!Success);
    else
        return(XDPSLSetAgentArg(dpy, arg, val));
}

/* New for DPS NX 2.0 */
void
XDPSFlushGC(
    Display *dpy,
    GC gc)
{
    if (dpy && gc)
        XDPSLFlushGC(dpy, gc);
}

/* === SUPPORT PROCS === */

void
DPSCAPChangeGC(
    register Display *agent,
    GC gc,
    unsigned long valuemask,
    XGCValues *values)
{
    register xChangeGCReq *req;
    unsigned long oldDirty = gc->dirty;

    /* ASSERT: called from within LockDisplay section */

    /* Always include the clip_mask */
    valuemask |= GCClipMask;
    /* +++ HACK!  Hide the gc->rects flag in arc_mode */
    valuemask |= GCArcMode;
    valuemask &= (1L << (GCLastBit + 1)) - 1;

    /* Stupid macro insists on Display being called 'dpy' */
    {
    Display *dpy = agent;
    Display *xdpy = (Display *)NULL;
    NXMacroGetReq(ChangeGC, req);
    }
    req->gc = XGContextFromGC(gc);
    gc->dirty = req->mask = valuemask;
    {
/* Derived from MIT XCrGC.c, _XGenerateGCList:
Copyright 1985, 1986, 1987, 1988, 1989 by the
Massachusetts Institute of Technology

Permission to use, copy, modify, distribute, and sell this software and its
documentation for any purpose is hereby granted without fee, provided that
the above copyright notice appear in all copies and that both that
copyright notice and this permission notice appear in supporting
documentation, and that the name of M.I.T. not be used in advertising or
publicity pertaining to distribution of the software without specific,
written prior permission.  M.I.T. makes no representations about the
suitability of this software for any purpose.  It is provided "as is"
without express or implied warranty.
*/
    /* Warning!  This code assumes that "unsigned int" is 32-bits wide */

    unsigned int vals[32];
    register unsigned int *value = vals;
    long nvalues;
    register XGCValues *gv = values;
    register unsigned long dirty = gc->dirty;

    /*
     * Note: The order of these tests are critical; the order must be the
     * same as the GC mask bits in the word.
     */
    if (dirty & GCFunction)          *value++ = gv->function;
    if (dirty & GCPlaneMask)         *value++ = gv->plane_mask;
    if (dirty & GCForeground)        *value++ = gv->foreground;
    if (dirty & GCBackground)        *value++ = gv->background;
    if (dirty & GCLineWidth)         *value++ = gv->line_width;
    if (dirty & GCLineStyle)         *value++ = gv->line_style;
    if (dirty & GCCapStyle)          *value++ = gv->cap_style;
    if (dirty & GCJoinStyle)         *value++ = gv->join_style;
    if (dirty & GCFillStyle)         *value++ = gv->fill_style;
    if (dirty & GCFillRule)          *value++ = gv->fill_rule;
    if (dirty & GCTile)              *value++ = gv->tile;
    if (dirty & GCStipple)           *value++ = gv->stipple;
    if (dirty & GCTileStipXOrigin)   *value++ = gv->ts_x_origin;
    if (dirty & GCTileStipYOrigin)   *value++ = gv->ts_y_origin;
    if (dirty & GCFont)              *value++ = gv->font;
    if (dirty & GCSubwindowMode)     *value++ = gv->subwindow_mode;
    if (dirty & GCGraphicsExposures) *value++ = gv->graphics_exposures;
    if (dirty & GCClipXOrigin)       *value++ = gv->clip_x_origin;
    if (dirty & GCClipYOrigin)       *value++ = gv->clip_y_origin;
    if (dirty & GCClipMask)          *value++ = gv->clip_mask;
    if (dirty & GCDashOffset)        *value++ = gv->dash_offset;
    if (dirty & GCDashList)          *value++ = gv->dashes;
    /* +++ HACK!  Hide gc->rects flag in GCArcMode */
    if (dirty & GCArcMode)           *value++ = gc->rects;

    req->length += (nvalues = value - vals);

    /*
     * note: Data is a macro that uses its arguments multiple
     * times, so "nvalues" is changed in a separate assignment
     * statement
     */

    nvalues <<= 2;
    Data32 (agent, (long *) vals, nvalues);
    }

    gc->dirty = oldDirty;

    /* ASSERT: SyncHandle called by caller */
}


DPSCAPData
DPSCAPCreate(
    Display *dpy, Display *agent)
{
    register DPSCAPData my = (DPSCAPData)Xcalloc(1, sizeof(DPSCAPDataRec));

    if (my == (DPSCAPData)NULL) return(NULL);
    my->dpy = dpy;
    my->agent = agent;
    my->typePSOutput = XInternAtom(
      dpy,
      DPSCAP_TYPE_PSOUTPUT,
      False);
    my->typePSOutputWithLen = XInternAtom(
      dpy,
      DPSCAP_TYPE_PSOUTPUT_LEN,
      False);
    my->typePSStatus = XInternAtom(
      dpy,
      DPSCAP_TYPE_PSSTATUS,
      False);
    my->typeNoop = XInternAtom(
      dpy,
      DPSCAP_TYPE_NOOP,
      False);
    my->typeSync = XInternAtom(
      dpy,
      DPSCAP_TYPE_SYNC,
      False);
    my->typeXError = XInternAtom(
      dpy,
      DPSCAP_TYPE_XERROR,
      False);
    my->typePSReady = XInternAtom(
      dpy,
      DPSCAP_TYPE_PSREADY,
      False);
    my->typeResume = XInternAtom(
      dpy,
      DPSCAP_TYPE_RESUME,
      False);
    return(my);
}

int
DPSCAPDestroy(
    XExtData *extData)
{
    register DPSCAPData my = (DPSCAPData) extData->private_data;
    register DPSCAPData n;

    if (my == (DPSCAPData)NULL) return(0);
    DPSCAPCloseAgent(my->agent);
    my->agent = NULL;
    /* my->extData->private_data = NIL; ???? +++ */
    if (my == gCSDPS->head)
        gCSDPS->head = my->next;
    else for (n = gCSDPS->head; n != NULL; n = n->next)
        if (n->next == my)
            {
            n->next = my->next;
            break;
            }
    Xfree(my);
    /* extData freed by caller (e.g., _XFreeExtData) */
    return(0);
}

void
DPSCAPStartUp(void)
{
    gCSDPS = (DPSCAPGlobals)Xcalloc(1, sizeof(DPSCAPGlobalsRec));
}


static unsigned char padAdd[] = {0, 3, 2, 1};

void
DPSCAPWrite(
    Display *agent,
    char *buf,
    unsigned len,
    DPSCAPIOFlags writePad,
    DPSCAPIOFlags bufMode)
{
    int pad = padAdd[len & 3];
    unsigned fullLen = (writePad == dpscap_pad) ? len + pad  : len;

    if (agent->bufptr + fullLen > agent->bufmax)
        N_XFlush(agent);
    if (agent->max_request_size && fullLen > agent->max_request_size)
        {
	DPSWarnProc(NULL, "DPS Client Library: request length exceeds max request size. Truncated.\n");
	len = agent->max_request_size;
	pad = 0;
	}
    if (bufMode == dpscap_insert)
        {
        agent->last_req = agent->bufptr;
        agent->request++;
        }
    bcopy(buf, agent->bufptr, len);
    agent->bufptr += len;
    if (writePad == dpscap_pad && pad)
        {
        bcopy((char *) padAdd, agent->bufptr, pad);
        agent->bufptr += pad;
        }
}


/* === EXT CALLBACK HOOKS === */

int
DPSCAPCloseDisplayProc(
    Display *dpy,
    XExtCodes *codes)
{
#ifdef CSDPS
    fprintf(stderr, "NX: Closing agent \"%s\"\n", dpy->display_name);
#endif

    /* Although it seems that we should free codes here, we can't
       because Xlib owns the storage */

    XDPSLSetShunt(dpy, (Display *) NULL);
    XDPSLSetCodes(dpy, (XExtCodes *) NULL);
    XDPSLSetSyncMask(dpy, DPSCAP_SYNCMASK_NONE);
    XDPSLCleanAll(dpy);
    XDPSPrivZapDpy(dpy);
    return(0);
}


int
DPSCAPCopyGCProc(
    Display *dpy,
    GC gc,
    XExtCodes *codes)
{
    XGCValues values;
    DPSCAPData my;
    XExtData *extData = XFindOnExtensionList(
      CSDPSHeadOfDpyExt(dpy),
      codes->extension);

    if (extData)
        my = (DPSCAPData) extData->private_data;
    else
        return(0);

    /* We change the GC unconditionally, since friggin' XCopyGC
       clears the dirty bits of the values that are copied! */

    DPSAssertWarn(XGetGCValues(dpy, gc, DPSGCBITS & ~(GCClipMask), &values),
	NULL, "DPS NX: XGetGCValues returned False\n");
    values.clip_mask = gc->values.clip_mask;
    DPSCAPChangeGC(my->agent, gc, DPSGCBITS, &values);
    /* We have to make sure that the agent completely processes
	the change to the GC.  If we allow the agent to update the
	GC in its own sweet time, the stupid client may delete the
	GC after the agent has already queued a request to, e.g.,
	copy the GC, but before the request is flushed. */
    XDPSLSync(dpy);
    return(1);
}

int
DPSCAPFreeGCProc(
    Display *pdpy,
    GC gc,
    XExtCodes *codes)
{
    register xCAPNotifyReq *req;
    DPSCAPData my;
    Display *dpy = pdpy;  /* Stupid macros insists on Display being 'dpy' */
    XExtData *extData = XFindOnExtensionList(
      CSDPSHeadOfDpyExt(dpy),
      codes->extension);

    if (extData)
        my = (DPSCAPData) extData->private_data;
    else
        return(0);

    /* Notify the agent that the client deleted a GC.  Let the
       agent figure out if it cares. */

    /* ASSERT: called from within LockDisplay section */

    dpy = my->agent;
    if (dpy == (Display *)NULL || dpy == pdpy)
        return(0);

    /* May need to sync changes to GC */
    if (gNXSyncGCMode == DPSNXSYNCGCMODE_DELAYED)
        XDPSLSync(pdpy);

    {
    Display *xdpy = pdpy;			    /* pdpy is X server */
    NXMacroGetReq(CAPNotify, req);
    }
    req->reqType = DPSCAPOPCODEBASE;
    req->type = X_CAPNotify;
    req->cxid = 0;
    req->notification = DPSCAPNOTE_FREEGC;
    req->data = XGContextFromGC(gc);
    req->extra = 0;
    /* Guarantee that everyone sees GC go away */
    XSync(pdpy, False);                             /* pdpy is X server */
    if (gNXSyncGCMode == DPSNXSYNCGCMODE_FLUSH)
        {
        LockDisplay(dpy);                           /* dpy means agent here */
        N_XFlush(dpy);
        UnlockDisplay(dpy);
	}
    else
        XDPSLSync(pdpy);

    /* ASSERT: SynchHandle called by caller */
    return(1);
}

#ifdef CSDPSDEBUG
static unsigned int gcCountFlushedClean = 0;
static unsigned int gcCountFlushedDirty = 0;
#endif /* CSDPSDEBUG */

int
DPSCAPFlushGCProc(
    Display *dpy,
    GC gc,
    XExtCodes *codes)
{
    XGCValues values;
    DPSCAPData my;
    XExtData *extData;
#ifdef CSDPSDEBUG
    unsigned long int dirty;
#endif /* CSDPSDEBUG */

    /* When GC is created, it is flushed with no dirty bits set,
       so we have to notice that situation. */

    if (gc->dirty)
        {
	if (XDPSLGetGCFlushMode(dpy) == XDPSNX_GC_UPDATES_FAST
	   || !(gc->dirty & DPSGCBITS))
	    return(0);
	}
    extData = XFindOnExtensionList(CSDPSHeadOfDpyExt(dpy), codes->extension);
    if (extData)
        my = (DPSCAPData) extData->private_data;
    else
        return(0);
    /* HERE IF (gc->dirty & DPSGCBITS || !gc->dirty) */
#ifdef CSDPSDEBUG
    dirty = gc->dirty;
#endif /* CSDPSDEBUG */
    DPSAssertWarn(XGetGCValues(dpy, gc, DPSGCBITS & ~(GCClipMask), &values),
	NULL, "NX: XGetGCValues returned False\n");
    values.clip_mask = gc->values.clip_mask;
    /* Must guarantee that gc change is registered by X server
       before notification is sent to agent. */
    XSync(dpy, False);
    DPSCAPChangeGC(my->agent, gc, DPSGCBITS, &values);
    /* We have to make sure that the agent completely processes
       the change to the GC.  If we allow the agent to update the
       GC in its own sweet time, the stupid client may delete the
       GC after the agent has already queued a request to, e.g.,
       copy the GC, but before the request is flushed. */
    if (gNXSyncGCMode == DPSNXSYNCGCMODE_SYNC)
        XDPSLSync(dpy);
    else
        XDPSLFlush(dpy);
#ifdef CSDPSDEBUG
    if (dirty)
        ++gcCountFlushedDirty;
    else
        ++gcCountFlushedClean;
#endif /* CSDPSDEBUG */
    return(1);
}