--- a/libgui/graphics/qopengl-functions.h	Tue Dec 06 14:37:51 2022 -0500
+++ b/libgui/graphics/qopengl-functions.h	Tue Dec 06 14:53:00 2022 -0500
@@ -34,424 +34,424 @@
 
 OCTAVE_BEGIN_NAMESPACE(octave)
 
-  // If we don't have QOPENGLFUNCTIONS_1_1, then we will default to
-  // calling OpenGL functions directly through the base
-  // opengl_functions class.
+// If we don't have QOPENGLFUNCTIONS_1_1, then we will default to
+// calling OpenGL functions directly through the base
+// opengl_functions class.
 
-  class qopengl_functions : public opengl_functions
-  {
-  public:
+class qopengl_functions : public opengl_functions
+{
+public:
 
-    qopengl_functions (void)
+  qopengl_functions (void)
 #if defined (HAVE_QOPENGLFUNCTIONS_1_1)
-      : m_glfcns ()
+    : m_glfcns ()
 #endif
-    { }
+  { }
 
-    qopengl_functions (const qopengl_functions&) = default;
+  qopengl_functions (const qopengl_functions&) = default;
 
-    qopengl_functions& operator = (const qopengl_functions&) = default;
+  qopengl_functions& operator = (const qopengl_functions&) = default;
 
-    ~qopengl_functions (void) = default;
+  ~qopengl_functions (void) = default;
 
-    void init (void)
-    {
+  void init (void)
+  {
 #if defined (HAVE_QOPENGLFUNCTIONS_1_1)
-      m_glfcns.initializeOpenGLFunctions ();
+    m_glfcns.initializeOpenGLFunctions ();
 #endif
-    }
+  }
 
 #if defined (HAVE_QOPENGLFUNCTIONS_1_1)
 
-    void glAlphaFunc (GLenum fcn, GLclampf ref)
-    {
-      m_glfcns.glAlphaFunc (fcn, ref);
-    }
+  void glAlphaFunc (GLenum fcn, GLclampf ref)
+  {
+    m_glfcns.glAlphaFunc (fcn, ref);
+  }
 
-    void glBegin (GLenum mode)
-    {
-      m_glfcns.glBegin (mode);
-    }
+  void glBegin (GLenum mode)
+  {
+    m_glfcns.glBegin (mode);
+  }
 
-    void glBindTexture (GLenum target, GLuint texture)
-    {
-      m_glfcns.glBindTexture (target, texture);
-    }
+  void glBindTexture (GLenum target, GLuint texture)
+  {
+    m_glfcns.glBindTexture (target, texture);
+  }
 
-    void glBitmap (GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig,
-                   GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
-    {
-      m_glfcns.glBitmap (width, height, xorig, yorig, xmove, ymove, bitmap);
-    }
+  void glBitmap (GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig,
+                 GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
+  {
+    m_glfcns.glBitmap (width, height, xorig, yorig, xmove, ymove, bitmap);
+  }
 
-    void glBlendFunc (GLenum sfactor, GLenum dfactor)
-    {
-      m_glfcns.glBlendFunc (sfactor, dfactor);
-    }
+  void glBlendFunc (GLenum sfactor, GLenum dfactor)
+  {
+    m_glfcns.glBlendFunc (sfactor, dfactor);
+  }
 
-    void glCallList (GLuint list)
-    {
-      m_glfcns.glCallList (list);
-    }
+  void glCallList (GLuint list)
+  {
+    m_glfcns.glCallList (list);
+  }
 
-    void glClearColor (GLclampf red, GLclampf green, GLclampf blue,
-                       GLclampf alpha)
-    {
-      m_glfcns.glClearColor (red, green, blue, alpha);
-    }
+  void glClearColor (GLclampf red, GLclampf green, GLclampf blue,
+                     GLclampf alpha)
+  {
+    m_glfcns.glClearColor (red, green, blue, alpha);
+  }
 
-    void glClear (GLbitfield mask)
-    {
-      m_glfcns.glClear (mask);
-    }
+  void glClear (GLbitfield mask)
+  {
+    m_glfcns.glClear (mask);
+  }
 
-    void glClipPlane (GLenum plane, const GLdouble *equation)
-    {
-      m_glfcns.glClipPlane (plane, equation);
-    }
+  void glClipPlane (GLenum plane, const GLdouble *equation)
+  {
+    m_glfcns.glClipPlane (plane, equation);
+  }
 
-    void glColor3dv (const GLdouble *v)
-    {
-      m_glfcns.glColor3dv (v);
-    }
+  void glColor3dv (const GLdouble *v)
+  {
+    m_glfcns.glColor3dv (v);
+  }
 
-    void glColor3f (GLfloat red, GLfloat green, GLfloat blue)
-    {
-      m_glfcns.glColor3f (red, green, blue);
-    }
+  void glColor3f (GLfloat red, GLfloat green, GLfloat blue)
+  {
+    m_glfcns.glColor3f (red, green, blue);
+  }
 
-    void glColor3fv (const GLfloat *v)
-    {
-      m_glfcns.glColor3fv (v);
-    }
+  void glColor3fv (const GLfloat *v)
+  {
+    m_glfcns.glColor3fv (v);
+  }
 
-    void glColor4d (GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
-    {
-      m_glfcns.glColor4d (red, green, blue, alpha);
-    }
+  void glColor4d (GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
+  {
+    m_glfcns.glColor4d (red, green, blue, alpha);
+  }
 
-    void glColor4f (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-    {
-      m_glfcns.glColor4f (red, green, blue, alpha);
-    }
+  void glColor4f (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+  {
+    m_glfcns.glColor4f (red, green, blue, alpha);
+  }
 
-    void glColor4fv (const GLfloat *v)
-    {
-      m_glfcns.glColor4fv (v);
-    }
+  void glColor4fv (const GLfloat *v)
+  {
+    m_glfcns.glColor4fv (v);
+  }
 
-    void glDeleteLists (GLuint list, GLsizei range)
-    {
-      m_glfcns.glDeleteLists (list, range);
-    }
+  void glDeleteLists (GLuint list, GLsizei range)
+  {
+    m_glfcns.glDeleteLists (list, range);
+  }
 
-    void glDeleteTextures (GLsizei n, const GLuint *textures)
-    {
-      m_glfcns.glDeleteTextures (n, textures);
-    }
+  void glDeleteTextures (GLsizei n, const GLuint *textures)
+  {
+    m_glfcns.glDeleteTextures (n, textures);
+  }
 
-    void glDepthFunc (GLenum fcn)
-    {
-      m_glfcns.glDepthFunc (fcn);
-    }
+  void glDepthFunc (GLenum fcn)
+  {
+    m_glfcns.glDepthFunc (fcn);
+  }
 
-    void glDisable (GLenum cap)
-    {
-      m_glfcns.glDisable (cap);
-    }
+  void glDisable (GLenum cap)
+  {
+    m_glfcns.glDisable (cap);
+  }
 
-    void glDrawPixels (GLsizei width, GLsizei height, GLenum format,
-                       GLenum type, const GLvoid *pixels)
-    {
-      m_glfcns.glDrawPixels (width, height, format, type, pixels);
-    }
+  void glDrawPixels (GLsizei width, GLsizei height, GLenum format,
+                     GLenum type, const GLvoid *pixels)
+  {
+    m_glfcns.glDrawPixels (width, height, format, type, pixels);
+  }
 
-    void glEdgeFlag (GLboolean flag)
-    {
-      m_glfcns.glEdgeFlag (flag);
-    }
+  void glEdgeFlag (GLboolean flag)
+  {
+    m_glfcns.glEdgeFlag (flag);
+  }
 
-    void glEnable (GLenum cap)
-    {
-      m_glfcns.glEnable (cap);
-    }
+  void glEnable (GLenum cap)
+  {
+    m_glfcns.glEnable (cap);
+  }
 
-    void glEndList (void)
-    {
-      m_glfcns.glEndList ();
-    }
+  void glEndList (void)
+  {
+    m_glfcns.glEndList ();
+  }
 
-    void glEnd (void)
-    {
-      m_glfcns.glEnd ();
-    }
+  void glEnd (void)
+  {
+    m_glfcns.glEnd ();
+  }
 
-    void glFinish (void)
-    {
-      m_glfcns.glFinish ();
-    }
+  void glFinish (void)
+  {
+    m_glfcns.glFinish ();
+  }
 
-    GLuint glGenLists (GLsizei range)
-    {
-      return m_glfcns.glGenLists (range);
-    }
+  GLuint glGenLists (GLsizei range)
+  {
+    return m_glfcns.glGenLists (range);
+  }
 
-    void glGenTextures (GLsizei n, GLuint *textures)
-    {
-      m_glfcns.glGenTextures (n, textures);
-    }
+  void glGenTextures (GLsizei n, GLuint *textures)
+  {
+    m_glfcns.glGenTextures (n, textures);
+  }
 
-    void glGetBooleanv (GLenum pname, GLboolean *data)
-    {
-      m_glfcns.glGetBooleanv (pname, data);
-    }
+  void glGetBooleanv (GLenum pname, GLboolean *data)
+  {
+    m_glfcns.glGetBooleanv (pname, data);
+  }
 
-    void glGetDoublev (GLenum pname, GLdouble *data)
-    {
-      m_glfcns.glGetDoublev (pname, data);
-    }
+  void glGetDoublev (GLenum pname, GLdouble *data)
+  {
+    m_glfcns.glGetDoublev (pname, data);
+  }
 
-    GLenum glGetError (void)
-    {
-      return m_glfcns.glGetError ();
-    }
+  GLenum glGetError (void)
+  {
+    return m_glfcns.glGetError ();
+  }
 
-    void glGetFloatv (GLenum pname, GLfloat *data)
-    {
-      m_glfcns.glGetFloatv (pname, data);
-    }
+  void glGetFloatv (GLenum pname, GLfloat *data)
+  {
+    m_glfcns.glGetFloatv (pname, data);
+  }
 
-    void glGetIntegerv (GLenum pname, GLint *data)
-    {
-      m_glfcns.glGetIntegerv (pname, data);
-    }
+  void glGetIntegerv (GLenum pname, GLint *data)
+  {
+    m_glfcns.glGetIntegerv (pname, data);
+  }
 
-    const GLubyte * glGetString (GLenum name)
-    {
-      return m_glfcns.glGetString (name);
-    }
+  const GLubyte * glGetString (GLenum name)
+  {
+    return m_glfcns.glGetString (name);
+  }
 
-    void glHint (GLenum target, GLenum mode)
-    {
-      m_glfcns.glHint (target, mode);
-    }
+  void glHint (GLenum target, GLenum mode)
+  {
+    m_glfcns.glHint (target, mode);
+  }
 
-    void glInitNames (void)
-    {
-      m_glfcns.glInitNames ();
-    }
+  void glInitNames (void)
+  {
+    m_glfcns.glInitNames ();
+  }
 
-    GLboolean glIsEnabled (GLenum cap)
-    {
-      return m_glfcns.glIsEnabled (cap);
-    }
+  GLboolean glIsEnabled (GLenum cap)
+  {
+    return m_glfcns.glIsEnabled (cap);
+  }
 
-    void glLightfv (GLenum light, GLenum pname, const GLfloat *params)
-    {
-      m_glfcns.glLightfv (light, pname, params);
-    }
+  void glLightfv (GLenum light, GLenum pname, const GLfloat *params)
+  {
+    m_glfcns.glLightfv (light, pname, params);
+  }
 
-    void glLineStipple (GLint factor, GLushort pattern)
-    {
-      m_glfcns.glLineStipple (factor, pattern);
-    }
+  void glLineStipple (GLint factor, GLushort pattern)
+  {
+    m_glfcns.glLineStipple (factor, pattern);
+  }
 
-    void glLineWidth (GLfloat width)
-    {
-      m_glfcns.glLineWidth (width);
-    }
+  void glLineWidth (GLfloat width)
+  {
+    m_glfcns.glLineWidth (width);
+  }
 
-    void glLoadIdentity (void)
-    {
-      m_glfcns.glLoadIdentity ();
-    }
+  void glLoadIdentity (void)
+  {
+    m_glfcns.glLoadIdentity ();
+  }
 
-    void glMaterialf (GLenum face, GLenum pname, GLfloat param)
-    {
-      m_glfcns.glMaterialf (face, pname, param);
-    }
+  void glMaterialf (GLenum face, GLenum pname, GLfloat param)
+  {
+    m_glfcns.glMaterialf (face, pname, param);
+  }
 
-    void glMaterialfv (GLenum face, GLenum pname, const GLfloat *params)
-    {
-      m_glfcns.glMaterialfv (face, pname, params);
-    }
+  void glMaterialfv (GLenum face, GLenum pname, const GLfloat *params)
+  {
+    m_glfcns.glMaterialfv (face, pname, params);
+  }
 
-    void glMatrixMode (GLenum mode)
-    {
-      m_glfcns.glMatrixMode (mode);
-    }
+  void glMatrixMode (GLenum mode)
+  {
+    m_glfcns.glMatrixMode (mode);
+  }
 
-    void glMultMatrixd (const GLdouble *m)
-    {
-      m_glfcns.glMultMatrixd (m);
-    }
+  void glMultMatrixd (const GLdouble *m)
+  {
+    m_glfcns.glMultMatrixd (m);
+  }
 
-    void glNewList (GLuint list, GLenum mode)
-    {
-      m_glfcns.glNewList (list, mode);
-    }
+  void glNewList (GLuint list, GLenum mode)
+  {
+    m_glfcns.glNewList (list, mode);
+  }
 
-    void glNormal3d (GLdouble nx, GLdouble ny, GLdouble nz)
-    {
-      m_glfcns.glNormal3d (nx, ny, nz);
-    }
+  void glNormal3d (GLdouble nx, GLdouble ny, GLdouble nz)
+  {
+    m_glfcns.glNormal3d (nx, ny, nz);
+  }
 
-    void glNormal3dv (const GLdouble *v)
-    {
-      m_glfcns.glNormal3dv (v);
-    }
+  void glNormal3dv (const GLdouble *v)
+  {
+    m_glfcns.glNormal3dv (v);
+  }
 
-    void glOrtho (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top,
-                  GLdouble near_val, GLdouble far_val)
-    {
-      m_glfcns.glOrtho (left, right, bottom, top, near_val, far_val);
-    }
+  void glOrtho (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top,
+                GLdouble near_val, GLdouble far_val)
+  {
+    m_glfcns.glOrtho (left, right, bottom, top, near_val, far_val);
+  }
 
-    void glPixelStorei (GLenum pname, GLint param)
-    {
-      m_glfcns.glPixelStorei (pname, param);
-    }
+  void glPixelStorei (GLenum pname, GLint param)
+  {
+    m_glfcns.glPixelStorei (pname, param);
+  }
 
-    void glPixelZoom (GLfloat xfactor, GLfloat yfactor)
-    {
-      m_glfcns.glPixelZoom (xfactor, yfactor);
-    }
+  void glPixelZoom (GLfloat xfactor, GLfloat yfactor)
+  {
+    m_glfcns.glPixelZoom (xfactor, yfactor);
+  }
 
-    void glPolygonMode (GLenum face, GLenum mode)
-    {
-      m_glfcns.glPolygonMode (face, mode);
-    }
+  void glPolygonMode (GLenum face, GLenum mode)
+  {
+    m_glfcns.glPolygonMode (face, mode);
+  }
 
-    void glPolygonOffset (GLfloat factor, GLfloat units)
-    {
-      m_glfcns.glPolygonOffset (factor, units);
-    }
+  void glPolygonOffset (GLfloat factor, GLfloat units)
+  {
+    m_glfcns.glPolygonOffset (factor, units);
+  }
 
-    void glPopAttrib (void)
-    {
-      m_glfcns.glPopAttrib ();
-    }
+  void glPopAttrib (void)
+  {
+    m_glfcns.glPopAttrib ();
+  }
 
-    void glPopMatrix (void)
-    {
-      m_glfcns.glPopMatrix ();
-    }
+  void glPopMatrix (void)
+  {
+    m_glfcns.glPopMatrix ();
+  }
 
-    void glPopName (void)
-    {
-      m_glfcns.glPopName ();
-    }
+  void glPopName (void)
+  {
+    m_glfcns.glPopName ();
+  }
 
-    void glPushAttrib (GLbitfield mask)
-    {
-      m_glfcns.glPushAttrib (mask);
-    }
+  void glPushAttrib (GLbitfield mask)
+  {
+    m_glfcns.glPushAttrib (mask);
+  }
 
-    void glPushMatrix (void)
-    {
-      m_glfcns.glPushMatrix ();
-    }
+  void glPushMatrix (void)
+  {
+    m_glfcns.glPushMatrix ();
+  }
 
-    void glPushName (GLuint name)
-    {
-      m_glfcns.glPushName (name);
-    }
+  void glPushName (GLuint name)
+  {
+    m_glfcns.glPushName (name);
+  }
 
-    void glRasterPos3d (GLdouble x, GLdouble y, GLdouble z)
-    {
-      m_glfcns.glRasterPos3d (x, y, z);
-    }
+  void glRasterPos3d (GLdouble x, GLdouble y, GLdouble z)
+  {
+    m_glfcns.glRasterPos3d (x, y, z);
+  }
 
-    void glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height,
-                       GLenum format, GLenum type, GLvoid *pixels)
-    {
-      m_glfcns.glReadPixels (x, y, width, height, format, type, pixels);
-    }
+  void glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height,
+                     GLenum format, GLenum type, GLvoid *pixels)
+  {
+    m_glfcns.glReadPixels (x, y, width, height, format, type, pixels);
+  }
 
-    GLint glRenderMode (GLenum mode)
-    {
-      return m_glfcns.glRenderMode (mode);
-    }
+  GLint glRenderMode (GLenum mode)
+  {
+    return m_glfcns.glRenderMode (mode);
+  }
 
-    void glRotated (GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
-    {
-      m_glfcns.glRotated (angle, x, y, z);
-    }
+  void glRotated (GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
+  {
+    m_glfcns.glRotated (angle, x, y, z);
+  }
 
-    void glScaled (GLdouble x, GLdouble y, GLdouble z)
-    {
-      m_glfcns.glScaled (x, y, z);
-    }
+  void glScaled (GLdouble x, GLdouble y, GLdouble z)
+  {
+    m_glfcns.glScaled (x, y, z);
+  }
 
-    void glScalef (GLfloat x, GLfloat y, GLfloat z)
-    {
-      m_glfcns.glScalef (x, y, z);
-    }
+  void glScalef (GLfloat x, GLfloat y, GLfloat z)
+  {
+    m_glfcns.glScalef (x, y, z);
+  }
 
-    void glSelectBuffer (GLsizei size, GLuint *buffer)
-    {
-      m_glfcns.glSelectBuffer (size, buffer);
-    }
+  void glSelectBuffer (GLsizei size, GLuint *buffer)
+  {
+    m_glfcns.glSelectBuffer (size, buffer);
+  }
 
-    void glShadeModel (GLenum mode)
-    {
-      m_glfcns.glShadeModel (mode);
-    }
+  void glShadeModel (GLenum mode)
+  {
+    m_glfcns.glShadeModel (mode);
+  }
 
-    void glTexCoord2d (GLdouble s, GLdouble t)
-    {
-      m_glfcns.glTexCoord2d (s, t);
-    }
+  void glTexCoord2d (GLdouble s, GLdouble t)
+  {
+    m_glfcns.glTexCoord2d (s, t);
+  }
 
-    void glTexImage2D (GLenum target, GLint level, GLint internalFormat,
-                       GLsizei width, GLsizei height, GLint border,
-                       GLenum format, GLenum type, const GLvoid *pixels)
-    {
-      m_glfcns.glTexImage2D (target, level, internalFormat, width, height,
-                             border, format, type, pixels);
-    }
+  void glTexImage2D (GLenum target, GLint level, GLint internalFormat,
+                     GLsizei width, GLsizei height, GLint border,
+                     GLenum format, GLenum type, const GLvoid *pixels)
+  {
+    m_glfcns.glTexImage2D (target, level, internalFormat, width, height,
+                           border, format, type, pixels);
+  }
 
-    void glTexParameteri (GLenum target, GLenum pname, GLint param)
-    {
-      m_glfcns.glTexParameteri (target, pname, param);
-    }
+  void glTexParameteri (GLenum target, GLenum pname, GLint param)
+  {
+    m_glfcns.glTexParameteri (target, pname, param);
+  }
 
-    void glTranslated (GLdouble x, GLdouble y, GLdouble z)
-    {
-      m_glfcns.glTranslated (x, y, z);
-    }
+  void glTranslated (GLdouble x, GLdouble y, GLdouble z)
+  {
+    m_glfcns.glTranslated (x, y, z);
+  }
 
-    void glTranslatef (GLfloat x, GLfloat y, GLfloat z)
-    {
-      m_glfcns.glTranslatef (x, y, z);
-    }
+  void glTranslatef (GLfloat x, GLfloat y, GLfloat z)
+  {
+    m_glfcns.glTranslatef (x, y, z);
+  }
 
-    void glVertex2d (GLdouble x, GLdouble y)
-    {
-      m_glfcns.glVertex2d (x, y);
-    }
+  void glVertex2d (GLdouble x, GLdouble y)
+  {
+    m_glfcns.glVertex2d (x, y);
+  }
 
-    void glVertex3d (GLdouble x, GLdouble y, GLdouble z)
-    {
-      m_glfcns.glVertex3d (x, y, z);
-    }
+  void glVertex3d (GLdouble x, GLdouble y, GLdouble z)
+  {
+    m_glfcns.glVertex3d (x, y, z);
+  }
 
-    void glVertex3dv (const GLdouble *v)
-    {
-      m_glfcns.glVertex3dv (v);
-    }
+  void glVertex3dv (const GLdouble *v)
+  {
+    m_glfcns.glVertex3dv (v);
+  }
 
-    void glViewport (GLint x, GLint y, GLsizei width, GLsizei height)
-    {
-      m_glfcns.glViewport (x, y, width, height);
-    }
+  void glViewport (GLint x, GLint y, GLsizei width, GLsizei height)
+  {
+    m_glfcns.glViewport (x, y, width, height);
+  }
 
-  private:
+private:
 
-    QOpenGLFunctions_1_1 m_glfcns;
+  QOpenGLFunctions_1_1 m_glfcns;
 
 #endif
-  };
+};
 
 OCTAVE_END_NAMESPACE(octave)