int __glXDispSwap_GetClipPlane(__GLXclientState *cl, GLbyte *pc)
{
__GLXcontext *cx;
ClientPtr client = cl->client;
int error;
GLdouble answer[4];
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
pc += __GLX_SINGLE_HDR_SIZE;
__GLX_SWAP_INT(pc + 0);
__glXClearErrorOccured();
glGetClipPlane(*(GLenum *)(pc + 0), answer);
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);
__GLX_SWAP_REPLY_HEADER();
__GLX_SEND_HEADER();
} else {
__GLX_SWAP_DOUBLE_ARRAY((GLbyte *)answer, 4);
__GLX_BEGIN_REPLY(32);
__GLX_SWAP_REPLY_HEADER();
__GLX_SEND_HEADER();
__GLX_SEND_DOUBLE_ARRAY(4);
}
return Success;
}
int __glXDisp_FeedbackBuffer(__GLXclientState *cl, GLbyte *pc)
{
GLsizei size;
GLenum type;
__GLXcontext *cx;
int error;
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
pc += __GLX_SINGLE_HDR_SIZE;
size = *(GLsizei *)(pc+0);
type = *(GLenum *)(pc+4);
if (cx->feedbackBufSize < size) {
cx->feedbackBuf = (GLfloat *) __glXRealloc(cx->feedbackBuf,
(size_t)size
* __GLX_SIZE_FLOAT32);
if (!cx->feedbackBuf) {
cl->client->errorValue = size;
return BadAlloc;
}
cx->feedbackBufSize = size;
}
glFeedbackBuffer(size, type, cx->feedbackBuf);
__GLX_NOTE_UNFLUSHED_CMDS(cx);
return Success;
}
int __glXDispSwap_FeedbackBuffer(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
GLsizei size;
GLenum type;
__GLX_DECLARE_SWAP_VARIABLES;
__GLXcontext *cx;
int error;
REQUEST_FIXED_SIZE(xGLXSingleReq, 8);
__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
pc += __GLX_SINGLE_HDR_SIZE;
__GLX_SWAP_INT(pc+0);
__GLX_SWAP_INT(pc+4);
size = *(GLsizei *)(pc+0);
type = *(GLenum *)(pc+4);
if (cx->feedbackBufSize < size) {
cx->feedbackBuf = (GLfloat *) __glXRealloc(cx->feedbackBuf,
(size_t) size
* __GLX_SIZE_FLOAT32);
if (!cx->feedbackBuf) {
cl->client->errorValue = size;
return BadAlloc;
}
cx->feedbackBufSize = size;
}
glFeedbackBuffer(size, type, cx->feedbackBuf);
__GLX_NOTE_UNFLUSHED_CMDS(cx);
return Success;
}
int
__glXDisp_FeedbackBuffer(__GLXclientState * cl, GLbyte * pc)
{
GLsizei size;
GLenum type;
__GLXcontext *cx;
int error;
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
pc += __GLX_SINGLE_HDR_SIZE;
size = *(GLsizei *) (pc + 0);
type = *(GLenum *) (pc + 4);
if (cx->feedbackBufSize < size) {
cx->feedbackBuf = (GLfloat *) realloc(cx->feedbackBuf,
(size_t) size
* __GLX_SIZE_FLOAT32);
if (!cx->feedbackBuf) {
cl->client->errorValue = size;
return BadAlloc;
}
cx->feedbackBufSize = size;
}
CALL_FeedbackBuffer(GET_DISPATCH(), (size, type, cx->feedbackBuf));
cx->hasUnflushedCommands = GL_TRUE;
return Success;
}
int
__glXDisp_SelectBuffer(__GLXclientState * cl, GLbyte * pc)
{
__GLXcontext *cx;
GLsizei size;
int error;
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
pc += __GLX_SINGLE_HDR_SIZE;
size = *(GLsizei *) (pc + 0);
if (cx->selectBufSize < size) {
cx->selectBuf = (GLuint *) realloc(cx->selectBuf,
(size_t) size * __GLX_SIZE_CARD32);
if (!cx->selectBuf) {
cl->client->errorValue = size;
return BadAlloc;
}
cx->selectBufSize = size;
}
CALL_SelectBuffer(GET_DISPATCH(), (size, cx->selectBuf));
cx->hasUnflushedCommands = GL_TRUE;
return Success;
}
int
__glXDispSwap_SelectBuffer(__GLXclientState * cl, GLbyte * pc)
{
ClientPtr client = cl->client;
__GLXcontext *cx;
GLsizei size;
__GLX_DECLARE_SWAP_VARIABLES;
int error;
REQUEST_FIXED_SIZE(xGLXSingleReq, 4);
__GLX_SWAP_INT(&((xGLXSingleReq *) pc)->contextTag);
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
pc += __GLX_SINGLE_HDR_SIZE;
__GLX_SWAP_INT(pc + 0);
size = *(GLsizei *) (pc + 0);
if (cx->selectBufSize < size) {
cx->selectBuf = reallocarray(cx->selectBuf,
(size_t) size, __GLX_SIZE_CARD32);
if (!cx->selectBuf) {
cl->client->errorValue = size;
return BadAlloc;
}
cx->selectBufSize = size;
}
glSelectBuffer(size, cx->selectBuf);
cx->hasUnflushedCommands = GL_TRUE;
return Success;
}
int __glXDisp_GetClipPlane(__GLXclientState *cl, GLbyte *pc)
{
__GLXcontext *cx;
ClientPtr client = cl->client;
int error;
GLdouble answer[4];
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
pc += __GLX_SINGLE_HDR_SIZE;
__glXClearErrorOccured();
glGetClipPlane(*(GLenum *)(pc + 0), answer);
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);
__GLX_SEND_HEADER();
} else {
__GLX_BEGIN_REPLY(32);
__GLX_SEND_HEADER();
__GLX_SEND_DOUBLE_ARRAY(4);
}
return Success;
}
int __glXDisp_GenTextures(__GLXclientState *cl, GLbyte *pc)
{
GLsizei n;
__GLXcontext *cx;
ClientPtr client = cl->client;
int error;
GLuint answerBuffer[200];
char *answer;
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
pc += __GLX_SINGLE_HDR_SIZE;
n = *(GLsizei *)(pc + 0);
__GLX_GET_ANSWER_BUFFER(answer,cl,n*4,4);
glGenTextures(
*(GLsizei *)(pc + 0),
(GLuint *) answer
);
__GLX_BEGIN_REPLY(n*4);
__GLX_SEND_HEADER();
__GLX_SEND_INT_ARRAY(n);
return Success;
}
int
__glXDisp_GetColorTable(__GLXclientState * cl, GLbyte * pc)
{
const GLXContextTag tag = __GLX_GET_SINGLE_CONTEXT_TAG(pc);
return GetColorTable(cl, pc + __GLX_SINGLE_HDR_SIZE, tag);
}
int
__glXDisp_GetPolygonStipple(__GLXclientState * cl, GLbyte * pc)
{
GLboolean lsbFirst;
__GLXcontext *cx;
ClientPtr client = cl->client;
int error;
GLubyte answerBuffer[200];
char *answer;
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
pc += __GLX_SINGLE_HDR_SIZE;
lsbFirst = *(GLboolean *) (pc + 0);
CALL_PixelStorei(GET_DISPATCH(), (GL_PACK_LSB_FIRST, lsbFirst));
__GLX_GET_ANSWER_BUFFER(answer, cl, 128, 1);
__glXClearErrorOccured();
CALL_GetPolygonStipple(GET_DISPATCH(), ((GLubyte *) answer));
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);
__GLX_SEND_HEADER();
}
else {
__GLX_BEGIN_REPLY(128);
__GLX_SEND_HEADER();
__GLX_SEND_BYTE_ARRAY(128);
}
return Success;
}
int __glXDisp_AreTexturesResident(__GLXclientState *cl, GLbyte *pc)
{
GLsizei n;
GLboolean retval;
__GLXcontext *cx;
ClientPtr client = cl->client;
int error;
GLboolean answerBuffer[200];
char *answer;
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
pc += __GLX_SINGLE_HDR_SIZE;
n = *(GLsizei *)(pc + 0);
__GLX_GET_ANSWER_BUFFER(answer,cl,n,1);
retval =
glAreTexturesResident(
*(GLsizei *)(pc + 0),
(GLuint *)(pc + 4),
(GLboolean *) answer
);
__GLX_PUT_RETVAL(retval);
__GLX_BEGIN_REPLY(n);
__GLX_SEND_HEADER();
__GLX_SEND_BYTE_ARRAY(n);
return Success;
}
int
__glXDispSwap_Finish(__GLXclientState * cl, GLbyte * pc)
{
ClientPtr client = cl->client;
__GLXcontext *cx;
int error;
__GLX_DECLARE_SWAP_VARIABLES;
REQUEST_SIZE_MATCH(xGLXSingleReq);
__GLX_SWAP_INT(&((xGLXSingleReq *) pc)->contextTag);
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
/* Do a local glFinish */
glFinish();
cx->hasUnflushedCommands = GL_FALSE;
/* Send empty reply packet to indicate finish is finished */
__GLX_BEGIN_REPLY(0);
__GLX_PUT_RETVAL(0);
__GLX_SWAP_REPLY_HEADER();
__GLX_SEND_HEADER();
return Success;
}
int
__glXDispSwap_GetColorTable(__GLXclientState * cl, GLbyte * pc)
{
const GLXContextTag tag = __GLX_GET_SINGLE_CONTEXT_TAG(pc);
ClientPtr client = cl->client;
REQUEST_FIXED_SIZE(xGLXSingleReq, 16);
return GetColorTable(cl, pc + __GLX_SINGLE_HDR_SIZE, tag);
}
int
__glXDisp_ReadPixels(__GLXclientState * cl, GLbyte * pc)
{
GLsizei width, height;
GLenum format, type;
GLboolean swapBytes, lsbFirst;
GLint compsize;
__GLXcontext *cx;
ClientPtr client = cl->client;
int error;
char *answer, answerBuffer[200];
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
pc += __GLX_SINGLE_HDR_SIZE;
width = *(GLsizei *) (pc + 8);
height = *(GLsizei *) (pc + 12);
format = *(GLenum *) (pc + 16);
type = *(GLenum *) (pc + 20);
swapBytes = *(GLboolean *) (pc + 24);
lsbFirst = *(GLboolean *) (pc + 25);
compsize = __glReadPixels_size(format, type, width, height);
if (compsize < 0)
compsize = 0;
CALL_PixelStorei(GET_DISPATCH(), (GL_PACK_SWAP_BYTES, swapBytes));
CALL_PixelStorei(GET_DISPATCH(), (GL_PACK_LSB_FIRST, lsbFirst));
__GLX_GET_ANSWER_BUFFER(answer, cl, compsize, 1);
__glXClearErrorOccured();
CALL_ReadPixels(GET_DISPATCH(), (*(GLint *) (pc + 0),
*(GLint *) (pc + 4),
*(GLsizei *) (pc + 8),
*(GLsizei *) (pc + 12),
*(GLenum *) (pc + 16),
*(GLenum *) (pc + 20), answer));
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);
__GLX_SEND_HEADER();
}
else {
__GLX_BEGIN_REPLY(compsize);
__GLX_SEND_HEADER();
__GLX_SEND_VOID_ARRAY(compsize);
}
cx->hasUnflushedCommands = GL_FALSE;
return Success;
}
int __glXDisp_EndList(__GLXclientState *cl, GLbyte *pc)
{
__GLXcontext *cx;
int error;
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
glEndList(
);
return Success;
}
int __glXDisp_Flush(__GLXclientState *cl, GLbyte *pc)
{
__GLXcontext *cx;
int error;
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
CALL_Flush( GET_DISPATCH(), () );
cx->hasUnflushedCommands = GL_FALSE;
return Success;
}
int __glXDisp_Flush(__GLXclientState *cl, GLbyte *pc)
{
__GLXcontext *cx;
int error;
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
glFlush();
__GLX_NOTE_FLUSHED_CMDS(cx);
return Success;
}
static int
ephyrGLXGetStringReal (__GLXclientState *a_cl, GLbyte *a_pc, Bool a_do_swap)
{
ClientPtr client=NULL ;
int context_tag=0, name=0, res=BadImplementation, length=0 ;
char *string=NULL;
__GLX_DECLARE_SWAP_VARIABLES;
EPHYR_RETURN_VAL_IF_FAIL (a_cl && a_pc, BadValue) ;
EPHYR_LOG ("enter\n") ;
client = a_cl->client ;
if (a_do_swap) {
__GLX_SWAP_INT (a_pc + 4);
__GLX_SWAP_INT (a_pc + __GLX_SINGLE_HDR_SIZE);
}
context_tag = __GLX_GET_SINGLE_CONTEXT_TAG (a_pc) ;
a_pc += __GLX_SINGLE_HDR_SIZE;
name = *(GLenum*)(a_pc + 0);
EPHYR_LOG ("context_tag:%d, name:%d\n", context_tag, name) ;
if (!ephyrHostGLXGetStringFromServer (context_tag,
name,
EPHYR_HOST_GLX_GetString,
&string)) {
EPHYR_LOG_ERROR ("failed to get string from server\n") ;
goto out ;
}
if (string) {
length = strlen (string) + 1;
EPHYR_LOG ("got string:'%s', size:%d\n", string, length) ;
} else {
EPHYR_LOG ("got string: string (null)\n") ;
}
__GLX_BEGIN_REPLY (length);
__GLX_PUT_SIZE (length);
__GLX_SEND_HEADER ();
if (a_do_swap) {
__GLX_SWAP_REPLY_SIZE ();
__GLX_SWAP_REPLY_HEADER ();
}
WriteToClient (client, length, (char *)string);
res = Success ;
out:
EPHYR_LOG ("leave\n") ;
return res ;
}
int __glXDispSwap_Flush(__GLXclientState *cl, GLbyte *pc)
{
__GLXcontext *cx;
int error;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
CALL_Flush( GET_DISPATCH(), () );
__GLX_NOTE_FLUSHED_CMDS(cx);
return Success;
}
int __glXDisp_GetMapiv(__GLXclientState *cl, GLbyte *pc)
{
GLenum target;
GLenum query;
GLint compsize;
__GLXcontext *cx;
ClientPtr client = cl->client;
int error;
GLint answerBuffer[200];
char *answer;
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
pc += __GLX_SINGLE_HDR_SIZE;
target = *(GLenum *)(pc + 0);
query = *(GLenum *)(pc + 4);
compsize = __glGetMapiv_size(target,query);
if (compsize < 0) compsize = 0;
__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
__glXClearErrorOccured();
glGetMapiv(
*(GLenum *)(pc + 0),
*(GLenum *)(pc + 4),
(GLint *) answer
);
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);
__GLX_PUT_SIZE(0);
__GLX_SEND_HEADER();
} else if (compsize == 1) {
__GLX_BEGIN_REPLY(0);
__GLX_PUT_SIZE(1);
__GLX_PUT_INT();
__GLX_SEND_HEADER();
} else {
__GLX_BEGIN_REPLY(compsize*4);
__GLX_PUT_SIZE(compsize);
__GLX_SEND_HEADER();
__GLX_SEND_INT_ARRAY(compsize);
}
return Success;
}
int __glXDisp_PixelStorei(__GLXclientState *cl, GLbyte *pc)
{
__GLXcontext *cx;
int error;
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
pc += __GLX_SINGLE_HDR_SIZE;
glPixelStorei(
*(GLenum *)(pc + 0),
*(GLint *)(pc + 4)
);
__GLX_NOTE_UNFLUSHED_CMDS(cx);
return Success;
}
int __glXDisp_DeleteLists(__GLXclientState *cl, GLbyte *pc)
{
__GLXcontext *cx;
int error;
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
pc += __GLX_SINGLE_HDR_SIZE;
glDeleteLists(
*(GLuint *)(pc + 0),
*(GLsizei *)(pc + 4)
);
__GLX_NOTE_UNFLUSHED_CMDS(cx);
return Success;
}
int __glXDispSwap_Flush(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
__GLXcontext *cx;
int error;
__GLX_DECLARE_SWAP_VARIABLES;
REQUEST_SIZE_MATCH(xGLXSingleReq);
__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
glFlush();
__GLX_NOTE_FLUSHED_CMDS(cx);
return Success;
}
int __glXDisp_GetTexLevelParameterfv(__GLXclientState *cl, GLbyte *pc)
{
GLenum pname;
GLint compsize;
__GLXcontext *cx;
ClientPtr client = cl->client;
int error;
GLfloat answerBuffer[200];
char *answer;
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
pc += __GLX_SINGLE_HDR_SIZE;
pname = *(GLenum *)(pc + 8);
compsize = __glGetTexLevelParameterfv_size(pname);
if (compsize < 0) compsize = 0;
__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
__glXClearErrorOccured();
glGetTexLevelParameterfv(
*(GLenum *)(pc + 0),
*(GLint *)(pc + 4),
*(GLenum *)(pc + 8),
(GLfloat *) answer
);
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);
__GLX_PUT_SIZE(0);
__GLX_SEND_HEADER();
} else if (compsize == 1) {
__GLX_BEGIN_REPLY(0);
__GLX_PUT_SIZE(1);
__GLX_PUT_FLOAT();
__GLX_SEND_HEADER();
} else {
__GLX_BEGIN_REPLY(compsize*4);
__GLX_PUT_SIZE(compsize);
__GLX_SEND_HEADER();
__GLX_SEND_FLOAT_ARRAY(compsize);
}
return Success;
}
int __glXDisp_DeleteTextures(__GLXclientState *cl, GLbyte *pc)
{
GLsizei n;
__GLXcontext *cx;
int error;
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
pc += __GLX_SINGLE_HDR_SIZE;
n = *(GLsizei *)(pc + 0);
glDeleteTextures(
*(GLsizei *)(pc + 0),
(GLuint *)(pc + 4)
);
return Success;
}
int __glXDisp_GetPixelMapusv(__GLXclientState *cl, GLbyte *pc)
{
GLenum map;
GLint compsize;
__GLXcontext *cx;
ClientPtr client = cl->client;
int error;
GLushort answerBuffer[200];
char *answer;
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
pc += __GLX_SINGLE_HDR_SIZE;
map = *(GLenum *)(pc + 0);
compsize = __glGetPixelMapusv_size(map);
if (compsize < 0) compsize = 0;
__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*2,2);
__glXClearErrorOccured();
glGetPixelMapusv(
*(GLenum *)(pc + 0),
(GLushort *) answer
);
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);
__GLX_PUT_SIZE(0);
__GLX_SEND_HEADER();
} else if (compsize == 1) {
__GLX_BEGIN_REPLY(0);
__GLX_PUT_SIZE(1);
__GLX_PUT_SHORT();
__GLX_SEND_HEADER();
} else {
__GLX_BEGIN_REPLY(compsize*2);
__GLX_PUT_SIZE(compsize);
__GLX_SEND_HEADER();
__GLX_SEND_SHORT_ARRAY(compsize);
}
return Success;
}
int __glXDisp_GetError(__GLXclientState *cl, GLbyte *pc)
{
GLenum retval;
__GLXcontext *cx;
ClientPtr client = cl->client;
int error;
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
retval =
glGetError(
);
__GLX_PUT_RETVAL(retval);
__GLX_BEGIN_REPLY(0);
__GLX_SEND_HEADER();
return Success;
}
int
__glXDispSwap_GetPolygonStipple(__GLXclientState * cl, GLbyte * pc)
{
GLboolean lsbFirst;
__GLXcontext *cx;
ClientPtr client = cl->client;
int error;
GLubyte answerBuffer[200];
char *answer;
xGLXSingleReply reply = { 0, };
__GLX_DECLARE_SWAP_VARIABLES;
REQUEST_FIXED_SIZE(xGLXSingleReq, 4);
__GLX_SWAP_INT(&((xGLXSingleReq *) pc)->contextTag);
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
pc += __GLX_SINGLE_HDR_SIZE;
lsbFirst = *(GLboolean *) (pc + 0);
glPixelStorei(GL_PACK_LSB_FIRST, lsbFirst);
__GLX_GET_ANSWER_BUFFER(answer, cl, 128, 1);
__glXClearErrorOccured();
glGetPolygonStipple((GLubyte *) answer);
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);
__GLX_SWAP_REPLY_HEADER();
__GLX_SEND_HEADER();
}
else {
__GLX_BEGIN_REPLY(128);
__GLX_SWAP_REPLY_HEADER();
__GLX_SEND_HEADER();
__GLX_SEND_BYTE_ARRAY(128);
}
return Success;
}
int __glXDisp_Finish(__GLXclientState *cl, GLbyte *pc)
{
__GLXcontext *cx;
ClientPtr client;
int error;
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
/* Do a local glFinish */
CALL_Finish( GET_DISPATCH(), () );
cx->hasUnflushedCommands = GL_FALSE;
/* Send empty reply packet to indicate finish is finished */
client = cl->client;
__GLX_BEGIN_REPLY(0);
__GLX_SEND_HEADER();
return Success;
}
int __glXDisp_Finish(__GLXclientState *cl, GLbyte *pc)
{
__GLXcontext *cx;
ClientPtr client;
int error;
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
/* Do a local glFinish */
glFinish();
__GLX_NOTE_FLUSHED_CMDS(cx);
/* Send empty reply packet to indicate finish is finished */
client = cl->client;
__GLX_BEGIN_REPLY(0);
__GLX_SEND_HEADER();
return Success;
}
