Du kannst nicht mehr als 25 Themen auswählen
Themen müssen entweder mit einem Buchstaben oder einer Ziffer beginnen. Sie können Bindestriche („-“) enthalten und bis zu 35 Zeichen lang sein.
620 Zeilen
22 KiB
620 Zeilen
22 KiB
#!/usr/bin/env python
|
|
|
|
import sys
|
|
from python_tqt.qt import *
|
|
from python_tqt.qtcanvas import *
|
|
import random
|
|
|
|
|
|
True = 1
|
|
False = 0
|
|
butterfly_fn = TQString.null
|
|
butterflyimg = []
|
|
logo_fn = TQString.null
|
|
logoimg = []
|
|
bouncy_logo = None
|
|
views = []
|
|
|
|
|
|
class ImageItem(TQCanvasRectangle):
|
|
def __init__(self,img,canvas):
|
|
TQCanvasRectangle.__init__(self,canvas)
|
|
self.imageRTTI=984376
|
|
self.image=img
|
|
self.pixmap=TQPixmap()
|
|
self.setSize(self.image.width(), self.image.height())
|
|
self.pixmap.convertFromImage(self.image, TQt.OrderedAlphaDither);
|
|
|
|
def rtti(self):
|
|
return self.imageRTTI
|
|
|
|
def hit(self,p):
|
|
ix = p.x()-self.x()
|
|
iy = p.y()-self.y()
|
|
if not self.image.valid( ix , iy ):
|
|
return False
|
|
self.pixel = self.image.pixel( ix, iy )
|
|
return (tqAlpha( self.pixel ) != 0)
|
|
|
|
def drawShape(self,p):
|
|
p.drawPixmap( self.x(), self.y(), self.pixmap )
|
|
|
|
|
|
class NodeItem(TQCanvasEllipse):
|
|
def __init__(self,canvas):
|
|
TQCanvasEllipse.__init__(self,6,6,canvas)
|
|
self.__inList=[]
|
|
self.__outList=[]
|
|
self.setPen(TQPen(TQt.black))
|
|
self.setBrush(TQBrush(TQt.red))
|
|
self.setZ(128)
|
|
|
|
def addInEdge(self,edge):
|
|
self.__inList.append(edge)
|
|
|
|
def addOutEdge(self,edge):
|
|
self.__outList.append(edge)
|
|
|
|
def moveBy(self,dx,dy):
|
|
TQCanvasEllipse.moveBy(self,dx,dy)
|
|
for each_edge in self.__inList:
|
|
each_edge.setToPoint( int(self.x()), int(self.y()) )
|
|
for each_edge in self.__outList:
|
|
each_edge.setFromPoint( int(self.x()), int(self.y()) )
|
|
|
|
class EdgeItem(TQCanvasLine):
|
|
__c=0
|
|
def __init__(self,fromNode, toNode,canvas):
|
|
TQCanvasLine.__init__(self,canvas)
|
|
self.__c=self.__c+1
|
|
self.setPen(TQPen(TQt.black))
|
|
self.setBrush(TQBrush(TQt.red))
|
|
fromNode.addOutEdge(self)
|
|
toNode.addInEdge(self)
|
|
self.setPoints(int(fromNode.x()),int(fromNode.y()), int(toNode.x()), int(toNode.y()))
|
|
self.setZ(127)
|
|
|
|
def setFromPoint(self,x,y):
|
|
self.setPoints(x,y,self.endPoint().x(),self.endPoint().y())
|
|
|
|
def setToPoint(self,x,y):
|
|
self.setPoints(self.startPoint().x(), self.startPoint().y(),x,y)
|
|
|
|
def count(self):
|
|
return self.__c
|
|
|
|
def moveBy(self,dx,dy):
|
|
pass
|
|
|
|
|
|
class FigureEditor(TQCanvasView):
|
|
def __init__(self,c,parent,name,f):
|
|
TQCanvasView.__init__(self,c,parent,name,f)
|
|
self.__moving=0
|
|
self.__moving_start= 0
|
|
|
|
def contentsMousePressEvent(self,e): # TQMouseEvent e
|
|
point = self.inverseWorldMatrix().map(e.pos())
|
|
ilist = self.canvas().collisions(point) #TQCanvasItemList ilist
|
|
for each_item in ilist:
|
|
if each_item.rtti()==984376:
|
|
if not each_item.hit(point):
|
|
continue
|
|
self.__moving=each_item
|
|
self.__moving_start=point
|
|
return
|
|
self.__moving=0
|
|
|
|
def clear(self):
|
|
ilist = self.canvas().allItems()
|
|
for each_item in ilist:
|
|
if each_item:
|
|
each_item.setCanvas(None)
|
|
del each_item
|
|
self.canvas().update()
|
|
|
|
def contentsMouseMoveEvent(self,e):
|
|
if self.__moving :
|
|
point = self.inverseWorldMatrix().map(e.pos());
|
|
self.__moving.moveBy(point.x() - self.__moving_start.x(),point.y() - self.__moving_start.y())
|
|
self.__moving_start = point
|
|
self.canvas().update()
|
|
|
|
|
|
class BouncyLogo(TQCanvasSprite):
|
|
def __init__(self,canvas):
|
|
# Make sure the logo exists.
|
|
global bouncy_logo
|
|
if bouncy_logo is None:
|
|
bouncy_logo=TQCanvasPixmapArray("qt-trans.xpm")
|
|
|
|
TQCanvasSprite.__init__(self,None,canvas)
|
|
self.setSequence(bouncy_logo)
|
|
self.setAnimated(True)
|
|
self.initPos()
|
|
self.logo_rtti=1234
|
|
|
|
def rtti(self):
|
|
return self.logo_rtti
|
|
|
|
def initPos(self):
|
|
self.initSpeed()
|
|
trial=1000
|
|
self.move(random.random()%self.canvas().width(), random.random()%self.canvas().height())
|
|
self.advance(0)
|
|
trial=trial-1
|
|
while (trial & (self.xVelocity()==0 )& (self.yVelocity()==0)):
|
|
elf.move(random.random()%self.canvas().width(), random.random()%self.canvas().height())
|
|
self.advance(0)
|
|
trial=trial-1
|
|
|
|
def initSpeed(self):
|
|
speed=4.0
|
|
d=random.random()%1024/1024.0
|
|
self.setVelocity(d*speed*2-speed, (1-d)*speed*2-speed)
|
|
|
|
def advance(self,stage):
|
|
if stage==0:
|
|
vx=self.xVelocity()
|
|
vy=self.yVelocity()
|
|
if (vx==0.0) & (vy==0.0):
|
|
self.initSpeed()
|
|
vx=self.xVelocity()
|
|
vy=self.yVelocity()
|
|
|
|
nx=self.x()+vx
|
|
ny=self.y()+vy
|
|
|
|
if (nx<0) | (nx >= self.canvas().width()):
|
|
vx=-vx
|
|
if (ny<0) | (ny >= self.canvas().height()):
|
|
vy=-vy
|
|
|
|
for bounce in [0,1,2,3]:
|
|
l=self.collisions(False)
|
|
for hit in l:
|
|
if (hit.rtti()==1234) & (hit.collidesWith(self)):
|
|
if bounce==0:
|
|
vx=-vx
|
|
elif bounce==1:
|
|
vy=-vy
|
|
vx=-vx
|
|
elif bounce==2:
|
|
vx=-vx
|
|
elif bounce==3:
|
|
vx=0
|
|
vy=0
|
|
self.setVelocity(vx,vy)
|
|
break
|
|
|
|
if (self.x()+vx < 0) | (self.x()+vx >= self.canvas().width()):
|
|
vx=0
|
|
if (self.y()+vy < 0) | (self.y()+vy >= self.canvas().height()):
|
|
vy=0
|
|
|
|
self.setVelocity(vx,vy)
|
|
elif stage==1:
|
|
TQCanvasItem.advance(self,stage)
|
|
|
|
|
|
class Main (TQMainWindow):
|
|
def __init__(self,c,parent,name,f=0):
|
|
TQMainWindow.__init__(self,parent,name,f)
|
|
self.editor=FigureEditor(c,self,name,f)
|
|
self.printer=TQPrinter()
|
|
self.dbf_id=0
|
|
self.canvas=c
|
|
self.mainCount=0
|
|
file=TQPopupMenu(self.menuBar())
|
|
file.insertItem("&Fill canvas", self.init, TQt.CTRL+TQt.Key_F)
|
|
file.insertItem("&Erase canvas", self.clear, TQt.CTRL+TQt.Key_E)
|
|
file.insertItem("&New view", self.newView, TQt.CTRL+TQt.Key_N)
|
|
file.insertSeparator();
|
|
file.insertItem("&Print", self._print, TQt.CTRL+TQt.Key_P)
|
|
file.insertSeparator()
|
|
file.insertItem("E&xit", tqApp, SLOT("quit()"), TQt.CTRL+TQt.Key_Q)
|
|
self.menuBar().insertItem("&File", file)
|
|
|
|
edit = TQPopupMenu(self.menuBar() )
|
|
edit.insertItem("Add &Circle", self.addCircle, TQt.ALT+TQt.Key_C)
|
|
edit.insertItem("Add &Hexagon", self.addHexagon, TQt.ALT+TQt.Key_H)
|
|
edit.insertItem("Add &Polygon", self.addPolygon, TQt.ALT+TQt.Key_P)
|
|
edit.insertItem("Add Spl&ine", self.addSpline, TQt.ALT+TQt.Key_I)
|
|
edit.insertItem("Add &Text", self.addText, TQt.ALT+TQt.Key_T)
|
|
edit.insertItem("Add &Line", self.addLine, TQt.ALT+TQt.Key_L)
|
|
edit.insertItem("Add &Rectangle", self.addRectangle, TQt.ALT+TQt.Key_R)
|
|
edit.insertItem("Add &Sprite", self.addSprite, TQt.ALT+TQt.Key_S)
|
|
edit.insertItem("Create &Mesh", self.addMesh, TQt.ALT+TQt.Key_M )
|
|
edit.insertItem("Add &Alpha-blended image", self.addButterfly, TQt.ALT+TQt.Key_A)
|
|
self.menuBar().insertItem("&Edit", edit)
|
|
|
|
view = TQPopupMenu(self.menuBar() );
|
|
view.insertItem("&Enlarge", self.enlarge, TQt.SHIFT+TQt.CTRL+TQt.Key_Plus);
|
|
view.insertItem("Shr&ink", self.shrink, TQt.SHIFT+TQt.CTRL+TQt.Key_Minus);
|
|
view.insertSeparator();
|
|
view.insertItem("&Rotate clockwise", self.rotateClockwise, TQt.CTRL+TQt.Key_PageDown);
|
|
view.insertItem("Rotate &counterclockwise", self.rotateCounterClockwise, TQt.CTRL+TQt.Key_PageUp);
|
|
view.insertItem("&Zoom in", self.zoomIn, TQt.CTRL+TQt.Key_Plus);
|
|
view.insertItem("Zoom &out", self.zoomOut, TQt.CTRL+TQt.Key_Minus);
|
|
view.insertItem("Translate left", self.moveL, TQt.CTRL+TQt.Key_Left);
|
|
view.insertItem("Translate right", self.moveR, TQt.CTRL+TQt.Key_Right);
|
|
view.insertItem("Translate up", self.moveU, TQt.CTRL+TQt.Key_Up);
|
|
view.insertItem("Translate down", self.moveD, TQt.CTRL+TQt.Key_Down);
|
|
view.insertItem("&Mirror", self.mirror, TQt.CTRL+TQt.Key_Home);
|
|
self.menuBar().insertItem("&View", view)
|
|
|
|
self.options = TQPopupMenu( self.menuBar() );
|
|
self.dbf_id = self.options.insertItem("Double buffer", self.toggleDoubleBuffer)
|
|
self.options.setItemChecked(self.dbf_id, True)
|
|
self.menuBar().insertItem("&Options",self.options)
|
|
|
|
self.menuBar().insertSeparator();
|
|
|
|
help = TQPopupMenu( self.menuBar() )
|
|
help.insertItem("&About", self.help, TQt.Key_F1)
|
|
help.insertItem("&About TQt", self.aboutTQt, TQt.Key_F2)
|
|
help.setItemChecked(self.dbf_id, True)
|
|
self.menuBar().insertItem("&Help",help)
|
|
|
|
self.statusBar()
|
|
|
|
self.setCentralWidget(self.editor)
|
|
|
|
self.printer = 0
|
|
self.tb=0
|
|
self.tp=0
|
|
|
|
self.init()
|
|
|
|
def init(self):
|
|
self.clear()
|
|
r=24
|
|
r=r+1
|
|
random.seed(r)
|
|
for i in range(self.canvas.width()/56):
|
|
self.addButterfly()
|
|
for j in range(self.canvas.width()/85):
|
|
self.addHexagon()
|
|
for k in range(self.canvas.width()/128):
|
|
self.addLogo()
|
|
|
|
def newView(self):
|
|
m=Main(self.canvas,None,"new windiw",TQt.WDestructiveClose)
|
|
tqApp.setMainWidget(m)
|
|
m.show()
|
|
tqApp.setMainWidget(None)
|
|
views.append(m)
|
|
|
|
def clear(self):
|
|
self.editor.clear()
|
|
|
|
def help(self):
|
|
TQMessageBox.information(None, "PyTQt Canvas Example",
|
|
"<h3>The PyTQt TQCanvas classes example</h3><hr>"
|
|
"<p>This is the PyTQt implementation of "
|
|
"TQt canvas example.</p> by Sadi Kose "
|
|
"<i>(kose@nuvox.net)</i><hr>"
|
|
"<ul>"
|
|
"<li> Press ALT-S for some sprites."
|
|
"<li> Press ALT-C for some circles."
|
|
"<li> Press ALT-L for some lines."
|
|
"<li> Drag the objects around."
|
|
"<li> Read the code!"
|
|
"</ul>","Dismiss")
|
|
|
|
def aboutTQt(self):
|
|
TQMessageBox.aboutTQt(self,"PyTQt Canvas Example")
|
|
|
|
def toggleDoubleBuffer(self):
|
|
s = not self.options.isItemChecked(self.dbf_id)
|
|
self.options.setItemChecked(self.dbf_id,s)
|
|
self.canvas.setDoubleBuffering(s)
|
|
|
|
def enlarge(self):
|
|
self.canvas.resize(self.canvas.width()*4/3, self.canvas.height()*4/3)
|
|
|
|
def shrink(self):
|
|
self.canvas.resize(self.canvas.width()*3/4, self.canvas.height()*3/4)
|
|
|
|
def rotateClockwise(self):
|
|
m = self.editor.worldMatrix()
|
|
m.rotate( 22.5 )
|
|
self.editor.setWorldMatrix( m )
|
|
|
|
def rotateCounterClockwise(self):
|
|
m = self.editor.worldMatrix()
|
|
m.rotate( -22.5 )
|
|
self.editor.setWorldMatrix( m )
|
|
|
|
def zoomIn(self):
|
|
m = self.editor.worldMatrix()
|
|
m.scale( 2.0, 2.0 )
|
|
self.editor.setWorldMatrix( m )
|
|
|
|
def zoomOut(self):
|
|
m = self.editor.worldMatrix()
|
|
m.scale( 0.5, 0.5 )
|
|
self.editor.setWorldMatrix( m )
|
|
|
|
def mirror(self):
|
|
m = self.editor.worldMatrix()
|
|
m.scale( -1, 1 )
|
|
self.editor.setWorldMatrix( m )
|
|
|
|
def moveL(self):
|
|
m = self.editor.worldMatrix()
|
|
m.translate( -16, 0 )
|
|
self.editor.setWorldMatrix( m )
|
|
|
|
def moveR(self):
|
|
m = self.editor.worldMatrix()
|
|
m.translate( +16, 0 )
|
|
self.editor.setWorldMatrix( m )
|
|
|
|
def moveU(self):
|
|
m = self.editor.worldMatrix()
|
|
m.translate( 0, -16 )
|
|
self.editor.setWorldMatrix( m )
|
|
|
|
def moveD(self):
|
|
m = self.editor.worldMatrix();
|
|
m.translate( 0, +16 );
|
|
self.editor.setWorldMatrix( m )
|
|
|
|
def _print(self):
|
|
if not self.printer:
|
|
self.printer = TQPrinter()
|
|
if self.printer.setup(self) :
|
|
pp=TQPainter(self.printer)
|
|
self.canvas.drawArea(TQRect(0,0,self.canvas.width(),self.canvas.height()),pp,False)
|
|
|
|
def addSprite(self):
|
|
i = BouncyLogo(self.canvas)
|
|
i.setZ(256*random.random()%256);
|
|
i.show();
|
|
|
|
def addButterfly(self):
|
|
if butterfly_fn.isEmpty():
|
|
return
|
|
if not butterflyimg:
|
|
butterflyimg.append(TQImage())
|
|
butterflyimg[0].load(butterfly_fn)
|
|
butterflyimg.append(TQImage())
|
|
butterflyimg[1] = butterflyimg[0].smoothScale( int(butterflyimg[0].width()*0.75),
|
|
int(butterflyimg[0].height()*0.75) )
|
|
butterflyimg.append(TQImage())
|
|
butterflyimg[2] = butterflyimg[0].smoothScale( int(butterflyimg[0].width()*0.5),
|
|
int(butterflyimg[0].height()*0.5) )
|
|
butterflyimg.append(TQImage())
|
|
butterflyimg[3] = butterflyimg[0].smoothScale( int(butterflyimg[0].width()*0.25),
|
|
int(butterflyimg[0].height()*0.25) )
|
|
|
|
i = ImageItem(butterflyimg[int(4*random.random()%4)],self.canvas)
|
|
i.move((self.canvas.width()-butterflyimg[0].width())*random.random()%(self.canvas.width()-butterflyimg[0].width()),
|
|
(self.canvas.height()-butterflyimg[0].height())*random.random()%(self.canvas.height()-butterflyimg[0].height()))
|
|
i.setZ(256*random.random()%256+250);
|
|
i.show()
|
|
|
|
def addLogo(self):
|
|
if logo_fn.isEmpty():
|
|
return;
|
|
if not logoimg:
|
|
logoimg.append(TQImage())
|
|
logoimg[0].load( logo_fn )
|
|
logoimg.append(TQImage())
|
|
logoimg[1] = logoimg[0].smoothScale( int(logoimg[0].width()*0.75),
|
|
int(logoimg[0].height()*0.75) )
|
|
logoimg.append(TQImage())
|
|
logoimg[2] = logoimg[0].smoothScale( int(logoimg[0].width()*0.5),
|
|
int(logoimg[0].height()*0.5) )
|
|
logoimg.append(TQImage())
|
|
logoimg[3] = logoimg[0].smoothScale( int(logoimg[0].width()*0.25),
|
|
int(logoimg[0].height()*0.25) );
|
|
|
|
i = ImageItem(logoimg[int(4*random.random()%4)],self.canvas)
|
|
i.move((self.canvas.width()-logoimg[0].width())*random.random()%(self.canvas.width()-logoimg[0].width()),
|
|
(self.canvas.height()-logoimg[0].width())*random.random()%(self.canvas.height()-logoimg[0].width()))
|
|
i.setZ(256*random.random()%256+256)
|
|
i.show()
|
|
|
|
def addCircle(self):
|
|
i = TQCanvasEllipse(50,50,self.canvas)
|
|
i.setBrush( TQBrush(TQColor(256*random.random()%32*8,256*random.random()%32*8,256*random.random()%32*8) ))
|
|
i.move(self.canvas.width()*random.random()%self.canvas.width(),self.canvas.width()*random.random()%self.canvas.height())
|
|
i.setZ(256*random.random()%256)
|
|
i.show()
|
|
|
|
def addHexagon(self):
|
|
i = TQCanvasPolygon(self.canvas)
|
|
size = canvas.width() / 25
|
|
pa=TQPointArray(6)
|
|
pa.setPoint(0,TQPoint(2*size,0))
|
|
pa.setPoint(1,TQPoint(size,-size*173/100))
|
|
pa.setPoint(2,TQPoint(-size,-size*173/100))
|
|
pa.setPoint(3,TQPoint(-2*size,0))
|
|
pa.setPoint(4,TQPoint(-size,size*173/100))
|
|
pa.setPoint(5,TQPoint(size,size*173/100))
|
|
i.setPoints(pa)
|
|
i.setBrush( TQBrush(TQColor(256*random.random()%32*8,256*random.random()%32*8,256*random.random()%32*8) ))
|
|
i.move(self.canvas.width()*random.random()%self.canvas.width(),self.canvas.width()*random.random()%self.canvas.height())
|
|
i.setZ(256*random.random()%256)
|
|
i.show()
|
|
|
|
def addPolygon(self):
|
|
i = TQCanvasPolygon(self.canvas)
|
|
size = self.canvas.width()/2
|
|
pa=TQPointArray(6)
|
|
pa.setPoint(0, TQPoint(0,0))
|
|
pa.setPoint(1, TQPoint(size,size/5))
|
|
pa.setPoint(2, TQPoint(size*4/5,size))
|
|
pa.setPoint(3, TQPoint(size/6,size*5/4))
|
|
pa.setPoint(4, TQPoint(size*3/4,size*3/4))
|
|
pa.setPoint(5, TQPoint(size*3/4,size/4))
|
|
|
|
i.setPoints(pa)
|
|
i.setBrush(TQBrush( TQColor(256*random.random()%32*8,256*random.random()%32*8,256*random.random()%32*8)) )
|
|
i.move(self.canvas.width()*random.random()%self.canvas.width(),self.canvas.width()*random.random()%self.canvas.height())
|
|
i.setZ(256*random.random()%256)
|
|
i.show()
|
|
|
|
def addSpline(self):
|
|
i = TQCanvasSpline(self.canvas)
|
|
size = canvas.width()/6
|
|
pa=TQPointArray(12)
|
|
pa.setPoint(0,TQPoint(0,0))
|
|
pa.setPoint(1,TQPoint(size/2,0))
|
|
pa.setPoint(2,TQPoint(size,size/2))
|
|
pa.setPoint(3,TQPoint(size,size))
|
|
pa.setPoint(4,TQPoint(size,size*3/2))
|
|
pa.setPoint(5,TQPoint(size/2,size*2))
|
|
pa.setPoint(6,TQPoint(0,size*2))
|
|
pa.setPoint(7,TQPoint(-size/2,size*2))
|
|
pa.setPoint(8,TQPoint(size/4,size*3/2))
|
|
pa.setPoint(9,TQPoint(0,size))
|
|
pa.setPoint(10,TQPoint(-size/4,size/2))
|
|
pa.setPoint(11,TQPoint(-size/2,0))
|
|
i.setControlPoints(pa)
|
|
i.setBrush( TQBrush(TQColor(256*random.random()%32*8,256*random.random()%32*8,256*random.random()%32*8) ))
|
|
i.move(self.canvas.width()*random.random()%self.canvas.width(),self.canvas.width()*random.random()%self.canvas.height())
|
|
i.setZ(256*random.random()%256)
|
|
i.show()
|
|
|
|
def addText(self):
|
|
i = TQCanvasText(self.canvas)
|
|
i.setText("TQCanvasText")
|
|
i.move(self.canvas.width()*random.random()%self.canvas.width(),self.canvas.width()*random.random()%self.canvas.height())
|
|
i.setZ(256*random.random()%256)
|
|
i.show()
|
|
|
|
def addLine(self):
|
|
i = TQCanvasLine(self.canvas);
|
|
i.setPoints( self.canvas.width()*random.random()%self.canvas.width(), self.canvas.width()*random.random()%self.canvas.height(),
|
|
self.canvas.width()*random.random()%self.canvas.width(), self.canvas.width()*random.random()%self.canvas.height() )
|
|
i.setPen( TQPen(TQColor(256*random.random()%32*8,256*random.random()%32*8,256*random.random()%32*8), 6) )
|
|
i.setZ(256*random.random()%256)
|
|
i.show()
|
|
|
|
def ternary(self,exp,x,y):
|
|
if exp:
|
|
return x
|
|
else:
|
|
return y
|
|
|
|
def addMesh(self):
|
|
x0 = 0;
|
|
y0 = 0;
|
|
|
|
if not self.tb:
|
|
self.tb = TQBrush( TQt.red )
|
|
if not self.tp:
|
|
self.tp = TQPen( TQt.black )
|
|
|
|
nodecount = 0;
|
|
|
|
w = self.canvas.width()
|
|
h = self.canvas.height()
|
|
|
|
dist = 30
|
|
rows = h / dist
|
|
cols = w / dist
|
|
|
|
#ifndef QT_NO_PROGRESSDIALOG
|
|
#progress=TQProgressDialog( "Creating mesh...", "Abort", rows,
|
|
# self, "progress", True );
|
|
#endif
|
|
|
|
lastRow=[]
|
|
for c in range(cols):
|
|
lastRow.append(NodeItem(self.canvas))
|
|
for j in range(rows):
|
|
n = self.ternary(j%2 , cols-1 , cols)
|
|
prev = 0;
|
|
for i in range(n):
|
|
el = NodeItem( self.canvas )
|
|
nodecount=nodecount+1
|
|
r = 20*20*random.random()
|
|
xrand = r %20
|
|
yrand = (r/20) %20
|
|
el.move( xrand + x0 + i*dist + self.ternary(j%2 , dist/2 , 0 ),
|
|
yrand + y0 + j*dist );
|
|
|
|
if j > 0 :
|
|
if i < cols-1 :
|
|
EdgeItem( lastRow[i], el, self.canvas ).show()
|
|
if j%2 :
|
|
EdgeItem( lastRow[i+1], el, self.canvas ).show()
|
|
elif i > 0 :
|
|
EdgeItem( lastRow[i-1], el, self.canvas ).show()
|
|
if prev:
|
|
EdgeItem( prev, el, self.canvas ).show()
|
|
|
|
if i > 0 :
|
|
lastRow[i-1] = prev
|
|
prev = el
|
|
el.show()
|
|
|
|
lastRow[n-1]=prev
|
|
#ifndef QT_NO_PROGRESSDIALOG
|
|
#progress.setProgress( j )
|
|
#if progress.wasCancelled() :
|
|
# break
|
|
#endif
|
|
|
|
#ifndef QT_NO_PROGRESSDIALOG
|
|
#progress.setProgress( rows )
|
|
#endif
|
|
#// tqDebug( "%d nodes, %d edges", nodecount, EdgeItem::count() );
|
|
|
|
def addRectangle(self):
|
|
i = TQCanvasRectangle( self.canvas.width()*random.random()%self.canvas.width(),
|
|
self.canvas.width()*random.random()%self.canvas.height(),
|
|
self.canvas.width()/5,self.canvas.width()/5,self.canvas)
|
|
z = 256*random.random()%256
|
|
i.setBrush( TQBrush(TQColor(z,z,z) ))
|
|
i.setPen( TQPen(TQColor(self.canvas.width()*random.random()%32*8,
|
|
self.canvas.width()*random.random()%32*8,
|
|
self.canvas.width()*random.random()%32*8), 6) )
|
|
i.setZ(z)
|
|
i.show()
|
|
|
|
|
|
if __name__=='__main__':
|
|
app=TQApplication(sys.argv)
|
|
|
|
if len(sys.argv) > 1:
|
|
butterfly_fn=TQString(sys.argv[1])
|
|
else:
|
|
butterfly_fn=TQString("butterfly.png")
|
|
|
|
if len(sys.argv) > 2:
|
|
logo_fn = TQString(sys.argv[2])
|
|
else:
|
|
logo_fn=TQString("qtlogo.png")
|
|
|
|
canvas=TQCanvas(800,600)
|
|
canvas.setAdvancePeriod(30)
|
|
m=Main(canvas,None,"pyqt canvas example")
|
|
m.resize(m.sizeHint())
|
|
|
|
tqApp.setMainWidget(m)
|
|
m.setCaption("TQt Canvas Example ported to PyTQt")
|
|
if TQApplication.desktop().width() > m.width() + 10 and TQApplication.desktop().height() > m.height() + 30:
|
|
m.show()
|
|
else:
|
|
m.showMaximized()
|
|
|
|
m.show();
|
|
#// m.help();
|
|
tqApp.setMainWidget(None);
|
|
|
|
TQObject.connect( tqApp, SIGNAL("lastWindowClosed()"), tqApp, SLOT("quit()") )
|
|
|
|
app.exec_loop()
|
|
|
|
# We need to explicitly delete the canvas now (and, therefore, the main
|
|
# window beforehand) to make sure that the sprite logo doesn't get garbage
|
|
# collected first.
|
|
views = []
|
|
del m
|
|
del canvas
|