Merge branch 'master' of git+ssh://git.freedesktop.org/git/xorg/xserver into pci-rework
This commit is contained in:
commit
21291d6ca7
|
@ -34,10 +34,7 @@ libglxdri_la_SOURCES = \
|
|||
glxdri.c
|
||||
|
||||
libglx_la_SOURCES = \
|
||||
g_disptab.c \
|
||||
g_disptab.h \
|
||||
g_disptab_EXT.c \
|
||||
g_disptab_EXT.h \
|
||||
glapi.c \
|
||||
glcontextmodes.c \
|
||||
glcontextmodes.h \
|
||||
|
@ -61,6 +58,8 @@ libglx_la_SOURCES = \
|
|||
indirect_reqsize.h \
|
||||
indirect_size_get.c \
|
||||
indirect_size_get.h \
|
||||
indirect_table.c \
|
||||
indirect_table.h \
|
||||
indirect_util.c \
|
||||
indirect_util.h \
|
||||
render2.c \
|
||||
|
@ -68,7 +67,6 @@ libglx_la_SOURCES = \
|
|||
renderpix.c \
|
||||
renderpixswap.c \
|
||||
rensize.c \
|
||||
rensizetab.c \
|
||||
single2.c \
|
||||
single2swap.c \
|
||||
singlepix.c \
|
||||
|
|
|
@ -1,840 +0,0 @@
|
|||
/* DO NOT EDIT - THIS FILE IS AUTOMATICALLY GENERATED */
|
||||
/*
|
||||
** License Applicability. Except to the extent portions of this file are
|
||||
** made subject to an alternative license as permitted in the SGI Free
|
||||
** Software License B, Version 1.1 (the "License"), the contents of this
|
||||
** file are subject only to the provisions of the License. You may not use
|
||||
** this file except in compliance with the License. You may obtain a copy
|
||||
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
|
||||
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
|
||||
**
|
||||
** http://oss.sgi.com/projects/FreeB
|
||||
**
|
||||
** Note that, as provided in the License, the Software is distributed on an
|
||||
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
|
||||
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
|
||||
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
|
||||
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
|
||||
**
|
||||
** Original Code. The Original Code is: OpenGL Sample Implementation,
|
||||
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
|
||||
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
|
||||
** Copyright in any portions created by third parties is as indicated
|
||||
** elsewhere herein. All Rights Reserved.
|
||||
**
|
||||
** Additional Notice Provisions: This software was created using the
|
||||
** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
|
||||
** not been independently verified as being compliant with the OpenGL(R)
|
||||
** version 1.2.1 Specification.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include "glxserver.h"
|
||||
#include "glxext.h"
|
||||
#include "g_disptab.h"
|
||||
#include "indirect_dispatch.h"
|
||||
|
||||
__GLXdispatchSingleProcPtr __glXSingleTable[__GLX_SINGLE_TABLE_SIZE] = {
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXRender,
|
||||
__glXRenderLarge,
|
||||
__glXCreateContext,
|
||||
__glXDestroyContext,
|
||||
__glXMakeCurrent,
|
||||
__glXIsDirect,
|
||||
__glXQueryVersion,
|
||||
__glXWaitGL, /* 0x08 */
|
||||
__glXWaitX,
|
||||
__glXCopyContext,
|
||||
__glXSwapBuffers,
|
||||
__glXUseXFont,
|
||||
__glXCreateGLXPixmap,
|
||||
__glXGetVisualConfigs,
|
||||
__glXDestroyGLXPixmap,
|
||||
__glXVendorPrivate, /* 0x10 */
|
||||
__glXVendorPrivateWithReply,
|
||||
__glXQueryExtensionsString,
|
||||
__glXQueryServerString,
|
||||
__glXClientInfo,
|
||||
__glXGetFBConfigs,
|
||||
__glXCreatePixmap,
|
||||
__glXDestroyPixmap,
|
||||
__glXCreateNewContext, /* 0x18 */
|
||||
__glXQueryContext,
|
||||
__glXMakeContextCurrent,
|
||||
__glXCreatePbuffer,
|
||||
__glXDestroyPbuffer,
|
||||
__glXGetDrawableAttributes,
|
||||
__glXChangeDrawableAttributes,
|
||||
__glXCreateWindow,
|
||||
__glXDestroyWindow, /* 0x20 */
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXDisp_NewList,
|
||||
__glXDisp_EndList,
|
||||
__glXDisp_DeleteLists,
|
||||
__glXDisp_GenLists,
|
||||
__glXDisp_FeedbackBuffer,
|
||||
__glXDisp_SelectBuffer,
|
||||
__glXDisp_RenderMode,
|
||||
__glXDisp_Finish,
|
||||
__glXDisp_PixelStoref,
|
||||
__glXDisp_PixelStorei,
|
||||
__glXDisp_ReadPixels,
|
||||
__glXDisp_GetBooleanv,
|
||||
__glXDisp_GetClipPlane,
|
||||
__glXDisp_GetDoublev,
|
||||
__glXDisp_GetError,
|
||||
__glXDisp_GetFloatv,
|
||||
__glXDisp_GetIntegerv,
|
||||
__glXDisp_GetLightfv,
|
||||
__glXDisp_GetLightiv,
|
||||
__glXDisp_GetMapdv,
|
||||
__glXDisp_GetMapfv,
|
||||
__glXDisp_GetMapiv,
|
||||
__glXDisp_GetMaterialfv,
|
||||
__glXDisp_GetMaterialiv,
|
||||
__glXDisp_GetPixelMapfv,
|
||||
__glXDisp_GetPixelMapuiv,
|
||||
__glXDisp_GetPixelMapusv,
|
||||
__glXDisp_GetPolygonStipple,
|
||||
__glXDisp_GetString,
|
||||
__glXDisp_GetTexEnvfv,
|
||||
__glXDisp_GetTexEnviv,
|
||||
__glXDisp_GetTexGendv,
|
||||
__glXDisp_GetTexGenfv,
|
||||
__glXDisp_GetTexGeniv,
|
||||
__glXDisp_GetTexImage,
|
||||
__glXDisp_GetTexParameterfv,
|
||||
__glXDisp_GetTexParameteriv,
|
||||
__glXDisp_GetTexLevelParameterfv,
|
||||
__glXDisp_GetTexLevelParameteriv,
|
||||
__glXDisp_IsEnabled,
|
||||
__glXDisp_IsList,
|
||||
__glXDisp_Flush,
|
||||
__glXDisp_AreTexturesResident,
|
||||
__glXDisp_DeleteTextures,
|
||||
__glXDisp_GenTextures,
|
||||
__glXDisp_IsTexture,
|
||||
__glXDisp_GetColorTable,
|
||||
__glXDisp_GetColorTableParameterfv,
|
||||
__glXDisp_GetColorTableParameteriv,
|
||||
__glXDisp_GetConvolutionFilter,
|
||||
__glXDisp_GetConvolutionParameterfv,
|
||||
__glXDisp_GetConvolutionParameteriv,
|
||||
__glXDisp_GetSeparableFilter,
|
||||
__glXDisp_GetHistogram,
|
||||
__glXDisp_GetHistogramParameterfv,
|
||||
__glXDisp_GetHistogramParameteriv,
|
||||
__glXDisp_GetMinmax,
|
||||
__glXDisp_GetMinmaxParameterfv,
|
||||
__glXDisp_GetMinmaxParameteriv,
|
||||
};
|
||||
|
||||
__GLXdispatchRenderProcPtr __glXRenderTable[] = {
|
||||
__glXNoSuchRenderOpcode,
|
||||
__glXDisp_CallList,
|
||||
__glXDisp_CallLists,
|
||||
__glXDisp_ListBase,
|
||||
__glXDisp_Begin,
|
||||
__glXDisp_Bitmap,
|
||||
__glXDisp_Color3bv,
|
||||
__glXDisp_Color3dv,
|
||||
__glXDisp_Color3fv,
|
||||
__glXDisp_Color3iv,
|
||||
__glXDisp_Color3sv,
|
||||
__glXDisp_Color3ubv,
|
||||
__glXDisp_Color3uiv,
|
||||
__glXDisp_Color3usv,
|
||||
__glXDisp_Color4bv,
|
||||
__glXDisp_Color4dv,
|
||||
__glXDisp_Color4fv,
|
||||
__glXDisp_Color4iv,
|
||||
__glXDisp_Color4sv,
|
||||
__glXDisp_Color4ubv,
|
||||
__glXDisp_Color4uiv,
|
||||
__glXDisp_Color4usv,
|
||||
__glXDisp_EdgeFlagv,
|
||||
__glXDisp_End,
|
||||
__glXDisp_Indexdv,
|
||||
__glXDisp_Indexfv,
|
||||
__glXDisp_Indexiv,
|
||||
__glXDisp_Indexsv,
|
||||
__glXDisp_Normal3bv,
|
||||
__glXDisp_Normal3dv,
|
||||
__glXDisp_Normal3fv,
|
||||
__glXDisp_Normal3iv,
|
||||
__glXDisp_Normal3sv,
|
||||
__glXDisp_RasterPos2dv,
|
||||
__glXDisp_RasterPos2fv,
|
||||
__glXDisp_RasterPos2iv,
|
||||
__glXDisp_RasterPos2sv,
|
||||
__glXDisp_RasterPos3dv,
|
||||
__glXDisp_RasterPos3fv,
|
||||
__glXDisp_RasterPos3iv,
|
||||
__glXDisp_RasterPos3sv,
|
||||
__glXDisp_RasterPos4dv,
|
||||
__glXDisp_RasterPos4fv,
|
||||
__glXDisp_RasterPos4iv,
|
||||
__glXDisp_RasterPos4sv,
|
||||
__glXDisp_Rectdv,
|
||||
__glXDisp_Rectfv,
|
||||
__glXDisp_Rectiv,
|
||||
__glXDisp_Rectsv,
|
||||
__glXDisp_TexCoord1dv,
|
||||
__glXDisp_TexCoord1fv,
|
||||
__glXDisp_TexCoord1iv,
|
||||
__glXDisp_TexCoord1sv,
|
||||
__glXDisp_TexCoord2dv,
|
||||
__glXDisp_TexCoord2fv,
|
||||
__glXDisp_TexCoord2iv,
|
||||
__glXDisp_TexCoord2sv,
|
||||
__glXDisp_TexCoord3dv,
|
||||
__glXDisp_TexCoord3fv,
|
||||
__glXDisp_TexCoord3iv,
|
||||
__glXDisp_TexCoord3sv,
|
||||
__glXDisp_TexCoord4dv,
|
||||
__glXDisp_TexCoord4fv,
|
||||
__glXDisp_TexCoord4iv,
|
||||
__glXDisp_TexCoord4sv,
|
||||
__glXDisp_Vertex2dv,
|
||||
__glXDisp_Vertex2fv,
|
||||
__glXDisp_Vertex2iv,
|
||||
__glXDisp_Vertex2sv,
|
||||
__glXDisp_Vertex3dv,
|
||||
__glXDisp_Vertex3fv,
|
||||
__glXDisp_Vertex3iv,
|
||||
__glXDisp_Vertex3sv,
|
||||
__glXDisp_Vertex4dv,
|
||||
__glXDisp_Vertex4fv,
|
||||
__glXDisp_Vertex4iv,
|
||||
__glXDisp_Vertex4sv,
|
||||
__glXDisp_ClipPlane,
|
||||
__glXDisp_ColorMaterial,
|
||||
__glXDisp_CullFace,
|
||||
__glXDisp_Fogf,
|
||||
__glXDisp_Fogfv,
|
||||
__glXDisp_Fogi,
|
||||
__glXDisp_Fogiv,
|
||||
__glXDisp_FrontFace,
|
||||
__glXDisp_Hint,
|
||||
__glXDisp_Lightf,
|
||||
__glXDisp_Lightfv,
|
||||
__glXDisp_Lighti,
|
||||
__glXDisp_Lightiv,
|
||||
__glXDisp_LightModelf,
|
||||
__glXDisp_LightModelfv,
|
||||
__glXDisp_LightModeli,
|
||||
__glXDisp_LightModeliv,
|
||||
__glXDisp_LineStipple,
|
||||
__glXDisp_LineWidth,
|
||||
__glXDisp_Materialf,
|
||||
__glXDisp_Materialfv,
|
||||
__glXDisp_Materiali,
|
||||
__glXDisp_Materialiv,
|
||||
__glXDisp_PointSize,
|
||||
__glXDisp_PolygonMode,
|
||||
__glXDisp_PolygonStipple,
|
||||
__glXDisp_Scissor,
|
||||
__glXDisp_ShadeModel,
|
||||
__glXDisp_TexParameterf,
|
||||
__glXDisp_TexParameterfv,
|
||||
__glXDisp_TexParameteri,
|
||||
__glXDisp_TexParameteriv,
|
||||
__glXDisp_TexImage1D,
|
||||
__glXDisp_TexImage2D,
|
||||
__glXDisp_TexEnvf,
|
||||
__glXDisp_TexEnvfv,
|
||||
__glXDisp_TexEnvi,
|
||||
__glXDisp_TexEnviv,
|
||||
__glXDisp_TexGend,
|
||||
__glXDisp_TexGendv,
|
||||
__glXDisp_TexGenf,
|
||||
__glXDisp_TexGenfv,
|
||||
__glXDisp_TexGeni,
|
||||
__glXDisp_TexGeniv,
|
||||
__glXDisp_InitNames,
|
||||
__glXDisp_LoadName,
|
||||
__glXDisp_PassThrough,
|
||||
__glXDisp_PopName,
|
||||
__glXDisp_PushName,
|
||||
__glXDisp_DrawBuffer,
|
||||
__glXDisp_Clear,
|
||||
__glXDisp_ClearAccum,
|
||||
__glXDisp_ClearIndex,
|
||||
__glXDisp_ClearColor,
|
||||
__glXDisp_ClearStencil,
|
||||
__glXDisp_ClearDepth,
|
||||
__glXDisp_StencilMask,
|
||||
__glXDisp_ColorMask,
|
||||
__glXDisp_DepthMask,
|
||||
__glXDisp_IndexMask,
|
||||
__glXDisp_Accum,
|
||||
__glXDisp_Disable,
|
||||
__glXDisp_Enable,
|
||||
__glXNoSuchRenderOpcode,
|
||||
__glXDisp_PopAttrib,
|
||||
__glXDisp_PushAttrib,
|
||||
__glXDisp_Map1d,
|
||||
__glXDisp_Map1f,
|
||||
__glXDisp_Map2d,
|
||||
__glXDisp_Map2f,
|
||||
__glXDisp_MapGrid1d,
|
||||
__glXDisp_MapGrid1f,
|
||||
__glXDisp_MapGrid2d,
|
||||
__glXDisp_MapGrid2f,
|
||||
__glXDisp_EvalCoord1dv,
|
||||
__glXDisp_EvalCoord1fv,
|
||||
__glXDisp_EvalCoord2dv,
|
||||
__glXDisp_EvalCoord2fv,
|
||||
__glXDisp_EvalMesh1,
|
||||
__glXDisp_EvalPoint1,
|
||||
__glXDisp_EvalMesh2,
|
||||
__glXDisp_EvalPoint2,
|
||||
__glXDisp_AlphaFunc,
|
||||
__glXDisp_BlendFunc,
|
||||
__glXDisp_LogicOp,
|
||||
__glXDisp_StencilFunc,
|
||||
__glXDisp_StencilOp,
|
||||
__glXDisp_DepthFunc,
|
||||
__glXDisp_PixelZoom,
|
||||
__glXDisp_PixelTransferf,
|
||||
__glXDisp_PixelTransferi,
|
||||
__glXDisp_PixelMapfv,
|
||||
__glXDisp_PixelMapuiv,
|
||||
__glXDisp_PixelMapusv,
|
||||
__glXDisp_ReadBuffer,
|
||||
__glXDisp_CopyPixels,
|
||||
__glXDisp_DrawPixels,
|
||||
__glXDisp_DepthRange,
|
||||
__glXDisp_Frustum,
|
||||
__glXDisp_LoadIdentity,
|
||||
__glXDisp_LoadMatrixf,
|
||||
__glXDisp_LoadMatrixd,
|
||||
__glXDisp_MatrixMode,
|
||||
__glXDisp_MultMatrixf,
|
||||
__glXDisp_MultMatrixd,
|
||||
__glXDisp_Ortho,
|
||||
__glXDisp_PopMatrix,
|
||||
__glXDisp_PushMatrix,
|
||||
__glXDisp_Rotated,
|
||||
__glXDisp_Rotatef,
|
||||
__glXDisp_Scaled,
|
||||
__glXDisp_Scalef,
|
||||
__glXDisp_Translated,
|
||||
__glXDisp_Translatef,
|
||||
__glXDisp_Viewport,
|
||||
__glXDisp_PolygonOffset,
|
||||
__glXDisp_DrawArrays,
|
||||
__glXDisp_Indexubv,
|
||||
__glXDisp_ColorSubTable,
|
||||
__glXDisp_CopyColorSubTable,
|
||||
__glXDisp_ActiveTextureARB,
|
||||
__glXDisp_MultiTexCoord1dvARB,
|
||||
__glXDisp_MultiTexCoord1fvARB,
|
||||
__glXDisp_MultiTexCoord1ivARB,
|
||||
__glXDisp_MultiTexCoord1svARB,
|
||||
__glXDisp_MultiTexCoord2dvARB,
|
||||
__glXDisp_MultiTexCoord2fvARB,
|
||||
__glXDisp_MultiTexCoord2ivARB,
|
||||
__glXDisp_MultiTexCoord2svARB,
|
||||
__glXDisp_MultiTexCoord3dvARB,
|
||||
__glXDisp_MultiTexCoord3fvARB,
|
||||
__glXDisp_MultiTexCoord3ivARB,
|
||||
__glXDisp_MultiTexCoord3svARB,
|
||||
__glXDisp_MultiTexCoord4dvARB,
|
||||
__glXDisp_MultiTexCoord4fvARB,
|
||||
__glXDisp_MultiTexCoord4ivARB,
|
||||
__glXDisp_MultiTexCoord4svARB, /* 213 */
|
||||
__glXNoSuchRenderOpcode,
|
||||
__glXNoSuchRenderOpcode,
|
||||
__glXNoSuchRenderOpcode,
|
||||
__glXNoSuchRenderOpcode,
|
||||
__glXNoSuchRenderOpcode,
|
||||
__glXNoSuchRenderOpcode,
|
||||
__glXNoSuchRenderOpcode, /* 220 */
|
||||
__glXNoSuchRenderOpcode,
|
||||
__glXNoSuchRenderOpcode,
|
||||
__glXNoSuchRenderOpcode,
|
||||
__glXNoSuchRenderOpcode,
|
||||
__glXNoSuchRenderOpcode,
|
||||
__glXNoSuchRenderOpcode,
|
||||
__glXNoSuchRenderOpcode,
|
||||
__glXNoSuchRenderOpcode,
|
||||
__glXDisp_SampleCoverageARB,
|
||||
#ifndef MISSING_GL_EXTS
|
||||
__glXDisp_WindowPos3fvMESA /* 230 */
|
||||
#else
|
||||
__glXNoSuchRenderOpcode
|
||||
#endif
|
||||
};
|
||||
|
||||
__GLXdispatchSingleProcPtr __glXSwapSingleTable[__GLX_SINGLE_TABLE_SIZE] = {
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXSwapRender,
|
||||
__glXSwapRenderLarge,
|
||||
__glXSwapCreateContext,
|
||||
__glXSwapDestroyContext,
|
||||
__glXSwapMakeCurrent,
|
||||
__glXSwapIsDirect,
|
||||
__glXSwapQueryVersion,
|
||||
__glXSwapWaitGL, /* 0x08 */
|
||||
__glXSwapWaitX,
|
||||
__glXSwapCopyContext,
|
||||
__glXSwapSwapBuffers,
|
||||
__glXSwapUseXFont,
|
||||
__glXSwapCreateGLXPixmap,
|
||||
__glXSwapGetVisualConfigs,
|
||||
__glXSwapDestroyGLXPixmap,
|
||||
__glXSwapVendorPrivate, /* 0x10 */
|
||||
__glXSwapVendorPrivateWithReply,
|
||||
__glXSwapQueryExtensionsString,
|
||||
__glXSwapQueryServerString,
|
||||
__glXSwapClientInfo,
|
||||
__glXSwapGetFBConfigs,
|
||||
__glXSwapCreatePixmap,
|
||||
__glXSwapDestroyPixmap,
|
||||
__glXSwapCreateNewContext, /* 0x18 */
|
||||
__glXSwapQueryContext,
|
||||
__glXSwapMakeContextCurrent,
|
||||
__glXSwapCreatePbuffer,
|
||||
__glXSwapDestroyPbuffer,
|
||||
__glXSwapGetDrawableAttributes,
|
||||
__glXSwapChangeDrawableAttributes,
|
||||
__glXSwapCreateWindow,
|
||||
__glXSwapDestroyWindow, /* 0x20 */
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXNoSuchSingleOpcode,
|
||||
__glXDispSwap_NewList,
|
||||
__glXDispSwap_EndList,
|
||||
__glXDispSwap_DeleteLists,
|
||||
__glXDispSwap_GenLists,
|
||||
__glXDispSwap_FeedbackBuffer,
|
||||
__glXDispSwap_SelectBuffer,
|
||||
__glXDispSwap_RenderMode,
|
||||
__glXDispSwap_Finish,
|
||||
__glXDispSwap_PixelStoref,
|
||||
__glXDispSwap_PixelStorei,
|
||||
__glXDispSwap_ReadPixels,
|
||||
__glXDispSwap_GetBooleanv,
|
||||
__glXDispSwap_GetClipPlane,
|
||||
__glXDispSwap_GetDoublev,
|
||||
__glXDispSwap_GetError,
|
||||
__glXDispSwap_GetFloatv,
|
||||
__glXDispSwap_GetIntegerv,
|
||||
__glXDispSwap_GetLightfv,
|
||||
__glXDispSwap_GetLightiv,
|
||||
__glXDispSwap_GetMapdv,
|
||||
__glXDispSwap_GetMapfv,
|
||||
__glXDispSwap_GetMapiv,
|
||||
__glXDispSwap_GetMaterialfv,
|
||||
__glXDispSwap_GetMaterialiv,
|
||||
__glXDispSwap_GetPixelMapfv,
|
||||
__glXDispSwap_GetPixelMapuiv,
|
||||
__glXDispSwap_GetPixelMapusv,
|
||||
__glXDispSwap_GetPolygonStipple,
|
||||
__glXDispSwap_GetString,
|
||||
__glXDispSwap_GetTexEnvfv,
|
||||
__glXDispSwap_GetTexEnviv,
|
||||
__glXDispSwap_GetTexGendv,
|
||||
__glXDispSwap_GetTexGenfv,
|
||||
__glXDispSwap_GetTexGeniv,
|
||||
__glXDispSwap_GetTexImage,
|
||||
__glXDispSwap_GetTexParameterfv,
|
||||
__glXDispSwap_GetTexParameteriv,
|
||||
__glXDispSwap_GetTexLevelParameterfv,
|
||||
__glXDispSwap_GetTexLevelParameteriv,
|
||||
__glXDispSwap_IsEnabled,
|
||||
__glXDispSwap_IsList,
|
||||
__glXDispSwap_Flush,
|
||||
__glXDispSwap_AreTexturesResident,
|
||||
__glXDispSwap_DeleteTextures,
|
||||
__glXDispSwap_GenTextures,
|
||||
__glXDispSwap_IsTexture,
|
||||
__glXDispSwap_GetColorTable,
|
||||
__glXDispSwap_GetColorTableParameterfv,
|
||||
__glXDispSwap_GetColorTableParameteriv,
|
||||
__glXDispSwap_GetConvolutionFilter,
|
||||
__glXDispSwap_GetConvolutionParameterfv,
|
||||
__glXDispSwap_GetConvolutionParameteriv,
|
||||
__glXDispSwap_GetSeparableFilter,
|
||||
__glXDispSwap_GetHistogram,
|
||||
__glXDispSwap_GetHistogramParameterfv,
|
||||
__glXDispSwap_GetHistogramParameteriv,
|
||||
__glXDispSwap_GetMinmax,
|
||||
__glXDispSwap_GetMinmaxParameterfv,
|
||||
__glXDispSwap_GetMinmaxParameteriv,
|
||||
};
|
||||
|
||||
__GLXdispatchRenderProcPtr __glXSwapRenderTable[__GLX_RENDER_TABLE_SIZE] = {
|
||||
__glXNoSuchRenderOpcode,
|
||||
__glXDispSwap_CallList,
|
||||
__glXDispSwap_CallLists,
|
||||
__glXDispSwap_ListBase,
|
||||
__glXDispSwap_Begin,
|
||||
__glXDispSwap_Bitmap,
|
||||
__glXDispSwap_Color3bv,
|
||||
__glXDispSwap_Color3dv,
|
||||
__glXDispSwap_Color3fv,
|
||||
__glXDispSwap_Color3iv,
|
||||
__glXDispSwap_Color3sv,
|
||||
__glXDispSwap_Color3ubv,
|
||||
__glXDispSwap_Color3uiv,
|
||||
__glXDispSwap_Color3usv,
|
||||
__glXDispSwap_Color4bv,
|
||||
__glXDispSwap_Color4dv,
|
||||
__glXDispSwap_Color4fv,
|
||||
__glXDispSwap_Color4iv,
|
||||
__glXDispSwap_Color4sv,
|
||||
__glXDispSwap_Color4ubv,
|
||||
__glXDispSwap_Color4uiv,
|
||||
__glXDispSwap_Color4usv,
|
||||
__glXDispSwap_EdgeFlagv,
|
||||
__glXDispSwap_End,
|
||||
__glXDispSwap_Indexdv,
|
||||
__glXDispSwap_Indexfv,
|
||||
__glXDispSwap_Indexiv,
|
||||
__glXDispSwap_Indexsv,
|
||||
__glXDispSwap_Normal3bv,
|
||||
__glXDispSwap_Normal3dv,
|
||||
__glXDispSwap_Normal3fv,
|
||||
__glXDispSwap_Normal3iv,
|
||||
__glXDispSwap_Normal3sv,
|
||||
__glXDispSwap_RasterPos2dv,
|
||||
__glXDispSwap_RasterPos2fv,
|
||||
__glXDispSwap_RasterPos2iv,
|
||||
__glXDispSwap_RasterPos2sv,
|
||||
__glXDispSwap_RasterPos3dv,
|
||||
__glXDispSwap_RasterPos3fv,
|
||||
__glXDispSwap_RasterPos3iv,
|
||||
__glXDispSwap_RasterPos3sv,
|
||||
__glXDispSwap_RasterPos4dv,
|
||||
__glXDispSwap_RasterPos4fv,
|
||||
__glXDispSwap_RasterPos4iv,
|
||||
__glXDispSwap_RasterPos4sv,
|
||||
__glXDispSwap_Rectdv,
|
||||
__glXDispSwap_Rectfv,
|
||||
__glXDispSwap_Rectiv,
|
||||
__glXDispSwap_Rectsv,
|
||||
__glXDispSwap_TexCoord1dv,
|
||||
__glXDispSwap_TexCoord1fv,
|
||||
__glXDispSwap_TexCoord1iv,
|
||||
__glXDispSwap_TexCoord1sv,
|
||||
__glXDispSwap_TexCoord2dv,
|
||||
__glXDispSwap_TexCoord2fv,
|
||||
__glXDispSwap_TexCoord2iv,
|
||||
__glXDispSwap_TexCoord2sv,
|
||||
__glXDispSwap_TexCoord3dv,
|
||||
__glXDispSwap_TexCoord3fv,
|
||||
__glXDispSwap_TexCoord3iv,
|
||||
__glXDispSwap_TexCoord3sv,
|
||||
__glXDispSwap_TexCoord4dv,
|
||||
__glXDispSwap_TexCoord4fv,
|
||||
__glXDispSwap_TexCoord4iv,
|
||||
__glXDispSwap_TexCoord4sv,
|
||||
__glXDispSwap_Vertex2dv,
|
||||
__glXDispSwap_Vertex2fv,
|
||||
__glXDispSwap_Vertex2iv,
|
||||
__glXDispSwap_Vertex2sv,
|
||||
__glXDispSwap_Vertex3dv,
|
||||
__glXDispSwap_Vertex3fv,
|
||||
__glXDispSwap_Vertex3iv,
|
||||
__glXDispSwap_Vertex3sv,
|
||||
__glXDispSwap_Vertex4dv,
|
||||
__glXDispSwap_Vertex4fv,
|
||||
__glXDispSwap_Vertex4iv,
|
||||
__glXDispSwap_Vertex4sv,
|
||||
__glXDispSwap_ClipPlane,
|
||||
__glXDispSwap_ColorMaterial,
|
||||
__glXDispSwap_CullFace,
|
||||
__glXDispSwap_Fogf,
|
||||
__glXDispSwap_Fogfv,
|
||||
__glXDispSwap_Fogi,
|
||||
__glXDispSwap_Fogiv,
|
||||
__glXDispSwap_FrontFace,
|
||||
__glXDispSwap_Hint,
|
||||
__glXDispSwap_Lightf,
|
||||
__glXDispSwap_Lightfv,
|
||||
__glXDispSwap_Lighti,
|
||||
__glXDispSwap_Lightiv,
|
||||
__glXDispSwap_LightModelf,
|
||||
__glXDispSwap_LightModelfv,
|
||||
__glXDispSwap_LightModeli,
|
||||
__glXDispSwap_LightModeliv,
|
||||
__glXDispSwap_LineStipple,
|
||||
__glXDispSwap_LineWidth,
|
||||
__glXDispSwap_Materialf,
|
||||
__glXDispSwap_Materialfv,
|
||||
__glXDispSwap_Materiali,
|
||||
__glXDispSwap_Materialiv,
|
||||
__glXDispSwap_PointSize,
|
||||
__glXDispSwap_PolygonMode,
|
||||
__glXDispSwap_PolygonStipple,
|
||||
__glXDispSwap_Scissor,
|
||||
__glXDispSwap_ShadeModel,
|
||||
__glXDispSwap_TexParameterf,
|
||||
__glXDispSwap_TexParameterfv,
|
||||
__glXDispSwap_TexParameteri,
|
||||
__glXDispSwap_TexParameteriv,
|
||||
__glXDispSwap_TexImage1D,
|
||||
__glXDispSwap_TexImage2D,
|
||||
__glXDispSwap_TexEnvf,
|
||||
__glXDispSwap_TexEnvfv,
|
||||
__glXDispSwap_TexEnvi,
|
||||
__glXDispSwap_TexEnviv,
|
||||
__glXDispSwap_TexGend,
|
||||
__glXDispSwap_TexGendv,
|
||||
__glXDispSwap_TexGenf,
|
||||
__glXDispSwap_TexGenfv,
|
||||
__glXDispSwap_TexGeni,
|
||||
__glXDispSwap_TexGeniv,
|
||||
__glXDispSwap_InitNames,
|
||||
__glXDispSwap_LoadName,
|
||||
__glXDispSwap_PassThrough,
|
||||
__glXDispSwap_PopName,
|
||||
__glXDispSwap_PushName,
|
||||
__glXDispSwap_DrawBuffer,
|
||||
__glXDispSwap_Clear,
|
||||
__glXDispSwap_ClearAccum,
|
||||
__glXDispSwap_ClearIndex,
|
||||
__glXDispSwap_ClearColor,
|
||||
__glXDispSwap_ClearStencil,
|
||||
__glXDispSwap_ClearDepth,
|
||||
__glXDispSwap_StencilMask,
|
||||
__glXDispSwap_ColorMask,
|
||||
__glXDispSwap_DepthMask,
|
||||
__glXDispSwap_IndexMask,
|
||||
__glXDispSwap_Accum,
|
||||
__glXDispSwap_Disable,
|
||||
__glXDispSwap_Enable,
|
||||
__glXNoSuchRenderOpcode,
|
||||
__glXDispSwap_PopAttrib,
|
||||
__glXDispSwap_PushAttrib,
|
||||
__glXDispSwap_Map1d,
|
||||
__glXDispSwap_Map1f,
|
||||
__glXDispSwap_Map2d,
|
||||
__glXDispSwap_Map2f,
|
||||
__glXDispSwap_MapGrid1d,
|
||||
__glXDispSwap_MapGrid1f,
|
||||
__glXDispSwap_MapGrid2d,
|
||||
__glXDispSwap_MapGrid2f,
|
||||
__glXDispSwap_EvalCoord1dv,
|
||||
__glXDispSwap_EvalCoord1fv,
|
||||
__glXDispSwap_EvalCoord2dv,
|
||||
__glXDispSwap_EvalCoord2fv,
|
||||
__glXDispSwap_EvalMesh1,
|
||||
__glXDispSwap_EvalPoint1,
|
||||
__glXDispSwap_EvalMesh2,
|
||||
__glXDispSwap_EvalPoint2,
|
||||
__glXDispSwap_AlphaFunc,
|
||||
__glXDispSwap_BlendFunc,
|
||||
__glXDispSwap_LogicOp,
|
||||
__glXDispSwap_StencilFunc,
|
||||
__glXDispSwap_StencilOp,
|
||||
__glXDispSwap_DepthFunc,
|
||||
__glXDispSwap_PixelZoom,
|
||||
__glXDispSwap_PixelTransferf,
|
||||
__glXDispSwap_PixelTransferi,
|
||||
__glXDispSwap_PixelMapfv,
|
||||
__glXDispSwap_PixelMapuiv,
|
||||
__glXDispSwap_PixelMapusv,
|
||||
__glXDispSwap_ReadBuffer,
|
||||
__glXDispSwap_CopyPixels,
|
||||
__glXDispSwap_DrawPixels,
|
||||
__glXDispSwap_DepthRange,
|
||||
__glXDispSwap_Frustum,
|
||||
__glXDispSwap_LoadIdentity,
|
||||
__glXDispSwap_LoadMatrixf,
|
||||
__glXDispSwap_LoadMatrixd,
|
||||
__glXDispSwap_MatrixMode,
|
||||
__glXDispSwap_MultMatrixf,
|
||||
__glXDispSwap_MultMatrixd,
|
||||
__glXDispSwap_Ortho,
|
||||
__glXDispSwap_PopMatrix,
|
||||
__glXDispSwap_PushMatrix,
|
||||
__glXDispSwap_Rotated,
|
||||
__glXDispSwap_Rotatef,
|
||||
__glXDispSwap_Scaled,
|
||||
__glXDispSwap_Scalef,
|
||||
__glXDispSwap_Translated,
|
||||
__glXDispSwap_Translatef,
|
||||
__glXDispSwap_Viewport,
|
||||
__glXDispSwap_PolygonOffset,
|
||||
__glXDispSwap_DrawArrays,
|
||||
__glXDispSwap_Indexubv,
|
||||
__glXDispSwap_ColorSubTable,
|
||||
__glXDispSwap_CopyColorSubTable,
|
||||
__glXDispSwap_ActiveTextureARB,
|
||||
__glXDispSwap_MultiTexCoord1dvARB,
|
||||
__glXDispSwap_MultiTexCoord1fvARB,
|
||||
__glXDispSwap_MultiTexCoord1ivARB,
|
||||
__glXDispSwap_MultiTexCoord1svARB,
|
||||
__glXDispSwap_MultiTexCoord2dvARB,
|
||||
__glXDispSwap_MultiTexCoord2fvARB,
|
||||
__glXDispSwap_MultiTexCoord2ivARB,
|
||||
__glXDispSwap_MultiTexCoord2svARB,
|
||||
__glXDispSwap_MultiTexCoord3dvARB,
|
||||
__glXDispSwap_MultiTexCoord3fvARB,
|
||||
__glXDispSwap_MultiTexCoord3ivARB,
|
||||
__glXDispSwap_MultiTexCoord3svARB,
|
||||
__glXDispSwap_MultiTexCoord4dvARB,
|
||||
__glXDispSwap_MultiTexCoord4fvARB,
|
||||
__glXDispSwap_MultiTexCoord4ivARB,
|
||||
__glXDispSwap_MultiTexCoord4svARB, /* 213 */
|
||||
__glXNoSuchRenderOpcode,
|
||||
__glXNoSuchRenderOpcode,
|
||||
__glXNoSuchRenderOpcode,
|
||||
__glXNoSuchRenderOpcode,
|
||||
__glXNoSuchRenderOpcode,
|
||||
__glXNoSuchRenderOpcode,
|
||||
__glXNoSuchRenderOpcode, /* 220 */
|
||||
__glXNoSuchRenderOpcode,
|
||||
__glXNoSuchRenderOpcode,
|
||||
__glXNoSuchRenderOpcode,
|
||||
__glXNoSuchRenderOpcode,
|
||||
__glXNoSuchRenderOpcode,
|
||||
__glXNoSuchRenderOpcode,
|
||||
__glXNoSuchRenderOpcode,
|
||||
__glXNoSuchRenderOpcode,
|
||||
__glXDispSwap_SampleCoverageARB,
|
||||
#ifndef MISSING_GL_EXTS
|
||||
__glXDispSwap_WindowPos3fvMESA /* 230 */
|
||||
#else
|
||||
__glXNoSuchRenderOpcode
|
||||
#endif
|
||||
};
|
|
@ -34,102 +34,20 @@
|
|||
** version 1.2.1 Specification.
|
||||
*/
|
||||
|
||||
extern int __glXRender(__GLXclientState*, GLbyte*);
|
||||
extern int __glXRenderLarge(__GLXclientState*, GLbyte*);
|
||||
extern int __glXCreateContext(__GLXclientState*, GLbyte*);
|
||||
extern int __glXDestroyContext(__GLXclientState*, GLbyte*);
|
||||
extern int __glXMakeCurrent(__GLXclientState*, GLbyte*);
|
||||
extern int __glXIsDirect(__GLXclientState*, GLbyte*);
|
||||
extern int __glXQueryVersion(__GLXclientState*, GLbyte*);
|
||||
extern int __glXWaitGL(__GLXclientState*, GLbyte*);
|
||||
extern int __glXWaitX(__GLXclientState*, GLbyte*);
|
||||
extern int __glXCopyContext(__GLXclientState*, GLbyte*);
|
||||
extern int __glXSwapBuffers(__GLXclientState*, GLbyte*);
|
||||
extern int __glXBindTexImageEXT(__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXCopySubBufferMESA(__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXGetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXUseXFont(__GLXclientState*, GLbyte*);
|
||||
extern int __glXCreateGLXPixmap(__GLXclientState*, GLbyte*);
|
||||
extern int __glXGetVisualConfigs(__GLXclientState*, GLbyte*);
|
||||
extern int __glXDestroyGLXPixmap(__GLXclientState*, GLbyte*);
|
||||
extern int __glXVendorPrivate(__GLXclientState*, GLbyte*);
|
||||
extern int __glXVendorPrivateWithReply(__GLXclientState*, GLbyte*);
|
||||
extern int __glXQueryExtensionsString(__GLXclientState*, GLbyte*);
|
||||
extern int __glXQueryServerString(__GLXclientState*, GLbyte*);
|
||||
extern int __glXClientInfo(__GLXclientState*, GLbyte*);
|
||||
extern int __glXMakeContextCurrent(__GLXclientState*, GLbyte*);
|
||||
extern int __glXGetFBConfigs(__GLXclientState*, GLbyte*);
|
||||
extern int __glXCreatePixmap(__GLXclientState*, GLbyte*);
|
||||
extern int __glXDestroyPixmap(__GLXclientState*, GLbyte*);
|
||||
extern int __glXCreateNewContext(__GLXclientState*, GLbyte*);
|
||||
extern int __glXQueryContext(__GLXclientState*, GLbyte*);
|
||||
extern int __glXMakeContextCurrent(__GLXclientState*, GLbyte*);
|
||||
extern int __glXCreatePbuffer(__GLXclientState*, GLbyte*);
|
||||
extern int __glXDestroyPbuffer(__GLXclientState*, GLbyte*);
|
||||
extern int __glXGetDrawableAttributes(__GLXclientState*, GLbyte*);
|
||||
extern int __glXChangeDrawableAttributes(__GLXclientState*, GLbyte*);
|
||||
extern int __glXCreateWindow(__GLXclientState*, GLbyte*);
|
||||
extern int __glXDestroyWindow(__GLXclientState*, GLbyte*);
|
||||
extern int __glXDisp_GetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXDisp_BindSwapBarrierSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXDisp_QueryMaxSwapBarriersSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXDisp_QueryHyperpipeNetworkSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXDisp_DestroyHyperpipeConfigSGIX (__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXDisp_QueryHyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXDisp_HyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
|
||||
extern int __glXSwapRender(__GLXclientState*, GLbyte*);
|
||||
extern int __glXSwapRenderLarge(__GLXclientState*, GLbyte*);
|
||||
extern int __glXSwapCreateContext(__GLXclientState*, GLbyte*);
|
||||
extern int __glXSwapDestroyContext(__GLXclientState*, GLbyte*);
|
||||
extern int __glXSwapMakeCurrent(__GLXclientState*, GLbyte*);
|
||||
extern int __glXSwapIsDirect(__GLXclientState*, GLbyte*);
|
||||
extern int __glXSwapQueryVersion(__GLXclientState*, GLbyte*);
|
||||
extern int __glXSwapWaitGL(__GLXclientState*, GLbyte*);
|
||||
extern int __glXSwapWaitX(__GLXclientState*, GLbyte*);
|
||||
extern int __glXSwapCopyContext(__GLXclientState*, GLbyte*);
|
||||
extern int __glXSwapSwapBuffers(__GLXclientState*, GLbyte*);
|
||||
extern int __glXSwapBindTexImageEXT(__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXSwapReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXSwapReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXSwapGetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXSwapUseXFont(__GLXclientState*, GLbyte*);
|
||||
extern int __glXSwapCreateGLXPixmap(__GLXclientState*, GLbyte*);
|
||||
extern int __glXSwapGetVisualConfigs(__GLXclientState*, GLbyte*);
|
||||
extern int __glXSwapDestroyGLXPixmap(__GLXclientState*, GLbyte*);
|
||||
extern int __glXSwapVendorPrivate(__GLXclientState*, GLbyte*);
|
||||
extern int __glXSwapVendorPrivateWithReply(__GLXclientState*, GLbyte*);
|
||||
extern int __glXSwapQueryExtensionsString(__GLXclientState*, GLbyte*);
|
||||
extern int __glXSwapQueryServerString(__GLXclientState*, GLbyte*);
|
||||
extern int __glXSwapClientInfo(__GLXclientState*, GLbyte*);
|
||||
extern int __glXSwapMakeContextCurrent(__GLXclientState*, GLbyte*);
|
||||
extern int __glXSwapGetFBConfigs(__GLXclientState*, GLbyte*);
|
||||
extern int __glXSwapCreatePixmap(__GLXclientState*, GLbyte*);
|
||||
extern int __glXSwapDestroyPixmap(__GLXclientState*, GLbyte*);
|
||||
extern int __glXSwapCreateNewContext(__GLXclientState*, GLbyte*);
|
||||
extern int __glXSwapQueryContext(__GLXclientState*, GLbyte*);
|
||||
extern int __glXSwapMakeContextCurrent(__GLXclientState*, GLbyte*);
|
||||
extern int __glXSwapCreatePbuffer(__GLXclientState*, GLbyte*);
|
||||
extern int __glXSwapDestroyPbuffer(__GLXclientState*, GLbyte*);
|
||||
extern int __glXSwapGetDrawableAttributes(__GLXclientState*, GLbyte*);
|
||||
extern int __glXSwapChangeDrawableAttributes(__GLXclientState*, GLbyte*);
|
||||
extern int __glXSwapCreateWindow(__GLXclientState*, GLbyte*);
|
||||
extern int __glXSwapDestroyWindow(__GLXclientState*, GLbyte*);
|
||||
|
||||
|
||||
#define __GLX_MIN_GLXCMD_OPCODE 1
|
||||
#define __GLX_MAX_GLXCMD_OPCODE 20
|
||||
#define __GLX_MIN_RENDER_OPCODE 1
|
||||
/*#define __GLX_MAX_RENDER_OPCODE 213*/
|
||||
#define __GLX_MAX_RENDER_OPCODE 230
|
||||
#define __GLX_MIN_SINGLE_OPCODE 1
|
||||
#define __GLX_MAX_SINGLE_OPCODE 159
|
||||
#define __GLX_SINGLE_TABLE_SIZE 160
|
||||
/*#define __GLX_RENDER_TABLE_SIZE 214*/
|
||||
#define __GLX_RENDER_TABLE_SIZE 231
|
||||
extern __GLXdispatchRenderProcPtr __glXRenderTable[__GLX_RENDER_TABLE_SIZE];
|
||||
extern __GLXdispatchSingleProcPtr __glXSingleTable[__GLX_SINGLE_TABLE_SIZE];
|
||||
extern __GLXdispatchRenderProcPtr __glXSwapRenderTable[__GLX_RENDER_TABLE_SIZE];
|
||||
extern __GLXdispatchSingleProcPtr __glXSwapSingleTable[__GLX_SINGLE_TABLE_SIZE];
|
||||
|
||||
/* Copied from mesa src/glx/x11/glxcmds.c
|
||||
*
|
||||
* Apparently there's no standardized opcode for this extension.
|
||||
*/
|
||||
#define X_GLXvop_CopySubBufferMESA 5154 /* temporary */
|
||||
extern int __glXDispSwap_GetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXDispSwap_BindSwapBarrierSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXDispSwap_QueryMaxSwapBarriersSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXDispSwap_QueryHyperpipeNetworkSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXDispSwap_DestroyHyperpipeConfigSGIX (__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXDispSwap_QueryHyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXDispSwap_HyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
|
||||
#endif /* _GLX_g_disptab_h_ */
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -1,47 +0,0 @@
|
|||
/* DO NOT EDIT - THIS FILE IS AUTOMATICALLY GENERATED */
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#ifndef _GLX_g_disptab_EXT_h_
|
||||
#define _GLX_g_disptab_EXT_h_
|
||||
/*
|
||||
** License Applicability. Except to the extent portions of this file are
|
||||
** made subject to an alternative license as permitted in the SGI Free
|
||||
** Software License B, Version 1.1 (the "License"), the contents of this
|
||||
** file are subject only to the provisions of the License. You may not use
|
||||
** this file except in compliance with the License. You may obtain a copy
|
||||
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
|
||||
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
|
||||
**
|
||||
** http://oss.sgi.com/projects/FreeB
|
||||
**
|
||||
** Note that, as provided in the License, the Software is distributed on an
|
||||
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
|
||||
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
|
||||
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
|
||||
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
|
||||
**
|
||||
** Original Code. The Original Code is: OpenGL Sample Implementation,
|
||||
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
|
||||
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
|
||||
** Copyright in any portions created by third parties is as indicated
|
||||
** elsewhere herein. All Rights Reserved.
|
||||
**
|
||||
** Additional Notice Provisions: This software was created using the
|
||||
** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
|
||||
** not been independently verified as being compliant with the OpenGL(R)
|
||||
** version 1.2.1 Specification.
|
||||
*/
|
||||
|
||||
#define __GLX_MIN_RENDER_OPCODE_EXT 2053
|
||||
#define __GLX_MAX_RENDER_OPCODE_EXT 4325
|
||||
#define __GLX_MIN_VENDPRIV_OPCODE_EXT 11
|
||||
#define __GLX_MAX_VENDPRIV_OPCODE_EXT 14
|
||||
#define __GLX_VENDPRIV_TABLE_SIZE_EXT (__GLX_MAX_VENDPRIV_OPCODE_EXT - __GLX_MIN_VENDPRIV_OPCODE_EXT + 1)
|
||||
#define __GLX_RENDER_TABLE_SIZE_EXT (__GLX_MAX_RENDER_OPCODE_EXT - __GLX_MIN_RENDER_OPCODE_EXT + 1)
|
||||
extern __GLXdispatchRenderProcPtr __glXRenderTable_EXT[__GLX_RENDER_TABLE_SIZE_EXT];
|
||||
extern __GLXdispatchVendorPrivProcPtr __glXVendorPrivTable_EXT[__GLX_VENDPRIV_TABLE_SIZE_EXT];
|
||||
extern __GLXdispatchRenderProcPtr __glXSwapRenderTable_EXT[__GLX_RENDER_TABLE_SIZE_EXT];
|
||||
extern __GLXdispatchVendorPrivProcPtr __glXSwapVendorPrivTable_EXT[__GLX_VENDPRIV_TABLE_SIZE_EXT];
|
||||
#endif /* _GLX_g_disptab_EXT_h_ */
|
353
GL/glx/glxcmds.c
353
GL/glx/glxcmds.c
|
@ -48,7 +48,6 @@
|
|||
#include "g_disptab.h"
|
||||
#include <pixmapstr.h>
|
||||
#include <windowstr.h>
|
||||
#include "g_disptab_EXT.h"
|
||||
#include "glxutil.h"
|
||||
#include "glxext.h"
|
||||
#include "glcontextmodes.h"
|
||||
|
@ -57,6 +56,8 @@
|
|||
#include "glthread.h"
|
||||
#include "dispatch.h"
|
||||
#include "indirect_dispatch.h"
|
||||
#include "indirect_table.h"
|
||||
#include "indirect_util.h"
|
||||
|
||||
/************************************************************************/
|
||||
|
||||
|
@ -66,18 +67,6 @@ GlxSetRenderTables (struct _glapi_table *table)
|
|||
_glapi_set_dispatch (table);
|
||||
}
|
||||
|
||||
static int __glXGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
static int __glXCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
static int __glXCreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
static int __glXMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc);
|
||||
|
||||
static int __glXBindSwapBarrierSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
static int __glXQueryMaxSwapBarriersSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
static int __glxQueryHyperpipeNetworkSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
static int __glxDestroyHyperpipeConfigSGIX (__GLXclientState *cl, GLbyte *pc);
|
||||
static int __glxQueryHyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
static int __glxHyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
|
||||
|
||||
/************************************************************************/
|
||||
|
||||
|
@ -254,7 +243,7 @@ int DoCreateContext(__GLXclientState *cl, GLXContextID gcId,
|
|||
}
|
||||
|
||||
|
||||
int __glXCreateContext(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_CreateContext(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXCreateContextReq *req = (xGLXCreateContextReq *) pc;
|
||||
return DoCreateContext( cl, req->context, req->shareList, req->visual,
|
||||
|
@ -262,7 +251,7 @@ int __glXCreateContext(__GLXclientState *cl, GLbyte *pc)
|
|||
}
|
||||
|
||||
|
||||
int __glXCreateNewContext(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_CreateNewContext(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXCreateNewContextReq *req = (xGLXCreateNewContextReq *) pc;
|
||||
return DoCreateContext( cl, req->context, req->shareList, req->fbconfig,
|
||||
|
@ -270,7 +259,7 @@ int __glXCreateNewContext(__GLXclientState *cl, GLbyte *pc)
|
|||
}
|
||||
|
||||
|
||||
int __glXCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_CreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXCreateContextWithConfigSGIXReq *req =
|
||||
(xGLXCreateContextWithConfigSGIXReq *) pc;
|
||||
|
@ -281,7 +270,7 @@ int __glXCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
|
|||
/*
|
||||
** Destroy a GL context as an X resource.
|
||||
*/
|
||||
int __glXDestroyContext(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_DestroyContext(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
ClientPtr client = cl->client;
|
||||
xGLXDestroyContextReq *req = (xGLXDestroyContextReq *) pc;
|
||||
|
@ -399,7 +388,7 @@ static void StartUsingContext(__GLXclientState *cl, __GLXcontext *glxc)
|
|||
** Make an OpenGL context and drawable current.
|
||||
*/
|
||||
|
||||
int __glXMakeCurrent(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_MakeCurrent(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXMakeCurrentReq *req = (xGLXMakeCurrentReq *) pc;
|
||||
|
||||
|
@ -407,7 +396,7 @@ int __glXMakeCurrent(__GLXclientState *cl, GLbyte *pc)
|
|||
req->context, req->oldContextTag );
|
||||
}
|
||||
|
||||
int __glXMakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_MakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXMakeContextCurrentReq *req = (xGLXMakeContextCurrentReq *) pc;
|
||||
|
||||
|
@ -415,7 +404,7 @@ int __glXMakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
|
|||
req->context, req->oldContextTag );
|
||||
}
|
||||
|
||||
int __glXMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_MakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXMakeCurrentReadSGIReq *req = (xGLXMakeCurrentReadSGIReq *) pc;
|
||||
|
||||
|
@ -750,7 +739,7 @@ int DoMakeCurrent( __GLXclientState *cl,
|
|||
return Success;
|
||||
}
|
||||
|
||||
int __glXIsDirect(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_IsDirect(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
ClientPtr client = cl->client;
|
||||
xGLXIsDirectReq *req = (xGLXIsDirectReq *) pc;
|
||||
|
@ -780,7 +769,7 @@ int __glXIsDirect(__GLXclientState *cl, GLbyte *pc)
|
|||
return Success;
|
||||
}
|
||||
|
||||
int __glXQueryVersion(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_QueryVersion(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
ClientPtr client = cl->client;
|
||||
xGLXQueryVersionReq *req = (xGLXQueryVersionReq *) pc;
|
||||
|
@ -811,7 +800,7 @@ int __glXQueryVersion(__GLXclientState *cl, GLbyte *pc)
|
|||
return Success;
|
||||
}
|
||||
|
||||
int __glXWaitGL(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_WaitGL(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXWaitGLReq *req = (xGLXWaitGLReq *)pc;
|
||||
int error;
|
||||
|
@ -823,7 +812,7 @@ int __glXWaitGL(__GLXclientState *cl, GLbyte *pc)
|
|||
return Success;
|
||||
}
|
||||
|
||||
int __glXWaitX(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_WaitX(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXWaitXReq *req = (xGLXWaitXReq *)pc;
|
||||
int error;
|
||||
|
@ -840,7 +829,7 @@ int __glXWaitX(__GLXclientState *cl, GLbyte *pc)
|
|||
return Success;
|
||||
}
|
||||
|
||||
int __glXCopyContext(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_CopyContext(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
ClientPtr client = cl->client;
|
||||
xGLXCopyContextReq *req = (xGLXCopyContextReq *) pc;
|
||||
|
@ -1011,7 +1000,7 @@ int DoGetVisualConfigs(__GLXclientState *cl, unsigned screen,
|
|||
return Success;
|
||||
}
|
||||
|
||||
int __glXGetVisualConfigs(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_GetVisualConfigs(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXGetVisualConfigsReq *req = (xGLXGetVisualConfigsReq *) pc;
|
||||
return DoGetVisualConfigs( cl, req->screen, GL_FALSE );
|
||||
|
@ -1187,14 +1176,14 @@ int DoGetFBConfigs(__GLXclientState *cl, unsigned screen, GLboolean do_swap)
|
|||
}
|
||||
|
||||
|
||||
int __glXGetFBConfigs(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_GetFBConfigs(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXGetFBConfigsReq *req = (xGLXGetFBConfigsReq *) pc;
|
||||
return DoGetFBConfigs( cl, req->screen, GL_FALSE );
|
||||
}
|
||||
|
||||
|
||||
int __glXGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_GetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXGetFBConfigsSGIXReq *req = (xGLXGetFBConfigsSGIXReq *) pc;
|
||||
return DoGetFBConfigs( cl, req->screen, GL_FALSE );
|
||||
|
@ -1290,21 +1279,21 @@ int DoCreateGLXPixmap(__GLXclientState *cl, XID fbconfigId,
|
|||
return Success;
|
||||
}
|
||||
|
||||
int __glXCreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_CreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXCreateGLXPixmapReq *req = (xGLXCreateGLXPixmapReq *) pc;
|
||||
return DoCreateGLXPixmap( cl, req->visual, req->screen,
|
||||
req->pixmap, req->glxpixmap );
|
||||
}
|
||||
|
||||
int __glXCreatePixmap(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_CreatePixmap(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXCreatePixmapReq *req = (xGLXCreatePixmapReq *) pc;
|
||||
return DoCreateGLXPixmap( cl, req->fbconfig, req->screen,
|
||||
req->pixmap, req->glxpixmap );
|
||||
}
|
||||
|
||||
int __glXCreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_CreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXCreateGLXPixmapWithConfigSGIXReq *req =
|
||||
(xGLXCreateGLXPixmapWithConfigSGIXReq *) pc;
|
||||
|
@ -1329,21 +1318,21 @@ int DoDestroyPixmap(__GLXclientState *cl, XID glxpixmap)
|
|||
return Success;
|
||||
}
|
||||
|
||||
int __glXDestroyGLXPixmap(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_DestroyGLXPixmap(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXDestroyGLXPixmapReq *req = (xGLXDestroyGLXPixmapReq *) pc;
|
||||
|
||||
return DoDestroyPixmap(cl, req->glxpixmap);
|
||||
}
|
||||
|
||||
int __glXDestroyPixmap(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_DestroyPixmap(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXDestroyPixmapReq *req = (xGLXDestroyPixmapReq *) pc;
|
||||
|
||||
return DoDestroyPixmap(cl, req->glxpixmap);
|
||||
}
|
||||
|
||||
int __glXCreatePbuffer(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_CreatePbuffer(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXCreatePbufferReq *req = (xGLXCreatePbufferReq *) pc;
|
||||
|
||||
|
@ -1352,7 +1341,7 @@ int __glXCreatePbuffer(__GLXclientState *cl, GLbyte *pc)
|
|||
return BadRequest;
|
||||
}
|
||||
|
||||
int __glXDestroyPbuffer(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_DestroyPbuffer(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXDestroyPbufferReq *req = (xGLXDestroyPbufferReq *) pc;
|
||||
|
||||
|
@ -1361,7 +1350,7 @@ int __glXDestroyPbuffer(__GLXclientState *cl, GLbyte *pc)
|
|||
return BadRequest;
|
||||
}
|
||||
|
||||
int __glXChangeDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_ChangeDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXChangeDrawableAttributesReq *req =
|
||||
(xGLXChangeDrawableAttributesReq *) pc;
|
||||
|
@ -1371,7 +1360,7 @@ int __glXChangeDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
|
|||
return BadRequest;
|
||||
}
|
||||
|
||||
int __glXCreateWindow(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_CreateWindow(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXCreateWindowReq *req = (xGLXCreateWindowReq *) pc;
|
||||
ClientPtr client = cl->client;
|
||||
|
@ -1403,7 +1392,7 @@ int __glXCreateWindow(__GLXclientState *cl, GLbyte *pc)
|
|||
return Success;
|
||||
}
|
||||
|
||||
int __glXDestroyWindow(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_DestroyWindow(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXDestroyWindowReq *req = (xGLXDestroyWindowReq *) pc;
|
||||
ClientPtr client = cl->client;
|
||||
|
@ -1428,7 +1417,7 @@ int __glXDestroyWindow(__GLXclientState *cl, GLbyte *pc)
|
|||
** this time that is of value. Consequently, this code must be
|
||||
** implemented by somebody other than SGI.
|
||||
*/
|
||||
int __glXSwapBuffers(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_SwapBuffers(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
ClientPtr client = cl->client;
|
||||
xGLXSwapBuffersReq *req = (xGLXSwapBuffersReq *) pc;
|
||||
|
@ -1518,21 +1507,21 @@ int DoQueryContext(__GLXclientState *cl, GLXContextID gcId)
|
|||
return Success;
|
||||
}
|
||||
|
||||
int __glXQueryContextInfoEXT(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_QueryContextInfoEXT(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXQueryContextInfoEXTReq *req = (xGLXQueryContextInfoEXTReq *) pc;
|
||||
|
||||
return DoQueryContext(cl, req->context);
|
||||
}
|
||||
|
||||
int __glXQueryContext(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_QueryContext(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXQueryContextReq *req = (xGLXQueryContextReq *) pc;
|
||||
|
||||
return DoQueryContext(cl, req->context);
|
||||
}
|
||||
|
||||
int __glXBindTexImageEXT(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_BindTexImageEXT(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
|
||||
ClientPtr client = cl->client;
|
||||
|
@ -1568,7 +1557,7 @@ int __glXBindTexImageEXT(__GLXclientState *cl, GLbyte *pc)
|
|||
pGlxPixmap);
|
||||
}
|
||||
|
||||
int __glXReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_ReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
|
||||
ClientPtr client = cl->client;
|
||||
|
@ -1601,7 +1590,7 @@ int __glXReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc)
|
|||
pGlxPixmap);
|
||||
}
|
||||
|
||||
int __glXCopySubBufferMESA(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_CopySubBufferMESA(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
|
||||
GLXContextTag tag = req->contextTag;
|
||||
|
@ -1701,7 +1690,7 @@ DoGetDrawableAttributes(__GLXclientState *cl, XID drawId)
|
|||
return Success;
|
||||
}
|
||||
|
||||
int __glXGetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_GetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXVendorPrivateWithReplyReq *req = (xGLXVendorPrivateWithReplyReq *)pc;
|
||||
CARD32 *data;
|
||||
|
@ -1713,7 +1702,7 @@ int __glXGetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc)
|
|||
return DoGetDrawableAttributes(cl, drawable);
|
||||
}
|
||||
|
||||
int __glXGetDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_GetDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXGetDrawableAttributesReq *req = (xGLXGetDrawableAttributesReq *)pc;
|
||||
|
||||
|
@ -1727,10 +1716,7 @@ int __glXGetDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
|
|||
** client library to send batches of GL rendering commands.
|
||||
*/
|
||||
|
||||
/*
|
||||
** Execute all the drawing commands in a request.
|
||||
*/
|
||||
int __glXRender(__GLXclientState *cl, GLbyte *pc)
|
||||
int DoRender(__GLXclientState *cl, GLbyte *pc, int do_swap)
|
||||
{
|
||||
xGLXRenderReq *req;
|
||||
ClientPtr client= cl->client;
|
||||
|
@ -1739,14 +1725,15 @@ int __glXRender(__GLXclientState *cl, GLbyte *pc)
|
|||
CARD16 opcode;
|
||||
__GLXrenderHeader *hdr;
|
||||
__GLXcontext *glxc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
||||
/*
|
||||
** NOTE: much of this code also appears in the byteswapping version of this
|
||||
** routine, __glXSwapRender(). Any changes made here should also be
|
||||
** duplicated there.
|
||||
*/
|
||||
|
||||
req = (xGLXRenderReq *) pc;
|
||||
if (do_swap) {
|
||||
__GLX_SWAP_SHORT(&req->length);
|
||||
__GLX_SWAP_INT(&req->contextTag);
|
||||
}
|
||||
|
||||
glxc = __glXForceCurrent(cl, req->contextTag, &error);
|
||||
if (!glxc) {
|
||||
return error;
|
||||
|
@ -1756,56 +1743,47 @@ int __glXRender(__GLXclientState *cl, GLbyte *pc)
|
|||
pc += sz_xGLXRenderReq;
|
||||
left = (req->length << 2) - sz_xGLXRenderReq;
|
||||
while (left > 0) {
|
||||
__GLXrenderSizeData *entry;
|
||||
__GLXrenderSizeData entry;
|
||||
int extra;
|
||||
void (* proc)(GLbyte *);
|
||||
__GLXdispatchRenderProcPtr proc;
|
||||
int err;
|
||||
|
||||
/*
|
||||
** Verify that the header length and the overall length agree.
|
||||
** Also, each command must be word aligned.
|
||||
*/
|
||||
hdr = (__GLXrenderHeader *) pc;
|
||||
if (do_swap) {
|
||||
__GLX_SWAP_SHORT(&hdr->length);
|
||||
__GLX_SWAP_SHORT(&hdr->opcode);
|
||||
}
|
||||
cmdlen = hdr->length;
|
||||
opcode = hdr->opcode;
|
||||
|
||||
/*
|
||||
** Check for core opcodes and grab entry data.
|
||||
*/
|
||||
if ( (opcode >= __GLX_MIN_RENDER_OPCODE) &&
|
||||
(opcode <= __GLX_MAX_RENDER_OPCODE) ) {
|
||||
entry = &__glXRenderSizeTable[opcode];
|
||||
proc = __glXRenderTable[opcode];
|
||||
#if __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT
|
||||
} else if ( (opcode >= __GLX_MIN_RENDER_OPCODE_EXT) &&
|
||||
(opcode <= __GLX_MAX_RENDER_OPCODE_EXT) ) {
|
||||
entry =
|
||||
&__glXRenderSizeTable_EXT[opcode -
|
||||
__GLX_MIN_RENDER_OPCODE_EXT];
|
||||
proc = __glXRenderTable_EXT[opcode -
|
||||
__GLX_MIN_RENDER_OPCODE_EXT];
|
||||
#endif /* __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT */
|
||||
} else {
|
||||
err = __glXGetProtocolSizeData(& Render_dispatch_info, opcode, & entry);
|
||||
proc = (__GLXdispatchRenderProcPtr)
|
||||
__glXGetProtocolDecodeFunction(& Render_dispatch_info, opcode, do_swap);
|
||||
|
||||
if ((err < 0) || (proc == NULL)) {
|
||||
client->errorValue = commandsDone;
|
||||
return __glXError(GLXBadRenderRequest);
|
||||
}
|
||||
|
||||
if (!entry->bytes) {
|
||||
/* unused opcode */
|
||||
client->errorValue = commandsDone;
|
||||
return __glXError(GLXBadRenderRequest);
|
||||
}
|
||||
if (entry->varsize) {
|
||||
if (entry.varsize) {
|
||||
/* variable size command */
|
||||
extra = (*entry->varsize)(pc + __GLX_RENDER_HDR_SIZE, False);
|
||||
extra = (*entry.varsize)(pc + __GLX_RENDER_HDR_SIZE, do_swap);
|
||||
if (extra < 0) {
|
||||
extra = 0;
|
||||
}
|
||||
if (cmdlen != __GLX_PAD(entry->bytes + extra)) {
|
||||
if (cmdlen != __GLX_PAD(entry.bytes + extra)) {
|
||||
return BadLength;
|
||||
}
|
||||
} else {
|
||||
/* constant size command */
|
||||
if (cmdlen != __GLX_PAD(entry->bytes)) {
|
||||
if (cmdlen != __GLX_PAD(entry.bytes)) {
|
||||
return BadLength;
|
||||
}
|
||||
}
|
||||
|
@ -1830,26 +1808,34 @@ int __glXRender(__GLXclientState *cl, GLbyte *pc)
|
|||
}
|
||||
|
||||
/*
|
||||
** Execute a large rendering request (one that spans multiple X requests).
|
||||
** Execute all the drawing commands in a request.
|
||||
*/
|
||||
int __glXRenderLarge(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_Render(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
return DoRender(cl, pc, False);
|
||||
}
|
||||
|
||||
int DoRenderLarge(__GLXclientState *cl, GLbyte *pc, int do_swap)
|
||||
{
|
||||
xGLXRenderLargeReq *req;
|
||||
ClientPtr client= cl->client;
|
||||
GLuint dataBytes;
|
||||
void (*proc)(GLbyte *);
|
||||
size_t dataBytes;
|
||||
__GLXrenderLargeHeader *hdr;
|
||||
__GLXcontext *glxc;
|
||||
int error;
|
||||
CARD16 opcode;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
||||
/*
|
||||
** NOTE: much of this code also appears in the byteswapping version of this
|
||||
** routine, __glXSwapRenderLarge(). Any changes made here should also be
|
||||
** duplicated there.
|
||||
*/
|
||||
|
||||
req = (xGLXRenderLargeReq *) pc;
|
||||
if (do_swap) {
|
||||
__GLX_SWAP_SHORT(&req->length);
|
||||
__GLX_SWAP_INT(&req->contextTag);
|
||||
__GLX_SWAP_INT(&req->dataBytes);
|
||||
__GLX_SWAP_SHORT(&req->requestNumber);
|
||||
__GLX_SWAP_SHORT(&req->requestTotal);
|
||||
}
|
||||
|
||||
glxc = __glXForceCurrent(cl, req->contextTag, &error);
|
||||
if (!glxc) {
|
||||
/* Reset in case this isn't 1st request. */
|
||||
|
@ -1870,8 +1856,11 @@ int __glXRenderLarge(__GLXclientState *cl, GLbyte *pc)
|
|||
pc += sz_xGLXRenderLargeReq;
|
||||
|
||||
if (cl->largeCmdRequestsSoFar == 0) {
|
||||
__GLXrenderSizeData *entry;
|
||||
int extra, cmdlen;
|
||||
__GLXrenderSizeData entry;
|
||||
int extra;
|
||||
size_t cmdlen;
|
||||
int err;
|
||||
|
||||
/*
|
||||
** This is the first request of a multi request command.
|
||||
** Make enough space in the buffer, then copy the entire request.
|
||||
|
@ -1882,48 +1871,39 @@ int __glXRenderLarge(__GLXclientState *cl, GLbyte *pc)
|
|||
}
|
||||
|
||||
hdr = (__GLXrenderLargeHeader *) pc;
|
||||
if (do_swap) {
|
||||
__GLX_SWAP_INT(&hdr->length);
|
||||
__GLX_SWAP_INT(&hdr->opcode);
|
||||
}
|
||||
cmdlen = hdr->length;
|
||||
opcode = hdr->opcode;
|
||||
|
||||
/*
|
||||
** Check for core opcodes and grab entry data.
|
||||
*/
|
||||
if ( (opcode >= __GLX_MIN_RENDER_OPCODE) &&
|
||||
(opcode <= __GLX_MAX_RENDER_OPCODE) ) {
|
||||
entry = &__glXRenderSizeTable[opcode];
|
||||
#if __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT
|
||||
} else if ( (opcode >= __GLX_MIN_RENDER_OPCODE_EXT) &&
|
||||
(opcode <= __GLX_MAX_RENDER_OPCODE_EXT) ) {
|
||||
opcode -= __GLX_MIN_RENDER_OPCODE_EXT;
|
||||
entry = &__glXRenderSizeTable_EXT[opcode];
|
||||
#endif /* __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT */
|
||||
} else {
|
||||
err = __glXGetProtocolSizeData(& Render_dispatch_info, opcode, & entry);
|
||||
if (err < 0) {
|
||||
client->errorValue = opcode;
|
||||
return __glXError(GLXBadLargeRequest);
|
||||
}
|
||||
|
||||
if (!entry->bytes) {
|
||||
/* unused opcode */
|
||||
client->errorValue = opcode;
|
||||
return __glXError(GLXBadLargeRequest);
|
||||
}
|
||||
if (entry->varsize) {
|
||||
if (entry.varsize) {
|
||||
/*
|
||||
** If it's a variable-size command (a command whose length must
|
||||
** be computed from its parameters), all the parameters needed
|
||||
** will be in the 1st request, so it's okay to do this.
|
||||
*/
|
||||
extra = (*entry->varsize)(pc + __GLX_RENDER_LARGE_HDR_SIZE, False);
|
||||
extra = (*entry.varsize)(pc + __GLX_RENDER_LARGE_HDR_SIZE, do_swap);
|
||||
if (extra < 0) {
|
||||
extra = 0;
|
||||
}
|
||||
/* large command's header is 4 bytes longer, so add 4 */
|
||||
if (cmdlen != __GLX_PAD(entry->bytes + 4 + extra)) {
|
||||
if (cmdlen != __GLX_PAD(entry.bytes + 4 + extra)) {
|
||||
return BadLength;
|
||||
}
|
||||
} else {
|
||||
/* constant size command */
|
||||
if (cmdlen != __GLX_PAD(entry->bytes + 4)) {
|
||||
if (cmdlen != __GLX_PAD(entry.bytes + 4)) {
|
||||
return BadLength;
|
||||
}
|
||||
}
|
||||
|
@ -1932,10 +1912,9 @@ int __glXRenderLarge(__GLXclientState *cl, GLbyte *pc)
|
|||
*/
|
||||
if (cl->largeCmdBufSize < cmdlen) {
|
||||
if (!cl->largeCmdBuf) {
|
||||
cl->largeCmdBuf = (GLbyte *) xalloc((size_t)cmdlen);
|
||||
cl->largeCmdBuf = (GLbyte *) xalloc(cmdlen);
|
||||
} else {
|
||||
cl->largeCmdBuf = (GLbyte *) xrealloc(cl->largeCmdBuf,
|
||||
(size_t)cmdlen);
|
||||
cl->largeCmdBuf = (GLbyte *) xrealloc(cl->largeCmdBuf, cmdlen);
|
||||
}
|
||||
if (!cl->largeCmdBuf) {
|
||||
return BadAlloc;
|
||||
|
@ -1983,6 +1962,8 @@ int __glXRenderLarge(__GLXclientState *cl, GLbyte *pc)
|
|||
cl->largeCmdRequestsSoFar++;
|
||||
|
||||
if (req->requestNumber == cl->largeCmdRequestsTotal) {
|
||||
__GLXdispatchRenderProcPtr proc;
|
||||
|
||||
/*
|
||||
** This is the last request; it must have enough bytes to complete
|
||||
** the command.
|
||||
|
@ -2003,21 +1984,17 @@ int __glXRenderLarge(__GLXclientState *cl, GLbyte *pc)
|
|||
return __glXError(GLXBadLargeRequest);
|
||||
}
|
||||
hdr = (__GLXrenderLargeHeader *) cl->largeCmdBuf;
|
||||
opcode = hdr->opcode;
|
||||
|
||||
/*
|
||||
** The opcode and length field in the header had already been
|
||||
** swapped when the first request was received.
|
||||
**
|
||||
** Use the opcode to index into the procedure table.
|
||||
*/
|
||||
if ( (opcode >= __GLX_MIN_RENDER_OPCODE) &&
|
||||
(opcode <= __GLX_MAX_RENDER_OPCODE) ) {
|
||||
proc = __glXRenderTable[opcode];
|
||||
#if __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT
|
||||
} else if ( (opcode >= __GLX_MIN_RENDER_OPCODE_EXT) &&
|
||||
(opcode <= __GLX_MAX_RENDER_OPCODE_EXT) ) {
|
||||
opcode -= __GLX_MIN_RENDER_OPCODE_EXT;
|
||||
proc = __glXRenderTable_EXT[opcode];
|
||||
#endif /* __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT */
|
||||
} else {
|
||||
opcode = hdr->opcode;
|
||||
|
||||
proc = (__GLXdispatchRenderProcPtr)
|
||||
__glXGetProtocolDecodeFunction(& Render_dispatch_info, opcode, do_swap);
|
||||
if (proc == NULL) {
|
||||
client->errorValue = opcode;
|
||||
return __glXError(GLXBadLargeRequest);
|
||||
}
|
||||
|
@ -2041,9 +2018,17 @@ int __glXRenderLarge(__GLXclientState *cl, GLbyte *pc)
|
|||
}
|
||||
}
|
||||
|
||||
/*
|
||||
** Execute a large rendering request (one that spans multiple X requests).
|
||||
*/
|
||||
int __glXDisp_RenderLarge(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
return DoRenderLarge(cl, pc, False);
|
||||
}
|
||||
|
||||
extern RESTYPE __glXSwapBarrierRes;
|
||||
|
||||
static int __glXBindSwapBarrierSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_BindSwapBarrierSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
ClientPtr client = cl->client;
|
||||
xGLXBindSwapBarrierSGIXReq *req = (xGLXBindSwapBarrierSGIXReq *) pc;
|
||||
|
@ -2073,7 +2058,7 @@ static int __glXBindSwapBarrierSGIX(__GLXclientState *cl, GLbyte *pc)
|
|||
}
|
||||
|
||||
|
||||
static int __glXQueryMaxSwapBarriersSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_QueryMaxSwapBarriersSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
ClientPtr client = cl->client;
|
||||
xGLXQueryMaxSwapBarriersSGIXReq *req =
|
||||
|
@ -2104,7 +2089,7 @@ static int __glXQueryMaxSwapBarriersSGIX(__GLXclientState *cl, GLbyte *pc)
|
|||
|
||||
#define GLX_BAD_HYPERPIPE_SGIX 92
|
||||
|
||||
static int __glxQueryHyperpipeNetworkSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_QueryHyperpipeNetworkSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
ClientPtr client = cl->client;
|
||||
xGLXQueryHyperpipeNetworkSGIXReq * req = (xGLXQueryHyperpipeNetworkSGIXReq *) pc;
|
||||
|
@ -2144,7 +2129,7 @@ static int __glxQueryHyperpipeNetworkSGIX(__GLXclientState *cl, GLbyte *pc)
|
|||
return Success;
|
||||
}
|
||||
|
||||
static int __glxDestroyHyperpipeConfigSGIX (__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_DestroyHyperpipeConfigSGIX (__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
ClientPtr client = cl->client;
|
||||
xGLXDestroyHyperpipeConfigSGIXReq * req =
|
||||
|
@ -2179,7 +2164,7 @@ static int __glxDestroyHyperpipeConfigSGIX (__GLXclientState *cl, GLbyte *pc)
|
|||
return Success;
|
||||
}
|
||||
|
||||
static int __glxQueryHyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_QueryHyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
ClientPtr client = cl->client;
|
||||
xGLXQueryHyperpipeConfigSGIXReq * req =
|
||||
|
@ -2223,7 +2208,7 @@ static int __glxQueryHyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc)
|
|||
return Success;
|
||||
}
|
||||
|
||||
static int __glxHyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_HyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
ClientPtr client = cl->client;
|
||||
xGLXHyperpipeConfigSGIXReq * req =
|
||||
|
@ -2274,40 +2259,21 @@ static int __glxHyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc)
|
|||
** allocating the entry points in the dispatch table.
|
||||
*/
|
||||
|
||||
int __glXVendorPrivate(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_VendorPrivate(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXVendorPrivateReq *req;
|
||||
GLint vendorcode;
|
||||
xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
|
||||
GLint vendorcode = req->vendorCode;
|
||||
__GLXdispatchVendorPrivProcPtr proc;
|
||||
|
||||
req = (xGLXVendorPrivateReq *) pc;
|
||||
vendorcode = req->vendorCode;
|
||||
|
||||
#ifndef __DARWIN__
|
||||
switch( vendorcode ) {
|
||||
case X_GLvop_SampleMaskSGIS:
|
||||
CALL_SampleMaskSGIS( GET_DISPATCH(),
|
||||
(*(GLfloat *)(pc + 4), *(GLboolean *)(pc + 8)) );
|
||||
return Success;
|
||||
case X_GLvop_SamplePatternSGIS:
|
||||
CALL_SamplePatternSGIS( GET_DISPATCH(), (*(GLenum *)(pc + 4)) );
|
||||
return Success;
|
||||
case X_GLXvop_BindSwapBarrierSGIX:
|
||||
return __glXBindSwapBarrierSGIX(cl, pc);
|
||||
case X_GLXvop_BindTexImageEXT:
|
||||
return __glXBindTexImageEXT(cl, pc);
|
||||
case X_GLXvop_ReleaseTexImageEXT:
|
||||
return __glXReleaseTexImageEXT(cl, pc);
|
||||
case X_GLXvop_CopySubBufferMESA:
|
||||
return __glXCopySubBufferMESA(cl, pc);
|
||||
}
|
||||
#endif
|
||||
|
||||
if ((vendorcode >= __GLX_MIN_VENDPRIV_OPCODE_EXT) &&
|
||||
(vendorcode <= __GLX_MAX_VENDPRIV_OPCODE_EXT)) {
|
||||
(*__glXVendorPrivTable_EXT[vendorcode-__GLX_MIN_VENDPRIV_OPCODE_EXT])
|
||||
(cl, (GLbyte*)req);
|
||||
proc = (__GLXdispatchVendorPrivProcPtr)
|
||||
__glXGetProtocolDecodeFunction(& VendorPriv_dispatch_info,
|
||||
vendorcode, 0);
|
||||
if (proc != NULL) {
|
||||
(*proc)(cl, (GLbyte*)req);
|
||||
return Success;
|
||||
}
|
||||
|
||||
/*
|
||||
** This sample implemention does not support any private requests.
|
||||
*/
|
||||
|
@ -2315,67 +2281,25 @@ int __glXVendorPrivate(__GLXclientState *cl, GLbyte *pc)
|
|||
return __glXError(GLXUnsupportedPrivateRequest);
|
||||
}
|
||||
|
||||
int __glXVendorPrivateWithReply(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_VendorPrivateWithReply(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXVendorPrivateWithReplyReq *req;
|
||||
GLint vendorcode;
|
||||
xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
|
||||
GLint vendorcode = req->vendorCode;
|
||||
__GLXdispatchVendorPrivProcPtr proc;
|
||||
|
||||
req = (xGLXVendorPrivateWithReplyReq *) pc;
|
||||
vendorcode = req->vendorCode;
|
||||
|
||||
switch (vendorcode) {
|
||||
case X_GLXvop_QueryContextInfoEXT:
|
||||
return __glXQueryContextInfoEXT(cl, pc);
|
||||
case X_GLXvop_MakeCurrentReadSGI:
|
||||
return __glXMakeCurrentReadSGI(cl, pc);
|
||||
case X_GLXvop_QueryMaxSwapBarriersSGIX:
|
||||
return __glXQueryMaxSwapBarriersSGIX(cl, pc);
|
||||
case X_GLXvop_QueryHyperpipeNetworkSGIX:
|
||||
return __glxQueryHyperpipeNetworkSGIX(cl, pc);
|
||||
case X_GLXvop_QueryHyperpipeConfigSGIX:
|
||||
return __glxQueryHyperpipeConfigSGIX(cl, pc);
|
||||
case X_GLXvop_DestroyHyperpipeConfigSGIX:
|
||||
return __glxDestroyHyperpipeConfigSGIX(cl, pc);
|
||||
case X_GLXvop_HyperpipeConfigSGIX:
|
||||
return __glxHyperpipeConfigSGIX(cl, pc);
|
||||
case X_GLXvop_GetFBConfigsSGIX:
|
||||
return __glXGetFBConfigsSGIX(cl, pc);
|
||||
case X_GLXvop_CreateContextWithConfigSGIX:
|
||||
return __glXCreateContextWithConfigSGIX(cl, pc);
|
||||
case X_GLXvop_CreateGLXPixmapWithConfigSGIX:
|
||||
return __glXCreateGLXPixmapWithConfigSGIX(cl, pc);
|
||||
case X_GLXvop_GetDrawableAttributesSGIX:
|
||||
return __glXGetDrawableAttributesSGIX(cl, pc);
|
||||
case X_GLvop_IsRenderbufferEXT:
|
||||
return __glXDisp_IsRenderbufferEXT(cl, pc);
|
||||
case X_GLvop_GenRenderbuffersEXT:
|
||||
return __glXDisp_GenRenderbuffersEXT(cl, pc);
|
||||
case X_GLvop_GetRenderbufferParameterivEXT:
|
||||
return __glXDisp_GetRenderbufferParameterivEXT(cl, pc);
|
||||
case X_GLvop_IsFramebufferEXT:
|
||||
return __glXDisp_IsFramebufferEXT(cl, pc);
|
||||
case X_GLvop_GenFramebuffersEXT:
|
||||
return __glXDisp_GenFramebuffersEXT(cl, pc);
|
||||
case X_GLvop_CheckFramebufferStatusEXT:
|
||||
return __glXDisp_CheckFramebufferStatusEXT(cl, pc);
|
||||
case X_GLvop_GetFramebufferAttachmentParameterivEXT:
|
||||
return __glXDisp_GetFramebufferAttachmentParameterivEXT(cl, pc);
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
if ((vendorcode >= __GLX_MIN_VENDPRIV_OPCODE_EXT) &&
|
||||
(vendorcode <= __GLX_MAX_VENDPRIV_OPCODE_EXT)) {
|
||||
return
|
||||
(*__glXVendorPrivTable_EXT[vendorcode-__GLX_MIN_VENDPRIV_OPCODE_EXT])
|
||||
(cl, (GLbyte*)req);
|
||||
proc = (__GLXdispatchVendorPrivProcPtr)
|
||||
__glXGetProtocolDecodeFunction(& VendorPriv_dispatch_info,
|
||||
vendorcode, 0);
|
||||
if (proc != NULL) {
|
||||
return (*proc)(cl, (GLbyte*)req);
|
||||
}
|
||||
|
||||
cl->client->errorValue = vendorcode;
|
||||
return __glXError(GLXUnsupportedPrivateRequest);
|
||||
}
|
||||
|
||||
int __glXQueryExtensionsString(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_QueryExtensionsString(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
ClientPtr client = cl->client;
|
||||
xGLXQueryExtensionsStringReq *req = (xGLXQueryExtensionsStringReq *) pc;
|
||||
|
@ -2420,7 +2344,7 @@ int __glXQueryExtensionsString(__GLXclientState *cl, GLbyte *pc)
|
|||
return Success;
|
||||
}
|
||||
|
||||
int __glXQueryServerString(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_QueryServerString(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
ClientPtr client = cl->client;
|
||||
xGLXQueryServerStringReq *req = (xGLXQueryServerStringReq *) pc;
|
||||
|
@ -2478,7 +2402,7 @@ int __glXQueryServerString(__GLXclientState *cl, GLbyte *pc)
|
|||
return Success;
|
||||
}
|
||||
|
||||
int __glXClientInfo(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_ClientInfo(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXClientInfoReq *req = (xGLXClientInfoReq *) pc;
|
||||
const char *buf;
|
||||
|
@ -2492,4 +2416,3 @@ int __glXClientInfo(__GLXclientState *cl, GLbyte *pc)
|
|||
|
||||
return Success;
|
||||
}
|
||||
|
||||
|
|
|
@ -44,8 +44,7 @@
|
|||
#include "glxutil.h"
|
||||
#include <GL/glxtokens.h>
|
||||
#include <unpack.h>
|
||||
#include <g_disptab.h>
|
||||
#include <g_disptab_EXT.h>
|
||||
#include "g_disptab.h"
|
||||
#include <pixmapstr.h>
|
||||
#include <windowstr.h>
|
||||
#include "glxext.h"
|
||||
|
@ -54,11 +53,9 @@
|
|||
#include "glthread.h"
|
||||
#include "dispatch.h"
|
||||
#include "indirect_dispatch.h"
|
||||
#include "indirect_table.h"
|
||||
#include "indirect_util.h"
|
||||
|
||||
static int __glXSwapGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
static int __glXSwapCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
static int __glXSwapCreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
static int __glXSwapMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc);
|
||||
|
||||
/************************************************************************/
|
||||
|
||||
|
@ -69,7 +66,7 @@ static int __glXSwapMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc);
|
|||
** it is called at the end of the unswapped routine.
|
||||
*/
|
||||
|
||||
int __glXSwapCreateContext(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_CreateContext(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXCreateContextReq *req = (xGLXCreateContextReq *) pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
@ -84,7 +81,7 @@ int __glXSwapCreateContext(__GLXclientState *cl, GLbyte *pc)
|
|||
req->screen, req->isDirect );
|
||||
}
|
||||
|
||||
int __glXSwapCreateNewContext(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_CreateNewContext(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXCreateNewContextReq *req = (xGLXCreateNewContextReq *) pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
@ -100,7 +97,7 @@ int __glXSwapCreateNewContext(__GLXclientState *cl, GLbyte *pc)
|
|||
req->screen, req->isDirect );
|
||||
}
|
||||
|
||||
int __glXSwapCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_CreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXCreateContextWithConfigSGIXReq *req =
|
||||
(xGLXCreateContextWithConfigSGIXReq *) pc;
|
||||
|
@ -117,7 +114,7 @@ int __glXSwapCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
|
|||
req->screen, req->isDirect );
|
||||
}
|
||||
|
||||
int __glXSwapDestroyContext(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_DestroyContext(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXDestroyContextReq *req = (xGLXDestroyContextReq *) pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
@ -125,10 +122,10 @@ int __glXSwapDestroyContext(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_SHORT(&req->length);
|
||||
__GLX_SWAP_INT(&req->context);
|
||||
|
||||
return __glXDestroyContext(cl, pc);
|
||||
return __glXDisp_DestroyContext(cl, pc);
|
||||
}
|
||||
|
||||
int __glXSwapMakeCurrent(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_MakeCurrent(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXMakeCurrentReq *req = (xGLXMakeCurrentReq *) pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
@ -142,7 +139,7 @@ int __glXSwapMakeCurrent(__GLXclientState *cl, GLbyte *pc)
|
|||
req->context, req->oldContextTag );
|
||||
}
|
||||
|
||||
int __glXSwapMakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_MakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXMakeContextCurrentReq *req = (xGLXMakeContextCurrentReq *) pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
@ -157,7 +154,7 @@ int __glXSwapMakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
|
|||
req->context, req->oldContextTag );
|
||||
}
|
||||
|
||||
int __glXSwapMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_MakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXMakeCurrentReadSGIReq *req = (xGLXMakeCurrentReadSGIReq *) pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
@ -172,7 +169,7 @@ int __glXSwapMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
|
|||
req->context, req->oldContextTag );
|
||||
}
|
||||
|
||||
int __glXSwapIsDirect(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_IsDirect(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXIsDirectReq *req = (xGLXIsDirectReq *) pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
@ -180,10 +177,10 @@ int __glXSwapIsDirect(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_SHORT(&req->length);
|
||||
__GLX_SWAP_INT(&req->context);
|
||||
|
||||
return __glXIsDirect(cl, pc);
|
||||
return __glXDisp_IsDirect(cl, pc);
|
||||
}
|
||||
|
||||
int __glXSwapQueryVersion(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_QueryVersion(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXQueryVersionReq *req = (xGLXQueryVersionReq *) pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
@ -192,10 +189,10 @@ int __glXSwapQueryVersion(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_INT(&req->majorVersion);
|
||||
__GLX_SWAP_INT(&req->minorVersion);
|
||||
|
||||
return __glXQueryVersion(cl, pc);
|
||||
return __glXDisp_QueryVersion(cl, pc);
|
||||
}
|
||||
|
||||
int __glXSwapWaitGL(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_WaitGL(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXWaitGLReq *req = (xGLXWaitGLReq *) pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
@ -203,10 +200,10 @@ int __glXSwapWaitGL(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_SHORT(&req->length);
|
||||
__GLX_SWAP_INT(&req->contextTag);
|
||||
|
||||
return __glXWaitGL(cl, pc);
|
||||
return __glXDisp_WaitGL(cl, pc);
|
||||
}
|
||||
|
||||
int __glXSwapWaitX(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_WaitX(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXWaitXReq *req = (xGLXWaitXReq *) pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
@ -214,10 +211,10 @@ int __glXSwapWaitX(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_SHORT(&req->length);
|
||||
__GLX_SWAP_INT(&req->contextTag);
|
||||
|
||||
return __glXWaitX(cl, pc);
|
||||
return __glXDisp_WaitX(cl, pc);
|
||||
}
|
||||
|
||||
int __glXSwapCopyContext(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_CopyContext(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXCopyContextReq *req = (xGLXCopyContextReq *) pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
@ -227,10 +224,10 @@ int __glXSwapCopyContext(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_INT(&req->dest);
|
||||
__GLX_SWAP_INT(&req->mask);
|
||||
|
||||
return __glXCopyContext(cl, pc);
|
||||
return __glXDisp_CopyContext(cl, pc);
|
||||
}
|
||||
|
||||
int __glXSwapGetVisualConfigs(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_GetVisualConfigs(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXGetVisualConfigsReq *req = (xGLXGetVisualConfigsReq *) pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
@ -239,7 +236,7 @@ int __glXSwapGetVisualConfigs(__GLXclientState *cl, GLbyte *pc)
|
|||
return DoGetVisualConfigs( cl, req->screen, GL_TRUE );
|
||||
}
|
||||
|
||||
int __glXSwapGetFBConfigs(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_GetFBConfigs(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXGetFBConfigsReq *req = (xGLXGetFBConfigsReq *) pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
@ -248,7 +245,7 @@ int __glXSwapGetFBConfigs(__GLXclientState *cl, GLbyte *pc)
|
|||
return DoGetFBConfigs( cl, req->screen, GL_TRUE );
|
||||
}
|
||||
|
||||
int __glXSwapGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_GetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXGetFBConfigsSGIXReq *req = (xGLXGetFBConfigsSGIXReq *) pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
@ -257,7 +254,7 @@ int __glXSwapGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc)
|
|||
return DoGetFBConfigs( cl, req->screen, GL_TRUE );
|
||||
}
|
||||
|
||||
int __glXSwapCreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_CreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXCreateGLXPixmapReq *req = (xGLXCreateGLXPixmapReq *) pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
@ -272,7 +269,7 @@ int __glXSwapCreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
|
|||
req->pixmap, req->glxpixmap );
|
||||
}
|
||||
|
||||
int __glXSwapCreatePixmap(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_CreatePixmap(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXCreatePixmapReq *req = (xGLXCreatePixmapReq *) pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
@ -287,7 +284,7 @@ int __glXSwapCreatePixmap(__GLXclientState *cl, GLbyte *pc)
|
|||
req->pixmap, req->glxpixmap );
|
||||
}
|
||||
|
||||
int __glXSwapCreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_CreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXCreateGLXPixmapWithConfigSGIXReq *req =
|
||||
(xGLXCreateGLXPixmapWithConfigSGIXReq *) pc;
|
||||
|
@ -303,7 +300,7 @@ int __glXSwapCreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
|
|||
req->pixmap, req->glxpixmap );
|
||||
}
|
||||
|
||||
int __glXSwapDestroyGLXPixmap(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_DestroyGLXPixmap(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXDestroyGLXPixmapReq *req = (xGLXDestroyGLXPixmapReq *) pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
@ -311,10 +308,10 @@ int __glXSwapDestroyGLXPixmap(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_SHORT(&req->length);
|
||||
__GLX_SWAP_INT(&req->glxpixmap);
|
||||
|
||||
return __glXDestroyGLXPixmap(cl, pc);
|
||||
return __glXDisp_DestroyGLXPixmap(cl, pc);
|
||||
}
|
||||
|
||||
int __glXSwapDestroyPixmap(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_DestroyPixmap(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXDestroyGLXPixmapReq *req = (xGLXDestroyGLXPixmapReq *) pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
@ -322,10 +319,10 @@ int __glXSwapDestroyPixmap(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_SHORT(&req->length);
|
||||
__GLX_SWAP_INT(&req->glxpixmap);
|
||||
|
||||
return __glXDestroyGLXPixmap(cl, pc);
|
||||
return __glXDisp_DestroyGLXPixmap(cl, pc);
|
||||
}
|
||||
|
||||
int __glXSwapQueryContext(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_QueryContext(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXQueryContextReq *req = (xGLXQueryContextReq *) pc;
|
||||
|
||||
|
@ -334,7 +331,7 @@ int __glXSwapQueryContext(__GLXclientState *cl, GLbyte *pc)
|
|||
return BadRequest;
|
||||
}
|
||||
|
||||
int __glXSwapCreatePbuffer(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_CreatePbuffer(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXCreatePbufferReq *req = (xGLXCreatePbufferReq *) pc;
|
||||
|
||||
|
@ -343,14 +340,14 @@ int __glXSwapCreatePbuffer(__GLXclientState *cl, GLbyte *pc)
|
|||
return BadRequest;
|
||||
}
|
||||
|
||||
int __glXSwapDestroyPbuffer(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_DestroyPbuffer(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXDestroyPbufferReq *req = (xGLXDestroyPbufferReq *) req;
|
||||
|
||||
return BadRequest;
|
||||
}
|
||||
|
||||
int __glXSwapChangeDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_ChangeDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXChangeDrawableAttributesReq *req =
|
||||
(xGLXChangeDrawableAttributesReq *) req;
|
||||
|
@ -358,7 +355,7 @@ int __glXSwapChangeDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
|
|||
return BadRequest;
|
||||
}
|
||||
|
||||
int __glXSwapCreateWindow(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_CreateWindow(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXCreateWindowReq *req = (xGLXCreateWindowReq *) pc;
|
||||
|
||||
|
@ -367,7 +364,7 @@ int __glXSwapCreateWindow(__GLXclientState *cl, GLbyte *pc)
|
|||
return BadRequest;
|
||||
}
|
||||
|
||||
int __glXSwapDestroyWindow(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_DestroyWindow(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXDestroyWindowReq *req = (xGLXDestroyWindowReq *) pc;
|
||||
|
||||
|
@ -376,7 +373,7 @@ int __glXSwapDestroyWindow(__GLXclientState *cl, GLbyte *pc)
|
|||
return BadRequest;
|
||||
}
|
||||
|
||||
int __glXSwapSwapBuffers(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_SwapBuffers(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXSwapBuffersReq *req = (xGLXSwapBuffersReq *) pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
@ -385,10 +382,10 @@ int __glXSwapSwapBuffers(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_INT(&req->contextTag);
|
||||
__GLX_SWAP_INT(&req->drawable);
|
||||
|
||||
return __glXSwapBuffers(cl, pc);
|
||||
return __glXDisp_SwapBuffers(cl, pc);
|
||||
}
|
||||
|
||||
int __glXSwapUseXFont(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_UseXFont(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXUseXFontReq *req = (xGLXUseXFontReq *) pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
@ -400,11 +397,11 @@ int __glXSwapUseXFont(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_INT(&req->count);
|
||||
__GLX_SWAP_INT(&req->listBase);
|
||||
|
||||
return __glXUseXFont(cl, pc);
|
||||
return __glXDisp_UseXFont(cl, pc);
|
||||
}
|
||||
|
||||
|
||||
int __glXSwapQueryExtensionsString(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_QueryExtensionsString(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXQueryExtensionsStringReq *req = (xGLXQueryExtensionsStringReq *)pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
@ -412,10 +409,10 @@ int __glXSwapQueryExtensionsString(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_SHORT(&req->length);
|
||||
__GLX_SWAP_INT(&req->screen);
|
||||
|
||||
return __glXQueryExtensionsString(cl, pc);
|
||||
return __glXDisp_QueryExtensionsString(cl, pc);
|
||||
}
|
||||
|
||||
int __glXSwapQueryServerString(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_QueryServerString(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXQueryServerStringReq *req = (xGLXQueryServerStringReq *)pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
@ -424,10 +421,10 @@ int __glXSwapQueryServerString(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_INT(&req->screen);
|
||||
__GLX_SWAP_INT(&req->name);
|
||||
|
||||
return __glXQueryServerString(cl, pc);
|
||||
return __glXDisp_QueryServerString(cl, pc);
|
||||
}
|
||||
|
||||
int __glXSwapClientInfo(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_ClientInfo(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXClientInfoReq *req = (xGLXClientInfoReq *)pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
@ -437,10 +434,10 @@ int __glXSwapClientInfo(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_INT(&req->minor);
|
||||
__GLX_SWAP_INT(&req->numbytes);
|
||||
|
||||
return __glXClientInfo(cl, pc);
|
||||
return __glXDisp_ClientInfo(cl, pc);
|
||||
}
|
||||
|
||||
int __glXSwapQueryContextInfoEXT(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_QueryContextInfoEXT(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXQueryContextInfoEXTReq *req = (xGLXQueryContextInfoEXTReq *) pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
@ -448,10 +445,10 @@ int __glXSwapQueryContextInfoEXT(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_SHORT(&req->length);
|
||||
__GLX_SWAP_INT(&req->context);
|
||||
|
||||
return __glXQueryContextInfoEXT(cl, pc);
|
||||
return __glXDisp_QueryContextInfoEXT(cl, pc);
|
||||
}
|
||||
|
||||
int __glXSwapBindTexImageEXT(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_BindTexImageEXT(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
|
||||
GLXDrawable *drawId;
|
||||
|
@ -469,10 +466,10 @@ int __glXSwapBindTexImageEXT(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_INT(drawId);
|
||||
__GLX_SWAP_INT(buffer);
|
||||
|
||||
return __glXBindTexImageEXT(cl, (GLbyte *)pc);
|
||||
return __glXDisp_BindTexImageEXT(cl, (GLbyte *)pc);
|
||||
}
|
||||
|
||||
int __glXSwapReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_ReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
|
||||
GLXDrawable *drawId;
|
||||
|
@ -490,10 +487,10 @@ int __glXSwapReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_INT(drawId);
|
||||
__GLX_SWAP_INT(buffer);
|
||||
|
||||
return __glXReleaseTexImageEXT(cl, (GLbyte *)pc);
|
||||
return __glXDisp_ReleaseTexImageEXT(cl, (GLbyte *)pc);
|
||||
}
|
||||
|
||||
int __glXSwapCopySubBufferMESA(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_CopySubBufferMESA(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
|
||||
GLXDrawable *drawId;
|
||||
|
@ -514,11 +511,11 @@ int __glXSwapCopySubBufferMESA(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_INT(pc + 12);
|
||||
__GLX_SWAP_INT(pc + 16);
|
||||
|
||||
return __glXCopySubBufferMESA(cl, pc);
|
||||
return __glXDisp_CopySubBufferMESA(cl, pc);
|
||||
|
||||
}
|
||||
|
||||
int __glXSwapGetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_GetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXVendorPrivateWithReplyReq *req = (xGLXVendorPrivateWithReplyReq *)pc;
|
||||
CARD32 *data;
|
||||
|
@ -530,10 +527,10 @@ int __glXSwapGetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_INT(&req->contextTag);
|
||||
__GLX_SWAP_INT(data);
|
||||
|
||||
return __glXGetDrawableAttributesSGIX(cl, pc);
|
||||
return __glXDisp_GetDrawableAttributesSGIX(cl, pc);
|
||||
}
|
||||
|
||||
int __glXSwapGetDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_GetDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXGetDrawableAttributesReq *req = (xGLXGetDrawableAttributesReq *)pc;
|
||||
|
||||
|
@ -542,7 +539,7 @@ int __glXSwapGetDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_SHORT(&req->length);
|
||||
__GLX_SWAP_INT(&req->drawable);
|
||||
|
||||
return __glXGetDrawableAttributes(cl, pc);
|
||||
return __glXDisp_GetDrawableAttributes(cl, pc);
|
||||
}
|
||||
|
||||
|
||||
|
@ -641,325 +638,17 @@ void __glXSwapGetDrawableAttributesReply(ClientPtr client,
|
|||
** client library to send batches of GL rendering commands.
|
||||
*/
|
||||
|
||||
int __glXSwapRender(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_Render(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXRenderReq *req;
|
||||
ClientPtr client= cl->client;
|
||||
int left, cmdlen, error;
|
||||
int commandsDone;
|
||||
CARD16 opcode;
|
||||
__GLXrenderHeader *hdr;
|
||||
__GLXcontext *cx;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
||||
/*
|
||||
** NOTE: much of this code also appears in the nonswapping version of this
|
||||
** routine, __glXRender(). Any changes made here should also be
|
||||
** duplicated there.
|
||||
*/
|
||||
|
||||
req = (xGLXRenderReq *) pc;
|
||||
__GLX_SWAP_SHORT(&req->length);
|
||||
__GLX_SWAP_INT(&req->contextTag);
|
||||
|
||||
cx = __glXForceCurrent(cl, req->contextTag, &error);
|
||||
if (!cx) {
|
||||
return error;
|
||||
}
|
||||
|
||||
commandsDone = 0;
|
||||
pc += sz_xGLXRenderReq;
|
||||
left = (req->length << 2) - sz_xGLXRenderReq;
|
||||
while (left > 0) {
|
||||
__GLXrenderSizeData *entry;
|
||||
int extra;
|
||||
void (* proc)(GLbyte *);
|
||||
|
||||
/*
|
||||
** Verify that the header length and the overall length agree.
|
||||
** Also, each command must be word aligned.
|
||||
*/
|
||||
hdr = (__GLXrenderHeader *) pc;
|
||||
__GLX_SWAP_SHORT(&hdr->length);
|
||||
__GLX_SWAP_SHORT(&hdr->opcode);
|
||||
cmdlen = hdr->length;
|
||||
opcode = hdr->opcode;
|
||||
|
||||
if ( (opcode >= __GLX_MIN_RENDER_OPCODE) &&
|
||||
(opcode <= __GLX_MAX_RENDER_OPCODE) ) {
|
||||
entry = &__glXRenderSizeTable[opcode];
|
||||
proc = __glXSwapRenderTable[opcode];
|
||||
#if __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT
|
||||
} else if ( (opcode >= __GLX_MIN_RENDER_OPCODE_EXT) &&
|
||||
(opcode <= __GLX_MAX_RENDER_OPCODE_EXT) ) {
|
||||
int index = opcode - __GLX_MIN_RENDER_OPCODE_EXT;
|
||||
entry = &__glXRenderSizeTable_EXT[index];
|
||||
proc = __glXSwapRenderTable_EXT[index];
|
||||
#endif /* __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT */
|
||||
} else {
|
||||
client->errorValue = commandsDone;
|
||||
return __glXError(GLXBadRenderRequest);
|
||||
}
|
||||
if (!entry->bytes) {
|
||||
/* unused opcode */
|
||||
client->errorValue = commandsDone;
|
||||
return __glXError(GLXBadRenderRequest);
|
||||
}
|
||||
if (entry->varsize) {
|
||||
/* variable size command */
|
||||
extra = (*entry->varsize)(pc + __GLX_RENDER_HDR_SIZE, True);
|
||||
if (extra < 0) {
|
||||
extra = 0;
|
||||
}
|
||||
if (cmdlen != __GLX_PAD(entry->bytes + extra)) {
|
||||
return BadLength;
|
||||
}
|
||||
} else {
|
||||
/* constant size command */
|
||||
if (cmdlen != __GLX_PAD(entry->bytes)) {
|
||||
return BadLength;
|
||||
}
|
||||
}
|
||||
if (left < cmdlen) {
|
||||
return BadLength;
|
||||
}
|
||||
|
||||
/*
|
||||
** Skip over the header and execute the command. We allow the
|
||||
** caller to trash the command memory. This is useful especially
|
||||
** for things that require double alignment - they can just shift
|
||||
** the data towards lower memory (trashing the header) by 4 bytes
|
||||
** and achieve the required alignment.
|
||||
*/
|
||||
(*proc)(pc + __GLX_RENDER_HDR_SIZE);
|
||||
pc += cmdlen;
|
||||
left -= cmdlen;
|
||||
commandsDone++;
|
||||
}
|
||||
__GLX_NOTE_UNFLUSHED_CMDS(cx);
|
||||
return Success;
|
||||
return DoRender(cl, pc, True);
|
||||
}
|
||||
|
||||
/*
|
||||
** Execute a large rendering request (one that spans multiple X requests).
|
||||
*/
|
||||
int __glXSwapRenderLarge(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_RenderLarge(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXRenderLargeReq *req;
|
||||
ClientPtr client= cl->client;
|
||||
size_t dataBytes;
|
||||
void (*proc)(GLbyte *);
|
||||
__GLXrenderLargeHeader *hdr;
|
||||
__GLXcontext *cx;
|
||||
int error;
|
||||
CARD16 opcode;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
||||
/*
|
||||
** NOTE: much of this code also appears in the nonswapping version of this
|
||||
** routine, __glXRenderLarge(). Any changes made here should also be
|
||||
** duplicated there.
|
||||
*/
|
||||
|
||||
req = (xGLXRenderLargeReq *) pc;
|
||||
__GLX_SWAP_SHORT(&req->length);
|
||||
__GLX_SWAP_INT(&req->contextTag);
|
||||
__GLX_SWAP_INT(&req->dataBytes);
|
||||
__GLX_SWAP_SHORT(&req->requestNumber);
|
||||
__GLX_SWAP_SHORT(&req->requestTotal);
|
||||
cx = __glXForceCurrent(cl, req->contextTag, &error);
|
||||
if (!cx) {
|
||||
/* Reset in case this isn't 1st request. */
|
||||
__glXResetLargeCommandStatus(cl);
|
||||
return error;
|
||||
}
|
||||
dataBytes = req->dataBytes;
|
||||
|
||||
/*
|
||||
** Check the request length.
|
||||
*/
|
||||
if ((req->length << 2) != __GLX_PAD(dataBytes) + sz_xGLXRenderLargeReq) {
|
||||
client->errorValue = req->length;
|
||||
/* Reset in case this isn't 1st request. */
|
||||
__glXResetLargeCommandStatus(cl);
|
||||
return BadLength;
|
||||
}
|
||||
pc += sz_xGLXRenderLargeReq;
|
||||
|
||||
if (cl->largeCmdRequestsSoFar == 0) {
|
||||
__GLXrenderSizeData *entry;
|
||||
int extra;
|
||||
size_t cmdlen;
|
||||
/*
|
||||
** This is the first request of a multi request command.
|
||||
** Make enough space in the buffer, then copy the entire request.
|
||||
*/
|
||||
if (req->requestNumber != 1) {
|
||||
client->errorValue = req->requestNumber;
|
||||
return __glXError(GLXBadLargeRequest);
|
||||
}
|
||||
hdr = (__GLXrenderLargeHeader *) pc;
|
||||
__GLX_SWAP_INT(&hdr->length);
|
||||
__GLX_SWAP_INT(&hdr->opcode);
|
||||
cmdlen = hdr->length;
|
||||
opcode = hdr->opcode;
|
||||
|
||||
if ( (opcode >= __GLX_MIN_RENDER_OPCODE) &&
|
||||
(opcode <= __GLX_MAX_RENDER_OPCODE) ) {
|
||||
entry = &__glXRenderSizeTable[opcode];
|
||||
proc = __glXSwapRenderTable[opcode];
|
||||
#if __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT
|
||||
} else if ( (opcode >= __GLX_MIN_RENDER_OPCODE_EXT) &&
|
||||
(opcode <= __GLX_MAX_RENDER_OPCODE_EXT) ) {
|
||||
int index = opcode - __GLX_MIN_RENDER_OPCODE_EXT;
|
||||
entry = &__glXRenderSizeTable_EXT[index];
|
||||
proc = __glXSwapRenderTable_EXT[index];
|
||||
#endif /* __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT */
|
||||
} else {
|
||||
client->errorValue = opcode;
|
||||
return __glXError(GLXBadLargeRequest);
|
||||
}
|
||||
|
||||
if (!entry->bytes) {
|
||||
/* unused opcode */
|
||||
client->errorValue = opcode;
|
||||
return __glXError(GLXBadLargeRequest);
|
||||
}
|
||||
if (entry->varsize) {
|
||||
/*
|
||||
** If it's a variable-size command (a command whose length must
|
||||
** be computed from its parameters), all the parameters needed
|
||||
** will be in the 1st request, so it's okay to do this.
|
||||
*/
|
||||
extra = (*entry->varsize)(pc + __GLX_RENDER_LARGE_HDR_SIZE, True);
|
||||
if (extra < 0) {
|
||||
extra = 0;
|
||||
}
|
||||
/* large command's header is 4 bytes longer, so add 4 */
|
||||
if (cmdlen != __GLX_PAD(entry->bytes + 4 + extra)) {
|
||||
return BadLength;
|
||||
}
|
||||
} else {
|
||||
/* constant size command */
|
||||
if (cmdlen != __GLX_PAD(entry->bytes + 4)) {
|
||||
return BadLength;
|
||||
}
|
||||
}
|
||||
/*
|
||||
** Make enough space in the buffer, then copy the entire request.
|
||||
*/
|
||||
if (cl->largeCmdBufSize < cmdlen) {
|
||||
if (!cl->largeCmdBuf) {
|
||||
cl->largeCmdBuf = (GLbyte *) xalloc(cmdlen);
|
||||
} else {
|
||||
cl->largeCmdBuf = (GLbyte *) xrealloc(cl->largeCmdBuf, cmdlen);
|
||||
}
|
||||
if (!cl->largeCmdBuf) {
|
||||
return BadAlloc;
|
||||
}
|
||||
cl->largeCmdBufSize = cmdlen;
|
||||
}
|
||||
memcpy(cl->largeCmdBuf, pc, dataBytes);
|
||||
|
||||
cl->largeCmdBytesSoFar = dataBytes;
|
||||
cl->largeCmdBytesTotal = cmdlen;
|
||||
cl->largeCmdRequestsSoFar = 1;
|
||||
cl->largeCmdRequestsTotal = req->requestTotal;
|
||||
return Success;
|
||||
|
||||
} else {
|
||||
/*
|
||||
** We are receiving subsequent (i.e. not the first) requests of a
|
||||
** multi request command.
|
||||
*/
|
||||
|
||||
/*
|
||||
** Check the request number and the total request count.
|
||||
*/
|
||||
if (req->requestNumber != cl->largeCmdRequestsSoFar + 1) {
|
||||
client->errorValue = req->requestNumber;
|
||||
__glXResetLargeCommandStatus(cl);
|
||||
return __glXError(GLXBadLargeRequest);
|
||||
}
|
||||
if (req->requestTotal != cl->largeCmdRequestsTotal) {
|
||||
client->errorValue = req->requestTotal;
|
||||
__glXResetLargeCommandStatus(cl);
|
||||
return __glXError(GLXBadLargeRequest);
|
||||
}
|
||||
|
||||
/*
|
||||
** Check that we didn't get too much data.
|
||||
*/
|
||||
if ((cl->largeCmdBytesSoFar + dataBytes) > cl->largeCmdBytesTotal) {
|
||||
client->errorValue = dataBytes;
|
||||
__glXResetLargeCommandStatus(cl);
|
||||
return __glXError(GLXBadLargeRequest);
|
||||
}
|
||||
memcpy(cl->largeCmdBuf + cl->largeCmdBytesSoFar, pc, dataBytes);
|
||||
cl->largeCmdBytesSoFar += dataBytes;
|
||||
cl->largeCmdRequestsSoFar++;
|
||||
|
||||
if (req->requestNumber == cl->largeCmdRequestsTotal) {
|
||||
/*
|
||||
** This is the last request; it must have enough bytes to complete
|
||||
** the command.
|
||||
*/
|
||||
/* NOTE: the two pad macros have been added below; they are needed
|
||||
** because the client library pads the total byte count, but not
|
||||
** the per-request byte counts. The Protocol Encoding says the
|
||||
** total byte count should not be padded, so a proposal will be
|
||||
** made to the ARB to relax the padding constraint on the total
|
||||
** byte count, thus preserving backward compatibility. Meanwhile,
|
||||
** the padding done below fixes a bug that did not allow
|
||||
** large commands of odd sizes to be accepted by the server.
|
||||
*/
|
||||
if (__GLX_PAD(cl->largeCmdBytesSoFar) !=
|
||||
__GLX_PAD(cl->largeCmdBytesTotal)) {
|
||||
client->errorValue = dataBytes;
|
||||
__glXResetLargeCommandStatus(cl);
|
||||
return __glXError(GLXBadLargeRequest);
|
||||
}
|
||||
hdr = (__GLXrenderLargeHeader *) cl->largeCmdBuf;
|
||||
/*
|
||||
** The opcode and length field in the header had already been
|
||||
** swapped when the first request was received.
|
||||
*/
|
||||
|
||||
/*
|
||||
** Use the opcode to index into the procedure table.
|
||||
*/
|
||||
opcode = hdr->opcode;
|
||||
if ( (opcode >= __GLX_MIN_RENDER_OPCODE) &&
|
||||
(opcode <= __GLX_MAX_RENDER_OPCODE) ) {
|
||||
proc = __glXSwapRenderTable[opcode];
|
||||
#if __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT
|
||||
} else if ( (opcode >= __GLX_MIN_RENDER_OPCODE_EXT) &&
|
||||
(opcode <= __GLX_MAX_RENDER_OPCODE_EXT) ) {
|
||||
int index = opcode - __GLX_MIN_RENDER_OPCODE_EXT;
|
||||
proc = __glXSwapRenderTable_EXT[index];
|
||||
#endif /* __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT */
|
||||
} else {
|
||||
client->errorValue = opcode;
|
||||
return __glXError(GLXBadLargeRequest);
|
||||
}
|
||||
|
||||
/*
|
||||
** Skip over the header and execute the command.
|
||||
*/
|
||||
(*proc)(cl->largeCmdBuf + __GLX_RENDER_LARGE_HDR_SIZE);
|
||||
__GLX_NOTE_UNFLUSHED_CMDS(cx);
|
||||
|
||||
/*
|
||||
** Reset for the next RenderLarge series.
|
||||
*/
|
||||
__glXResetLargeCommandStatus(cl);
|
||||
} else {
|
||||
/*
|
||||
** This is neither the first nor the last request.
|
||||
*/
|
||||
}
|
||||
return Success;
|
||||
}
|
||||
return DoRenderLarge(cl, pc, True);
|
||||
}
|
||||
|
||||
/************************************************************************/
|
||||
|
@ -969,10 +658,11 @@ int __glXSwapRenderLarge(__GLXclientState *cl, GLbyte *pc)
|
|||
** allocating these entry points in the dispatch table.
|
||||
*/
|
||||
|
||||
int __glXSwapVendorPrivate(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDispSwap_VendorPrivate(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXVendorPrivateReq *req;
|
||||
GLint vendorcode;
|
||||
__GLXdispatchVendorPrivProcPtr proc;
|
||||
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
||||
|
@ -982,41 +672,24 @@ int __glXSwapVendorPrivate(__GLXclientState *cl, GLbyte *pc)
|
|||
|
||||
vendorcode = req->vendorCode;
|
||||
|
||||
#ifndef __DARWIN__
|
||||
switch( vendorcode ) {
|
||||
case X_GLvop_SampleMaskSGIS:
|
||||
__GLX_SWAP_FLOAT(pc + 4);
|
||||
__GLX_SWAP_INT(pc + 8);
|
||||
CALL_SampleMaskSGIS( GET_DISPATCH(),
|
||||
(*(GLfloat *)(pc + 4), *(GLboolean *)(pc + 8)) );
|
||||
return Success;
|
||||
case X_GLvop_SamplePatternSGIS:
|
||||
__GLX_SWAP_INT(pc + 4);
|
||||
CALL_SamplePatternSGIS( GET_DISPATCH(), (*(GLenum *)(pc + 4)) );
|
||||
return Success;
|
||||
case X_GLXvop_BindTexImageEXT:
|
||||
return __glXSwapBindTexImageEXT(cl, pc);
|
||||
case X_GLXvop_ReleaseTexImageEXT:
|
||||
return __glXSwapReleaseTexImageEXT(cl, pc);
|
||||
case X_GLXvop_CopySubBufferMESA:
|
||||
return __glXSwapCopySubBufferMESA(cl, pc);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
if ((vendorcode >= __GLX_MIN_VENDPRIV_OPCODE_EXT) &&
|
||||
(vendorcode <= __GLX_MAX_VENDPRIV_OPCODE_EXT)) {
|
||||
(*__glXSwapVendorPrivTable_EXT[vendorcode-__GLX_MIN_VENDPRIV_OPCODE_EXT])(cl, (GLbyte*)req);
|
||||
proc = (__GLXdispatchVendorPrivProcPtr)
|
||||
__glXGetProtocolDecodeFunction(& VendorPriv_dispatch_info,
|
||||
vendorcode, 1);
|
||||
if (proc != NULL) {
|
||||
(*proc)(cl, (GLbyte*)req);
|
||||
return Success;
|
||||
}
|
||||
|
||||
cl->client->errorValue = req->vendorCode;
|
||||
return __glXError(GLXUnsupportedPrivateRequest);
|
||||
}
|
||||
|
||||
int __glXSwapVendorPrivateWithReply(__GLXclientState *cl, GLbyte *pc)
|
||||
|
||||
int __glXDispSwap_VendorPrivateWithReply(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXVendorPrivateWithReplyReq *req;
|
||||
GLint vendorcode;
|
||||
__GLXdispatchVendorPrivProcPtr proc;
|
||||
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
||||
|
@ -1026,42 +699,13 @@ int __glXSwapVendorPrivateWithReply(__GLXclientState *cl, GLbyte *pc)
|
|||
|
||||
vendorcode = req->vendorCode;
|
||||
|
||||
switch (vendorcode) {
|
||||
case X_GLXvop_QueryContextInfoEXT:
|
||||
return __glXSwapQueryContextInfoEXT(cl, pc);
|
||||
case X_GLXvop_MakeCurrentReadSGI:
|
||||
return __glXSwapMakeCurrentReadSGI(cl, pc);
|
||||
case X_GLXvop_GetFBConfigsSGIX:
|
||||
return __glXSwapGetFBConfigsSGIX(cl, pc);
|
||||
case X_GLXvop_CreateContextWithConfigSGIX:
|
||||
return __glXSwapCreateContextWithConfigSGIX(cl, pc);
|
||||
case X_GLXvop_CreateGLXPixmapWithConfigSGIX:
|
||||
return __glXSwapCreateGLXPixmapWithConfigSGIX(cl, pc);
|
||||
case X_GLXvop_GetDrawableAttributesSGIX:
|
||||
return __glXSwapGetDrawableAttributesSGIX(cl, pc);
|
||||
case X_GLvop_IsRenderbufferEXT:
|
||||
return __glXDispSwap_IsRenderbufferEXT(cl, pc);
|
||||
case X_GLvop_GenRenderbuffersEXT:
|
||||
return __glXDispSwap_GenRenderbuffersEXT(cl, pc);
|
||||
case X_GLvop_GetRenderbufferParameterivEXT:
|
||||
return __glXDispSwap_GetRenderbufferParameterivEXT(cl, pc);
|
||||
case X_GLvop_IsFramebufferEXT:
|
||||
return __glXDispSwap_IsFramebufferEXT(cl, pc);
|
||||
case X_GLvop_GenFramebuffersEXT:
|
||||
return __glXDispSwap_GenFramebuffersEXT(cl, pc);
|
||||
case X_GLvop_CheckFramebufferStatusEXT:
|
||||
return __glXDispSwap_CheckFramebufferStatusEXT(cl, pc);
|
||||
case X_GLvop_GetFramebufferAttachmentParameterivEXT:
|
||||
return __glXDispSwap_GetFramebufferAttachmentParameterivEXT(cl, pc);
|
||||
default:
|
||||
break;
|
||||
proc = (__GLXdispatchVendorPrivProcPtr)
|
||||
__glXGetProtocolDecodeFunction(& VendorPriv_dispatch_info,
|
||||
vendorcode, 1);
|
||||
if (proc != NULL) {
|
||||
return (*proc)(cl, (GLbyte*)req);
|
||||
}
|
||||
|
||||
|
||||
if ((vendorcode >= __GLX_MIN_VENDPRIV_OPCODE_EXT) &&
|
||||
(vendorcode <= __GLX_MAX_VENDPRIV_OPCODE_EXT)) {
|
||||
return (*__glXSwapVendorPrivTable_EXT[vendorcode-__GLX_MIN_VENDPRIV_OPCODE_EXT])(cl, (GLbyte*)req);
|
||||
}
|
||||
cl->client->errorValue = req->vendorCode;
|
||||
return __glXError(GLXUnsupportedPrivateRequest);
|
||||
}
|
||||
|
|
|
@ -53,7 +53,6 @@
|
|||
#include "glcontextmodes.h"
|
||||
|
||||
#include "g_disptab.h"
|
||||
#include "g_disptab_EXT.h"
|
||||
#include "glapitable.h"
|
||||
#include "glapi.h"
|
||||
#include "glthread.h"
|
||||
|
|
|
@ -32,6 +32,8 @@
|
|||
#include "unpack.h"
|
||||
#include "glxutil.h"
|
||||
#include "glxext.h"
|
||||
#include "indirect_table.h"
|
||||
#include "indirect_util.h"
|
||||
|
||||
/*
|
||||
** The last context used by the server. It is the context that is current
|
||||
|
@ -452,7 +454,7 @@ static int __glXDispatch(ClientPtr client)
|
|||
{
|
||||
REQUEST(xGLXSingleReq);
|
||||
CARD8 opcode;
|
||||
int (*proc)(__GLXclientState *cl, GLbyte *pc);
|
||||
__GLXdispatchSingleProcPtr proc;
|
||||
__GLXclientState *cl;
|
||||
int retval;
|
||||
|
||||
|
@ -481,13 +483,6 @@ static int __glXDispatch(ClientPtr client)
|
|||
cl->client = client;
|
||||
}
|
||||
|
||||
/*
|
||||
** Check for valid opcode.
|
||||
*/
|
||||
if (opcode >= __GLX_SINGLE_TABLE_SIZE) {
|
||||
return BadRequest;
|
||||
}
|
||||
|
||||
/*
|
||||
** If we're expecting a glXRenderLarge request, this better be one.
|
||||
*/
|
||||
|
@ -499,29 +494,27 @@ static int __glXDispatch(ClientPtr client)
|
|||
/*
|
||||
** Use the opcode to index into the procedure table.
|
||||
*/
|
||||
if (client->swapped)
|
||||
proc = __glXSwapSingleTable[opcode];
|
||||
else
|
||||
proc = __glXSingleTable[opcode];
|
||||
proc = (__GLXdispatchSingleProcPtr) __glXGetProtocolDecodeFunction(& Single_dispatch_info,
|
||||
opcode,
|
||||
client->swapped);
|
||||
if (proc != NULL) {
|
||||
__glXleaveServer();
|
||||
|
||||
__glXleaveServer();
|
||||
inDispatch = True;
|
||||
|
||||
inDispatch = True;
|
||||
retval = (*proc)(cl, (GLbyte *) stuff);
|
||||
|
||||
retval = proc(cl, (GLbyte *) stuff);
|
||||
inDispatch = False;
|
||||
|
||||
inDispatch = False;
|
||||
|
||||
__glXenterServer();
|
||||
__glXenterServer();
|
||||
}
|
||||
else {
|
||||
retval = BadRequest;
|
||||
}
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
int __glXNoSuchSingleOpcode(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
return BadRequest;
|
||||
}
|
||||
|
||||
void __glXNoSuchRenderOpcode(GLbyte *pc)
|
||||
{
|
||||
return;
|
||||
|
|
|
@ -67,7 +67,6 @@ extern GLboolean __glXFreeContext(__GLXcontext *glxc);
|
|||
extern void __glXFlushContextCache(void);
|
||||
|
||||
extern void __glXNoSuchRenderOpcode(GLbyte*);
|
||||
extern int __glXNoSuchSingleOpcode(__GLXclientState*, GLbyte*);
|
||||
extern void __glXErrorCallBack(__GLinterface *gc, GLenum code);
|
||||
extern void __glXClearErrorOccured(void);
|
||||
extern GLboolean __glXErrorOccured(void);
|
||||
|
@ -90,6 +89,9 @@ extern int DoDestroyPixmap(__GLXclientState *cl, XID glxpixmapId);
|
|||
|
||||
extern int DoQueryContext(__GLXclientState *cl, GLXContextID gcId);
|
||||
|
||||
extern int DoRender(__GLXclientState *cl, GLbyte *pc, int do_swap);
|
||||
extern int DoRenderLarge(__GLXclientState *cl, GLbyte *pc, int do_swap);
|
||||
|
||||
extern void GlxExtensionInit(void);
|
||||
|
||||
extern Bool __glXCoreType(void);
|
||||
|
|
|
@ -48,8 +48,11 @@
|
|||
const char GLServerVersion[] = "1.2";
|
||||
static const char GLServerExtensions[] =
|
||||
"GL_ARB_depth_texture "
|
||||
"GL_ARB_draw_buffers "
|
||||
"GL_ARB_imaging "
|
||||
"GL_ARB_multisample "
|
||||
"GL_ARB_multitexture "
|
||||
"GL_ARB_occlusion_query "
|
||||
"GL_ARB_point_parameters "
|
||||
"GL_ARB_point_sprite "
|
||||
"GL_ARB_shadow "
|
||||
|
@ -61,9 +64,9 @@ static const char GLServerExtensions[] =
|
|||
"GL_ARB_texture_env_crossbar "
|
||||
"GL_ARB_texture_env_dot3 "
|
||||
"GL_ARB_texture_mirrored_repeat "
|
||||
"GL_ARB_texture_non_power_of_two "
|
||||
"GL_ARB_transpose_matrix "
|
||||
"GL_ARB_window_pos "
|
||||
"GL_ARB_texture_non_power_of_two "
|
||||
"GL_EXT_abgr "
|
||||
"GL_EXT_bgra "
|
||||
"GL_EXT_blend_color "
|
||||
|
@ -75,13 +78,17 @@ static const char GLServerExtensions[] =
|
|||
"GL_EXT_copy_texture "
|
||||
"GL_EXT_draw_range_elements "
|
||||
"GL_EXT_fog_coord "
|
||||
"GL_EXT_framebuffer_object "
|
||||
"GL_EXT_multi_draw_arrays "
|
||||
"GL_EXT_packed_pixels "
|
||||
"GL_EXT_paletted_texture "
|
||||
"GL_EXT_point_parameters "
|
||||
"GL_EXT_polygon_offset "
|
||||
"GL_EXT_rescale_normal "
|
||||
"GL_EXT_secondary_color "
|
||||
"GL_EXT_separate_specular_color "
|
||||
"GL_EXT_shadow_funcs "
|
||||
"GL_EXT_shared_texture_palette "
|
||||
"GL_EXT_stencil_two_side "
|
||||
"GL_EXT_stencil_wrap "
|
||||
"GL_EXT_subtexture "
|
||||
|
@ -93,29 +100,41 @@ static const char GLServerExtensions[] =
|
|||
"GL_EXT_texture_env_dot3 "
|
||||
"GL_EXT_texture_lod "
|
||||
"GL_EXT_texture_lod_bias "
|
||||
"GL_EXT_texture_mirror_clamp "
|
||||
"GL_EXT_texture_object "
|
||||
"GL_EXT_texture_rectangle "
|
||||
"GL_EXT_vertex_array "
|
||||
"GL_EXT_framebuffer_object "
|
||||
"GL_APPLE_packed_pixels "
|
||||
"GL_ATI_texture_mirror_once "
|
||||
"GL_ATI_draw_buffers "
|
||||
"GL_ATI_texture_env_combine3 "
|
||||
"GL_ATI_texture_mirror_once "
|
||||
"GL_HP_occlusion_test "
|
||||
"GL_IBM_texture_mirrored_repeat "
|
||||
"GL_INGR_blend_func_separate "
|
||||
"GL_MESA_pack_invert "
|
||||
"GL_MESA_ycbcr_texture "
|
||||
"GL_NV_blend_square "
|
||||
"GL_NV_depth_clamp "
|
||||
"GL_NV_fog_distance "
|
||||
"GL_NV_light_max_exponent "
|
||||
"GL_NV_multisample_filter_hint "
|
||||
"GL_NV_point_sprite "
|
||||
"GL_NV_texgen_reflection "
|
||||
"GL_NV_texture_rectangle "
|
||||
"GL_NV_texture_env_combine4 "
|
||||
"GL_NV_texture_expand_normal "
|
||||
"GL_NV_texture_rectangle "
|
||||
"GL_SGI_color_matrix "
|
||||
"GL_SGI_color_table "
|
||||
"GL_SGIS_generate_mipmap "
|
||||
"GL_SGIS_multisample "
|
||||
"GL_SGIS_point_parameters "
|
||||
"GL_SGIS_texture_border_clamp "
|
||||
"GL_SGIS_texture_edge_clamp "
|
||||
"GL_SGIS_texture_lod "
|
||||
"GL_SGIX_depth_texture "
|
||||
"GL_SGIX_shadow "
|
||||
"GL_SGIX_shadow_ambient "
|
||||
"GL_SUN_slice_accum "
|
||||
;
|
||||
|
||||
/*
|
||||
|
|
|
@ -196,12 +196,12 @@ extern __GLXprocPtr __glXProcTable[];
|
|||
/*
|
||||
* Tables for computing the size of each rendering command.
|
||||
*/
|
||||
typedef int (*gl_proto_size_func)(const GLbyte *, Bool);
|
||||
|
||||
typedef struct {
|
||||
int bytes;
|
||||
int (*varsize)(const GLbyte *pc, Bool swap);
|
||||
gl_proto_size_func varsize;
|
||||
} __GLXrenderSizeData;
|
||||
extern __GLXrenderSizeData __glXRenderSizeTable[];
|
||||
extern __GLXrenderSizeData __glXRenderSizeTable_EXT[];
|
||||
|
||||
/************************************************************************/
|
||||
|
||||
|
@ -252,6 +252,6 @@ extern int __glXImageSize(GLenum format, GLenum type,
|
|||
GLint imageHeight, GLint rowLength, GLint skipImages, GLint skipRows,
|
||||
GLint alignment);
|
||||
|
||||
extern int __glXDrawArraysSize(const GLbyte *pc, Bool swap);
|
||||
extern int __glXDrawArraysReqSize(const GLbyte *pc, Bool swap);
|
||||
|
||||
#endif /* !__GLX_server_h__ */
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -61,12 +61,16 @@ extern HIDDEN void __glXDisp_ActiveTextureARB(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_ActiveTextureARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_VertexAttrib4ubvNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_VertexAttrib4ubvNV(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetColorTableParameterfvSGI(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetColorTableParameterfvSGI(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_GetProgramNamedParameterdvNV(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetProgramNamedParameterdvNV(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_Histogram(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Histogram(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetMapfv(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetMapfv(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_RasterPos4dv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_RasterPos4dv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_PolygonStipple(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_PolygonStipple(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetPixelMapfv(struct __GLXclientStateRec *, GLbyte *);
|
||||
|
@ -79,16 +83,26 @@ extern HIDDEN void __glXDisp_VertexAttrib4svNV(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_VertexAttrib4svNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_EvalCoord2fv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_EvalCoord2fv(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_DestroyPixmap(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_DestroyPixmap(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_ProgramEnvParameter4dvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_ProgramEnvParameter4dvARB(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetMapiv(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetMapiv(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_SwapBuffers(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_SwapBuffers(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_Indexubv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Indexubv(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_Render(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_Render(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_GetQueryivARB(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetQueryivARB(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_TexImage3D(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_TexImage3D(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_MakeContextCurrent(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_MakeContextCurrent(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_GetFBConfigs(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetFBConfigs(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_Color3ubv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Color3ubv(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetQueryObjectivARB(struct __GLXclientStateRec *, GLbyte *);
|
||||
|
@ -105,16 +119,18 @@ extern HIDDEN void __glXDisp_VertexAttribs1dvNV(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_VertexAttribs1dvNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Normal3bv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Normal3bv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_TexGeniv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_TexGeniv(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_VendorPrivate(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_VendorPrivate(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_CreateGLXPixmapWithConfigSGIX(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_CreateGLXPixmapWithConfigSGIX(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_Vertex3iv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Vertex3iv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_CopyConvolutionFilter1D(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_CopyConvolutionFilter1D(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_BlendColor(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_BlendColor(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_CallLists(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_CallLists(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Scalef(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Scalef(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Normal3iv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Normal3iv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_PassThrough(GLbyte * pc);
|
||||
|
@ -123,8 +139,10 @@ extern HIDDEN void __glXDisp_Viewport(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_Viewport(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_VertexAttrib4NusvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_VertexAttrib4NusvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_PrioritizeTextures(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_PrioritizeTextures(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_CopyTexSubImage2D(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_CopyTexSubImage2D(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_DepthRange(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_DepthRange(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_ResetHistogram(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_ResetHistogram(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetProgramNamedParameterfvNV(struct __GLXclientStateRec *, GLbyte *);
|
||||
|
@ -145,10 +163,14 @@ extern HIDDEN int __glXDisp_GetConvolutionParameteriv(struct __GLXclientStateRec
|
|||
extern HIDDEN int __glXDispSwap_GetConvolutionParameteriv(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_Vertex2dv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Vertex2dv(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetVisualConfigs(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetVisualConfigs(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_MultiTexCoord1fvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_MultiTexCoord1fvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_TexCoord3iv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_TexCoord3iv(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_CopyContext(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_CopyContext(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_Color3fv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Color3fv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_PointSize(GLbyte * pc);
|
||||
|
@ -161,36 +183,40 @@ extern HIDDEN void __glXDisp_Vertex4sv(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_Vertex4sv(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetTexEnvfv(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetTexEnvfv(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_LineStipple(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_LineStipple(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_TexEnvi(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_TexEnvi(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetClipPlane(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetClipPlane(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_VertexAttribs3dvNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_VertexAttribs3dvNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_LightModeli(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_LightModeli(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_VertexAttribs4fvNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_VertexAttribs4fvNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Scaled(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Scaled(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Scalef(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Scalef(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_CallLists(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_CallLists(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_AlphaFunc(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_AlphaFunc(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_TexCoord2iv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_TexCoord2iv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_CompressedTexImage1DARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_CompressedTexImage1DARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Rotated(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Rotated(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_ReadPixels(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_ReadPixels(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_EdgeFlagv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_EdgeFlagv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Color4iv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Color4iv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Rotatef(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Rotatef(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_TexParameterf(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_TexParameterf(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_TexParameteri(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_TexParameteri(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_DestroyContext(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_DestroyContext(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_DrawPixels(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_DrawPixels(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_MultiTexCoord2svARB(GLbyte * pc);
|
||||
|
@ -215,8 +241,6 @@ extern HIDDEN void __glXDisp_Color4usv(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_Color4usv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Fogi(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Fogi(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_DepthRange(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_DepthRange(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_RasterPos3iv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_RasterPos3iv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_PixelMapfv(GLbyte * pc);
|
||||
|
@ -229,8 +253,6 @@ extern HIDDEN int __glXDisp_AreTexturesResident(struct __GLXclientStateRec *, GL
|
|||
extern HIDDEN int __glXDispSwap_AreTexturesResident(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_IsRenderbufferEXT(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_IsRenderbufferEXT(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_ColorTableParameteriv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_ColorTableParameteriv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_PointParameterfvEXT(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_PointParameterfvEXT(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Color3bv(GLbyte * pc);
|
||||
|
@ -291,8 +313,14 @@ extern HIDDEN int __glXDisp_CheckFramebufferStatusEXT(struct __GLXclientStateRec
|
|||
extern HIDDEN int __glXDispSwap_CheckFramebufferStatusEXT(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_GetVertexAttribivARB(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetVertexAttribivARB(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_GetFBConfigsSGIX(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetFBConfigsSGIX(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_CreateNewContext(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_CreateNewContext(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_GetMinmax(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetMinmax(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_GetVertexAttribdvNV(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetVertexAttribdvNV(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_Normal3fv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Normal3fv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_VertexAttrib4ivARB(GLbyte * pc);
|
||||
|
@ -305,6 +333,8 @@ extern HIDDEN void __glXDisp_MultiTexCoord3fvARB(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_MultiTexCoord3fvARB(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetProgramParameterfvNV(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetProgramParameterfvNV(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_BindTexture(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_BindTexture(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_TexSubImage2D(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_TexSubImage2D(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_DeleteRenderbuffersEXT(GLbyte * pc);
|
||||
|
@ -313,8 +343,12 @@ extern HIDDEN void __glXDisp_TexGenfv(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_TexGenfv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_VertexAttrib4bvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_VertexAttrib4bvARB(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_CreateContextWithConfigSGIX(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_CreateContextWithConfigSGIX(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_FramebufferTexture3DEXT(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_FramebufferTexture3DEXT(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_CopySubBufferMESA(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_CopySubBufferMESA(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_BlendEquation(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_BlendEquation(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetError(struct __GLXclientStateRec *, GLbyte *);
|
||||
|
@ -337,6 +371,8 @@ extern HIDDEN void __glXDisp_EndQueryARB(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_EndQueryARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_DepthMask(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_DepthMask(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Rotated(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Rotated(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetMaterialiv(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetMaterialiv(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_StencilOp(GLbyte * pc);
|
||||
|
@ -345,6 +381,8 @@ extern HIDDEN void __glXDisp_MultiTexCoord3svARB(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_MultiTexCoord3svARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_TexEnvfv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_TexEnvfv(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_QueryServerString(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_QueryServerString(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_LoadMatrixf(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_LoadMatrixf(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Color4bv(GLbyte * pc);
|
||||
|
@ -361,6 +399,8 @@ extern HIDDEN void __glXDisp_LogicOp(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_LogicOp(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_TexCoord4fv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_TexCoord4fv(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_WaitX(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_WaitX(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_VertexAttrib2dvNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_VertexAttrib2dvNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_FramebufferRenderbufferEXT(GLbyte * pc);
|
||||
|
@ -371,6 +411,8 @@ extern HIDDEN int __glXDisp_GenTextures(struct __GLXclientStateRec *, GLbyte *);
|
|||
extern HIDDEN int __glXDispSwap_GenTextures(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_FramebufferTexture1DEXT(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_FramebufferTexture1DEXT(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetDrawableAttributes(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetDrawableAttributes(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_ProgramParameter4fvNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_ProgramParameter4fvNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_RasterPos2sv(GLbyte * pc);
|
||||
|
@ -383,6 +425,8 @@ extern HIDDEN void __glXDisp_TexCoord2fv(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_TexCoord2fv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_TexCoord1sv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_TexCoord1sv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_TexGeniv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_TexGeniv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_DepthFunc(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_DepthFunc(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_PixelMapusv(GLbyte * pc);
|
||||
|
@ -391,6 +435,8 @@ extern HIDDEN void __glXDisp_PointParameterivNV(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_PointParameterivNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_BlendFunc(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_BlendFunc(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_WaitGL(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_WaitGL(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_MultiTexCoord3dvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_MultiTexCoord3dvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_ProgramNamedParameter4dvNV(GLbyte * pc);
|
||||
|
@ -407,22 +453,26 @@ extern HIDDEN void __glXDisp_PushAttrib(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_PushAttrib(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_VertexAttrib4usvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_VertexAttrib4usvARB(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_DestroyPbuffer(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_DestroyPbuffer(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_TexParameteriv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_TexParameteriv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_WindowPos3fvMESA(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_WindowPos3fvMESA(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_VertexAttrib1svNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_VertexAttrib1svNV(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_QueryExtensionsString(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_QueryExtensionsString(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_RasterPos3fv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_RasterPos3fv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_CopyTexSubImage3D(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_CopyTexSubImage3D(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetColorTable(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetColorTable(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_SelectBuffer(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_SelectBuffer(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_Indexiv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Indexiv(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_CreateContext(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_CreateContext(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_CopyColorTable(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_CopyColorTable(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetHistogramParameterfv(struct __GLXclientStateRec *, GLbyte *);
|
||||
|
@ -431,8 +481,12 @@ extern HIDDEN void __glXDisp_Frustum(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_Frustum(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetString(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetString(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_CreateGLXPixmap(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_CreateGLXPixmap(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_TexEnvf(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_TexEnvf(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetProgramStringARB(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetProgramStringARB(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_MultiTexCoord3ivARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_MultiTexCoord3ivARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_VertexAttrib1dvARB(GLbyte * pc);
|
||||
|
@ -443,16 +497,18 @@ extern HIDDEN int __glXDisp_GetTexLevelParameteriv(struct __GLXclientStateRec *,
|
|||
extern HIDDEN int __glXDispSwap_GetTexLevelParameteriv(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_ClearAccum(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_ClearAccum(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_QueryVersion(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_QueryVersion(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_GetVertexAttribfvARB(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetVertexAttribfvARB(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_SecondaryColor3ivEXT(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_SecondaryColor3ivEXT(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_TexCoord4iv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_TexCoord4iv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_PolygonOffset(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_PolygonOffset(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_SampleMaskSGIS(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_SampleMaskSGIS(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_ColorTableParameteriv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_ColorTableParameteriv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_VertexAttrib4ubvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_VertexAttrib4ubvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_CopyTexImage2D(GLbyte * pc);
|
||||
|
@ -467,6 +523,8 @@ extern HIDDEN void __glXDisp_Color4fv(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_Color4fv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_MultiTexCoord4ivARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_MultiTexCoord4ivARB(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_CreatePixmap(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_CreatePixmap(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_Lightiv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Lightiv(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetQueryObjectuivARB(struct __GLXclientStateRec *, GLbyte *);
|
||||
|
@ -479,8 +537,6 @@ extern HIDDEN void __glXDisp_VertexAttrib2dvARB(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_VertexAttrib2dvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_VertexAttribs2svNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_VertexAttribs2svNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_VertexAttrib2fvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_VertexAttrib2fvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Rectdv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Rectdv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_VertexAttrib4NivARB(GLbyte * pc);
|
||||
|
@ -495,8 +551,8 @@ extern HIDDEN void __glXDisp_CompressedTexSubImage1DARB(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_CompressedTexSubImage1DARB(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetVertexAttribivNV(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetVertexAttribivNV(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_GetProgramStringARB(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetProgramStringARB(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_IsQueryARB(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_IsQueryARB(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_TexGeni(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_TexGeni(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_TexGenf(GLbyte * pc);
|
||||
|
@ -513,6 +569,8 @@ extern HIDDEN void __glXDisp_VertexAttribs1fvNV(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_VertexAttribs1fvNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_VertexAttrib4NuivARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_VertexAttrib4NuivARB(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_DestroyWindow(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_DestroyWindow(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_Color4sv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Color4sv(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_IsProgramNV(struct __GLXclientStateRec *, GLbyte *);
|
||||
|
@ -531,14 +589,18 @@ extern HIDDEN int __glXDisp_DeleteQueriesARB(struct __GLXclientStateRec *, GLbyt
|
|||
extern HIDDEN int __glXDispSwap_DeleteQueriesARB(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_GetMapdv(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetMapdv(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_DestroyGLXPixmap(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_DestroyGLXPixmap(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_SamplePatternSGIS(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_SamplePatternSGIS(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_PixelStoref(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_PixelStoref(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_IsQueryARB(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_IsQueryARB(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_PrioritizeTextures(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_PrioritizeTextures(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_PixelStorei(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_PixelStorei(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_Color4iv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Color4iv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_EvalCoord2dv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_EvalCoord2dv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_VertexAttrib3svARB(GLbyte * pc);
|
||||
|
@ -563,12 +625,16 @@ extern HIDDEN void __glXDisp_TexImage1D(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_TexImage1D(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_FrontFace(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_FrontFace(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_SecondaryColor3ubvEXT(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_SecondaryColor3ubvEXT(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_RenderLarge(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_RenderLarge(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_VertexAttrib4dvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_VertexAttrib4dvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_PolygonOffset(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_PolygonOffset(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_ExecuteProgramNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_ExecuteProgramNV(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetColorTableParameterivSGI(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetColorTableParameterivSGI(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_Normal3dv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Normal3dv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Lightf(GLbyte * pc);
|
||||
|
@ -585,6 +651,8 @@ extern HIDDEN int __glXDisp_GetFramebufferAttachmentParameterivEXT(struct __GLXc
|
|||
extern HIDDEN int __glXDispSwap_GetFramebufferAttachmentParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_MultiTexCoord4dvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_MultiTexCoord4dvARB(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_CreatePbuffer(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_CreatePbuffer(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_GetDoublev(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetDoublev(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_MultMatrixd(GLbyte * pc);
|
||||
|
@ -603,6 +671,8 @@ extern HIDDEN void __glXDisp_VertexAttrib3fvARB(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_VertexAttrib3fvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_ClearColor(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_ClearColor(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_IsDirect(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_IsDirect(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_DeleteFramebuffersEXT(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_DeleteFramebuffersEXT(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_TexEnviv(GLbyte * pc);
|
||||
|
@ -633,6 +703,8 @@ extern HIDDEN void __glXDisp_VertexAttrib3svNV(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_VertexAttrib3svNV(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetTexEnviv(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetTexEnviv(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_VendorPrivateWithReply(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_VendorPrivateWithReply(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_SeparableFilter2D(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_SeparableFilter2D(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Map1d(GLbyte * pc);
|
||||
|
@ -647,6 +719,8 @@ extern HIDDEN void __glXDisp_ProgramParameters4fvNV(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_ProgramParameters4fvNV(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetProgramivNV(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetProgramivNV(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_ChangeDrawableAttributes(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_ChangeDrawableAttributes(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_GetMinmaxParameteriv(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetMinmaxParameteriv(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_PixelTransferf(GLbyte * pc);
|
||||
|
@ -661,12 +735,10 @@ extern HIDDEN void __glXDisp_TexCoord1dv(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_TexCoord1dv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_PixelTransferi(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_PixelTransferi(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetVertexAttribdvNV(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetVertexAttribdvNV(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_SecondaryColor3ubvEXT(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_SecondaryColor3ubvEXT(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_VertexAttrib3fvNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_VertexAttrib3fvNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Rotatef(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Rotatef(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Clear(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Clear(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_ReadBuffer(GLbyte * pc);
|
||||
|
@ -681,8 +753,10 @@ extern HIDDEN void __glXDisp_ConvolutionParameterf(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_ConvolutionParameterf(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetColorTableParameteriv(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetColorTableParameteriv(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_ShadeModel(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_ShadeModel(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_ReleaseTexImageEXT(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_ReleaseTexImageEXT(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_CallList(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_CallList(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_VertexAttribs2fvNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_VertexAttribs2fvNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Rectiv(GLbyte * pc);
|
||||
|
@ -697,6 +771,10 @@ extern HIDDEN void __glXDisp_BindRenderbufferEXT(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_BindRenderbufferEXT(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Vertex3sv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Vertex3sv(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetColorTableSGI(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetColorTableSGI(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_BindTexImageEXT(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_BindTexImageEXT(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_ProgramLocalParameter4fvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_ProgramLocalParameter4fvARB(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_DeleteProgramsNV(struct __GLXclientStateRec *, GLbyte *);
|
||||
|
@ -711,6 +789,8 @@ extern HIDDEN int __glXDisp_GetProgramStringNV(struct __GLXclientStateRec *, GLb
|
|||
extern HIDDEN int __glXDispSwap_GetProgramStringNV(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_LineWidth(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_LineWidth(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_VertexAttrib2fvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_VertexAttrib2fvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_TexGendv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_TexGendv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_ResetMinmax(GLbyte * pc);
|
||||
|
@ -723,8 +803,10 @@ extern HIDDEN void __glXDisp_VertexAttribs4dvNV(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_VertexAttribs4dvNV(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetMaterialfv(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetMaterialfv(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_CallList(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_CallList(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_UseXFont(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_UseXFont(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_ShadeModel(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_ShadeModel(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Materialfv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Materialfv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_TexCoord3fv(GLbyte * pc);
|
||||
|
@ -735,8 +817,8 @@ extern HIDDEN void __glXDisp_MultiTexCoord1ivARB(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_MultiTexCoord1ivARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_MultiTexCoord2ivARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_MultiTexCoord2ivARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_CopyTexSubImage2D(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_CopyTexSubImage2D(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_DrawArrays(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_DrawArrays(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Color3iv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Color3iv(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetProgramLocalParameterdvARB(struct __GLXclientStateRec *, GLbyte *);
|
||||
|
@ -759,16 +841,18 @@ extern HIDDEN void __glXDisp_PopMatrix(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_PopMatrix(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_AreTexturesResidentEXT(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_AreTexturesResidentEXT(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_MakeCurrentReadSGI(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_MakeCurrentReadSGI(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_GetTexGeniv(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetTexGeniv(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_MakeCurrent(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_MakeCurrent(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_Map2d(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Map2d(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Map2f(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Map2f(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_ProgramStringARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_ProgramStringARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_RasterPos4dv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_RasterPos4dv(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetCompressedTexImageARB(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetCompressedTexImageARB(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_GetTexGenfv(struct __GLXclientStateRec *, GLbyte *);
|
||||
|
@ -799,6 +883,8 @@ extern HIDDEN void __glXDisp_Translatef(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_Translatef(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_StencilMask(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_StencilMask(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_CreateWindow(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_CreateWindow(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_GetLightiv(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetLightiv(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_IsList(struct __GLXclientStateRec *, GLbyte *);
|
||||
|
@ -813,8 +899,8 @@ extern HIDDEN void __glXDisp_CopyTexSubImage1D(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_CopyTexSubImage1D(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_CullFace(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_CullFace(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_BindTexture(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_BindTexture(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_QueryContextInfoEXT(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_QueryContextInfoEXT(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_VertexAttribs3svNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_VertexAttribs3svNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_StencilFunc(GLbyte * pc);
|
||||
|
@ -837,6 +923,8 @@ extern HIDDEN int __glXDisp_GetPixelMapuiv(struct __GLXclientStateRec *, GLbyte
|
|||
extern HIDDEN int __glXDispSwap_GetPixelMapuiv(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_Indexfv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Indexfv(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_QueryContext(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_QueryContext(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_SecondaryColor3svEXT(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_SecondaryColor3svEXT(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_IndexMask(GLbyte * pc);
|
||||
|
@ -885,8 +973,8 @@ extern HIDDEN void __glXDisp_TexCoord4dv(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_TexCoord4dv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Begin(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Begin(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_LightModeli(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_LightModeli(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_ClientInfo(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_ClientInfo(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_Rectfv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Rectfv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_LightModelf(GLbyte * pc);
|
||||
|
@ -901,16 +989,14 @@ extern HIDDEN void __glXDisp_MultiTexCoord2fvARB(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_MultiTexCoord2fvARB(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetRenderbufferParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetRenderbufferParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_DrawArrays(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_DrawArrays(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_SelectBuffer(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_SelectBuffer(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_ColorMask(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_ColorMask(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_RasterPos4iv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_RasterPos4iv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Enable(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Enable(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_LineStipple(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_LineStipple(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_VertexAttribs4svNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_VertexAttribs4svNV(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetMinmaxParameterfv(struct __GLXclientStateRec *, GLbyte *);
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -967,57 +967,6 @@ __glGetMinmaxParameterfv_size( GLenum e )
|
|||
}
|
||||
}
|
||||
|
||||
INTERNAL PURE FASTCALL GLint
|
||||
__glPointParameterfvEXT_size( GLenum e )
|
||||
{
|
||||
switch( e ) {
|
||||
case GL_POINT_SIZE_MIN:
|
||||
/* case GL_POINT_SIZE_MIN_ARB:*/
|
||||
/* case GL_POINT_SIZE_MIN_SGIS:*/
|
||||
case GL_POINT_SIZE_MAX:
|
||||
/* case GL_POINT_SIZE_MAX_ARB:*/
|
||||
/* case GL_POINT_SIZE_MAX_SGIS:*/
|
||||
case GL_POINT_FADE_THRESHOLD_SIZE:
|
||||
/* case GL_POINT_FADE_THRESHOLD_SIZE_ARB:*/
|
||||
/* case GL_POINT_FADE_THRESHOLD_SIZE_SGIS:*/
|
||||
case GL_POINT_SPRITE_R_MODE_NV:
|
||||
case GL_POINT_SPRITE_COORD_ORIGIN:
|
||||
return 1;
|
||||
case GL_POINT_DISTANCE_ATTENUATION:
|
||||
/* case GL_POINT_DISTANCE_ATTENUATION_ARB:*/
|
||||
/* case GL_POINT_DISTANCE_ATTENUATION_SGIS:*/
|
||||
return 3;
|
||||
default: return 0;
|
||||
}
|
||||
}
|
||||
|
||||
INTERNAL PURE FASTCALL GLint
|
||||
__glGetProgramivNV_size( GLenum e )
|
||||
{
|
||||
switch( e ) {
|
||||
case GL_PROGRAM_LENGTH_NV:
|
||||
case GL_PROGRAM_TARGET_NV:
|
||||
case GL_PROGRAM_RESIDENT_NV:
|
||||
return 1;
|
||||
default: return 0;
|
||||
}
|
||||
}
|
||||
|
||||
INTERNAL PURE FASTCALL GLint
|
||||
__glGetVertexAttribdvARB_size( GLenum e )
|
||||
{
|
||||
switch( e ) {
|
||||
case GL_VERTEX_PROGRAM_ARB:
|
||||
case GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB:
|
||||
case GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB:
|
||||
case GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB:
|
||||
case GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB:
|
||||
case GL_CURRENT_VERTEX_ATTRIB_ARB:
|
||||
return 1;
|
||||
default: return 0;
|
||||
}
|
||||
}
|
||||
|
||||
INTERNAL PURE FASTCALL GLint
|
||||
__glGetProgramivARB_size( GLenum e )
|
||||
{
|
||||
|
@ -1073,11 +1022,15 @@ __glGetProgramivARB_size( GLenum e )
|
|||
}
|
||||
|
||||
INTERNAL PURE FASTCALL GLint
|
||||
__glGetQueryivARB_size( GLenum e )
|
||||
__glGetVertexAttribdvARB_size( GLenum e )
|
||||
{
|
||||
switch( e ) {
|
||||
case GL_QUERY_COUNTER_BITS_ARB:
|
||||
case GL_CURRENT_QUERY_ARB:
|
||||
case GL_VERTEX_PROGRAM_ARB:
|
||||
case GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB:
|
||||
case GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB:
|
||||
case GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB:
|
||||
case GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB:
|
||||
case GL_CURRENT_VERTEX_ATTRIB_ARB:
|
||||
return 1;
|
||||
default: return 0;
|
||||
}
|
||||
|
@ -1094,6 +1047,53 @@ __glGetQueryObjectivARB_size( GLenum e )
|
|||
}
|
||||
}
|
||||
|
||||
INTERNAL PURE FASTCALL GLint
|
||||
__glGetQueryivARB_size( GLenum e )
|
||||
{
|
||||
switch( e ) {
|
||||
case GL_QUERY_COUNTER_BITS_ARB:
|
||||
case GL_CURRENT_QUERY_ARB:
|
||||
return 1;
|
||||
default: return 0;
|
||||
}
|
||||
}
|
||||
|
||||
INTERNAL PURE FASTCALL GLint
|
||||
__glPointParameterfvEXT_size( GLenum e )
|
||||
{
|
||||
switch( e ) {
|
||||
case GL_POINT_SIZE_MIN:
|
||||
/* case GL_POINT_SIZE_MIN_ARB:*/
|
||||
/* case GL_POINT_SIZE_MIN_SGIS:*/
|
||||
case GL_POINT_SIZE_MAX:
|
||||
/* case GL_POINT_SIZE_MAX_ARB:*/
|
||||
/* case GL_POINT_SIZE_MAX_SGIS:*/
|
||||
case GL_POINT_FADE_THRESHOLD_SIZE:
|
||||
/* case GL_POINT_FADE_THRESHOLD_SIZE_ARB:*/
|
||||
/* case GL_POINT_FADE_THRESHOLD_SIZE_SGIS:*/
|
||||
case GL_POINT_SPRITE_R_MODE_NV:
|
||||
case GL_POINT_SPRITE_COORD_ORIGIN:
|
||||
return 1;
|
||||
case GL_POINT_DISTANCE_ATTENUATION:
|
||||
/* case GL_POINT_DISTANCE_ATTENUATION_ARB:*/
|
||||
/* case GL_POINT_DISTANCE_ATTENUATION_SGIS:*/
|
||||
return 3;
|
||||
default: return 0;
|
||||
}
|
||||
}
|
||||
|
||||
INTERNAL PURE FASTCALL GLint
|
||||
__glGetProgramivNV_size( GLenum e )
|
||||
{
|
||||
switch( e ) {
|
||||
case GL_PROGRAM_LENGTH_NV:
|
||||
case GL_PROGRAM_TARGET_NV:
|
||||
case GL_PROGRAM_RESIDENT_NV:
|
||||
return 1;
|
||||
default: return 0;
|
||||
}
|
||||
}
|
||||
|
||||
INTERNAL PURE FASTCALL GLint
|
||||
__glGetVertexAttribdvNV_size( GLenum e )
|
||||
{
|
||||
|
@ -1153,10 +1153,12 @@ ALIAS( GetHistogramParameteriv, GetHistogramParameterfv )
|
|||
ALIAS( GetMinmaxParameteriv, GetMinmaxParameterfv )
|
||||
ALIAS( GetVertexAttribfvARB, GetVertexAttribdvARB )
|
||||
ALIAS( GetVertexAttribivARB, GetVertexAttribdvARB )
|
||||
ALIAS( PointParameterivNV, PointParameterfvEXT )
|
||||
ALIAS( GetQueryObjectuivARB, GetQueryObjectivARB )
|
||||
ALIAS( GetColorTableParameterfvSGI, GetColorTableParameterfv )
|
||||
ALIAS( GetColorTableParameterivSGI, GetColorTableParameterfv )
|
||||
ALIAS( GetVertexAttribfvNV, GetVertexAttribdvNV )
|
||||
ALIAS( GetVertexAttribivNV, GetVertexAttribdvNV )
|
||||
ALIAS( PointParameterivNV, PointParameterfvEXT )
|
||||
|
||||
# undef PURE
|
||||
# undef FASTCALL
|
||||
|
|
|
@ -79,14 +79,16 @@ extern INTERNAL PURE FASTCALL GLint __glGetHistogramParameterfv_size(GLenum);
|
|||
extern INTERNAL PURE FASTCALL GLint __glGetHistogramParameteriv_size(GLenum);
|
||||
extern INTERNAL PURE FASTCALL GLint __glGetMinmaxParameterfv_size(GLenum);
|
||||
extern INTERNAL PURE FASTCALL GLint __glGetMinmaxParameteriv_size(GLenum);
|
||||
extern INTERNAL PURE FASTCALL GLint __glGetProgramivNV_size(GLenum);
|
||||
extern INTERNAL PURE FASTCALL GLint __glGetProgramivARB_size(GLenum);
|
||||
extern INTERNAL PURE FASTCALL GLint __glGetVertexAttribdvARB_size(GLenum);
|
||||
extern INTERNAL PURE FASTCALL GLint __glGetVertexAttribfvARB_size(GLenum);
|
||||
extern INTERNAL PURE FASTCALL GLint __glGetVertexAttribivARB_size(GLenum);
|
||||
extern INTERNAL PURE FASTCALL GLint __glGetProgramivARB_size(GLenum);
|
||||
extern INTERNAL PURE FASTCALL GLint __glGetQueryivARB_size(GLenum);
|
||||
extern INTERNAL PURE FASTCALL GLint __glGetQueryObjectivARB_size(GLenum);
|
||||
extern INTERNAL PURE FASTCALL GLint __glGetQueryObjectuivARB_size(GLenum);
|
||||
extern INTERNAL PURE FASTCALL GLint __glGetQueryivARB_size(GLenum);
|
||||
extern INTERNAL PURE FASTCALL GLint __glGetColorTableParameterfvSGI_size(GLenum);
|
||||
extern INTERNAL PURE FASTCALL GLint __glGetColorTableParameterivSGI_size(GLenum);
|
||||
extern INTERNAL PURE FASTCALL GLint __glGetProgramivNV_size(GLenum);
|
||||
extern INTERNAL PURE FASTCALL GLint __glGetVertexAttribdvNV_size(GLenum);
|
||||
extern INTERNAL PURE FASTCALL GLint __glGetVertexAttribfvNV_size(GLenum);
|
||||
extern INTERNAL PURE FASTCALL GLint __glGetVertexAttribivNV_size(GLenum);
|
||||
|
|
1552
GL/glx/indirect_table.c
Normal file
1552
GL/glx/indirect_table.c
Normal file
File diff suppressed because it is too large
Load Diff
106
GL/glx/indirect_table.h
Normal file
106
GL/glx/indirect_table.h
Normal file
|
@ -0,0 +1,106 @@
|
|||
/*
|
||||
* (C) Copyright IBM Corporation 2005, 2006
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* 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, sub license,
|
||||
* 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 (including the next
|
||||
* paragraph) 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 NON-INFRINGEMENT. IN NO EVENT SHALL
|
||||
* IBM,
|
||||
* AND/OR THEIR SUPPLIERS 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.
|
||||
*/
|
||||
|
||||
/**
|
||||
* \file indirect_table.h
|
||||
*
|
||||
* \author Ian Romanick <idr@us.ibm.com>
|
||||
*/
|
||||
|
||||
#ifndef INDIRECT_TABLE_H
|
||||
#define INDIRECT_TABLE_H
|
||||
|
||||
#include <inttypes.h>
|
||||
|
||||
/**
|
||||
*/
|
||||
struct __glXDispatchInfo {
|
||||
/**
|
||||
* Number of significant bits in the protocol opcode. Opcodes with values
|
||||
* larger than ((1 << bits) - 1) are invalid.
|
||||
*/
|
||||
unsigned bits;
|
||||
|
||||
/**
|
||||
*/
|
||||
const int_fast16_t * dispatch_tree;
|
||||
|
||||
/**
|
||||
* Array of protocol decode and dispatch functions index by the opcode
|
||||
* search tree (i.e., \c dispatch_tree). The first element in each pair
|
||||
* is the non-byte-swapped version, and the second element is the
|
||||
* byte-swapped version.
|
||||
*/
|
||||
const void *(*dispatch_functions)[2];
|
||||
|
||||
/**
|
||||
* Pointer to size validation data. This table is indexed with the same
|
||||
* value as ::dispatch_functions.
|
||||
*
|
||||
* The first element in the pair is the size, in bytes, of the fixed-size
|
||||
* portion of the protocol.
|
||||
*
|
||||
* For opcodes that have a variable-size portion, the second value is an
|
||||
* index in \c size_func_table to calculate that size. If there is no
|
||||
* variable-size portion, this index will be ~0.
|
||||
*
|
||||
* \note
|
||||
* If size checking is not to be performed on this type of protocol
|
||||
* data, this pointer will be \c NULL.
|
||||
*/
|
||||
const int_fast16_t (*size_table)[2];
|
||||
|
||||
/**
|
||||
* Array of functions used to calculate the variable-size portion of
|
||||
* protocol messages. Indexed by the second element of the entries
|
||||
* in \c ::size_table.
|
||||
*
|
||||
* \note
|
||||
* If size checking is not to be performed on this type of protocol
|
||||
* data, this pointer will be \c NULL.
|
||||
*/
|
||||
const gl_proto_size_func *size_func_table;
|
||||
};
|
||||
|
||||
/**
|
||||
* Sentinel value for an empty leaf in the \c dispatch_tree.
|
||||
*/
|
||||
#define EMPTY_LEAF INT_FAST16_MIN
|
||||
|
||||
/**
|
||||
* Declare the index \c x as a leaf index.
|
||||
*/
|
||||
#define LEAF(x) -x
|
||||
|
||||
/**
|
||||
* Determine if an index is a leaf index.
|
||||
*/
|
||||
#define IS_LEAF_INDEX(x) ((x) <= 0)
|
||||
|
||||
extern const struct __glXDispatchInfo Single_dispatch_info;
|
||||
extern const struct __glXDispatchInfo Render_dispatch_info;
|
||||
extern const struct __glXDispatchInfo VendorPriv_dispatch_info;
|
||||
|
||||
#endif /* INDIRECT_TABLE_H */
|
|
@ -52,6 +52,7 @@
|
|||
#include "glthread.h"
|
||||
#include "dispatch.h"
|
||||
#include "glxext.h"
|
||||
#include "indirect_table.h"
|
||||
#include "indirect_util.h"
|
||||
|
||||
|
||||
|
@ -204,3 +205,114 @@ __glXSendReplySwap( ClientPtr client, const void * data, size_t elements,
|
|||
WriteToClient( client, reply_ints * 4, (char *) data );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static int
|
||||
get_decode_index(const struct __glXDispatchInfo *dispatch_info,
|
||||
unsigned opcode)
|
||||
{
|
||||
int remaining_bits;
|
||||
int next_remain;
|
||||
const int_fast16_t * const tree = dispatch_info->dispatch_tree;
|
||||
int_fast16_t index;
|
||||
|
||||
|
||||
remaining_bits = dispatch_info->bits;
|
||||
if (opcode >= (1U << remaining_bits)) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
index = 0;
|
||||
for (/* empty */; remaining_bits > 0; remaining_bits = next_remain) {
|
||||
unsigned mask;
|
||||
unsigned child_index;
|
||||
|
||||
|
||||
/* Calculate the slice of bits used by this node.
|
||||
*
|
||||
* If remaining_bits = 8 and tree[index] = 3, the mask of just the
|
||||
* remaining bits is 0x00ff and the mask for the remaining bits after
|
||||
* this node is 0x001f. By taking 0x00ff & ~0x001f, we get 0x00e0.
|
||||
* This masks the 3 bits that we would want for this node.
|
||||
*/
|
||||
|
||||
next_remain = remaining_bits - tree[index];
|
||||
mask = ((1 << remaining_bits) - 1) &
|
||||
~((1 << next_remain) - 1);
|
||||
|
||||
|
||||
/* Using the mask, calculate the index of the opcode in the node.
|
||||
* With that index, fetch the index of the next node.
|
||||
*/
|
||||
|
||||
child_index = (opcode & mask) >> next_remain;
|
||||
index = tree[index + 1 + child_index];
|
||||
|
||||
|
||||
/* If the next node is an empty leaf, the opcode is for a non-existant
|
||||
* function. We're done.
|
||||
*
|
||||
* If the next node is a non-empty leaf, look up the function pointer
|
||||
* and return it.
|
||||
*/
|
||||
|
||||
if (index == EMPTY_LEAF) {
|
||||
return -1;
|
||||
}
|
||||
else if (IS_LEAF_INDEX(index)) {
|
||||
unsigned func_index;
|
||||
|
||||
|
||||
/* The value stored in the tree for a leaf node is the base of
|
||||
* the function pointers for that leaf node. The offset for the
|
||||
* function for a particular opcode is the remaining bits in the
|
||||
* opcode.
|
||||
*/
|
||||
|
||||
func_index = -index;
|
||||
func_index += opcode & ((1 << next_remain) - 1);
|
||||
return func_index;
|
||||
}
|
||||
}
|
||||
|
||||
/* We should *never* get here!!!
|
||||
*/
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
void *
|
||||
__glXGetProtocolDecodeFunction(const struct __glXDispatchInfo *dispatch_info,
|
||||
int opcode, int swapped_version)
|
||||
{
|
||||
const int func_index = get_decode_index(dispatch_info, opcode);
|
||||
|
||||
return (func_index < 0)
|
||||
? NULL
|
||||
: (void *) dispatch_info->dispatch_functions[func_index][swapped_version];
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
__glXGetProtocolSizeData(const struct __glXDispatchInfo *dispatch_info,
|
||||
int opcode, __GLXrenderSizeData *data)
|
||||
{
|
||||
if (dispatch_info->size_table != NULL) {
|
||||
const int func_index = get_decode_index(dispatch_info, opcode);
|
||||
|
||||
if ((func_index >= 0)
|
||||
&& (dispatch_info->size_table[func_index][0] != 0)) {
|
||||
const int var_offset =
|
||||
dispatch_info->size_table[func_index][1];
|
||||
|
||||
data->bytes = dispatch_info->size_table[func_index][0];
|
||||
data->varsize = (var_offset != ~0)
|
||||
? dispatch_info->size_func_table[var_offset]
|
||||
: NULL;
|
||||
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
|
|
@ -40,4 +40,14 @@ extern void __glXSendReplySwap( ClientPtr client, const void * data,
|
|||
size_t elements, size_t element_size, GLboolean always_array,
|
||||
CARD32 retval );
|
||||
|
||||
struct __glXDispatchInfo;
|
||||
|
||||
extern void *__glXGetProtocolDecodeFunction(
|
||||
const struct __glXDispatchInfo *dispatch_info, int opcode,
|
||||
int swapped_version);
|
||||
|
||||
extern int __glXGetProtocolSizeData(
|
||||
const struct __glXDispatchInfo *dispatch_info, int opcode,
|
||||
__GLXrenderSizeData *data);
|
||||
|
||||
#endif /* __GLX_INDIRECT_UTIL_H__ */
|
||||
|
|
|
@ -323,7 +323,7 @@ int __glXTypeSize(GLenum enm)
|
|||
}
|
||||
}
|
||||
|
||||
int __glXDrawArraysSize( const GLbyte *pc, Bool swap )
|
||||
int __glXDrawArraysReqSize( const GLbyte *pc, Bool swap )
|
||||
{
|
||||
__GLXdispatchDrawArraysHeader *hdr = (__GLXdispatchDrawArraysHeader *) pc;
|
||||
__GLXdispatchDrawArraysComponentHeader *compHeader;
|
||||
|
|
2552
GL/glx/rensizetab.c
2552
GL/glx/rensizetab.c
File diff suppressed because it is too large
Load Diff
|
@ -392,3 +392,13 @@ int __glXDisp_GetString(__GLXclientState *cl, GLbyte *pc)
|
|||
{
|
||||
return DoGetString(cl, pc, GL_FALSE);
|
||||
}
|
||||
|
||||
int __glXDisp_GetProgramStringARB(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
return BadRequest;
|
||||
}
|
||||
|
||||
int __glXDisp_GetProgramStringNV(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
return BadRequest;
|
||||
}
|
||||
|
|
|
@ -270,3 +270,13 @@ int __glXDispSwap_GetString(__GLXclientState *cl, GLbyte *pc)
|
|||
{
|
||||
return DoGetString(cl, pc, GL_TRUE);
|
||||
}
|
||||
|
||||
int __glXDispSwap_GetProgramStringARB(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
return BadRequest;
|
||||
}
|
||||
|
||||
int __glXDispSwap_GetProgramStringNV(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
return BadRequest;
|
||||
}
|
||||
|
|
|
@ -462,3 +462,61 @@ int __glXDisp_GetColorTable(__GLXclientState *cl, GLbyte *pc)
|
|||
|
||||
return Success;
|
||||
}
|
||||
|
||||
int __glXDisp_GetColorTableSGI(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
GLint compsize;
|
||||
GLenum format, type, target;
|
||||
GLboolean swapBytes;
|
||||
__GLXcontext *cx;
|
||||
ClientPtr client = cl->client;
|
||||
int error;
|
||||
char *answer, answerBuffer[200];
|
||||
GLint width=0;
|
||||
|
||||
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
|
||||
if (!cx) {
|
||||
return error;
|
||||
}
|
||||
|
||||
pc += __GLX_VENDPRIV_HDR_SIZE;
|
||||
target = *(GLenum *)(pc + 0);
|
||||
format = *(GLenum *)(pc + 4);
|
||||
type = *(GLenum *)(pc + 8);
|
||||
swapBytes = *(GLboolean *)(pc + 12);
|
||||
|
||||
CALL_GetColorTableParameterivSGI( GET_DISPATCH(), (target, GL_COLOR_TABLE_WIDTH, &width) );
|
||||
/*
|
||||
* The one query above might fail if we're in a state where queries
|
||||
* are illegal, but then width would still be zero anyway.
|
||||
*/
|
||||
compsize = __glGetTexImage_size(target,1,format,type,width,1,1);
|
||||
if (compsize < 0) compsize = 0;
|
||||
|
||||
CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, swapBytes) );
|
||||
__GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
|
||||
__glXClearErrorOccured();
|
||||
CALL_GetColorTableSGI( GET_DISPATCH(), (
|
||||
*(GLenum *)(pc + 0),
|
||||
*(GLenum *)(pc + 4),
|
||||
*(GLenum *)(pc + 8),
|
||||
answer
|
||||
) );
|
||||
|
||||
if (__glXErrorOccured()) {
|
||||
__GLX_BEGIN_REPLY(0);
|
||||
__GLX_SEND_HEADER();
|
||||
} else {
|
||||
__GLX_BEGIN_REPLY(compsize);
|
||||
((xGLXGetColorTableReply *)&__glXReply)->width = width;
|
||||
__GLX_SEND_HEADER();
|
||||
__GLX_SEND_VOID_ARRAY(compsize);
|
||||
}
|
||||
|
||||
return Success;
|
||||
}
|
||||
|
||||
int __glXDisp_GetCompressedTexImageARB(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
return BadRequest;
|
||||
}
|
||||
|
|
|
@ -517,3 +517,67 @@ int __glXDispSwap_GetColorTable(__GLXclientState *cl, GLbyte *pc)
|
|||
|
||||
return Success;
|
||||
}
|
||||
|
||||
int __glXDispSwap_GetColorTableSGI(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
GLint compsize;
|
||||
GLenum format, type, target;
|
||||
GLboolean swapBytes;
|
||||
__GLXcontext *cx;
|
||||
ClientPtr client = cl->client;
|
||||
int error;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
char *answer, answerBuffer[200];
|
||||
GLint width=0;
|
||||
|
||||
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
|
||||
if (!cx) {
|
||||
return error;
|
||||
}
|
||||
|
||||
pc += __GLX_VENDPRIV_HDR_SIZE;
|
||||
__GLX_SWAP_INT(pc+0);
|
||||
__GLX_SWAP_INT(pc+4);
|
||||
__GLX_SWAP_INT(pc+8);
|
||||
|
||||
format = *(GLenum *)(pc + 4);
|
||||
type = *(GLenum *)(pc + 8);
|
||||
target = *(GLenum *)(pc + 0);
|
||||
swapBytes = *(GLboolean *)(pc + 12);
|
||||
|
||||
CALL_GetColorTableParameterivSGI( GET_DISPATCH(), (target, GL_COLOR_TABLE_WIDTH, &width) );
|
||||
/*
|
||||
* The one query above might fail if we're in a state where queries
|
||||
* are illegal, but then width would still be zero anyway.
|
||||
*/
|
||||
compsize = __glGetTexImage_size(target,1,format,type,width,1,1);
|
||||
if (compsize < 0) compsize = 0;
|
||||
|
||||
CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, !swapBytes) );
|
||||
__GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
|
||||
__glXClearErrorOccured();
|
||||
CALL_GetColorTableSGI( GET_DISPATCH(), (
|
||||
*(GLenum *)(pc + 0),
|
||||
*(GLenum *)(pc + 4),
|
||||
*(GLenum *)(pc + 8),
|
||||
answer
|
||||
) );
|
||||
|
||||
if (__glXErrorOccured()) {
|
||||
__GLX_BEGIN_REPLY(0);
|
||||
__GLX_SWAP_REPLY_HEADER();
|
||||
} else {
|
||||
__GLX_BEGIN_REPLY(compsize);
|
||||
__GLX_SWAP_REPLY_HEADER();
|
||||
__GLX_SWAP_INT(&width);
|
||||
((xGLXGetColorTableReply *)&__glXReply)->width = width;
|
||||
__GLX_SEND_VOID_ARRAY(compsize);
|
||||
}
|
||||
|
||||
return Success;
|
||||
}
|
||||
|
||||
int __glXDispSwap_GetCompressedTexImageARB(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
return BadRequest;
|
||||
}
|
||||
|
|
|
@ -47,6 +47,7 @@
|
|||
#include "glapi.h"
|
||||
#include "glthread.h"
|
||||
#include "dispatch.h"
|
||||
#include "indirect_dispatch.h"
|
||||
#include <GL/gl.h>
|
||||
#include <pixmapstr.h>
|
||||
#include <windowstr.h>
|
||||
|
@ -156,7 +157,7 @@ MakeBitmapsFromFont(FontPtr pFont, int first, int count, int list_base)
|
|||
|
||||
/************************************************************************/
|
||||
|
||||
int __glXUseXFont(__GLXclientState *cl, GLbyte *pc)
|
||||
int __glXDisp_UseXFont(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
ClientPtr client = cl->client;
|
||||
xGLXUseXFontReq *req;
|
||||
|
|
|
@ -468,7 +468,7 @@ symlink_mesa_shader_slang_library() {
|
|||
action slang_core_gc.h
|
||||
action slang_fragment_builtin_gc.h
|
||||
action slang_shader_syn.h
|
||||
action slang_version_syn.h
|
||||
action slang_pp_version_syn.h
|
||||
action slang_vertex_builtin_gc.h
|
||||
}
|
||||
|
||||
|
|
|
@ -174,6 +174,7 @@ dnl glibc backtrace support check (hw/xfree86/common/xf86Events.c)
|
|||
AC_CHECK_HEADER([execinfo.h],[
|
||||
AC_CHECK_LIB(c, backtrace, [
|
||||
AC_DEFINE(HAVE_BACKTRACE, 1, [Has backtrace support])
|
||||
AC_DEFINE(HAVE_EXECINFO_H, 1, [Have execinfo.h])
|
||||
])]
|
||||
)
|
||||
|
||||
|
@ -1165,6 +1166,10 @@ int main () {
|
|||
fi
|
||||
AC_SUBST([SOLARIS_ASM_CFLAGS])
|
||||
;;
|
||||
gnu*)
|
||||
XORG_OS="gnu"
|
||||
XORG_OS_SUBDIR="hurd"
|
||||
;;
|
||||
*)
|
||||
XORG_OS="unknown"
|
||||
XORG_OS_SUBDIR="unknown"
|
||||
|
@ -1669,6 +1674,7 @@ hw/xfree86/os-support/Makefile
|
|||
hw/xfree86/os-support/bsd/Makefile
|
||||
hw/xfree86/os-support/bus/Makefile
|
||||
hw/xfree86/os-support/drm/Makefile
|
||||
hw/xfree86/os-support/hurd/Makefile
|
||||
hw/xfree86/os-support/misc/Makefile
|
||||
hw/xfree86/os-support/linux/Makefile
|
||||
hw/xfree86/os-support/lynxos/Makefile
|
||||
|
|
|
@ -667,13 +667,7 @@ InitPtrFeedbackClassDeviceStruct(DeviceIntPtr dev, PtrCtrlProcPtr controlProc)
|
|||
if (!feedc)
|
||||
return FALSE;
|
||||
feedc->CtrlProc = controlProc;
|
||||
#ifdef sgi
|
||||
feedc->ctrl.num = 1;
|
||||
feedc->ctrl.den = 1;
|
||||
feedc->ctrl.threshold = 1;
|
||||
#else
|
||||
feedc->ctrl = defaultPointerControl;
|
||||
#endif
|
||||
feedc->ctrl.id = 0;
|
||||
if ( (feedc->next = dev->ptrfeed) )
|
||||
feedc->ctrl.id = dev->ptrfeed->ctrl.id + 1;
|
||||
|
|
89
dix/events.c
89
dix/events.c
|
@ -458,13 +458,7 @@ XineramaCheckVirtualMotion(
|
|||
if (qe)
|
||||
{
|
||||
sprite.hot.pScreen = qe->pScreen; /* should always be Screen 0 */
|
||||
#ifdef XEVIE
|
||||
xeviehot.x =
|
||||
#endif
|
||||
sprite.hot.x = qe->event->u.keyButtonPointer.rootX;
|
||||
#ifdef XEVIE
|
||||
xeviehot.y =
|
||||
#endif
|
||||
sprite.hot.y = qe->event->u.keyButtonPointer.rootY;
|
||||
pWin = inputInfo.pointer->grab ? inputInfo.pointer->grab->confineTo :
|
||||
NullWindow;
|
||||
|
@ -501,24 +495,12 @@ XineramaCheckVirtualMotion(
|
|||
lims = *REGION_EXTENTS(sprite.screen, &sprite.Reg2);
|
||||
|
||||
if (sprite.hot.x < lims.x1)
|
||||
#ifdef XEVIE
|
||||
xeviehot.x =
|
||||
#endif
|
||||
sprite.hot.x = lims.x1;
|
||||
else if (sprite.hot.x >= lims.x2)
|
||||
#ifdef XEVIE
|
||||
xeviehot.x =
|
||||
#endif
|
||||
sprite.hot.x = lims.x2 - 1;
|
||||
if (sprite.hot.y < lims.y1)
|
||||
#ifdef XEVIE
|
||||
xeviehot.y =
|
||||
#endif
|
||||
sprite.hot.y = lims.y1;
|
||||
else if (sprite.hot.y >= lims.y2)
|
||||
#ifdef XEVIE
|
||||
xeviehot.y =
|
||||
#endif
|
||||
sprite.hot.y = lims.y2 - 1;
|
||||
|
||||
if (REGION_NUM_RECTS(&sprite.Reg2) > 1)
|
||||
|
@ -531,6 +513,10 @@ XineramaCheckVirtualMotion(
|
|||
qe->event->u.keyButtonPointer.rootY = sprite.hot.y;
|
||||
}
|
||||
}
|
||||
#ifdef XEVIE
|
||||
xeviehot.x = sprite.hot.x;
|
||||
xeviehot.y = sprite.hot.y;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
|
@ -548,33 +534,15 @@ XineramaCheckMotion(xEvent *xE)
|
|||
panoramiXdataPtr[0].x;
|
||||
XE_KBPTR.rootY += panoramiXdataPtr[sprite.screen->myNum].y -
|
||||
panoramiXdataPtr[0].y;
|
||||
#ifdef XEVIE
|
||||
xeviehot.x =
|
||||
#endif
|
||||
sprite.hot.x = XE_KBPTR.rootX;
|
||||
#ifdef XEVIE
|
||||
xeviehot.y =
|
||||
#endif
|
||||
sprite.hot.y = XE_KBPTR.rootY;
|
||||
if (sprite.hot.x < sprite.physLimits.x1)
|
||||
#ifdef XEVIE
|
||||
xeviehot.x =
|
||||
#endif
|
||||
sprite.hot.x = sprite.physLimits.x1;
|
||||
else if (sprite.hot.x >= sprite.physLimits.x2)
|
||||
#ifdef XEVIE
|
||||
xeviehot.x =
|
||||
#endif
|
||||
sprite.hot.x = sprite.physLimits.x2 - 1;
|
||||
if (sprite.hot.y < sprite.physLimits.y1)
|
||||
#ifdef XEVIE
|
||||
xeviehot.y =
|
||||
#endif
|
||||
sprite.hot.y = sprite.physLimits.y1;
|
||||
else if (sprite.hot.y >= sprite.physLimits.y2)
|
||||
#ifdef XEVIE
|
||||
xeviehot.y =
|
||||
#endif
|
||||
sprite.hot.y = sprite.physLimits.y2 - 1;
|
||||
|
||||
if (sprite.hotShape)
|
||||
|
@ -592,6 +560,8 @@ XineramaCheckMotion(xEvent *xE)
|
|||
}
|
||||
|
||||
#ifdef XEVIE
|
||||
xeviehot.x = sprite.hot.x;
|
||||
xeviehot.y = sprite.hot.y;
|
||||
xeviewin =
|
||||
#endif
|
||||
sprite.win = XYToWindow(sprite.hot.x, sprite.hot.y);
|
||||
|
@ -817,13 +787,7 @@ CheckVirtualMotion(
|
|||
if (qe)
|
||||
{
|
||||
sprite.hot.pScreen = qe->pScreen;
|
||||
#ifdef XEVIE
|
||||
xeviehot.x =
|
||||
#endif
|
||||
sprite.hot.x = qe->event->u.keyButtonPointer.rootX;
|
||||
#ifdef XEVIE
|
||||
xeviehot.y =
|
||||
#endif
|
||||
sprite.hot.y = qe->event->u.keyButtonPointer.rootY;
|
||||
pWin = inputInfo.pointer->grab ? inputInfo.pointer->grab->confineTo :
|
||||
NullWindow;
|
||||
|
@ -835,31 +799,16 @@ CheckVirtualMotion(
|
|||
if (sprite.hot.pScreen != pWin->drawable.pScreen)
|
||||
{
|
||||
sprite.hot.pScreen = pWin->drawable.pScreen;
|
||||
#ifdef XEVIE
|
||||
xeviehot.x = xeviehot.y = 0;
|
||||
#endif
|
||||
sprite.hot.x = sprite.hot.y = 0;
|
||||
}
|
||||
lims = *REGION_EXTENTS(pWin->drawable.pScreen, &pWin->borderSize);
|
||||
if (sprite.hot.x < lims.x1)
|
||||
#ifdef XEVIE
|
||||
xeviehot.x =
|
||||
#endif
|
||||
sprite.hot.x = lims.x1;
|
||||
else if (sprite.hot.x >= lims.x2)
|
||||
#ifdef XEVIE
|
||||
xeviehot.x =
|
||||
#endif
|
||||
sprite.hot.x = lims.x2 - 1;
|
||||
if (sprite.hot.y < lims.y1)
|
||||
#ifdef XEVIE
|
||||
xeviehot.y =
|
||||
#endif
|
||||
sprite.hot.y = lims.y1;
|
||||
else if (sprite.hot.y >= lims.y2)
|
||||
#ifdef XEVIE
|
||||
xeviehot.y =
|
||||
#endif
|
||||
sprite.hot.y = lims.y2 - 1;
|
||||
#ifdef SHAPE
|
||||
if (wBoundingShape(pWin))
|
||||
|
@ -872,6 +821,10 @@ CheckVirtualMotion(
|
|||
qe->event->u.keyButtonPointer.rootY = sprite.hot.y;
|
||||
}
|
||||
}
|
||||
#ifdef XEVIE
|
||||
xeviehot.x = sprite.hot.x;
|
||||
xeviehot.y = sprite.hot.y;
|
||||
#endif
|
||||
ROOT = WindowTable[sprite.hot.pScreen->myNum];
|
||||
}
|
||||
|
||||
|
@ -2053,37 +2006,23 @@ CheckMotion(xEvent *xE)
|
|||
sprite.hot.pScreen = sprite.hotPhys.pScreen;
|
||||
ROOT = WindowTable[sprite.hot.pScreen->myNum];
|
||||
}
|
||||
#ifdef XEVIE
|
||||
xeviehot.x =
|
||||
#endif
|
||||
sprite.hot.x = XE_KBPTR.rootX;
|
||||
#ifdef XEVIE
|
||||
xeviehot.y =
|
||||
#endif
|
||||
sprite.hot.y = XE_KBPTR.rootY;
|
||||
if (sprite.hot.x < sprite.physLimits.x1)
|
||||
#ifdef XEVIE
|
||||
xeviehot.x =
|
||||
#endif
|
||||
sprite.hot.x = sprite.physLimits.x1;
|
||||
else if (sprite.hot.x >= sprite.physLimits.x2)
|
||||
#ifdef XEVIE
|
||||
xeviehot.x =
|
||||
#endif
|
||||
sprite.hot.x = sprite.physLimits.x2 - 1;
|
||||
if (sprite.hot.y < sprite.physLimits.y1)
|
||||
#ifdef XEVIE
|
||||
xeviehot.y =
|
||||
#endif
|
||||
sprite.hot.y = sprite.physLimits.y1;
|
||||
else if (sprite.hot.y >= sprite.physLimits.y2)
|
||||
#ifdef XEVIE
|
||||
xeviehot.y =
|
||||
#endif
|
||||
sprite.hot.y = sprite.physLimits.y2 - 1;
|
||||
#ifdef SHAPE
|
||||
if (sprite.hotShape)
|
||||
ConfineToShape(sprite.hotShape, &sprite.hot.x, &sprite.hot.y);
|
||||
#endif
|
||||
#ifdef XEVIE
|
||||
xeviehot.x = sprite.hot.x;
|
||||
xeviehot.y = sprite.hot.y;
|
||||
#endif
|
||||
sprite.hotPhys = sprite.hot;
|
||||
if ((sprite.hotPhys.x != XE_KBPTR.rootX) ||
|
||||
|
|
|
@ -143,6 +143,7 @@ FontPtr defaultFont; /* not declared in dix.h to avoid including font.h in
|
|||
Bool loadableFonts = FALSE;
|
||||
CursorPtr rootCursor;
|
||||
Bool blackRoot=FALSE;
|
||||
Bool whiteRoot=FALSE;
|
||||
ClientPtr requestingClient; /* XXX this should be obsolete now, remove? */
|
||||
|
||||
_X_EXPORT TimeStamp currentTime;
|
||||
|
|
21
dix/window.c
21
dix/window.c
|
@ -343,9 +343,6 @@ MakeRootTile(WindowPtr pWin)
|
|||
for (j = len; j > 0; j--)
|
||||
*to++ = *from;
|
||||
|
||||
if (blackRoot)
|
||||
bzero(back, sizeof(back));
|
||||
|
||||
(*pGC->ops->PutImage)((DrawablePtr)pWin->background.pixmap, pGC, 1,
|
||||
0, 0, len, 4, 0, XYBitmap, (char *)back);
|
||||
|
||||
|
@ -506,6 +503,7 @@ void
|
|||
InitRootWindow(WindowPtr pWin)
|
||||
{
|
||||
ScreenPtr pScreen = pWin->drawable.pScreen;
|
||||
int backFlag = CWBorderPixel | CWCursor | CWBackingStore;
|
||||
|
||||
if (!(*pScreen->CreateWindow)(pWin))
|
||||
return; /* XXX */
|
||||
|
@ -514,12 +512,23 @@ InitRootWindow(WindowPtr pWin)
|
|||
pWin->cursorIsNone = FALSE;
|
||||
pWin->optional->cursor = rootCursor;
|
||||
rootCursor->refcnt++;
|
||||
MakeRootTile(pWin);
|
||||
|
||||
if (!blackRoot && !whiteRoot) {
|
||||
MakeRootTile(pWin);
|
||||
backFlag |= CWBackPixmap;
|
||||
}
|
||||
else {
|
||||
if (blackRoot)
|
||||
pWin->background.pixel = pScreen->blackPixel;
|
||||
else
|
||||
pWin->background.pixel = pScreen->whitePixel;
|
||||
backFlag |= CWBackPixel;
|
||||
}
|
||||
|
||||
pWin->backingStore = defaultBackingStore;
|
||||
pWin->forcedBS = (defaultBackingStore != NotUseful);
|
||||
/* We SHOULD check for an error value here XXX */
|
||||
(*pScreen->ChangeWindowAttributes)(pWin,
|
||||
CWBackPixmap|CWBorderPixel|CWCursor|CWBackingStore);
|
||||
(*pScreen->ChangeWindowAttributes)(pWin, backFlag);
|
||||
|
||||
MapWindow(pWin, serverClient);
|
||||
}
|
||||
|
|
|
@ -452,24 +452,72 @@ exaTryDriverComposite(CARD8 op,
|
|||
return 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* exaTryMagicTwoPassCompositeHelper implements PictOpOver using two passes of
|
||||
* simpler operations PictOpOutReverse and PictOpAdd. Mainly used for component
|
||||
* alpha and limited 1-tmu cards.
|
||||
*
|
||||
* From http://anholt.livejournal.com/32058.html:
|
||||
*
|
||||
* The trouble is that component-alpha rendering requires two different sources
|
||||
* for blending: one for the source value to the blender, which is the
|
||||
* per-channel multiplication of source and mask, and one for the source alpha
|
||||
* for multiplying with the destination channels, which is the multiplication
|
||||
* of the source channels by the mask alpha. So the equation for Over is:
|
||||
*
|
||||
* dst.A = src.A * mask.A + (1 - (src.A * mask.A)) * dst.A
|
||||
* dst.R = src.R * mask.R + (1 - (src.A * mask.R)) * dst.R
|
||||
* dst.G = src.G * mask.G + (1 - (src.A * mask.G)) * dst.G
|
||||
* dst.B = src.B * mask.B + (1 - (src.A * mask.B)) * dst.B
|
||||
*
|
||||
* But we can do some simpler operations, right? How about PictOpOutReverse,
|
||||
* which has a source factor of 0 and dest factor of (1 - source alpha). We
|
||||
* can get the source alpha value (srca.X = src.A * mask.X) out of the texture
|
||||
* blenders pretty easily. So we can do a component-alpha OutReverse, which
|
||||
* gets us:
|
||||
*
|
||||
* dst.A = 0 + (1 - (src.A * mask.A)) * dst.A
|
||||
* dst.R = 0 + (1 - (src.A * mask.R)) * dst.R
|
||||
* dst.G = 0 + (1 - (src.A * mask.G)) * dst.G
|
||||
* dst.B = 0 + (1 - (src.A * mask.B)) * dst.B
|
||||
*
|
||||
* OK. And if an op doesn't use the source alpha value for the destination
|
||||
* factor, then we can do the channel multiplication in the texture blenders
|
||||
* to get the source value, and ignore the source alpha that we wouldn't use.
|
||||
* We've supported this in the Radeon driver for a long time. An example would
|
||||
* be PictOpAdd, which does:
|
||||
*
|
||||
* dst.A = src.A * mask.A + dst.A
|
||||
* dst.R = src.R * mask.R + dst.R
|
||||
* dst.G = src.G * mask.G + dst.G
|
||||
* dst.B = src.B * mask.B + dst.B
|
||||
*
|
||||
* Hey, this looks good! If we do a PictOpOutReverse and then a PictOpAdd right
|
||||
* after it, we get:
|
||||
*
|
||||
* dst.A = src.A * mask.A + ((1 - (src.A * mask.A)) * dst.A)
|
||||
* dst.R = src.R * mask.R + ((1 - (src.A * mask.R)) * dst.R)
|
||||
* dst.G = src.G * mask.G + ((1 - (src.A * mask.G)) * dst.G)
|
||||
* dst.B = src.B * mask.B + ((1 - (src.A * mask.B)) * dst.B)
|
||||
*/
|
||||
|
||||
static int
|
||||
exaTryComponentAlphaHelper(CARD8 op,
|
||||
PicturePtr pSrc,
|
||||
PicturePtr pMask,
|
||||
PicturePtr pDst,
|
||||
INT16 xSrc,
|
||||
INT16 ySrc,
|
||||
INT16 xMask,
|
||||
INT16 yMask,
|
||||
INT16 xDst,
|
||||
INT16 yDst,
|
||||
CARD16 width,
|
||||
CARD16 height)
|
||||
exaTryMagicTwoPassCompositeHelper(CARD8 op,
|
||||
PicturePtr pSrc,
|
||||
PicturePtr pMask,
|
||||
PicturePtr pDst,
|
||||
INT16 xSrc,
|
||||
INT16 ySrc,
|
||||
INT16 xMask,
|
||||
INT16 yMask,
|
||||
INT16 xDst,
|
||||
INT16 yDst,
|
||||
CARD16 width,
|
||||
CARD16 height)
|
||||
{
|
||||
ExaScreenPriv (pDst->pDrawable->pScreen);
|
||||
|
||||
assert(op == PictOpOver);
|
||||
assert(pMask->componentAlpha == TRUE);
|
||||
|
||||
if (pExaScr->info->CheckComposite &&
|
||||
(!(*pExaScr->info->CheckComposite)(PictOpOutReverse, pSrc, pMask,
|
||||
|
@ -580,19 +628,30 @@ exaComposite(CARD8 op,
|
|||
(!pMask || !pMask->repeat || pMask->repeat == RepeatNormal) &&
|
||||
!pSrc->alphaMap && (!pMask || !pMask->alphaMap) && !pDst->alphaMap)
|
||||
{
|
||||
Bool isSrcSolid;
|
||||
|
||||
ret = exaTryDriverComposite(op, pSrc, pMask, pDst, xSrc, ySrc, xMask,
|
||||
yMask, xDst, yDst, width, height);
|
||||
if (ret == 1)
|
||||
goto done;
|
||||
|
||||
/* For generic masks and solid src pictures, mach64 can do Over in two
|
||||
* passes, similar to the component-alpha case.
|
||||
*/
|
||||
isSrcSolid = pSrc->pDrawable->width == 1 &&
|
||||
pSrc->pDrawable->height == 1 &&
|
||||
pSrc->repeat;
|
||||
|
||||
/* If we couldn't do the Composite in a single pass, and it was a
|
||||
* component-alpha Over, see if we can do it in two passes with
|
||||
* an OutReverse and then an Add.
|
||||
*/
|
||||
if (ret == -1 && pMask && pMask->componentAlpha && op == PictOpOver) {
|
||||
ret = exaTryComponentAlphaHelper(op, pSrc, pMask, pDst, xSrc, ySrc,
|
||||
xMask, yMask, xDst, yDst,
|
||||
width, height);
|
||||
if (ret == -1 && op == PictOpOver && pMask &&
|
||||
(pMask->componentAlpha || isSrcSolid)) {
|
||||
ret = exaTryMagicTwoPassCompositeHelper(op, pSrc, pMask, pDst,
|
||||
xSrc, ySrc,
|
||||
xMask, yMask, xDst, yDst,
|
||||
width, height);
|
||||
if (ret == 1)
|
||||
goto done;
|
||||
}
|
||||
|
|
|
@ -364,6 +364,9 @@ ddxProcessArgument(int argc, char *argv[], int i)
|
|||
if (strcmp (argv[i], "-render") == 0) /* -render */
|
||||
{
|
||||
Render = FALSE;
|
||||
#ifdef COMPOSITE
|
||||
noCompositeExtension = TRUE;
|
||||
#endif
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
|
|
@ -3023,7 +3023,7 @@ static void
|
|||
CheckGenericGA()
|
||||
{
|
||||
/* This needs to be changed for multiple domains */
|
||||
#if !defined(__sparc__) && !defined(__powerpc__) && !defined(__mips__) && !defined(__ia64__)
|
||||
#if !defined(__sparc__) && !defined(__powerpc__) && !defined(__mips__) && !defined(__ia64__) && !defined(__arm__) && !defined(__s390__)
|
||||
IOADDRESS GenericIOBase = VGAHW_GET_IOBASE();
|
||||
CARD8 CurrentValue, TestValue;
|
||||
|
||||
|
|
|
@ -761,7 +761,8 @@ typedef enum {
|
|||
FLAG_RENDER_COLORMAP_MODE,
|
||||
FLAG_HANDLE_SPECIAL_KEYS,
|
||||
FLAG_RANDR,
|
||||
FLAG_AIGLX
|
||||
FLAG_AIGLX,
|
||||
FLAG_IGNORE_ABI
|
||||
} FlagValues;
|
||||
|
||||
static OptionInfoRec FlagOptions[] = {
|
||||
|
@ -833,6 +834,8 @@ static OptionInfoRec FlagOptions[] = {
|
|||
{0}, FALSE },
|
||||
{ FLAG_AIGLX, "AIGLX", OPTV_BOOLEAN,
|
||||
{0}, FALSE },
|
||||
{ FLAG_IGNORE_ABI, "IgnoreABI", OPTV_BOOLEAN,
|
||||
{0}, FALSE },
|
||||
{ -1, NULL, OPTV_NONE,
|
||||
{0}, FALSE },
|
||||
};
|
||||
|
@ -891,6 +894,10 @@ configServerFlags(XF86ConfFlagsPtr flagsconf, XF86OptionPtr layoutopts)
|
|||
&(xf86Info.grabInfo.allowDeactivate));
|
||||
xf86GetOptValBool(FlagOptions, FLAG_ALLOW_CLOSEDOWN_GRABS,
|
||||
&(xf86Info.grabInfo.allowClosedown));
|
||||
xf86GetOptValBool(FlagOptions, FLAG_IGNORE_ABI, &xf86Info.ignoreABI);
|
||||
if (&xf86Info.ignoreABI) {
|
||||
xf86Msg(X_CONFIG, "Ignoring ABI Version\n");
|
||||
}
|
||||
|
||||
/*
|
||||
* Set things up based on the config file information. Some of these
|
||||
|
|
|
@ -88,6 +88,9 @@ static char *DFLT_MOUSE_DEV = "/dev/devi/mouse0";
|
|||
#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
|
||||
static char *DFLT_MOUSE_DEV = "/dev/sysmouse";
|
||||
static char *DFLT_MOUSE_PROTO = "auto";
|
||||
#elif defined(linux)
|
||||
static char DFLT_MOUSE_DEV[] = "/dev/input/mice";
|
||||
static char DFLT_MOUSE_PROTO[] = "auto";
|
||||
#else
|
||||
static char *DFLT_MOUSE_DEV = "/dev/mouse";
|
||||
static char *DFLT_MOUSE_PROTO = "auto";
|
||||
|
|
|
@ -576,24 +576,40 @@ xf86InitOrigins(void)
|
|||
/* force edge lists */
|
||||
if(screen->left) {
|
||||
ref = screen->left->screennum;
|
||||
if (! xf86Screens[ref] || ! xf86Screens[ref]->pScreen) {
|
||||
ErrorF("Referenced uninitialized screen in Layout!\n");
|
||||
break;
|
||||
}
|
||||
pLayout->left = AddEdge(pLayout->left,
|
||||
0, xf86Screens[i]->pScreen->height,
|
||||
xf86Screens[ref]->pScreen->width, 0, ref);
|
||||
}
|
||||
if(screen->right) {
|
||||
ref = screen->right->screennum;
|
||||
if (! xf86Screens[ref] || ! xf86Screens[ref]->pScreen) {
|
||||
ErrorF("Referenced uninitialized screen in Layout!\n");
|
||||
break;
|
||||
}
|
||||
pScreen = xf86Screens[i]->pScreen;
|
||||
pLayout->right = AddEdge(pLayout->right,
|
||||
0, pScreen->height, -pScreen->width, 0, ref);
|
||||
}
|
||||
if(screen->top) {
|
||||
ref = screen->top->screennum;
|
||||
if (! xf86Screens[ref] || ! xf86Screens[ref]->pScreen) {
|
||||
ErrorF("Referenced uninitialized screen in Layout!\n");
|
||||
break;
|
||||
}
|
||||
pLayout->up = AddEdge(pLayout->up,
|
||||
0, xf86Screens[i]->pScreen->width,
|
||||
0, xf86Screens[ref]->pScreen->height, ref);
|
||||
}
|
||||
if(screen->bottom) {
|
||||
ref = screen->bottom->screennum;
|
||||
if (! xf86Screens[ref] || ! xf86Screens[ref]->pScreen) {
|
||||
ErrorF("Referenced uninitialized screen in Layout!\n");
|
||||
break;
|
||||
}
|
||||
pScreen = xf86Screens[i]->pScreen;
|
||||
pLayout->down = AddEdge(pLayout->down,
|
||||
0, pScreen->width, 0, -pScreen->height, ref);
|
||||
|
@ -609,6 +625,10 @@ xf86InitOrigins(void)
|
|||
break;
|
||||
case PosRelative:
|
||||
ref = screen->refscreen->screennum;
|
||||
if (! xf86Screens[ref] || ! xf86Screens[ref]->pScreen) {
|
||||
ErrorF("Referenced uninitialized screen in Layout!\n");
|
||||
break;
|
||||
}
|
||||
if(screensLeft & (1 << ref)) break;
|
||||
dixScreenOrigins[i].x = dixScreenOrigins[ref].x + screen->x;
|
||||
dixScreenOrigins[i].y = dixScreenOrigins[ref].y + screen->y;
|
||||
|
@ -616,6 +636,10 @@ xf86InitOrigins(void)
|
|||
break;
|
||||
case PosRightOf:
|
||||
ref = screen->refscreen->screennum;
|
||||
if (! xf86Screens[ref] || ! xf86Screens[ref]->pScreen) {
|
||||
ErrorF("Referenced uninitialized screen in Layout!\n");
|
||||
break;
|
||||
}
|
||||
if(screensLeft & (1 << ref)) break;
|
||||
pScreen = xf86Screens[ref]->pScreen;
|
||||
dixScreenOrigins[i].x =
|
||||
|
@ -625,6 +649,10 @@ xf86InitOrigins(void)
|
|||
break;
|
||||
case PosLeftOf:
|
||||
ref = screen->refscreen->screennum;
|
||||
if (! xf86Screens[ref] || ! xf86Screens[ref]->pScreen) {
|
||||
ErrorF("Referenced uninitialized screen in Layout!\n");
|
||||
break;
|
||||
}
|
||||
if(screensLeft & (1 << ref)) break;
|
||||
pScreen = xf86Screens[i]->pScreen;
|
||||
dixScreenOrigins[i].x =
|
||||
|
@ -634,6 +662,10 @@ xf86InitOrigins(void)
|
|||
break;
|
||||
case PosBelow:
|
||||
ref = screen->refscreen->screennum;
|
||||
if (! xf86Screens[ref] || ! xf86Screens[ref]->pScreen) {
|
||||
ErrorF("Referenced uninitialized screen in Layout!\n");
|
||||
break;
|
||||
}
|
||||
if(screensLeft & (1 << ref)) break;
|
||||
pScreen = xf86Screens[ref]->pScreen;
|
||||
dixScreenOrigins[i].x = dixScreenOrigins[ref].x;
|
||||
|
@ -643,6 +675,10 @@ xf86InitOrigins(void)
|
|||
break;
|
||||
case PosAbove:
|
||||
ref = screen->refscreen->screennum;
|
||||
if (! xf86Screens[ref] || ! xf86Screens[ref]->pScreen) {
|
||||
ErrorF("Referenced uninitialized screen in Layout!\n");
|
||||
break;
|
||||
}
|
||||
if(screensLeft & (1 << ref)) break;
|
||||
pScreen = xf86Screens[i]->pScreen;
|
||||
dixScreenOrigins[i].x = dixScreenOrigins[ref].x;
|
||||
|
|
|
@ -137,7 +137,8 @@ static int numFormats = 6;
|
|||
#endif
|
||||
static Bool formatsDone = FALSE;
|
||||
|
||||
InputDriverRec XF86KEYBOARD = {
|
||||
#ifdef USE_DEPRECATED_KEYBOARD_DRIVER
|
||||
static InputDriverRec XF86KEYBOARD = {
|
||||
1,
|
||||
"keyboard",
|
||||
NULL,
|
||||
|
@ -146,6 +147,7 @@ InputDriverRec XF86KEYBOARD = {
|
|||
NULL,
|
||||
0
|
||||
};
|
||||
#endif
|
||||
|
||||
static Bool
|
||||
xf86CreateRootWindow(WindowPtr pWin)
|
||||
|
@ -562,6 +564,10 @@ InitOutput(ScreenInfo *pScreenInfo, int argc, char **argv)
|
|||
/* Tell the loader the default module search path */
|
||||
LoaderSetPath(xf86ModulePath);
|
||||
|
||||
if (xf86Info.ignoreABI) {
|
||||
LoaderSetOptions(LDR_OPT_ABI_MISMATCH_NONFATAL);
|
||||
}
|
||||
|
||||
#ifdef TESTING
|
||||
{
|
||||
char **list, **l;
|
||||
|
|
|
@ -47,6 +47,22 @@
|
|||
#include "xf86Priv.h"
|
||||
#include "xf86DDC.h"
|
||||
|
||||
static void
|
||||
printModeRejectMessage(int index, DisplayModePtr p, int status)
|
||||
{
|
||||
char *type;
|
||||
|
||||
if (p->type & M_T_BUILTIN)
|
||||
type = "built-in ";
|
||||
else if (p->type & M_T_DEFAULT)
|
||||
type = "default ";
|
||||
else
|
||||
type = "";
|
||||
|
||||
xf86DrvMsg(index, X_INFO, "Not using %smode \"%s\" (%s)\n", type, p->name,
|
||||
xf86ModeStatusToString(status));
|
||||
}
|
||||
|
||||
/*
|
||||
* xf86GetNearestClock --
|
||||
* Find closest clock to given frequency (in kHz). This assumes the
|
||||
|
@ -1644,18 +1660,7 @@ xf86ValidateModes(ScrnInfoPtr scrp, DisplayModePtr availModes,
|
|||
q->name = xnfstrdup(p->name);
|
||||
q->status = MODE_OK;
|
||||
} else {
|
||||
if (p->type & M_T_BUILTIN)
|
||||
xf86DrvMsg(scrp->scrnIndex, X_INFO,
|
||||
"Not using built-in mode \"%s\" (%s)\n",
|
||||
p->name, xf86ModeStatusToString(status));
|
||||
else if (p->type & M_T_DEFAULT)
|
||||
xf86DrvMsg(scrp->scrnIndex, X_INFO,
|
||||
"Not using default mode \"%s\" (%s)\n", p->name,
|
||||
xf86ModeStatusToString(status));
|
||||
else
|
||||
xf86DrvMsg(scrp->scrnIndex, X_INFO,
|
||||
"Not using mode \"%s\" (%s)\n", p->name,
|
||||
xf86ModeStatusToString(status));
|
||||
printModeRejectMessage(scrp->scrnIndex, p, status);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1758,7 +1763,8 @@ xf86ValidateModes(ScrnInfoPtr scrp, DisplayModePtr availModes,
|
|||
* horizontal timing parameters that CRTs may have
|
||||
* problems with.
|
||||
*/
|
||||
if ((q->type & M_T_DEFAULT) &&
|
||||
if (!scrp->monitor->reducedblanking &&
|
||||
(q->type & M_T_DEFAULT) &&
|
||||
((double)q->HTotal / (double)q->HDisplay) < 1.15)
|
||||
continue;
|
||||
|
||||
|
@ -1795,39 +1801,14 @@ xf86ValidateModes(ScrnInfoPtr scrp, DisplayModePtr availModes,
|
|||
|
||||
repeat = FALSE;
|
||||
lookupNext:
|
||||
if (repeat && ((status = p->status) != MODE_OK)) {
|
||||
if (p->type & M_T_BUILTIN)
|
||||
xf86DrvMsg(scrp->scrnIndex, X_INFO,
|
||||
"Not using built-in mode \"%s\" (%s)\n",
|
||||
p->name, xf86ModeStatusToString(status));
|
||||
else if (p->type & M_T_DEFAULT)
|
||||
xf86DrvMsg(scrp->scrnIndex, X_INFO,
|
||||
"Not using default mode \"%s\" (%s)\n", p->name,
|
||||
xf86ModeStatusToString(status));
|
||||
else
|
||||
xf86DrvMsg(scrp->scrnIndex, X_INFO,
|
||||
"Not using mode \"%s\" (%s)\n", p->name,
|
||||
xf86ModeStatusToString(status));
|
||||
}
|
||||
if (repeat && ((status = p->status) != MODE_OK))
|
||||
printModeRejectMessage(scrp->scrnIndex, p, status);
|
||||
saveType = p->type;
|
||||
status = xf86LookupMode(scrp, p, clockRanges, strategy);
|
||||
if (repeat && status == MODE_NOMODE) {
|
||||
if (repeat && status == MODE_NOMODE)
|
||||
continue;
|
||||
}
|
||||
if (status != MODE_OK) {
|
||||
if (p->type & M_T_BUILTIN)
|
||||
xf86DrvMsg(scrp->scrnIndex, X_INFO,
|
||||
"Not using built-in mode \"%s\" (%s)\n",
|
||||
p->name, xf86ModeStatusToString(status));
|
||||
else if (p->type & M_T_DEFAULT)
|
||||
xf86DrvMsg(scrp->scrnIndex, X_INFO,
|
||||
"Not using default mode \"%s\" (%s)\n", p->name,
|
||||
xf86ModeStatusToString(status));
|
||||
else
|
||||
xf86DrvMsg(scrp->scrnIndex, X_INFO,
|
||||
"Not using mode \"%s\" (%s)\n", p->name,
|
||||
xf86ModeStatusToString(status));
|
||||
}
|
||||
if (status != MODE_OK)
|
||||
printModeRejectMessage(scrp->scrnIndex, p, status);
|
||||
if (status == MODE_ERROR) {
|
||||
ErrorF("xf86ValidateModes: "
|
||||
"unexpected result from xf86LookupMode()\n");
|
||||
|
@ -2022,20 +2003,6 @@ xf86PruneDriverModes(ScrnInfoPtr scrp)
|
|||
return;
|
||||
n = p->next;
|
||||
if (p->status != MODE_OK) {
|
||||
#if 0
|
||||
if (p->type & M_T_BUILTIN)
|
||||
xf86DrvMsg(scrp->scrnIndex, X_INFO,
|
||||
"Not using built-in mode \"%s\" (%s)\n", p->name,
|
||||
xf86ModeStatusToString(p->status));
|
||||
else if (p->type & M_T_DEFAULT)
|
||||
xf86DrvMsg(scrp->scrnIndex, X_INFO,
|
||||
"Not using default mode \"%s\" (%s)\n", p->name,
|
||||
xf86ModeStatusToString(p->status));
|
||||
else
|
||||
xf86DrvMsg(scrp->scrnIndex, X_INFO,
|
||||
"Not using mode \"%s\" (%s)\n", p->name,
|
||||
xf86ModeStatusToString(p->status));
|
||||
#endif
|
||||
xf86DeleteMode(&(scrp->modes), p);
|
||||
}
|
||||
p = n;
|
||||
|
|
|
@ -166,6 +166,7 @@ typedef struct {
|
|||
MessageType randRFrom;
|
||||
Bool aiglx;
|
||||
MessageType aiglxFrom;
|
||||
Bool ignoreABI;
|
||||
struct {
|
||||
Bool disabled; /* enable/disable deactivating
|
||||
* grabs or closing the
|
||||
|
|
|
@ -129,14 +129,19 @@ typedef enum {
|
|||
MODE_ERROR = -1 /* error condition */
|
||||
} ModeStatus;
|
||||
|
||||
/*
|
||||
* The mode sets are, from best to worst: USERDEF, DRIVER, and DEFAULT/BUILTIN.
|
||||
* Preferred will bubble a mode to the top within a set.
|
||||
*/
|
||||
# define M_T_BUILTIN 0x01 /* built-in mode */
|
||||
# define M_T_CLOCK_C (0x02 | M_T_BUILTIN) /* built-in mode - configure clock */
|
||||
# define M_T_CRTC_C (0x04 | M_T_BUILTIN) /* built-in mode - configure CRTC */
|
||||
# define M_T_CLOCK_CRTC_C (M_T_CLOCK_C | M_T_CRTC_C)
|
||||
/* built-in mode - configure CRTC and clock */
|
||||
# define M_T_PREFERRED 0x08 /* preferred mode within a set */
|
||||
# define M_T_DEFAULT 0x10 /* (VESA) default modes */
|
||||
# define M_T_USERDEF 0x20 /* One of the modes from the config file */
|
||||
# define M_T_EDID 0x40 /* Mode from the EDID info from the monitor */
|
||||
# define M_T_DRIVER 0x40 /* Supplied by the driver (EDID, etc) */
|
||||
|
||||
/* Video mode */
|
||||
typedef struct _DisplayModeRec {
|
||||
|
|
|
@ -605,6 +605,10 @@ the builtin handler will be used.
|
|||
.TP 7
|
||||
.BI "Option \*qAIGLX\*q \*q" boolean \*q
|
||||
enable or disable AIGLX. AIGLX is enabled by default.
|
||||
.TP 7
|
||||
.BI "Option \*qIgnoreABI\*q \*q" boolean \*q
|
||||
Allow modules built for a different, potentially incompatible version of
|
||||
the X server to load. Disabled by default.
|
||||
.SH MODULE SECTION
|
||||
The
|
||||
.B Module
|
||||
|
|
|
@ -3,7 +3,7 @@ DRI_SUBDIRS=drm
|
|||
endif
|
||||
|
||||
SUBDIRS = bus @XORG_OS_SUBDIR@ misc $(DRI_SUBDIRS)
|
||||
DIST_SUBDIRS = bsd bus drm misc linux lynxos solaris sysv sco usl
|
||||
DIST_SUBDIRS = bsd bus drm misc linux lynxos solaris sysv sco usl hurd
|
||||
|
||||
sdk_HEADERS = xf86_OSproc.h xf86_OSlib.h xf86_ansic.h xf86_libc.h \
|
||||
assyntax.h xf86OSKbd.h xf86OSmouse.h
|
||||
|
|
17
hw/xfree86/os-support/hurd/Makefile.am
Normal file
17
hw/xfree86/os-support/hurd/Makefile.am
Normal file
|
@ -0,0 +1,17 @@
|
|||
noinst_LTLIBRARIES = libhurd.la
|
||||
|
||||
libhurd_la_SOURCES = hurd_init.c hurd_mmap.c \
|
||||
hurd_mouse.c hurd_video.c \
|
||||
$(srcdir)/../shared/VTsw_noop.c \
|
||||
$(srcdir)/../shared/posix_tty.c \
|
||||
$(srcdir)/../shared/libc_wrapper.c \
|
||||
$(srcdir)/../shared/stdResource.c \
|
||||
$(srcdir)/../shared/stdPci.c \
|
||||
$(srcdir)/../shared/sigiostubs.c \
|
||||
$(srcdir)/../shared/pm_noop.c \
|
||||
$(srcdir)/../shared/kmod_noop.c \
|
||||
$(srcdir)/../shared/agp_noop.c
|
||||
|
||||
AM_CFLAGS = -DUSESTDRES -DHAVE_SYSV_IPC $(XORG_CFLAGS) @SERVER_DEFINES@ @LOADER_DEFINES@
|
||||
|
||||
INCLUDES = $(XORG_INCS)
|
90
hw/xfree86/os-support/hurd/hurd_init.c
Normal file
90
hw/xfree86/os-support/hurd/hurd_init.c
Normal file
|
@ -0,0 +1,90 @@
|
|||
/*
|
||||
* Copyright 1997,1998 by UCHIYAMA Yasushi
|
||||
*
|
||||
* 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 UCHIYAMA Yasushi not be used in
|
||||
* advertising or publicity pertaining to distribution of the software without
|
||||
* specific, written prior permission. UCHIYAMA Yasushi makes no representations
|
||||
* about the suitability of this software for any purpose. It is provided
|
||||
* "as is" without express or implied warranty.
|
||||
*
|
||||
* UCHIYAMA YASUSHI DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
||||
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
||||
* EVENT SHALL UCHIYAMA YASUSHI BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
||||
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
||||
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
||||
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||||
* PERFORMANCE OF THIS SOFTWARE.
|
||||
*
|
||||
*/
|
||||
/* $XFree86: xc/programs/Xserver/hw/xfree86/os-support/hurd/hurd_init.c,v 1.1 1998/08/16 10:25:48 dawes Exp $ */
|
||||
|
||||
#ifdef HAVE_XORG_CONFIG_H
|
||||
#include <xorg-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
|
||||
#include "input.h"
|
||||
#include "scrnintstr.h"
|
||||
|
||||
#include "compiler.h"
|
||||
|
||||
#include "xf86.h"
|
||||
#include "xf86Priv.h"
|
||||
#include "xf86_OSlib.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <errno.h>
|
||||
#include <sys/time.h>
|
||||
#include <sys/file.h>
|
||||
#include <assert.h>
|
||||
#include <mach.h>
|
||||
|
||||
int
|
||||
xf86ProcessArgument( int argc,char **argv, int i )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
void
|
||||
xf86UseMsg()
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
xf86OpenConsole()
|
||||
{
|
||||
if( serverGeneration == 1 )
|
||||
{
|
||||
kern_return_t err;
|
||||
mach_port_t device;
|
||||
int fd;
|
||||
err = get_privileged_ports( NULL, &device );
|
||||
if( err )
|
||||
{
|
||||
errno = err;
|
||||
FatalError( "xf86KbdInit can't get_privileged_ports. (%s)\n" , strerror(errno) );
|
||||
}
|
||||
mach_port_deallocate (mach_task_self (), device);
|
||||
|
||||
if( ( fd = open( "/dev/kbd" , O_RDONLY|O_NONBLOCK ) ) < 0 )
|
||||
{
|
||||
fprintf( stderr , "Cannot open keyboard (%s)\n",strerror(errno) );
|
||||
exit(1);
|
||||
}
|
||||
xf86Info.consoleFd = fd;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
void
|
||||
xf86CloseConsole()
|
||||
{
|
||||
close( xf86Info.consoleFd );
|
||||
return;
|
||||
}
|
96
hw/xfree86/os-support/hurd/hurd_mmap.c
Normal file
96
hw/xfree86/os-support/hurd/hurd_mmap.c
Normal file
|
@ -0,0 +1,96 @@
|
|||
/*
|
||||
* Copyright 1997 by UCHIYAMA Yasushi
|
||||
*
|
||||
* 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 UCHIYAMA Yasushi not be used in
|
||||
* advertising or publicity pertaining to distribution of the software without
|
||||
* specific, written prior permission. UCHIYAMA Yasushi makes no representations
|
||||
* about the suitability of this software for any purpose. It is provided
|
||||
* "as is" without express or implied warranty.
|
||||
*
|
||||
* UCHIYAMA YASUSHI DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
||||
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
||||
* EVENT SHALL UCHIYAMA YASUSHI BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
||||
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
||||
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
||||
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||||
* PERFORMANCE OF THIS SOFTWARE.
|
||||
*
|
||||
*/
|
||||
/* $XFree86$ */
|
||||
#ifdef HAVE_XORG_CONFIG_H
|
||||
#include <xorg-config.h>
|
||||
#endif
|
||||
|
||||
#include<mach.h>
|
||||
#include<device/device.h>
|
||||
#include<mach/machine/mach_i386.h>
|
||||
|
||||
#include <X11/X.h>
|
||||
|
||||
#include "xf86.h"
|
||||
#include "xf86Priv.h"
|
||||
#include "xf86_OSlib.h"
|
||||
|
||||
#define BIOS_SIZE 0x20000
|
||||
|
||||
int
|
||||
xf86ReadBIOS(unsigned long Base,unsigned long Offset,unsigned char *Buf,int Len)
|
||||
{
|
||||
mach_port_t device,iopl_dev;
|
||||
memory_object_t iopl_mem;
|
||||
vm_address_t addr = (vm_address_t)0; /* serach starting address */
|
||||
kern_return_t err;
|
||||
|
||||
|
||||
err = get_privileged_ports (NULL, &device);
|
||||
if( err )
|
||||
{
|
||||
errno = err;
|
||||
FatalError("xf86ReadBIOS() can't get_privileged_ports. (%s)\n",strerror(errno));
|
||||
}
|
||||
err = device_open(device,D_READ|D_WRITE,"iopl",&iopl_dev);
|
||||
mach_port_deallocate (mach_task_self (), device);
|
||||
if( err )
|
||||
{
|
||||
errno = err;
|
||||
FatalError("xf86ReadBIOS() can't device_open. (%s)\n",strerror(errno));
|
||||
}
|
||||
err = device_map(iopl_dev,VM_PROT_READ|VM_PROT_WRITE, Base , BIOS_SIZE ,&iopl_mem,0);
|
||||
if( err )
|
||||
{
|
||||
errno = err;
|
||||
FatalError("xf86ReadBIOS() can't device_map. (%s)\n",strerror(errno));
|
||||
}
|
||||
err = vm_map(mach_task_self(),
|
||||
&addr,
|
||||
BIOS_SIZE,
|
||||
0,
|
||||
TRUE,
|
||||
iopl_mem,
|
||||
Base,
|
||||
FALSE,
|
||||
VM_PROT_READ|VM_PROT_WRITE,
|
||||
VM_PROT_READ|VM_PROT_WRITE,
|
||||
VM_INHERIT_SHARE);
|
||||
mach_port_deallocate(mach_task_self(),iopl_mem);
|
||||
if( err )
|
||||
{
|
||||
errno = err;
|
||||
FatalError("xf86ReadBIOS() can't vm_map. (%s)\n",strerror(errno));
|
||||
}
|
||||
|
||||
memcpy(Buf,(void*)((int)addr + Offset), Len);
|
||||
|
||||
err = vm_deallocate(mach_task_self(), addr, BIOS_SIZE);
|
||||
if( err )
|
||||
{
|
||||
errno = err;
|
||||
FatalError("xf86ReadBIOS() can't vm_deallocate. (%s)\n",strerror(errno));
|
||||
}
|
||||
|
||||
return Len;
|
||||
}
|
301
hw/xfree86/os-support/hurd/hurd_mouse.c
Normal file
301
hw/xfree86/os-support/hurd/hurd_mouse.c
Normal file
|
@ -0,0 +1,301 @@
|
|||
/*
|
||||
* Copyright 1997,1998 by UCHIYAMA Yasushi
|
||||
*
|
||||
* 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 UCHIYAMA Yasushi not be used in
|
||||
* advertising or publicity pertaining to distribution of the software without
|
||||
* specific, written prior permission. UCHIYAMA Yasushi makes no representations
|
||||
* about the suitability of this software for any purpose. It is provided
|
||||
* "as is" without express or implied warranty.
|
||||
*
|
||||
* UCHIYAMA YASUSHI DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
||||
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
||||
* EVENT SHALL UCHIYAMA YASUSHI BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
||||
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
||||
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
||||
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||||
* PERFORMANCE OF THIS SOFTWARE.
|
||||
*
|
||||
*/
|
||||
/* $XFree86: xc/programs/Xserver/hw/xfree86/os-support/hurd/hurd_mouse.c,v 1.7 2000/02/10 22:33:44 dawes Exp $ */
|
||||
|
||||
#define NEED_EVENTS
|
||||
#ifdef HAVE_XORG_CONFIG_H
|
||||
#include <xorg-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xproto.h>
|
||||
#include "inputstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "mipointer.h"
|
||||
|
||||
#include "xf86.h"
|
||||
#include "xf86Xinput.h"
|
||||
#include "xf86OSmouse.h"
|
||||
#include "xf86_OSlib.h"
|
||||
#include "xisb.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <errno.h>
|
||||
#include <sys/time.h>
|
||||
#include <sys/file.h>
|
||||
#include <assert.h>
|
||||
#include <mach.h>
|
||||
#include <sys/ioctl.h>
|
||||
|
||||
typedef unsigned short kev_type; /* kd event type */
|
||||
typedef unsigned char Scancode;
|
||||
|
||||
struct mouse_motion {
|
||||
short mm_deltaX; /* units? */
|
||||
short mm_deltaY;
|
||||
};
|
||||
|
||||
typedef struct {
|
||||
kev_type type; /* see below */
|
||||
struct timeval time; /* timestamp */
|
||||
union { /* value associated with event */
|
||||
boolean_t up; /* MOUSE_LEFT .. MOUSE_RIGHT */
|
||||
Scancode sc; /* KEYBD_EVENT */
|
||||
struct mouse_motion mmotion; /* MOUSE_MOTION */
|
||||
} value;
|
||||
} kd_event;
|
||||
|
||||
/*
|
||||
* kd_event ID's.
|
||||
*/
|
||||
#define MOUSE_LEFT 1 /* mouse left button up/down */
|
||||
#define MOUSE_MIDDLE 2
|
||||
#define MOUSE_RIGHT 3
|
||||
#define MOUSE_MOTION 4 /* mouse motion */
|
||||
#define KEYBD_EVENT 5 /* key up/down */
|
||||
|
||||
#define NUMEVENTS 64
|
||||
|
||||
/*
|
||||
* OsMouseProc --
|
||||
* Handle the initialization, etc. of a mouse
|
||||
*/
|
||||
static int
|
||||
OsMouseProc(DeviceIntPtr pPointer, int what)
|
||||
{
|
||||
InputInfoPtr pInfo;
|
||||
MouseDevPtr pMse;
|
||||
unsigned char map[MSE_MAXBUTTONS + 1];
|
||||
int nbuttons;
|
||||
|
||||
pInfo = pPointer->public.devicePrivate;
|
||||
pMse = pInfo->private;
|
||||
pMse->device = pPointer;
|
||||
|
||||
switch (what) {
|
||||
case DEVICE_INIT:
|
||||
pPointer->public.on = FALSE;
|
||||
|
||||
for (nbuttons = 0; nbuttons < MSE_MAXBUTTONS; ++nbuttons)
|
||||
map[nbuttons + 1] = nbuttons + 1;
|
||||
|
||||
InitPointerDeviceStruct((DevicePtr)pPointer,
|
||||
map,
|
||||
min(pMse->buttons, MSE_MAXBUTTONS),
|
||||
miPointerGetMotionEvents,
|
||||
pMse->Ctrl,
|
||||
miPointerGetMotionBufferSize());
|
||||
|
||||
/* X valuator */
|
||||
xf86InitValuatorAxisStruct(pPointer, 0, 0, -1, 1, 0, 1);
|
||||
xf86InitValuatorDefaults(pPointer, 0);
|
||||
/* Y valuator */
|
||||
xf86InitValuatorAxisStruct(pPointer, 1, 0, -1, 1, 0, 1);
|
||||
xf86InitValuatorDefaults(pPointer, 1);
|
||||
xf86MotionHistoryAllocate(pInfo);
|
||||
break;
|
||||
|
||||
case DEVICE_ON:
|
||||
pInfo->fd = xf86OpenSerial(pInfo->options);
|
||||
if (pInfo->fd == -1)
|
||||
xf86Msg(X_WARNING, "%s: cannot open input device\n", pInfo->name);
|
||||
else {
|
||||
pMse->buffer = XisbNew(pInfo->fd,
|
||||
NUMEVENTS * sizeof(kd_event));
|
||||
if (!pMse->buffer) {
|
||||
xfree(pMse);
|
||||
xf86CloseSerial(pInfo->fd);
|
||||
pInfo->fd = -1;
|
||||
} else {
|
||||
xf86FlushInput(pInfo->fd);
|
||||
AddEnabledDevice(pInfo->fd);
|
||||
}
|
||||
}
|
||||
pMse->lastButtons = 0;
|
||||
pMse->lastMappedButtons = 0;
|
||||
pMse->emulateState = 0;
|
||||
pPointer->public.on = TRUE;
|
||||
break;
|
||||
|
||||
case DEVICE_OFF:
|
||||
case DEVICE_CLOSE:
|
||||
if (pInfo->fd != -1) {
|
||||
RemoveEnabledDevice(pInfo->fd);
|
||||
if (pMse->buffer) {
|
||||
XisbFree(pMse->buffer);
|
||||
pMse->buffer = NULL;
|
||||
}
|
||||
xf86CloseSerial(pInfo->fd);
|
||||
pInfo->fd = -1;
|
||||
}
|
||||
pPointer->public.on = FALSE;
|
||||
usleep(300000);
|
||||
break;
|
||||
}
|
||||
return Success;
|
||||
}
|
||||
|
||||
/*
|
||||
* OsMouseReadInput --
|
||||
* Get some events from our queue. Process all outstanding events now.
|
||||
*/
|
||||
static void
|
||||
OsMouseReadInput(InputInfoPtr pInfo)
|
||||
{
|
||||
MouseDevPtr pMse;
|
||||
static kd_event eventList[NUMEVENTS];
|
||||
int n, c;
|
||||
kd_event *event = eventList;
|
||||
unsigned char *pBuf;
|
||||
|
||||
pMse = pInfo->private;
|
||||
|
||||
XisbBlockDuration(pMse->buffer, -1);
|
||||
pBuf = (unsigned char *)eventList;
|
||||
n = 0;
|
||||
while ((c = XisbRead(pMse->buffer)) >= 0 && n < sizeof(eventList))
|
||||
pBuf[n++] = (unsigned char)c;
|
||||
|
||||
if (n == 0)
|
||||
return;
|
||||
|
||||
n /= sizeof(kd_event);
|
||||
while( n-- ) {
|
||||
int buttons = pMse->lastButtons;
|
||||
int dx = 0, dy = 0;
|
||||
switch (event->type) {
|
||||
case MOUSE_RIGHT:
|
||||
buttons = buttons & 6 |(event->value.up ? 0 : 1);
|
||||
break;
|
||||
case MOUSE_MIDDLE:
|
||||
buttons = buttons & 5 |(event->value.up ? 0 : 2);
|
||||
break;
|
||||
case MOUSE_LEFT:
|
||||
buttons = buttons & 3 |(event->value.up ? 0 : 4) ;
|
||||
break;
|
||||
case MOUSE_MOTION:
|
||||
dx = event->value.mmotion.mm_deltaX;
|
||||
dy = - event->value.mmotion.mm_deltaY;
|
||||
break;
|
||||
default:
|
||||
ErrorF("Bad mouse event (%d)\n",event->type);
|
||||
continue;
|
||||
}
|
||||
pMse->PostEvent(pInfo, buttons, dx, dy, 0, 0);
|
||||
++event;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
static Bool
|
||||
OsMousePreInit(InputInfoPtr pInfo, const char *protocol, int flags)
|
||||
{
|
||||
MouseDevPtr pMse;
|
||||
|
||||
/* This is called when the protocol is "OSMouse". */
|
||||
|
||||
pMse = pInfo->private;
|
||||
pMse->protocol = protocol;
|
||||
xf86Msg(X_CONFIG, "%s: Protocol: %s\n", pInfo->name, protocol);
|
||||
|
||||
/* Collect the options, and process the common options. */
|
||||
xf86CollectInputOptions(pInfo, NULL, NULL);
|
||||
xf86ProcessCommonOptions(pInfo, pInfo->options);
|
||||
|
||||
/* Check if the device can be opened. */
|
||||
pInfo->fd = xf86OpenSerial(pInfo->options);
|
||||
if (pInfo->fd == -1) {
|
||||
if (xf86GetAllowMouseOpenFail())
|
||||
xf86Msg(X_WARNING, "%s: cannot open input device\n", pInfo->name);
|
||||
else {
|
||||
xf86Msg(X_ERROR, "%s: cannot open input device\n", pInfo->name);
|
||||
xfree(pMse);
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
xf86CloseSerial(pInfo->fd);
|
||||
pInfo->fd = -1;
|
||||
|
||||
/* Process common mouse options (like Emulate3Buttons, etc). */
|
||||
pMse->CommonOptions(pInfo);
|
||||
|
||||
/* Setup the local procs. */
|
||||
pInfo->device_control = OsMouseProc;
|
||||
pInfo->read_input = OsMouseReadInput;
|
||||
|
||||
pInfo->flags |= XI86_CONFIGURED;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static int
|
||||
SupportedInterfaces(void)
|
||||
{
|
||||
/* XXX Need to check this. */
|
||||
return MSE_SERIAL | MSE_BUS | MSE_PS2 | MSE_XPS2 | MSE_AUTO;
|
||||
}
|
||||
|
||||
static const char *internalNames[] = {
|
||||
"OSMouse",
|
||||
NULL
|
||||
};
|
||||
|
||||
static const char **
|
||||
BuiltinNames(void)
|
||||
{
|
||||
return internalNames;
|
||||
}
|
||||
|
||||
static Bool
|
||||
CheckProtocol(const char *protocol)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; internalNames[i]; i++)
|
||||
if (xf86NameCmp(protocol, internalNames[i]) == 0)
|
||||
return TRUE;
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/* XXX Is this appropriate? If not, this function should be removed. */
|
||||
static const char *
|
||||
DefaultProtocol(void)
|
||||
{
|
||||
return "OSMouse";
|
||||
}
|
||||
|
||||
OSMouseInfoPtr
|
||||
xf86OSMouseInit(int flags)
|
||||
{
|
||||
OSMouseInfoPtr p;
|
||||
|
||||
p = xcalloc(sizeof(OSMouseInfoRec), 1);
|
||||
if (!p)
|
||||
return NULL;
|
||||
p->SupportedInterfaces = SupportedInterfaces;
|
||||
p->BuiltinNames = BuiltinNames;
|
||||
p->DefaultProtocol = DefaultProtocol;
|
||||
p->CheckProtocol = CheckProtocol;
|
||||
p->PreInit = OsMousePreInit;
|
||||
return p;
|
||||
}
|
||||
|
191
hw/xfree86/os-support/hurd/hurd_video.c
Normal file
191
hw/xfree86/os-support/hurd/hurd_video.c
Normal file
|
@ -0,0 +1,191 @@
|
|||
/*
|
||||
* Copyright 1997, 1998 by UCHIYAMA Yasushi
|
||||
*
|
||||
* 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 UCHIYAMA Yasushi not be used in
|
||||
* advertising or publicity pertaining to distribution of the software without
|
||||
* specific, written prior permission. UCHIYAMA Yasushi makes no representations
|
||||
* about the suitability of this software for any purpose. It is provided
|
||||
* "as is" without express or implied warranty.
|
||||
*
|
||||
* UCHIYAMA YASUSHI DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
||||
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
||||
* EVENT SHALL UCHIYAMA YASUSHI BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
||||
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
||||
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
||||
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||||
* PERFORMANCE OF THIS SOFTWARE.
|
||||
*
|
||||
*/
|
||||
/* $XFree86: xc/programs/Xserver/hw/xfree86/os-support/hurd/hurd_video.c,v 1.3 1999/04/29 12:24:52 dawes Exp $ */
|
||||
|
||||
#ifdef HAVE_XORG_CONFIG_H
|
||||
#include <xorg-config.h>
|
||||
#endif
|
||||
|
||||
#include <mach.h>
|
||||
#include <device/device.h>
|
||||
#include <mach/machine/mach_i386.h>
|
||||
|
||||
#include <X11/X.h>
|
||||
#include "input.h"
|
||||
#include "scrnintstr.h"
|
||||
|
||||
#include "xf86.h"
|
||||
#include "xf86Priv.h"
|
||||
#include "xf86_OSlib.h"
|
||||
#include "xf86OSpriv.h"
|
||||
|
||||
/**************************************************************************
|
||||
* Video Memory Mapping section
|
||||
***************************************************************************/
|
||||
pointer
|
||||
xf86MapVidMem(int ScreenNum,int Flags, unsigned long Base, unsigned long Size)
|
||||
{
|
||||
mach_port_t device,iopl_dev;
|
||||
memory_object_t iopl_mem;
|
||||
kern_return_t err;
|
||||
vm_address_t addr=(vm_address_t)0;
|
||||
|
||||
err = get_privileged_ports (NULL, &device);
|
||||
if( err )
|
||||
{
|
||||
errno = err;
|
||||
FatalError("xf86MapVidMem() can't get_privileged_ports. (%s)\n",strerror(errno));
|
||||
}
|
||||
err = device_open(device,D_READ|D_WRITE,"iopl",&iopl_dev);
|
||||
mach_port_deallocate (mach_task_self(), device);
|
||||
if( err )
|
||||
{
|
||||
errno = err;
|
||||
FatalError("xf86MapVidMem() can't device_open. (%s)\n",strerror(errno));
|
||||
}
|
||||
|
||||
err = device_map(iopl_dev,VM_PROT_READ|VM_PROT_WRITE, Base , Size ,&iopl_mem,0);
|
||||
if( err )
|
||||
{
|
||||
errno = err;
|
||||
FatalError("xf86MapVidMem() can't device_map. (%s)\n",strerror(errno));
|
||||
}
|
||||
err = vm_map(mach_task_self(),
|
||||
&addr,
|
||||
Size,
|
||||
0, /* mask */
|
||||
TRUE, /* anywhere */
|
||||
iopl_mem,
|
||||
(vm_offset_t)Base,
|
||||
FALSE, /* copy on write */
|
||||
VM_PROT_READ|VM_PROT_WRITE,
|
||||
VM_PROT_READ|VM_PROT_WRITE,
|
||||
VM_INHERIT_SHARE);
|
||||
mach_port_deallocate(mach_task_self(),iopl_mem);
|
||||
if( err )
|
||||
{
|
||||
errno = err;
|
||||
FatalError("xf86MapVidMem() can't vm_map.(iopl_mem) (%s)\n",strerror(errno));
|
||||
}
|
||||
mach_port_deallocate(mach_task_self(),iopl_dev);
|
||||
if( err )
|
||||
{
|
||||
errno = err;
|
||||
FatalError("xf86MapVidMem() can't mach_port_deallocate.(iopl_dev) (%s)\n",strerror(errno));
|
||||
}
|
||||
return (pointer)addr;
|
||||
}
|
||||
|
||||
void
|
||||
xf86UnMapVidMem(int ScreenNum,pointer Base,unsigned long Size)
|
||||
{
|
||||
kern_return_t err = vm_deallocate(mach_task_self(), (int)Base, Size);
|
||||
if( err )
|
||||
{
|
||||
errno = err;
|
||||
ErrorF("xf86UnMapVidMem: can't dealloc framebuffer space (%s)\n",strerror(errno));
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
Bool
|
||||
xf86LinearVidMem()
|
||||
{
|
||||
return(TRUE);
|
||||
}
|
||||
|
||||
/**************************************************************************
|
||||
* I/O Permissions section
|
||||
***************************************************************************/
|
||||
mach_port_t io_port;
|
||||
|
||||
Bool
|
||||
xf86EnableIO()
|
||||
{
|
||||
mach_port_t device;
|
||||
kern_return_t err;
|
||||
|
||||
err = get_privileged_ports(NULL, &device);
|
||||
if( err )
|
||||
{
|
||||
errno = err;
|
||||
FatalError("xf86EnableIO() can't get_privileged_ports. (%s)\n",strerror(errno));
|
||||
}
|
||||
err = device_open(device,D_READ|D_WRITE,"io",&io_port);
|
||||
mach_port_deallocate(mach_task_self(), device);
|
||||
if( err )
|
||||
{
|
||||
errno = err;
|
||||
FatalError("xf86EnableIO() can't device_open. (%s)\n",strerror(errno));
|
||||
}
|
||||
|
||||
err = i386_io_port_add(mach_thread_self (), io_port);
|
||||
if( err )
|
||||
{
|
||||
errno = err;
|
||||
FatalError("xf86EnableIO() can't i386_io_port_add.(io_port) (%s)\n",strerror(errno));
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
void
|
||||
xf86DisableIO()
|
||||
{
|
||||
kern_return_t err;
|
||||
|
||||
err = i386_io_port_remove(mach_thread_self (), io_port);
|
||||
if( err )
|
||||
{
|
||||
errno = err;
|
||||
FatalError("xf86DisableIO() can't i386_io_port_remove.(io_port) (%s)\n",strerror(errno));
|
||||
}
|
||||
mach_port_deallocate(mach_task_self(), io_port);
|
||||
return;
|
||||
}
|
||||
|
||||
/**************************************************************************
|
||||
* Interrupt Handling section
|
||||
**************************************************************************/
|
||||
Bool
|
||||
xf86DisableInterrupts()
|
||||
{
|
||||
return TRUE;
|
||||
}
|
||||
void
|
||||
xf86EnableInterrupts()
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
void
|
||||
xf86MapReadSideEffects(int ScreenNum, int Flags, pointer Base,
|
||||
unsigned long Size)
|
||||
{
|
||||
}
|
||||
|
||||
Bool
|
||||
xf86CheckMTRR(int s)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
|
|
@ -464,7 +464,7 @@ mapVidMem(int ScreenNum, unsigned long Base, unsigned long Size, int flags)
|
|||
Base,realBase,alignOff);
|
||||
#endif
|
||||
|
||||
#if defined(__ia64__)
|
||||
#if defined(__ia64__) || defined(__arm__) || defined(__s390__)
|
||||
#ifndef MAP_WRITECOMBINED
|
||||
#define MAP_WRITECOMBINED 0x00010000
|
||||
#endif
|
||||
|
@ -594,7 +594,7 @@ xf86DisableIO(void)
|
|||
#if defined(__powerpc__)
|
||||
munmap(ioBase, 0x20000);
|
||||
ioBase = NULL;
|
||||
#elif !defined(__mc68000__) && !defined(__sparc__) && !defined(__mips__) && !defined(__sh__) && !defined(__hppa__)
|
||||
#elif !defined(__mc68000__) && !defined(__sparc__) && !defined(__mips__) && !defined(__sh__) && !defined(__hppa__) && !defined(__arm__) && !defined(__s390__)
|
||||
iopl(0);
|
||||
ioperm(0, 1024, 0);
|
||||
#endif
|
||||
|
@ -613,12 +613,12 @@ xf86DisableIO(void)
|
|||
_X_EXPORT Bool
|
||||
xf86DisableInterrupts()
|
||||
{
|
||||
#if !defined(__mc68000__) && !defined(__powerpc__) && !defined(__sparc__) && !defined(__mips__) && !defined(__ia64__) && !defined(__sh__) && !defined(__hppa__)
|
||||
#if !defined(__mc68000__) && !defined(__powerpc__) && !defined(__sparc__) && !defined(__mips__) && !defined(__ia64__) && !defined(__sh__) && !defined(__hppa__) && !defined(__arm__) && !defined(__s390__)
|
||||
if (!ExtendedEnabled)
|
||||
if (iopl(3) || ioperm(0, 1024, 1))
|
||||
return (FALSE);
|
||||
#endif
|
||||
#if defined(__alpha__) || defined(__mc68000__) || defined(__powerpc__) || defined(__sparc__) || defined(__mips__) || defined(__arm__) || defined(__sh__) || defined(__ia64__) || defined(__hppa__)
|
||||
#if defined(__alpha__) || defined(__mc68000__) || defined(__powerpc__) || defined(__sparc__) || defined(__mips__) || defined(__arm__) || defined(__sh__) || defined(__ia64__) || defined(__hppa__) || defined(__s390__)
|
||||
#else
|
||||
# ifdef __GNUC__
|
||||
# if defined(__ia64__)
|
||||
|
@ -632,7 +632,7 @@ xf86DisableInterrupts()
|
|||
asm("cli");
|
||||
# endif
|
||||
#endif
|
||||
#if !defined(__mc68000__) && !defined(__powerpc__) && !defined(__sparc__) && !defined(__mips__) && !defined(__sh__) && !defined(__ia64__) && !defined(__hppa__)
|
||||
#if !defined(__mc68000__) && !defined(__powerpc__) && !defined(__sparc__) && !defined(__mips__) && !defined(__sh__) && !defined(__ia64__) && !defined(__hppa__) && !defined(__arm__) && !defined(__s390__)
|
||||
if (!ExtendedEnabled) {
|
||||
iopl(0);
|
||||
ioperm(0, 1024, 0);
|
||||
|
@ -645,12 +645,12 @@ xf86DisableInterrupts()
|
|||
_X_EXPORT void
|
||||
xf86EnableInterrupts()
|
||||
{
|
||||
#if !defined(__mc68000__) && !defined(__powerpc__) && !defined(__sparc__) && !defined(__mips__) && !defined(__ia64__) && !defined(__sh__) && !defined(__hppa__)
|
||||
#if !defined(__mc68000__) && !defined(__powerpc__) && !defined(__sparc__) && !defined(__mips__) && !defined(__ia64__) && !defined(__sh__) && !defined(__hppa__) && !defined(__arm__) && !defined(__s390__)
|
||||
if (!ExtendedEnabled)
|
||||
if (iopl(3) || ioperm(0, 1024, 1))
|
||||
return;
|
||||
#endif
|
||||
#if defined(__alpha__) || defined(__mc68000__) || defined(__powerpc__) || defined(__sparc__) || defined(__mips__) || defined(__arm__) || defined(__sh__) || defined(__ia64__) || defined(__hppa__)
|
||||
#if defined(__alpha__) || defined(__mc68000__) || defined(__powerpc__) || defined(__sparc__) || defined(__mips__) || defined(__arm__) || defined(__sh__) || defined(__ia64__) || defined(__hppa__) || defined(__s390__)
|
||||
#else
|
||||
# ifdef __GNUC__
|
||||
# if defined(__ia64__)
|
||||
|
@ -664,7 +664,7 @@ xf86EnableInterrupts()
|
|||
asm("sti");
|
||||
# endif
|
||||
#endif
|
||||
#if !defined(__mc68000__) && !defined(__powerpc__) && !defined(__sparc__) && !defined(__mips__) && !defined(__sh__) && !defined(__ia64__) && !defined(__hppa__)
|
||||
#if !defined(__mc68000__) && !defined(__powerpc__) && !defined(__sparc__) && !defined(__mips__) && !defined(__sh__) && !defined(__ia64__) && !defined(__hppa__) && !defined(__arm__) && !defined(__s390__)
|
||||
if (!ExtendedEnabled) {
|
||||
iopl(0);
|
||||
ioperm(0, 1024, 0);
|
||||
|
|
|
@ -175,7 +175,7 @@ typedef struct _vgaHWRec {
|
|||
#define BITS_PER_GUN 6
|
||||
#define COLORMAP_SIZE 256
|
||||
|
||||
#if defined(__powerpc__)
|
||||
#if defined(__powerpc__) || defined(__arm__) || defined(__s390__)
|
||||
#define DACDelay(hw) /* No legacy VGA support */
|
||||
#else
|
||||
#define DACDelay(hw) \
|
||||
|
|
|
@ -58,6 +58,13 @@ void ddxInitGlobals(void)
|
|||
int
|
||||
ddxProcessArgument (int argc, char *argv[], int i)
|
||||
{
|
||||
|
||||
#ifdef COMPOSITE
|
||||
/* XXX terrible hack */
|
||||
extern Bool noCompositeExtension;
|
||||
noCompositeExtension = TRUE;
|
||||
#endif
|
||||
|
||||
if (!strcmp(argv[i], "-display")) {
|
||||
if (++i < argc) {
|
||||
xnestDisplayName = argv[i];
|
||||
|
|
|
@ -56,6 +56,8 @@ extern void *g_pClipboardDisplay;
|
|||
extern Window g_iClipboardWindow;
|
||||
extern Atom g_atomLastOwnedSelection;
|
||||
|
||||
/* BPS - g_hwndClipboard needed for X app->Windows paste fix */
|
||||
extern HWND g_hwndClipboard;
|
||||
|
||||
/*
|
||||
* Local function prototypes
|
||||
|
@ -141,6 +143,12 @@ winProcessXEventsTimeout (HWND hwnd, int iWindow, Display *pDisplay,
|
|||
* Process a given Windows message
|
||||
*/
|
||||
|
||||
/* BPS - Define our own message, which we'll post to ourselves to facilitate
|
||||
* resetting the delayed rendering mechanism after each paste from X app to
|
||||
* Windows app. TODO - Perhaps move to win.h with the other WM_USER messages.
|
||||
*/
|
||||
#define WM_USER_PASTE_COMPLETE (WM_USER + 1003)
|
||||
|
||||
LRESULT CALLBACK
|
||||
winClipboardWindowProc (HWND hwnd, UINT message,
|
||||
WPARAM wParam, LPARAM lParam)
|
||||
|
@ -167,16 +175,19 @@ winClipboardWindowProc (HWND hwnd, UINT message,
|
|||
|
||||
case WM_CREATE:
|
||||
{
|
||||
HWND first, next;
|
||||
DWORD error_code = 0;
|
||||
winDebug ("winClipboardWindowProc - WM_CREATE\n");
|
||||
|
||||
first = GetClipboardViewer(); /* Get handle to first viewer in chain. */
|
||||
if (first == hwnd) return 0; /* Make sure it's not us! */
|
||||
/* Add ourselves to the clipboard viewer chain */
|
||||
s_hwndNextViewer = SetClipboardViewer (hwnd);
|
||||
if (s_hwndNextViewer == hwnd)
|
||||
{
|
||||
s_hwndNextViewer = NULL;
|
||||
winErrorFVerb (1, "winClipboardWindowProc - WM_CREATE: "
|
||||
"attempted to set next window to ourselves.");
|
||||
}
|
||||
next = SetClipboardViewer (hwnd);
|
||||
error_code = GetLastError();
|
||||
if (SUCCEEDED(error_code) && (next == first)) /* SetClipboardViewer must have succeeded, and the handle */
|
||||
s_hwndNextViewer = next; /* it returned must have been the first window in the chain */
|
||||
else
|
||||
s_fCBCInitialized = FALSE;
|
||||
}
|
||||
return 0;
|
||||
|
||||
|
@ -220,28 +231,27 @@ winClipboardWindowProc (HWND hwnd, UINT message,
|
|||
* expensive than just putting ourselves back into the chain.
|
||||
*/
|
||||
|
||||
HWND first, next;
|
||||
DWORD error_code = 0;
|
||||
winDebug ("winClipboardWindowProc - WM_WM_REINIT: Enter\n");
|
||||
if (hwnd != GetClipboardViewer ())
|
||||
{
|
||||
winDebug (" WM_WM_REINIT: Replacing us(%x) with %x at head "
|
||||
"of chain\n", hwnd, s_hwndNextViewer);
|
||||
s_fCBCInitialized = FALSE;
|
||||
ChangeClipboardChain (hwnd, s_hwndNextViewer);
|
||||
s_hwndNextViewer = NULL;
|
||||
s_fCBCInitialized = FALSE;
|
||||
winDebug (" WM_WM_REINIT: Putting us back at head of chain.\n");
|
||||
s_hwndNextViewer = SetClipboardViewer (hwnd);
|
||||
if (s_hwndNextViewer == hwnd)
|
||||
{
|
||||
s_hwndNextViewer = NULL;
|
||||
winErrorFVerb (1, "winClipboardWindowProc - WM_WM_REINIT: "
|
||||
"attempted to set next window to ourselves.\n");
|
||||
}
|
||||
}
|
||||
|
||||
first = GetClipboardViewer(); /* Get handle to first viewer in chain. */
|
||||
if (first == hwnd) return 0; /* Make sure it's not us! */
|
||||
winDebug (" WM_WM_REINIT: Replacing us(%x) with %x at head "
|
||||
"of chain\n", hwnd, s_hwndNextViewer);
|
||||
s_fCBCInitialized = FALSE;
|
||||
ChangeClipboardChain (hwnd, s_hwndNextViewer);
|
||||
s_hwndNextViewer = NULL;
|
||||
s_fCBCInitialized = FALSE;
|
||||
winDebug (" WM_WM_REINIT: Putting us back at head of chain.\n");
|
||||
first = GetClipboardViewer(); /* Get handle to first viewer in chain. */
|
||||
if (first == hwnd) return 0; /* Make sure it's not us! */
|
||||
next = SetClipboardViewer (hwnd);
|
||||
error_code = GetLastError();
|
||||
if (SUCCEEDED(error_code) && (next == first)) /* SetClipboardViewer must have succeeded, and the handle */
|
||||
s_hwndNextViewer = next; /* it returned must have been the first window in the chain */
|
||||
else
|
||||
{
|
||||
winDebug (" WM_WM_REINIT: already at head of viewer chain.\n");
|
||||
}
|
||||
s_fCBCInitialized = FALSE;
|
||||
}
|
||||
winDebug ("winClipboardWindowProc - WM_WM_REINIT: Exit\n");
|
||||
return 0;
|
||||
|
@ -325,8 +335,6 @@ winClipboardWindowProc (HWND hwnd, UINT message,
|
|||
* previous XSetSelectionOwner messages.
|
||||
*/
|
||||
XSync (pDisplay, FALSE);
|
||||
|
||||
winDebug("winClipboardWindowProc - XSync done.\n");
|
||||
|
||||
/* Release PRIMARY selection if owned */
|
||||
iReturn = XGetSelectionOwner (pDisplay, XA_PRIMARY);
|
||||
|
@ -525,6 +533,13 @@ winClipboardWindowProc (HWND hwnd, UINT message,
|
|||
SetClipboardData (CF_TEXT, NULL);
|
||||
}
|
||||
|
||||
/* BPS - Post ourselves a user message whose handler will reset the
|
||||
* delayed rendering mechanism after the paste is complete. This is
|
||||
* necessary because calling SetClipboardData() with a NULL argument
|
||||
* here will cause the data we just put on the clipboard to be lost!
|
||||
*/
|
||||
PostMessage(g_hwndClipboard, WM_USER_PASTE_COMPLETE, 0, 0);
|
||||
|
||||
/* Special handling for WM_RENDERALLFORMATS */
|
||||
if (message == WM_RENDERALLFORMATS)
|
||||
{
|
||||
|
@ -542,6 +557,37 @@ winClipboardWindowProc (HWND hwnd, UINT message,
|
|||
winDebug ("winClipboardWindowProc - WM_RENDER*FORMAT - Returning.\n");
|
||||
return 0;
|
||||
}
|
||||
/* BPS - This WM_USER message is posted by us. It gives us the opportunity
|
||||
* to reset the delayed rendering mechanism after each and every paste
|
||||
* from an X app to a Windows app. Without such a mechanism, subsequent
|
||||
* changes of selection in the X app owning the selection are not
|
||||
* reflected in pastes into Windows apps, since Windows won't send us the
|
||||
* WM_RENDERFORMAT message unless someone has set changed data (or NULL)
|
||||
* on the clipboard. */
|
||||
case WM_USER_PASTE_COMPLETE:
|
||||
{
|
||||
if (hwnd != GetClipboardOwner ())
|
||||
/* In case we've lost the selection since posting the message */
|
||||
return 0;
|
||||
winDebug ("winClipboardWindowProc - WM_USER_PASTE_COMPLETE\n");
|
||||
|
||||
/* Set up for another delayed rendering callback */
|
||||
OpenClipboard (g_hwndClipboard);
|
||||
|
||||
/* Take ownership of the Windows clipboard */
|
||||
EmptyClipboard ();
|
||||
|
||||
/* Advertise Unicode if we support it */
|
||||
if (g_fUnicodeSupport)
|
||||
SetClipboardData (CF_UNICODETEXT, NULL);
|
||||
|
||||
/* Always advertise regular text */
|
||||
SetClipboardData (CF_TEXT, NULL);
|
||||
|
||||
/* Release the clipboard */
|
||||
CloseClipboard ();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Let Windows perform default processing for unhandled messages */
|
||||
|
|
|
@ -304,7 +304,6 @@ winTopLevelWindowProc (HWND hwnd, UINT message,
|
|||
winScreenInfo *s_pScreenInfo = NULL;
|
||||
HWND hwndScreen = NULL;
|
||||
DrawablePtr pDraw = NULL;
|
||||
int iX, iY, iWidth, iHeight, iBorder;
|
||||
winWMMessageRec wmMsg;
|
||||
Bool fWMMsgInitialized = FALSE;
|
||||
static Bool s_fTracking = FALSE;
|
||||
|
@ -394,6 +393,15 @@ winTopLevelWindowProc (HWND hwnd, UINT message,
|
|||
* currently being created.
|
||||
*/
|
||||
winReorderWindowsMultiWindow ();
|
||||
|
||||
/* Fix a 'round title bar corner background should be transparent not black' problem when first painted */
|
||||
RECT rWindow;
|
||||
HRGN hRgnWindow;
|
||||
GetWindowRect(hwnd, &rWindow);
|
||||
hRgnWindow = CreateRectRgnIndirect(&rWindow);
|
||||
SetWindowRgn (hwnd, hRgnWindow, TRUE);
|
||||
DeleteObject(hRgnWindow);
|
||||
|
||||
return 0;
|
||||
|
||||
case WM_INIT_SYS_MENU:
|
||||
|
@ -433,20 +441,19 @@ winTopLevelWindowProc (HWND hwnd, UINT message,
|
|||
|
||||
/* BeginPaint gives us an hdc that clips to the invalidated region */
|
||||
hdcUpdate = BeginPaint (hwnd, &ps);
|
||||
|
||||
/* Get the position and dimensions of the window */
|
||||
iBorder = wBorderWidth (pWin);
|
||||
iX = pWin->drawable.x;
|
||||
iY = pWin->drawable.y;
|
||||
iWidth = pWin->drawable.width;
|
||||
iHeight = pWin->drawable.height;
|
||||
/* Avoid the BitBlt's if the PAINTSTRUCT is bogus */
|
||||
if (ps.rcPaint.right==0 && ps.rcPaint.bottom==0 && ps.rcPaint.left==0 && ps.rcPaint.top==0)
|
||||
{
|
||||
EndPaint (hwndScreen, &ps);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Try to copy from the shadow buffer */
|
||||
if (!BitBlt (hdcUpdate,
|
||||
0, 0,
|
||||
iWidth, iHeight,
|
||||
ps.rcPaint.left, ps.rcPaint.top,
|
||||
ps.rcPaint.right - ps.rcPaint.left, ps.rcPaint.bottom - ps.rcPaint.top,
|
||||
s_pScreenPriv->hdcShadow,
|
||||
iX, iY,
|
||||
ps.rcPaint.left + pWin->drawable.x, ps.rcPaint.top + pWin->drawable.y,
|
||||
SRCCOPY))
|
||||
{
|
||||
LPVOID lpMsgBuf;
|
||||
|
|
|
@ -540,8 +540,9 @@ winShadowUpdateGDI (ScreenPtr pScreen,
|
|||
* handle large regions by creating a clipping region and
|
||||
* doing a single blit constrained to that clipping region.
|
||||
*/
|
||||
if (pScreenInfo->dwClipUpdatesNBoxes == 0
|
||||
|| dwBox < pScreenInfo->dwClipUpdatesNBoxes)
|
||||
if (!pScreenInfo->fMultiWindow &&
|
||||
(pScreenInfo->dwClipUpdatesNBoxes == 0 ||
|
||||
dwBox < pScreenInfo->dwClipUpdatesNBoxes))
|
||||
{
|
||||
/* Loop through all boxes in the damaged region */
|
||||
while (dwBox--)
|
||||
|
@ -566,7 +567,7 @@ winShadowUpdateGDI (ScreenPtr pScreen,
|
|||
++pBox;
|
||||
}
|
||||
}
|
||||
else
|
||||
else if (!pScreenInfo->fMultiWindow)
|
||||
{
|
||||
/* Compute a GDI region from the damaged region */
|
||||
hrgnCombined = CreateRectRgn (pBox->x1, pBox->y1, pBox->x2, pBox->y2);
|
||||
|
|
|
@ -222,6 +222,9 @@
|
|||
/* Support IPv6 for TCP connections */
|
||||
#undef IPv6
|
||||
|
||||
/* Support os-specific local connections */
|
||||
#undef LOCALCONN
|
||||
|
||||
/* Support MIT Misc extension */
|
||||
#undef MITMISC
|
||||
|
||||
|
|
|
@ -73,6 +73,7 @@ extern int limitNoFile;
|
|||
extern Bool defeatAccessControl;
|
||||
extern long maxBigRequestSize;
|
||||
extern Bool blackRoot;
|
||||
extern Bool whiteRoot;
|
||||
|
||||
extern Bool CoreDump;
|
||||
|
||||
|
|
|
@ -109,4 +109,7 @@
|
|||
/* Name of the period field in struct kbd_repeat */
|
||||
#undef LNX_KBD_PERIOD_NAME
|
||||
|
||||
/* Have execinfo.h */
|
||||
#undef HAVE_EXECINFO_H
|
||||
|
||||
#endif /* _XORG_CONFIG_H_ */
|
||||
|
|
|
@ -1188,7 +1188,11 @@ ResetHosts (char *display)
|
|||
FreeHost (host);
|
||||
}
|
||||
|
||||
#if defined WIN32 && defined __MINGW32__
|
||||
#define ETC_HOST_PREFIX "X"
|
||||
#else
|
||||
#define ETC_HOST_PREFIX "/etc/X"
|
||||
#endif
|
||||
#define ETC_HOST_SUFFIX ".hosts"
|
||||
fnamelen = strlen(ETC_HOST_PREFIX) + strlen(ETC_HOST_SUFFIX) +
|
||||
strlen(display) + 1;
|
||||
|
|
10
os/utils.c
10
os/utils.c
|
@ -271,10 +271,6 @@ long Memory_fail = 0;
|
|||
#include <stdlib.h> /* for random() */
|
||||
#endif
|
||||
|
||||
#ifdef sgi
|
||||
int userdefinedfontpath = 0;
|
||||
#endif /* sgi */
|
||||
|
||||
char *dev_tty_from_init = NULL; /* since we need to parse it anyway */
|
||||
|
||||
OsSigHandlerPtr
|
||||
|
@ -646,6 +642,7 @@ void UseMsg(void)
|
|||
ErrorF("v video blanking for screen-saver\n");
|
||||
ErrorF("-v screen-saver without video blanking\n");
|
||||
ErrorF("-wm WhenMapped default backing-store\n");
|
||||
ErrorF("-wr create root window with white background\n");
|
||||
ErrorF("-x string loads named extension at init time \n");
|
||||
ErrorF("-maxbigreqsize set maximal bigrequest size \n");
|
||||
#ifdef PANORAMIX
|
||||
|
@ -843,9 +840,6 @@ ProcessCommandLine(int argc, char *argv[])
|
|||
{
|
||||
if(++i < argc)
|
||||
{
|
||||
#ifdef sgi
|
||||
userdefinedfontpath = 1;
|
||||
#endif /* sgi */
|
||||
defaultFontPath = argv[i];
|
||||
}
|
||||
else
|
||||
|
@ -990,6 +984,8 @@ ProcessCommandLine(int argc, char *argv[])
|
|||
defaultScreenSaverBlanking = DontPreferBlanking;
|
||||
else if ( strcmp( argv[i], "-wm") == 0)
|
||||
defaultBackingStore = WhenMapped;
|
||||
else if ( strcmp( argv[i], "-wr") == 0)
|
||||
whiteRoot = TRUE;
|
||||
else if ( strcmp( argv[i], "-maxbigreqsize") == 0) {
|
||||
if(++i < argc) {
|
||||
long reqSizeArg = atol(argv[i]);
|
||||
|
|
|
@ -150,11 +150,7 @@ unsigned ndx;
|
|||
break;
|
||||
default:
|
||||
ErrorF("unknown key behavior 0x%04x\n",behavior.type);
|
||||
#if defined(MetroLink)
|
||||
return;
|
||||
#else
|
||||
break;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
XkbHandleActions(keybd,keybd,xE,count);
|
||||
|
|
Loading…
Reference in New Issue
Block a user