/* $Xorg: XpGetData.c,v 1.4 2000/08/17 19:46:07 cpqbld Exp $ */ /****************************************************************************** ****************************************************************************** ** ** (c) Copyright 1996 Hewlett-Packard Company ** (c) Copyright 1996 International Business Machines Corp. ** (c) Copyright 1996 Sun Microsystems, Inc. ** (c) Copyright 1996 Novell, Inc. ** (c) Copyright 1996 Digital Equipment Corp. ** (c) Copyright 1996 Fujitsu Limited ** (c) Copyright 1996 Hitachi, Ltd. ** ** Permission is hereby granted, free of charge, to any person obtaining a copy ** of this software and associated documentation files (the "Software"), to deal ** in the Software without restriction, including without limitation the rights ** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell ** copies of the Software, and to permit persons to whom the Software is ** furnished to do so, subject to the following conditions: ** ** The above copyright notice and this permission notice shall be included in ** all copies or substantial portions of the Software. ** ** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE ** COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER ** IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN ** CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ** ** Except as contained in this notice, the names of the copyright holders shall ** not be used in advertising or otherwise to promote the sale, use or other ** dealings in this Software without prior written authorization from said ** copyright holders. ** ****************************************************************************** *****************************************************************************/ /* $XFree86: xc/lib/Xp/XpGetData.c,v 1.5 2002/10/16 00:37:32 dawes Exp $ */ #define NEED_REPLIES #include <X11/extensions/Printstr.h> #include <X11/Xlibint.h> #include "XpExtUtil.h" #define MAX_XP_BUFFER_SIZE 32768 /* * At the tail of every async struct of ours is attached the * following "dev private" information needed by our async handler. */ typedef struct { XPContext context; XPSaveProc save_proc; XPFinishProc finish_proc; XPointer client_data; _XAsyncHandler *async; unsigned long seq; /* sequence # that will trigger handler */ } _XpState; /* * The following is the handler for async replies from * XpGetDocumentData(). */ static Bool _XpGetDocDataHandler(dpy, rep, buf, len, adata) register Display *dpy; register xReply *rep; char *buf; int len; XPointer adata; { register _XpState *state; xPrintGetDocumentDataReply replbuf; xPrintGetDocumentDataReply *repl; int dataLen; char *data; state = (_XpState *)adata; /* * Bypass this handler if the reply is NOT the one we're looking for. */ if (dpy->last_request_read != state->seq) { return False; } /* * When an error occurs, call the finish_proc and then de-queue * this event handler. Once an error occurs, all bets are off. * The error XPGetDocError is *not* the most descriptive, so the * caller will be encouraged to dig around for the corresponding * generated error. * * Note - Do not confuse the "generated" errors here with * XPGetDocSecondConsumer which is returned in a protocol reply. */ if (rep->generic.type == X_Error) { (*state->finish_proc)( (Display *) dpy, (XPContext) state->context, XPGetDocError, (XPointer) state->client_data ); DeqAsyncHandler(dpy, state->async); Xfree(state->async); return False; } repl = (xPrintGetDocumentDataReply *) _XGetAsyncReply(dpy, (char *)&replbuf, rep, buf, len, 0, False); if (repl->dataLen) { /* * Call save_proc in cases where there was document data */ dataLen = repl->length << 2; /*with pad len*/ data = (char *) _XAllocTemp( dpy, dataLen ); _XGetAsyncData( dpy, (char *) data, buf, len, SIZEOF(xPrintGetDocumentDataReply), dataLen, 0); (*state->save_proc)( (Display *) dpy, (XPContext) state->context, (unsigned char *) data, (unsigned int) repl->dataLen, /* actual len */ (XPointer) state->client_data ); _XFreeTemp( dpy, (char *) data, dataLen ); } if (repl->finishedFlag) { /* * Call finish_proc */ (*state->finish_proc)( (Display *) dpy, (XPContext) state->context, (XPGetDocStatus) repl->statusCode, (XPointer) state->client_data ); /* * De-queue this async handler - we're done. */ DeqAsyncHandler( dpy, state->async ); Xfree(state->async); } return True; /* the reply WAS consumed by this handler */ } /****************************************************************************** * * XpGetDocumentData() * * ...registers callbacks to be triggered when async protocol replies * come back in response to the origial request. * * Returned Status indicate whether the callbacks will be used * (finish_proc and possibly save_proc), or whether they will * never be used. * */ Status XpGetDocumentData ( Display *dpy, XPContext context, XPSaveProc save_proc, XPFinishProc finish_proc, XPointer client_data ) { xPrintGetDocumentDataReq *req; XExtDisplayInfo *info = (XExtDisplayInfo *) xp_find_display (dpy); _XAsyncHandler *async; _XpState *async_state; if (XpCheckExtInit(dpy, XP_DONT_CHECK) == -1) return(0); /* No such extension */ async = (_XAsyncHandler *)Xmalloc(sizeof(_XAsyncHandler) + sizeof(_XpState)); if (!async) return(0); /* malloc error */ async_state = (_XpState *)(async + 1); LockDisplay (dpy); GetReq(PrintGetDocumentData,req); req->reqType = info->codes->major_opcode; req->printReqType = X_PrintGetDocumentData; req->printContext = context; req->maxBufferSize = MAX_XP_BUFFER_SIZE; /* use as a hint to X server */ async_state->context = context; async_state->save_proc = save_proc; async_state->finish_proc = finish_proc; async_state->client_data = client_data; async_state->seq = dpy->request; async_state->async = async; async->next = dpy->async_handlers; async->handler = _XpGetDocDataHandler; async->data = (XPointer)async_state; dpy->async_handlers = async; UnlockDisplay(dpy); SyncHandle(); return(1); /* success at registering a handler */ }