NAME
	  glXMakeCurrent - attach a GLX	context	to a window or a GLX
	  pixmap


     C SPECIFICATION
	  Bool glXMakeCurrent( Display *dpy,
			       GLXDrawable drawable,
			       GLXContext ctx )


     PARAMETERS
	  dpy	    Specifies the connection to	the X server.

	  drawable  Specifies a	GLX drawable.  Must be either an X
		    window ID or a GLX pixmap ID.

	  ctx	    Specifies a	GLX rendering context that is to be
		    attached to	drawable.

     DESCRIPTION
	  glXMakeCurrent does two things:  It makes ctx	the current
	  GLX rendering	context	of the calling thread, replacing the
	  previously current context if	there was one, and it attaches
	  ctx to a GLX drawable, either	a window or a GLX pixmap.  As
	  a result of these two	actions, subsequent GL rendering calls
	  use rendering	context	ctx to modify GLX drawable drawable.
	  Because glXMakeCurrent always	replaces the current rendering
	  context with ctx, there can be only one current context per
	  thread.

	  Pending commands to the previous context, if any, are
	  flushed before it is released.

	  The first time ctx is	made current to	any thread, its
	  viewport is set to the full size of drawable.	 Subsequent
	  calls	by any thread to glXMakeCurrent	with ctx have no
	  effect on its	viewport.

	  To release the current context without assigning a new one,
	  call glXMakeCurrent with drawable set	None and ctx set to
	  NULL

	  glXMakeCurrent returns True if it is successful, False
	  otherwise.  If False is returned, the	previously current
	  rendering context and	drawable (if any) remain unchanged.

     NOTES
	  A process is a single-execution environment, implemented in
	  a single address space, consisting of	one or more threads.

	  A thread is one of a set of subprocesses that	share a	single
	  address space, but maintain separate program counters, stack
	  spaces, and other related global data.  A thread that	is the
	  only member of its subprocess	group is equivalent to a
	  process.

     ERRORS
	  BadMatch is generated	if drawable was	not created with the
	  same X screen	and visual as ctx.  It is also generated if
	  drawable is None and ctx is not NULL.

	  BadAccess is generated if ctx	was current to another thread
	  at the time glXMakeCurrent was called.

	  GLXBadDrawable is generated if drawable is not a valid GLX
	  drawable.

	  GLXBadContext	is generated if	ctx is not a valid GLX
	  context.

	  GLXBadContextState is	generated if glXMakeCurrent is
	  executed between the execution of glBegin and	the
	  corresponding	execution of glEnd.

	  GLXBadContextState is	also generated if the rendering
	  context current to the calling thread	has GL renderer	state
	  GL_FEEDBACK or GL_SELECT.

	  GLXBadCurrentWindow is generated if there are	pending	GL
	  commands for the previous context and	the current drawable
	  is a window that is no longer	valid.

	  BadAlloc may be generated if the server has delayed
	  allocation of	ancillary buffers until	glXMakeCurrent is
	  called, only to find that it has insufficient	resources to
	  complete the allocation.

     SEE ALSO
	  glXCreateContext, glXCreateGLXPixmap