(I think you should bring this up in the OpenGl community;
if the with-statement supports the usage I don't see why not. [[GvR]])

(Doing so.  -- Andrew Dalke)

OpenGL programmers have complained about using Python
because the code indentation doesn't follow the display
tree.  For an example pulled from one of my (Andrew Dalke)
projects
{{{
        glBegin(GL_QUAD_STRIP)
        glColor3f(1.0,1.0,1.0) #corner 1
        glNormal3f(0.57735027, 0.57735027, 0.57735027)
        glVertex3f(0.5, 0.5, 0.5)
        glColor3f(1.0,0.0,1.0) #corner 2
        glNormal3f(0.57735027, -0.57735027, 0.57735027)
        glVertex3f(0.5, -0.5, 0.5)
        ...
        glEnd()
}}}
Some people write this as some variant of
{{{
        glBegin(GL_QUAD_STRIP)
        if 1:
          glColor3f(1.0,1.0,1.0) #corner 1
          glNormal3f(0.57735027, 0.57735027, 0.57735027)
          glVertex3f(0.5, 0.5, 0.5)
          glColor3f(1.0,0.0,1.0) #corner 2
          glNormal3f(0.57735027, -0.57735027, 0.57735027)
          glVertex3f(0.5, -0.5, 0.5)
          ...
        glEnd()
}}}

and sometimes using try/finally so that errors don't cause
the gl state to become corrupted.

Would an appropriate use of this proposal be to allow
{{{
  with QUAD_STRIP:
      glColor3f(1.0,1.0,1.0) #corner 1
      glNormal3f(0.57735027, 0.57735027, 0.57735027)
      glVertex3f(0.5, 0.5, 0.5)
      glColor3f(1.0,0.0,1.0) #corner 2
      glNormal3f(0.57735027, -0.57735027, 0.57735027)
      glVertex3f(0.5, -0.5, 0.5)
      ....
}}}
where there are a bunch of small classes for each of the
possible glBegins, such as
{{{
class QUAD_STRIP:
  @staticmethod
  def __enter__():
    glBegin(GL_QUAD_STRIP)
  @staticmethod
  def __exit__(*args):
    glEnd()
}}}

If so, I rather like that ability as it makes the graphics
programmer's intent clearer and prevents problems balancing
glBegin and glEnd - even in the face of code errors in
the actual code block! -- Andrew Dalke

----

I'm (Andrew Dalke) often one to resist change to Python.
The WithStatement is a counter-example.  I really like how
it cleans up some OpenGL programming.  Consider this example
from OpenGLContext's indexlineset.py

{{{
           dl = displaylist.DisplayList()
           ...
           # compile the color-friendly ILS
           dl.start()
           try:
               glEnable( GL_COLOR_MATERIAL )
               for polyline, color in zip(indices, colorIndices):
                   if type(color) == int:
                       glColor3d( *colors[color] )
                       glBegin( GL_LINE_STRIP )
                       try:
                           for i in polyline:
                               glVertex3f(*points[i])
                       finally:
                           glEnd()
                    else:
                       glBegin( GL_LINE_STRIP )
                       try:
                           for i,c in zip(polyline, color):
                               glColor3d( *colors[c] )
                               glVertex3f(*points[i])
                       finally:
                            glEnd()
               glDisable( GL_COLOR_MATERIAL )
           finally:
               dl.end()
}}}

Assuming a few minor helper classes and a couple of
new {{{__enter__/__exit__}}} methods and it can be rewritten
using 'with' statements like this:

{{{
           dl = displaylist.DisplayList()
           ...
           with dl:
               with GLEnable( GL_COLOR_MATERIAL ):
                   for polyline, color in zip(indices, colorIndices):
                       if type(color) == int:
                           glColor3d( *colors[color] )
                       with GLGeometry( GL_LINE_STRIP ):
                           for i in polyline:
                               glVertex3f(*points[i])
                    else:
                       with GLBegin( GL_LINE_STRIP ):
                           for i,c in zip(polyline, color):
                               glColor3d( *colors[c] )
                               glVertex3f(*points[i])
}}}

Shorter, cleaner, less error-prone, easier to read and
maintain.  +1 from me! -- Andrew Dalke