Dear
PyQt4 developers -
I am currently running Python 2.5,2, with IDLE version 1.2.2 under Win_XP.
I'm new to using PyQt along with PyOpenGL. I have searched a bit and
surprised, I was unable to find the answer to my most basic question
concerning the functionality of Python's print statement when running the
PyQt4_OpenGL demo from Python's default interaction shell, IDLE. It seems
that Qt's interaction loop freezes up once the stdout buffer is perhaps
full?, in any case, using Python print statements from inside a PyQt
program seems to need more supporting infrastructure than that included in
the attached PyQtOpenGL demo..
Print statements on lines 53-62 of the attached program are currently
commented out,
such that it runs much like the original "hellogl.py" demo typically found
on the path:
C:\Python25\Lib\site-packages\PyQt4\examples\opengl.py
If one reintroduces these "print" and/or "sys.stdout.write()" program
lines, one does find some of the text making it back to IDLE's Python shell
window... but soon enough we seem to encounter program interaction
death.....
I have heard from some that Python's default interaction shell IDLE is
not all so well equipped to make all of this work, Perhaps I may need to be
looking at using a different development shell or IDE?, is there a common
denominator as to how stdout and stdin are supposed to work in a Python
environment, and do most of them handle it in the same way....it seems like
some of this may still require some further development of either the IDE's
involved, PyQt4 or perhaps Qt4, depending on where best to fix this
problem...any suggestions?
I gather there may be an easy way to establish a Qt window for displaying
the stdout stream, and /or a way to keep Python's print statements working
as they typically do inside Python's interaction shell..... It would be
great if likewise, some of Python's default keyboard/ "rawinput()" and
sys.stdin.read()" inputput logic also could work as python programmers are
familiar.. I'm sure this is covered somewhere, perhaps partly in Qt4's
doc's, and perhaps somewhere in PyQt's notes.... a pointer to any related
documentation would be great!
Please forgive me for not yet understanding the nuance of this, I'm
still pretty new to using PyQt along with OpenGL.
Thanks ahead of time for any assistance you may provide.
All the best
-Peter
#!/usr/bin/env python
print "--- Hello_PyQtOpenGL.py ------------------------------------"
print
"""PyQt4 port of the opengl/hellogl example from Qt v4.x"""
import sys
import math
#---
from PyQt4 import QtCore, QtGui, QtOpenGL
try:
from OpenGL import GL
except ImportError:
app = QtGui.QApplication(sys.argv)
QtGui.QMessageBox.critical(None, "OpenGL hellogl",
"PyOpenGL must be installed to run this example.",
QtGui.QMessageBox.Ok | QtGui.QMessageBox.Default,
QtGui.QMessageBox.NoButton)
sys.exit(1)
#----------------------------------
def Get_OpenGL_ProjectionMat() :
# glMatrixMode( GL_PROJECTION )
Mat4x4 = glGetFloatv( GL_PROJECTION_MATRIX )
return( Mat4x4.T )
def Set_OpenGL_ProjectionMat( Mat4x4 ) :
glMatrixMode( GL_PROJECTION ) # Set stupped Open_GL Matrix access
state
glLoadMatrix( Mat4x4.T )
#-----------
def Get_OpenGL_ModelViewMat() :
# glMatrixMode( GL_MODELVIEW )
Mat4x4 = glGetFloatv( GL_MODELVIEW_MATRIX )
return( Mat4x4.T )
def Set_OpenGL_ModelViewMat( Mat4x4 ) :
glMatrixMode( GL_MODELVIEW ) # Set stupped Open_GL Matrix access
state
glLoadMatrix( Mat4x4.T )
#-----------
def Print_OpenGL_Matrixs() :
pass
# print "GL_ModelViewMat:"
# sys.stdout.write( "GL_ModelViewMat:" )
# print Get_OpenGL_ModelViewMat
# print
# print "GL_ProjectionMat:"
# sys.stdout.write( "GL_ProjectionMat:" )
# print Get_OpenGL_ProjectionMat
# print
#-----------------------------------------------------------------------------
class Window(QtGui.QWidget):
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.glWidget = GLWidget()
self.xSlider = self.createSlider(QtCore.SIGNAL("xRotationChanged(int)"),
self.glWidget.setXRotation)
self.ySlider = self.createSlider(QtCore.SIGNAL("yRotationChanged(int)"),
self.glWidget.setYRotation)
self.zSlider = self.createSlider(QtCore.SIGNAL("zRotationChanged(int)"),
self.glWidget.setZRotation)
mainLayout = QtGui.QHBoxLayout()
mainLayout.addWidget(self.glWidget)
mainLayout.addWidget(self.xSlider)
mainLayout.addWidget(self.ySlider)
mainLayout.addWidget(self.zSlider)
self.setLayout(mainLayout)
self.xSlider.setValue(15 * 16)
self.ySlider.setValue(345 * 16)
self.zSlider.setValue(0 * 16)
self.setWindowTitle(self.tr("Hello_PyQtOpenGL"))
def createSlider(self, changedSignal, setterSlot):
slider = QtGui.QSlider(QtCore.Qt.Vertical)
slider.setRange(0, 360 * 16)
slider.setSingleStep(16)
slider.setPageStep(15 * 16)
slider.setTickInterval(15 * 16)
slider.setTickPosition(QtGui.QSlider.TicksRight)
self.glWidget.connect(slider, QtCore.SIGNAL("valueChanged(int)"),
setterSlot)
self.connect(self.glWidget, changedSignal, slider,
QtCore.SLOT("setValue(int)"))
return slider
#------
class GLWidget(QtOpenGL.QGLWidget):
def __init__(self, parent=None):
QtOpenGL.QGLWidget.__init__(self, parent)
self.object = 0
self.xRot = 0
self.yRot = 0
self.zRot = 0
self.lastPos = QtCore.QPoint()
self.trolltechGreen = QtGui.QColor.fromCmykF(0.40, 0.0, 1.0, 0.0)
self.trolltechPurple = QtGui.QColor.fromCmykF(0.39, 0.39, 0.0, 0.0)
def xRotation(self):
return self.xRot
def yRotation(self):
return self.yRot
def zRotation(self):
return self.zRot
def minimumSizeHint(self):
return QtCore.QSize(50, 50)
def sizeHint(self):
# return QtCore.QSize(400, 400)
return QtCore.QSize(800, 800)
def setXRotation(self, angle):
angle = self.normalizeAngle(angle)
if angle != self.xRot:
self.xRot = angle
self.emit(QtCore.SIGNAL("xRotationChanged(int)"), angle)
self.updateGL()
def setYRotation(self, angle):
angle = self.normalizeAngle(angle)
if angle != self.yRot:
self.yRot = angle
self.emit(QtCore.SIGNAL("yRotationChanged(int)"), angle)
self.updateGL()
def setZRotation(self, angle):
angle = self.normalizeAngle(angle)
if angle != self.zRot:
self.zRot = angle
self.emit(QtCore.SIGNAL("zRotationChanged(int)"), angle)
self.updateGL()
def initializeGL(self):
self.qglClearColor(self.trolltechPurple.dark())
self.object = self.makeObject()
GL.glShadeModel(GL.GL_FLAT)
GL.glEnable(GL.GL_DEPTH_TEST)
GL.glEnable(GL.GL_CULL_FACE)
def paintGL(self):
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
GL.glLoadIdentity()
GL.glTranslated(0.0, 0.0, -10.0)
GL.glRotated(self.xRot / 16.0, 1.0, 0.0, 0.0)
GL.glRotated(self.yRot / 16.0, 0.0, 1.0, 0.0)
GL.glRotated(self.zRot / 16.0, 0.0, 0.0, 1.0)
Print_OpenGL_Matrixs() # For debuging Python
side OpenGL matrix creation
GL.glCallList(self.object)
def resizeGL(self, width, height):
side = min(width, height)
GL.glViewport((width - side) / 2, (height - side) / 2, side, side)
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glLoadIdentity()
GL.glOrtho(-0.5, +0.5, +0.5, -0.5, 4.0, 15.0)
GL.glMatrixMode(GL.GL_MODELVIEW)
def mousePressEvent(self, event):
self.lastPos = QtCore.QPoint(event.pos())
def mouseMoveEvent(self, event):
dx = event.x() - self.lastPos.x()
dy = event.y() - self.lastPos.y()
if event.buttons() & QtCore.Qt.LeftButton:
self.setXRotation(self.xRot + 8 * dy)
self.setYRotation(self.yRot + 8 * dx)
elif event.buttons() & QtCore.Qt.RightButton:
self.setXRotation(self.xRot + 8 * dy)
self.setZRotation(self.zRot + 8 * dx)
self.lastPos = QtCore.QPoint(event.pos())
def makeObject(self):
genList = GL.glGenLists(1)
GL.glNewList(genList, GL.GL_COMPILE)
GL.glBegin(GL.GL_QUADS)
x1 = +0.06
y1 = -0.14
x2 = +0.14
y2 = -0.06
x3 = +0.08
y3 = +0.00
x4 = +0.30
y4 = +0.22
self.quad(x1, y1, x2, y2, y2, x2, y1, x1)
self.quad(x3, y3, x4, y4, y4, x4, y3, x3)
self.extrude(x1, y1, x2, y2)
self.extrude(x2, y2, y2, x2)
self.extrude(y2, x2, y1, x1)
self.extrude(y1, x1, x1, y1)
self.extrude(x3, y3, x4, y4)
self.extrude(x4, y4, y4, x4)
self.extrude(y4, x4, y3, x3)
Pi = 3.14159265358979323846
NumSectors = 200
for i in range(NumSectors):
angle1 = (i * 2 * Pi) / NumSectors
x5 = 0.30 * math.sin(angle1)
y5 = 0.30 * math.cos(angle1)
x6 = 0.20 * math.sin(angle1)
y6 = 0.20 * math.cos(angle1)
angle2 = ((i + 1) * 2 * Pi) / NumSectors
x7 = 0.20 * math.sin(angle2)
y7 = 0.20 * math.cos(angle2)
x8 = 0.30 * math.sin(angle2)
y8 = 0.30 * math.cos(angle2)
self.quad(x5, y5, x6, y6, x7, y7, x8, y8)
self.extrude(x6, y6, x7, y7)
self.extrude(x8, y8, x5, y5)
GL.glEnd()
GL.glEndList()
return genList
def quad(self, x1, y1, x2, y2, x3, y3, x4, y4):
self.qglColor(self.trolltechGreen)
GL.glVertex3d(x1, y1, -0.05)
GL.glVertex3d(x2, y2, -0.05)
GL.glVertex3d(x3, y3, -0.05)
GL.glVertex3d(x4, y4, -0.05)
GL.glVertex3d(x4, y4, +0.05)
GL.glVertex3d(x3, y3, +0.05)
GL.glVertex3d(x2, y2, +0.05)
GL.glVertex3d(x1, y1, +0.05)
def extrude(self, x1, y1, x2, y2):
self.qglColor(self.trolltechGreen.dark(250 + int(100 * x1)))
GL.glVertex3d(x1, y1, +0.05)
GL.glVertex3d(x2, y2, +0.05)
GL.glVertex3d(x2, y2, -0.05)
GL.glVertex3d(x1, y1, -0.05)
def normalizeAngle(self, angle):
while angle < 0:
angle += 360 * 16
while angle > 360 * 16:
angle -= 360 * 16
return angle
#--------------------------------------
if __name__ == '__main__':
app = QtGui.QApplication(sys.argv)
window = Window()
window.show()
# sys.exit(app.exec_())
print
print "--- Hello_PyQtOpenGL.py --- Done ------------------------------"
_______________________________________________
PyQt mailing list PyQt@riverbankcomputing.com
http://www.riverbankcomputing.com/mailman/listinfo/pyqt
