def readSave():
save = open("chess.save", "r")
startData = save.readline().strip('\n')
if startData == "True":
st = True
else:
st = False
if st:
# read board
readBoard(save)
# read global variables
readGlobal(save)
# read w_pieces and b_pieces
readPiecesArrays(save, "W")
readPiecesArrays(save, "b")
# read deleted pieces
read_r_PiecesArrays(save, "W")
read_r_PiecesArrays(save, "b")
# read r_avail
read_r_avail(save)
# read p_moves
read_p_moves(save)
# read firstPawns
read_firstPawns(save)
if not globVar.ready:
Canvas.not_ready_error()
def Ccircle(args): # Command called when circle is called
print 'draw a circle with radius %d' % (args[0]) #debug
# If the cursor is the centre then to draw it we need to find
# the corners of the containg box, so just remove/add the radius
# to the x and y axis
Canvas.create_oval(cpos[0] - args[0], cpos[1] - args[0], cpos[0] + args[0],
cpos[1] + args[0])
def init(self):
if self.fInit: return
self.fInit = 1
print "init", self
# line
self.fLineToOwner = Canvas.Line(self.fCanvas,
0,
0,
0,
0,
fill='gray30',
width=1)
# disc
self.fDisc = Canvas.Oval(self.fCanvas, 0, 0, 0, 0)
self.fDisc.config(width=1)
outlineColor, fillColor = Node.kColors[self.xType]
self.fDisc.config(outline=outlineColor, fill=fillColor)
Node.DiscToNode[self.fDisc] = self
outlineColor, fillColor = Node.kColors[self.xType]
self.fDisc.config(outline=outlineColor, fill=fillColor)
# label
self.fLabel = Canvas.CanvasText(self.fCanvas,
0,
0,
font=('helvetica', 8),
justify='center',
anchor='s',
text='')
def draw(self, canvas: Canvas):
data = numpy.fromstring(self.fig.canvas.tostring_rgb(),
dtype=numpy.uint8,
sep='')
data = data.reshape(self.fig.canvas.get_width_height()[::-1] + (3, ))
print("k")
canvas.draw_numpy(0, 0, data, max_color_value=255)
def checkWin():
won = False
potenial_moves()
if (globVar.p_w_Num == 0 or len(globVar.p_w_moves) == 0
or len(globVar.w_pieces) == 1 or globVar.no_w_king):
# Canvas.clear()
won = True
globVar.checkmate = True
Canvas.drawBoard()
print(" Black wins!")
print("\n Press Enter to exit.")
input("")
delete_save()
elif (globVar.p_b_Num == 0 or len(globVar.p_b_moves) == 0
or len(globVar.b_pieces) == 1 or globVar.no_b_king):
# Canvas.clear()
won = True
globVar.checkmate = True
Canvas.drawBoard()
print(" White wins!")
print("\n Press Enter to exit.")
input("")
delete_save()
return won
def GetTrsr(self): ################################### GETTRSR
''' This class won't win a Design Award! '''
Mz = self.ry
# convyort left fog squares to wall
for r in np.ndindex(Mz.shape):
if Mz[r] == Sqr.Fog:
Mz[r] = Sqr.Wall
self.DrawSqr(r)
trsr = np.unravel_index(self.path.argmax(), self.path.shape)
y = self.offset[1] + trsr[0]
x = self.offset[0] + trsr[1]
Canvas.Display(x, y, [5], [100, 100, 0], [200, 200, 0], 'T')
r = Coor(trsr)
while self.path[r] > 0:
for dr in Globus.ls():
r1 = r + dr
if self.path[r1] == self.path[r] - 1:
y = self.offset[1] + r1[0]
x = self.offset[0] + r1[1]
Canvas.Display(x, y, [5], [10, 100, 240], [50, 30, 80],
'»')
sys.stdout.flush()
time.sleep(args.s)
r = r1
break
return trsr
def begin(n):
set_globals()
global N
N = n
W_v = multiprocessing.Value('i', 0)
b_v = multiprocessing.Value('i', 0)
total_num_moves = multiprocessing.Value('i', 0)
games_played = multiprocessing.Value('i', 0)
num = multiprocessing.Value('i', int(n))
lock = multiprocessing.Lock()
procs = []
for i in range(int(n)):
procs.append(
multiprocessing.Process(target=run,
args=(total_num_moves, games_played, W_v,
b_v, lock, i, num)))
progress(games_played, num)
done = 0
while done < int(N):
for i in range(multiprocessing.cpu_count()):
if done + i < int(N):
procs[done + i].start()
for i in range(multiprocessing.cpu_count()):
if done + i < int(N):
procs[done + i].join()
done += multiprocessing.cpu_count()
Canvas.clear()
print("\n Done! Below is the final score.")
draw_score(int(n), W_v, b_v, total_num_moves, games_played, num)
Canvas.pressEnter()
def show(self):
self.tk.wm_title(self.title)
self.board = Canvas(self.tk,relief=SUNKEN, bd=2, width=self.ww, height=self.wh)
self.board.pack(fill=BOTH)
Rectangle(self.board, (0,0), (self.ww,self.wh), fill="white", width=1)
b = Button(self.tk, text="Close", font=self.font, command = self.close )
b.pack()
def checkWin():
won = False
potenial_moves()
if (globVar.p_w_Num == 0 or len(globVar.p_w_moves) == 0
or len(globVar.w_pieces) == 1 or globVar.no_w_king):
won = True
globVar.checkmate = True
if not globVar.simulation:
Canvas.drawBoard()
print(" Black wins!")
print("\n Press Enter to exit.")
input("")
delete_save()
else:
simulate.b_victories += 1
elif (globVar.p_b_Num == 0 or len(globVar.p_b_moves) == 0
or len(globVar.b_pieces) == 1 or globVar.no_b_king):
won = True
globVar.checkmate = True
if not globVar.simulation:
Canvas.drawBoard()
print(" White wins!")
print("\n Press Enter to exit.")
input("")
delete_save()
else:
simulate.W_victories += 1
return won
def _remakeOutline(self):
if not self.mapped:
return
import Canvas
if self.outline:
self.outline.delete()
if not self.points:
self.outline = None
elif len(self.points) < 2:
pt = self._mapToCanvas(self.points[0])
ul = (pt[0] - 1, pt[1] - 1)
lr = (pt[0] + 1, pt[1] + 1)
self.outline = Canvas.Rectangle(self.canvas, [ul, lr],
fill="black")
else:
coords = []
for pt in self.points:
coords.append(self._mapToCanvas(pt))
if "closed" in self.opt.getvalue():
if self.points[0] != self.points[-1]:
coords.append(self._mapToCanvas(self.points[0]))
else:
del self.points[-1]
self.outline = Canvas.Line(self.canvas,
coords,
fill="black",
width=3)
def Cline(args): # Command called when line is called
next_pos = [cpos[0] + args[0],
cpos[1] + args[1]] # Evalutate next position
print 'draw a line from : %d, %d to : %d, %d' % (cpos[0], cpos[1],
next_pos[0], next_pos[1])
Canvas.create_line(cpos[0], cpos[1], next_pos[0],
next_pos[1]) # Draw the line on the canvas
Cposition(next_pos) # Change the cursor position
def showCrossover(self):
self.GenerCanvas = [
Canvas.Canvas(self.population, 1),
Canvas.Canvas(self.population, 1)
]
self.vboxc[0].addWidget(self.GenerCanvas[0])
self.vboxc[1].addWidget(self.GenerCanvas[1])
self.GenerCanvas[0].drawImage()
self.GenerCanvas[1].drawImage()
def init(self):
self.fHighlight = Canvas.Oval(self.fCanvas, 0, 0, 0, 0)
self.fHighlight.config(outline="#FF0000", width="1")
self.fLabel = Canvas.CanvasText(self.fCanvas,
7,
7,
font=('courier', 8),
justify='left',
anchor='nw',
text='')
def Render(self, canvas, obj):
if obj:
if self.Attribute(0) == '':
obj.at = Canvas.Position()
else:
obj.at = Canvas.Position(float(self.Attribute(0)),
float(self.Attribute(1)))
if self.Attribute(2) != '':
obj.at.angle = float(self.Attribute(2))
super(KicadAt, self).Render(canvas, obj)
def __init__(self, mastr, sq, *a, **k):
self.highlight = 0
Frame.__init__(self, mastr, border=0, *a, **k)
self.ca = Canvas(master=self, border=0, width=48, height=48)
self.ca.pack(expand=1, fill=BOTH)
self.l = ImageItem(self.ca, 0, 16, anchor=NW)
self.t = ImageItem(self.ca, 16, 0, anchor=NW)
self.c = ImageItem(self.ca, 16, 16, anchor=NW)
self.b = ImageItem(self.ca, 16, 32, anchor=NW)
self.r = ImageItem(self.ca, 32, 16, anchor=NW)
self.seq = sq
def parse_args(args):
args.pop(0) # remove script arg
s = "".join(args)
globVar.show_all_menus = ("m" in s)
## GRAPHICS
if ("a" in s):
globVar.unicode = False
globVar.limited_unicode = False
if ("l" in s):
globVar.unicode = False
globVar.limited_unicode = True
if ("u" in s):
globVar.unicode = True
globVar.limited_unicode = False
if globVar.limited_unicode:
colors.limited_pieces()
# Game speed
globVar.slow_speed = not ("f" in s)
if ("s" in s):
globVar.slow_speed = True
# AI
if ("n" in s):
globVar.chill = False
globVar.aggressive = False
if ("c" in s):
globVar.chill = True
globVar.aggressive = False
if ("g" in s):
globVar.chill = False
globVar.aggressive = True
# GAME MODES
if ("0" in s):
globVar.numPlayers = 0
elif ("1" in s):
globVar.numPlayers = 1
elif ("2" in s):
globVar.numPlayers = 2
if ("i" in s):
globVar.simulation = True
globVar.numPlayers = 0
Canvas.simulateMenu()
exit()
if ("h" in s):
Canvas.help()
exit()
def main():
path = pathlib.Path("chess.save")
if path.exists():
Canvas.loadSave()
running = True
else:
running = Canvas.startScreen()
while(running):
running = state()
utils.delete_save()
def r_c(x):
if x == 'c': # col
choice = Canvas.chooseCol()
choice = choice.upper()
choice = ord(choice)
choice -= 65
else: # row
choice = Canvas.chooseRow()
choice = (8 - choice)
return int(choice)
def begin(n):
set_globals()
global N
N = n
W_v = multiprocessing.Value('i', 0)
b_v = multiprocessing.Value('i', 0)
total_num_moves = multiprocessing.Value('i', 0)
games_played = multiprocessing.Value('i', 0)
num = multiprocessing.Value('i', int(n))
lock = multiprocessing.Lock()
counts = []
for i in range(int(multiprocessing.cpu_count())):
counts.append(0)
dist = int(N)
i = 0
while dist > 0:
counts[i % len(counts)] += 1
i += 1
dist -= 1
procs = []
for i in range(len(counts)):
games_to_play = counts[i]
p = multiprocessing.Process(target=run_games,
args=(total_num_moves, games_played, W_v,
b_v, lock, i, num, games_to_play))
procs.append(p)
progress(games_played, num)
for p in procs:
p.start()
for p in procs:
p.join()
# done = 0
# while done < int(N):
# for i in range(multiprocessing.cpu_count()):
# if done + i < int(N):
# procs[done + i].start()
# for i in range(multiprocessing.cpu_count()):
# if done + i < int(N):
# procs[done + i].join()
# done += multiprocessing.cpu_count()
Canvas.clear()
print("\n Done! Below is the final score.")
draw_score(int(n), W_v, b_v, total_num_moves, games_played, num)
Canvas.pressEnter()
def __init__(self, app):
"""
Create a main window for the given application.
"""
defaultOptions["palette"] = app.palette()
Systray.__init__(self)
self.expansions = 0
self.client = None
self.server = None
self.running = False
self.recovery = False
mainWidgets["main"] = self
mainWidgets["app"] = app
self.canvas = Canvas(self)
mainWidgets["canvas"] = self.canvas
self.tabWidget = TabWidget(self)
mainWidgets["tab"] = self.tabWidget
self.setCentralWidget(self.tabWidget)
#self.setCentralWidget(self.canvas)
self.createActions()
self.createMenus()
self.createToolBars()
self.createStatusBar()
self.createDockWindows()
self.createConfigWindows()
self.createPopupWindows()
self.createProgressBar()
self.newScene()
self.debugWindow.hide()
self.tm.hide()
self.routes.hide()
self.setVisible(True)
self.center()
self.saveLayout(environ["config"] + "defaultLayout")
self.defaultLayout = True
if options["restore"]:
self.loadLayout()
self.defaultLayout = False
self.loadProject()
atexit.register(self.cleanup)
def select():
print(" Select which piece to move.")
selecting = True
while selecting:
col = utils.r_c('c')
row = utils.r_c('r')
if board.Grid(row,col).piece.color != globVar.player:
Canvas.selectError()
else:
board.Grid(row,col).piece.selected = True # display fromSqr as selected
selecting = False
return board.Grid(row,col)
def setGconmember(self,member,value):
# If the VCS Canvas is displayed, then bring the canvas to the front before
# redisplaying the updated contents.
if (self.parent.mode == 1) and (self.parent.iscanvasdisplayed()):
Canvas.finish_queued_X_server_requests( self.parent )
self.parent.canvas.BLOCK_X_SERVER()
self.parent.canvasraised()
_vcs.setGconmember(self, member, value, self.parent.mode)
# If the VCS Canvas is displayed, then update the backing store
if (self.parent.mode == 1) and (self.parent.iscanvasdisplayed()):
self.parent.flush()
self.parent.backing_store()
self.parent.canvas.UNBLOCK_X_SERVER()
def initUI(self):
self.canvas = Canvas()
self.setCentralWidget(self.canvas)
self.initActions()
self.initMenu()
self.setWindowTitle("Draw Pixel")
self.resize(800, 600)
self.toolbar = QToolBar("Size Bar", self)
self.toolbar.addAction("PlaceHolder")
self.sizeSlider = QSlider(self)
self.toolbar.addWidget(self.sizeSlider)
def turn():
utils.potenial_moves()
Canvas.drawBoard()
if (globVar.noPlayers or globVar.numPlayers == 0):
ai_turn()
elif (globVar.numPlayers == 1 and globVar.player == "b"):
ai_turn()
elif (globVar.numPlayers == 2 or globVar.player == "W" and
globVar.numPlayers == 1):
human_turn()
globVar.removed = False
def setGfimember(self, member, value):
# If the VCS Canvas is displayed, then bring the canvas to the front before
# redisplaying the updated contents.
if (self.parent.mode == 1) and (self.parent.iscanvasdisplayed()):
Canvas.finish_queued_X_server_requests(self.parent)
self.parent.canvas.BLOCK_X_SERVER()
self.parent.canvasraised()
_vcs.setGfimember(self, member, value, self.parent.mode)
# If the VCS Canvas is displayed, then update the backing store
if (self.parent.mode == 1) and (self.parent.iscanvasdisplayed()):
self.parent.flush()
self.parent.backing_store()
self.parent.canvas.UNBLOCK_X_SERVER()
def init(gui = 0, mode=1, pause_time=0, call_from_gui=0, size=None, backend="vtk"):
'''
Function: init # Initialize, Construct a VCS Canvas Object
Description of Function:
Construct the VCS Canas object. There can only be at most 8 VCS
Canvases open at any given time.
Graphics User Interface Mode:
gui = 0|1 if ==1, create the canvas with GUI controls
(Default setting is *not* to display GUI controls)
Example of Use:
import vcs,cu
file=cu.open('filename.nc')
slab=file.getslab('variable')
a=vcs.init() # This examples constructs 4 VCS Canvas
a.plot(slab) # Plot slab using default settings
b=vcs.init() # Construct VCS object
template=b.gettemplate('AMIP') # Get 'example' template object
b.plot(slab,template) # Plot slab using template 'AMIP'
c=vcs.init() # Construct new VCS object
isofill=c.getisofill('quick') # Get 'quick' isofill graphics method
c.plot(slab,template,isofill) # Plot slab using template and isofill objects
d=vcs.init() # Construct new VCS object
isoline=c.getisoline('quick') # Get 'quick' isoline graphics method
c.plot(isoline,slab,template) # Plot slab using isoline and template objects
'''
canvas = Canvas.Canvas(gui=gui, mode=mode, pause_time=pause_time, call_from_gui=call_from_gui, size=size, backend=backend)
global canvaslist
canvaslist.append(canvas)
return canvas
def startTutorial(self):
"""
Start the interactive tutorial.
"""
if isinstance(mainWidgets["canvas"], Tutorial):
self.log.append(
"You are already doing the tutorial! If you would like to stop or restart, select 'Close' from the File menu now."
)
return
if not self.closeTopology():
return
self.project = "Tutorial"
self.filename = ""
self.canvas = Tutorial(self)
mainWidgets["canvas"] = self.canvas
self.tabWidget.removeTab(0)
self.tabWidget.addTab(self.canvas, "Tutorial")
self.canvas.start()
for nodeType in nodeTypes.keys():
itemTypes = nodeTypes[nodeType]
itemTypes[nodeType] = 0
self.properties.clear()
self.interfaces.clear()
self.routes.clear()
self.resetLayout(True)
self.lockDocks()
def __init__(self, parent):
QtGui.QMainWindow.__init__(self)
UI_DrawingWindow.__init__(self)
self.setupUi(self)
self.parent = parent
self.canvas = Canvas.Canvas(self.drawing_panel)
self.logger = logging.getLogger(__name__)
self.logger.setLevel(logging.INFO)
self.register_buttons()
# set max counts in progresss bar
self.count_progress_bar.setMaximum(
config.Settings.SAMPLE_COUNT_PER_DIGIT)
self.count_progress_bar.setValue(
config.Settings.SAMPLE_COUNT_PER_DIGIT)
# Attach this window to the Server
globals.device_server.attach_active_drawing_window(self)
# Panel Updater timer
self.timer = QtCore.QTimer(self)
self.timer.setInterval(config.Settings.REFRESH_INTERVAL)
self.connect(self.timer, QtCore.SIGNAL("timeout()"), self.update_panel)
self.timer.start()
def __init__(self, master, frame, sw, sh):
'''
Constructor for the plot area.
'''
# initialization of
self.sw = sw
self.sh = sh
self.frame = frame
# empty value list
self.value_list = []
# canvas area where the value lines and the coordinate system
self.canvas = Canvas(self.frame, bg = "white")
self.canvas.pack(expand = YES, fill = BOTH)
#if the used os is a windows or a mac, they need a factor 1.5 for the y-axis
if os.name == "nt":
self.win_osx_factor = 1.5
elif os.name == "mac":
self.win_osx_factor = 1.5
# if its a linux machine factor is 1
else:
self.win_osx_factor = 1
def showSelection(self):
self.GenerCanvas = [Canvas.Canvas(self.population, 1)]
self.warning1.setText(
"<div style='color: rgb(255, 255, 255); text-align: center;'>Расставьте уникальное значение для каждого изображения, где 1 - наименее подходящее изображение, "
+ str(self.population.size) + " - наиболее подходящее.</div>")
self.hboxs.addWidget(self.GenerCanvas[0])
self.GenerCanvas[0].drawImage()
def startTutorial(self):
"""
Start the interactive tutorial.
"""
if isinstance(mainWidgets["canvas"], Tutorial):
self.log.append("You are already doing the tutorial! If you would like to stop or restart, select 'Close' from the File menu now.")
return
if not self.closeTopology():
return
self.project = "Tutorial"
self.filename = ""
self.canvas = Tutorial(self)
mainWidgets["canvas"] = self.canvas
self.tabWidget.removeTab(0)
self.tabWidget.addTab(self.canvas, "Tutorial")
self.canvas.start()
for nodeType in nodeTypes.keys():
itemTypes = nodeTypes[nodeType]
itemTypes[nodeType] = 0
self.properties.clear()
self.interfaces.clear()
self.routes.clear()
self.resetLayout(True)
self.lockDocks()
def load_painter(self):
# Загружаем холст
self.paint_page.setLayout(self.paint_page_lay)
# Текущий цвет - черный, ширина кисти - 10
self.now_col = QColor(0, 0, 0)
self.now_width = 10
self.point_width.setValue(10)
# Подвязываем кнопку с изменением ширины кисти к соответсвующему слоту
self.point_width.valueChanged.connect(self.change_width)
# Создаем холст как экземпляр класса Canvas из доп.модуля Canvas
self.canvas = Canvas.Canvas(self.main_paint_widg)
self.canvas.move(1, 1)
self.canvas.resize(self.main_paint_widg.width() - 1,
self.main_paint_widg.height() - 1)
print(self.main_paint_widg.size(), self.canvas.size(),
self.border_lab.size())
# Устанавливаем границы рамки
self.border_lab.setStyleSheet(
'border-style: solid; border-width: 2px; border-color: black;')
self.canvas.setStyleSheet('background-color: white;')
# Устанавливаем сильный фокус для перехвата всех событий
# клавиатуры и мыши
self.setFocusPolicy(Qt.StrongFocus)
# Подвязываем действия из меню к слотам
self.actionSave.triggered.connect(self.save_file)
self.actionSave_as.triggered.connect(self.save_as_file)
self.actionOpen.triggered.connect(self.open_file)
self.actionReference.triggered.connect(self.open_reference)
# и кнопку очистки холста, а также задания цвета кисти
self.bt_clear.clicked.connect(self.clear_canvas)
self.bt_set_color.clicked.connect(self.set_color_with_bt)
# Имя файла изначально не задано, файл не сохранен
self.file_name = ''
self.saved = False
self.resizeEvent(QResizeEvent(self.size(), self.size()))
def check_pawn(pc):
W_success = (pc.type == "pawn") and (globVar.player == "W") and (pc.row
== 0)
b_success = (pc.type == "pawn") and (globVar.player == "b") and (pc.row
== 7)
if W_success or b_success:
if ((globVar.numPlayers == 1 and globVar.player == "W")
or globVar.numPlayers == 2):
choice = Canvas.pawn_to_new()
else:
choice = random.randint(1, 4)
color = pc.color
label = pc.label
row = pc.row
col = pc.col
if choice == 1:
pc = pieces.Rook(color, "rook")
elif choice == 2:
pc = pieces.Knight(color, "knight")
elif choice == 3:
pc = pieces.Bishop(color, "bishop")
elif choice == 4:
pc = pieces.Queen(color, "queen")
pc.label = label
pc.row = row
pc.col = col
updatePieces(pc)
board.uGrid(pc)
class SonarScanner: def __init__(self, sonarPort, motorPort): self.motor = MotorScanner(motorPort) self.sonar = Sonar(sonarPort) self.canvas = Canvas() # # Function to scan from 0 to 360. Each step takes SCAN_STEP Radian def scan(self): # initialize data data = [] # Go to start angle self.motor.gotoAngle(SCANNER_START_ANGLE, 'cw') nStep = int((SCANNER_END_ANGLE - SCANNER_START_ANGLE)/SCANNER_SCAN_STEP) for i in range(0, nStep): # go to angle angle = SCANNER_START_ANGLE + SCANNER_SCAN_STEP*i self.motor.gotoAngle(angle, 'ccw') # read sonar data z = self.sonar.getSmoothSonarDistance(0.05) data.append(z) # Back to zero angle self.motor.gotoAngle(0, 'cw') return data def drawScanData(self, data): for i in range(0, len(data)): r = data[i]*SCANNER_DRAW_SCALE th = SCANNER_START_ANGLE + SCANNER_SCAN_STEP*i if(r > 200): continue x0 = int(SCANNER_DRAW_X0) y0 = int(SCANNER_DRAW_Y0) x1 = int(x0 + r*cos(th)) y1 = int(y0 + r*sin(th)) print radToDeg(th), r print (x0, y0, x1, y1) self.canvas.drawLine((x0, y0, x1, y1))
def __init__(self, parent=None):
super(Mozayik, self).__init__(parent)
mainLayout = QHBoxLayout()
#setup button icons
assets = os.getcwd() + "/assets"
if os.path.exists(assets):
os.chdir(assets)
trash = assets + "/trash.png"
if os.path.isfile(trash):
trashIcon = QIcon(QPixmap(trash))
add = assets + "/plus.png"
if os.path.isfile(add):
addIcon = QIcon(QPixmap(add))
folder = assets + "/folder.png"
if os.path.isfile(folder):
folderIcon = QIcon(QPixmap(folder))
#setup buttons
self.enterFolderButton = QPushButton(folderIcon, "")
self.enterFolderButton.clicked.connect(self.enterFolderContact)
self.addTilesButton = QPushButton(addIcon, "")
self.addTilesButton.clicked.connect(self.addTilesContact)
self.deleteButton = QPushButton(trashIcon, "")
self.deleteButton.clicked.connect(self.deleteContact)
#layout buttons
buttonLayout1 = QHBoxLayout()
buttonLayout1.addWidget(self.enterFolderButton)
buttonLayout1.addWidget(self.addTilesButton)
buttonLayout1.addWidget(self.deleteButton)
#setup image viewer
scrollView = QScrollArea()
scrollView.setBackgroundRole(QPalette.Dark)
self.viewer = Viewer()
scrollView.setWidget(self.viewer)
size = QSize(350,600)
scrollView.setMaximumSize(size)
#scrollView.setMinimumSize(size)
#setup mozayik area
#self.mozayik = QLabel("Area reserved")
self.mozayik = Canvas()
#layout main view
viewLayout1 = QVBoxLayout()
viewLayout1.addLayout(buttonLayout1)
viewLayout1.setAlignment(buttonLayout1,Qt.AlignRight)
viewLayout1.addWidget(scrollView)
viewLayout1.setAlignment(scrollView,Qt.AlignLeft)
mainLayout.addLayout(viewLayout1)
mainLayout.addWidget(self.mozayik)
self.setLayout(mainLayout)
self.setWindowTitle("Mozayik")
def __construct__(self):
#extract, contain, and properly indent python content
funcname = self.vbl_elem.getAttribute('name')
args = self.vbl_elem.getAttribute('args')
script = Canvas.normalize_python(node=self, definition="def %s(%s):"%(funcname, args))
#run the code (which will define a function where we need it)
try: exec script in self.parent.__dict__
except Exception, msg: Events.Error(self, msg, "bad syntax in python block")
class CanvasDemo:
colors = ["pink", "grey", "yellow", "green", "red", "purple", "cyan",
"pink", "grey", "yellow", "green", "red", "purple", "cyan",
"pink", "grey", "yellow", "green", "red", "purple", "cyan"]
layers = 5
root = canvas = groups = None
def __init__(self, root):
self.root = root
# make a frame and a canvas and some buttons
frame = Frame(self.root)
frame.pack(fill=X)
label = Label(frame, text="Canvas test")
label.pack()
self.canvas = Canvas(frame, bg="grey", width=600, height=600)
self.canvas.pack()
cmd = Button(frame, text="Scale", command=self.scale)
cmd.pack()
self.groups = []
for i in range(self.layers):
self.groups.append(Group(self.canvas))
# time the creation of the rectangles
start = time()
self.makeShapes()
print "Took ", time() - start, " seconds to make", self.layers,"layers"
def makeShapes(self):
# make 100 rectangles
for group in range(self.layers):
actual = self.groups[group]
MouseHandler(actual)
for i1 in range(10):
for i2 in range(10):
makeRectangle(self.canvas, actual, i1*40+10+group*20,
i2*40+10+group*5,
35, 35, self.colors[group], 2)
def scale(self):
for group in self.groups:
group.scale(0, 0, 1.1, 1.1)
def __construct__(self):
#extract, contain, and properly indent python content
funcname = self.vbl_elem.getAttribute('name')
args = self.vbl_elem.getAttribute('args')
prefix = "def %s(%s): import threading; t = threading.Thread(target=_thread_%s, args=[%s]); t.setDaemon(True); t.start();"%(funcname, args, funcname, args)
definitionLine = "def _thread_%s(%s):"%(funcname, args)
script = Canvas.normalize_python(node=self, prefix=prefix, definition=definitionLine)
#run the code (which will define a function where we need it)
try: exec script in self.parent.__dict__
except Exception, msg: Events.Error(self, msg, "bad syntax in python block\s%s"%script)
def __init__(self, app):
"""
Create a main window for the given application.
"""
defaultOptions["palette"] = app.palette()
Systray.__init__(self)
self.expansions = 0
self.client = None
self.server = None
self.running = False
self.recovery = False
mainWidgets["main"] = self
mainWidgets["app"] = app
self.canvas = Canvas(self)
mainWidgets["canvas"] = self.canvas
self.tabWidget = TabWidget(self)
mainWidgets["tab"] = self.tabWidget
self.setCentralWidget(self.tabWidget)
# self.setCentralWidget(self.canvas)
self.createActions()
self.createMenus()
self.createToolBars()
self.createStatusBar()
self.createDockWindows()
self.createConfigWindows()
self.createPopupWindows()
self.createProgressBar()
self.newScene()
self.debugWindow.hide()
self.tm.hide()
self.routes.hide()
self.setVisible(True)
self.center()
self.saveLayout(environ["config"] + "defaultLayout")
self.defaultLayout = True
if options["restore"]:
self.loadLayout()
self.defaultLayout = False
self.loadProject()
atexit.register(self.cleanup)
def __construct__(self):
#extract, wrap, and properly indent python content
self.funcname = self['name'] or "_%s_%s"%(self.on, self.canvas._uidcount)
self.canvas.__dict__['_uidcount'] += 1
args = self['args'] or "value"
script = Canvas.normalize_python(node=self, definition="def %s(%s):"%(self.funcname, args))
#run the code (which will define a function where we need it)
try: exec script in self.parent.__dict__
except Exception, msg: Events.Error(self, msg, "bad syntax in python block")
#if a reference is given adjust the target to that, otherwise use the parent per normal
if self['reference']:
self.parent.constrain(attr='early', func=self._reference)
else:
self.parent.constrain(attr=self.on, func=self.parent.__dict__[self.funcname])
def closeTopology(self):
"""
Close the current topology.
"""
if self.running:
self.log.append("You cannot close a topology when one is still running!")
return False
scene = self.canvas.scene()
if scene and scene.items():
reply = QtGui.QMessageBox.warning(
self,
self.tr(Core.globals.PROG_NAME),
self.tr("Save before closing?"),
QtGui.QMessageBox.Yes | QtGui.QMessageBox.No | QtGui.QMessageBox.Cancel,
)
if reply == QtGui.QMessageBox.Yes:
if not self.saveTopology():
return False
elif reply == QtGui.QMessageBox.No:
pass
else:
return False
if isinstance(mainWidgets["canvas"], Tutorial):
self.canvas = Canvas(self)
mainWidgets["canvas"] = self.canvas
self.tabWidget.removeTab(0)
self.tabWidget.addTab(self.canvas, "Default Project")
self.project = ""
self.unlockDocks()
self.filename = ""
scene = Scene(self.canvas)
scene.setItemIndexMethod(QtGui.QGraphicsScene.NoIndex)
self.canvas.setScene(scene)
self.expansions = 0
for nodeType in nodeTypes.keys():
itemTypes = nodeTypes[nodeType]
itemTypes[nodeType] = 0
self.properties.clear()
self.interfaces.clear()
self.routes.clear()
return True
def __initUI(self):
self.parent.title("Sudoku")
self.pack(fill=BOTH)
self.canvas = Canvas(self,
width=WIDTH,
height=HEIGHT)
self.canvas.pack(fill=BOTH, side=TOP)
clear_button = Button(self,
text="Clear answers",
command=self.__clear_answers)
clear_button.pack(fill=BOTH, side=BOTTOM)
self.__draw_grid()
self.__draw_puzzle()
self.canvas.bind("<Button-1>", self.__cell_clicked)
self.canvas.bind("<Key>", self.__key_pressed)
def __init__(self, root):
self.root = root
# make a frame and a canvas and some buttons
frame = Frame(self.root)
frame.pack(fill=X)
label = Label(frame, text="Canvas test")
label.pack()
self.canvas = Canvas(frame, bg="grey", width=600, height=600)
self.canvas.pack()
cmd = Button(frame, text="Scale", command=self.scale)
cmd.pack()
self.groups = []
for i in range(self.layers):
self.groups.append(Group(self.canvas))
# time the creation of the rectangles
start = time()
self.makeShapes()
print "Took ", time() - start, " seconds to make", self.layers,"layers"
'end' : C_end
}
Functions = {
}
Loop_Def = []
Loop_Time = 0
file = open('test3.txt', 'r')
for line in file:
line = string.lower(trim(line))
if line == 'end':
print InCall
if InCall == 'Loop':
print Loop_Time
for i in range(Loop_Time):
Execute(Loop_Def)
InCall = 'Main'
if InCall == 'Main':
Execute([line])
elif InCall == 'Loop':
Loop_Def += [line]
else:
Functions[InCall] += [line]
file.close()
Canvas.complete()
def transformToWindowCoordinates(points):
return [[(1 + t[0]) * WIDTH / 2 , (1 - t[1]) * HEIGHT / 2] for t in points]
if __name__ == "__main__":
#check parameters
if len(sys.argv) != 2:
print "pointViewerTemplate.py"
sys.exit(-1)
# create main window
mw = Tk()
# create and position canvas and buttons
cFr = Frame(mw, width=WIDTH, height=HEIGHT, relief="sunken", bd=1)
cFr.pack(side="top")
can = Canvas(cFr, width=WIDTH, height=HEIGHT)
can.pack()
bFr = Frame(mw)
bFr.pack(side="left")
bRotYn = Button(bFr, text="<-", command=rotYn)
bRotYn.pack(side="left")
bRotYp = Button(bFr, text="->", command=rotYp)
bRotYp.pack(side="left")
eFr = Frame(mw)
eFr.pack(side="right")
bExit = Button(eFr, text="Quit", command=(lambda root=mw: quit(root)))
bExit.pack()
modelObj = model.parse(sys.argv[1])
cam.setupCameraForModel(modelObj)
draw()
if __name__ == "__main__":
#check parameters
if len(sys.argv) != 1:
print "LineClipping"
sys.exit(-1)
# create main window
mw = Tk()
mw._root().wm_title("Line clipping (Cohen-Sutherland Algorithm)")
# create and position canvas and buttons
cFr = Frame(mw, width=WIDTH, height=HEIGHT, relief="sunken", bd=1)
cFr.pack(side="top")
can = Canvas(cFr, width=WIDTH, height=HEIGHT)
can.bind("<Button-1>",mouseEvent)
can.pack()
cFr = Frame(mw)
cFr.pack(side="left")
bClear = Button(cFr, text="Clear", command=clearAll)
bClear.pack(side="left")
eFr = Frame(mw)
eFr.pack(side="right")
bExit = Button(eFr, text="Quit", command=(lambda root=mw: quit(root)))
bExit.pack()
# start
mw.mainloop()
def paper(width=400, height=300, colour="white"): global canvas, tk, paper_w, paper_h paper_w = width ; paper_h = height tk = Tk() canvas = Canvas(tk, width=width, height=height, background=colour) canvas.pack(fill=BOTH, expand=Y)
def sched_queerity():
tk.after(min_queerity_sleep + int(random()*(max_queerity_sleep-min_queerity_sleep)), queerity)
intro()
if os_name == 'posix':
def exiting():
system("xset r on")
atexit.register(exiting)
system("xset r off")
cursor="dot #111111"
else:
cursor=None
tk = Tk()
canvas = Canvas(tk, width=w, height=h, background='black', cursor=cursor)
canvas.pack(fill=BOTH, expand=Y)
center = w/2+h/2*1j
tk.bind("h", help)
tk.bind("i", info)
tk.bind("<Escape>", do_exit)
start()
sched_queerity()
tk.mainloop()
def C_circle(args):
Canvas.create_oval(cursor_pos[0]-int(args[0]), cursor_pos[1]-int(args[0]), cursor_pos[0]+int(args[0]), cursor_pos[1]+int(args[0]))
class SudokuUI(Frame):
"""
The Tkinter UI, responsible for drawing the board and accepting user input.
"""
def __init__(self, parent, game):
self.game = game
Frame.__init__(self, parent)
self.parent = parent
self.row, self.col = -1, -1
self.__initUI()
def __initUI(self):
self.parent.title("Sudoku")
self.pack(fill=BOTH)
self.canvas = Canvas(self,
width=WIDTH,
height=HEIGHT)
self.canvas.pack(fill=BOTH, side=TOP)
clear_button = Button(self,
text="Clear answers",
command=self.__clear_answers)
clear_button.pack(fill=BOTH, side=BOTTOM)
self.__draw_grid()
self.__draw_puzzle()
self.canvas.bind("<Button-1>", self.__cell_clicked)
self.canvas.bind("<Key>", self.__key_pressed)
def __draw_grid(self):
"""
Draws grid divided with blue lines into 3x3 squares
"""
for i in xrange(10):
color = "blue" if i % 3 == 0 else "gray"
x0 = MARGIN + i * SIDE
y0 = MARGIN
x1 = MARGIN + i * SIDE
y1 = HEIGHT - MARGIN
self.canvas.create_line(x0, y0, x1, y1, fill=color)
x0 = MARGIN
y0 = MARGIN + i * SIDE
x1 = WIDTH - MARGIN
y1 = MARGIN + i * SIDE
self.canvas.create_line(x0, y0, x1, y1, fill=color)
def __draw_puzzle(self):
self.canvas.delete("numbers")
for i in xrange(9):
for j in xrange(9):
answer = self.game.puzzle[i][j]
if answer != 0:
x = MARGIN + j * SIDE + SIDE / 2
y = MARGIN + i * SIDE + SIDE / 2
original = self.game.start_puzzle[i][j]
color = "black" if answer == original else "sea green"
self.canvas.create_text(
x, y, text=answer, tags="numbers", fill=color
)
def __draw_cursor(self):
self.canvas.delete("cursor")
if self.row >= 0 and self.col >= 0:
x0 = MARGIN + self.col * SIDE + 1
y0 = MARGIN + self.row * SIDE + 1
x1 = MARGIN + (self.col + 1) * SIDE - 1
y1 = MARGIN + (self.row + 1) * SIDE - 1
self.canvas.create_rectangle(
x0, y0, x1, y1,
outline="red", tags="cursor"
)
def __draw_victory(self):
# create a oval (which will be a circle)
x0 = y0 = MARGIN + SIDE * 2
x1 = y1 = MARGIN + SIDE * 7
self.canvas.create_oval(
x0, y0, x1, y1,
tags="victory", fill="dark orange", outline="orange"
)
# create text
x = y = MARGIN + 4 * SIDE + SIDE / 2
self.canvas.create_text(
x, y,
text="You win!", tags="victory",
fill="white", font=("Arial", 32)
)
def __cell_clicked(self, event):
if self.game.game_over:
return
x, y = event.x, event.y
if (MARGIN < x < WIDTH - MARGIN and MARGIN < y < HEIGHT - MARGIN):
self.canvas.focus_set()
# get row and col numbers from x,y coordinates
row, col = (y - MARGIN) / SIDE, (x - MARGIN) / SIDE
# if cell was selected already - deselect it
if (row, col) == (self.row, self.col):
self.row, self.col = -1, -1
elif self.game.puzzle[row][col] == 0:
self.row, self.col = row, col
else:
self.row, self.col = -1, -1
self.__draw_cursor()
def __key_pressed(self, event):
if self.game.game_over:
return
if self.row >= 0 and self.col >= 0 and event.char in "1234567890":
self.game.puzzle[self.row][self.col] = int(event.char)
self.col, self.row = -1, -1
self.__draw_puzzle()
self.__draw_cursor()
if self.game.check_win():
self.__draw_victory()
def __clear_answers(self):
self.game.start()
self.canvas.delete("victory")
self.__draw_puzzle()
def __init__(self, sonarPort, motorPort): self.motor = MotorScanner(motorPort) self.sonar = Sonar(sonarPort) self.canvas = Canvas()
from Tkinter import *
sigma = 10.
r = 28.
b = 8/3.
def lorenz(v,t):
x,y,z = v
return [ sigma*(y-x) , r*x-y-x*z , x*y-b*z ]
t = linspace(0,50,10000)
v = [5,5,0]
res = odeint(lorenz,v,t)
plot(res[:,0],res[:,1])
show()
i = 0
screen = Tk()
wd,ht = screen.winfo_screenwidth(),screen.winfo_screenheight()
screen.geometry("%dx%d+0+0"%(wd,ht))
canv = Canvas(screen,height=ht,width=wd,background="black")
canv.pack()
update()
screen.mainloop()
class Plot(object):
'''
A canvas will be created where the selected values will be plotted as lines, with the best fitting scale.
Initial version by:
Michel Heiniger and Sandra Lang
Latest source code can be found at:
https://github.com/nebelriss/FluidX
'''
def __init__(self, master, frame, sw, sh):
'''
Constructor for the plot area.
'''
# initialization of
self.sw = sw
self.sh = sh
self.frame = frame
# empty value list
self.value_list = []
# canvas area where the value lines and the coordinate system
self.canvas = Canvas(self.frame, bg = "white")
self.canvas.pack(expand = YES, fill = BOTH)
#if the used os is a windows or a mac, they need a factor 1.5 for the y-axis
if os.name == "nt":
self.win_osx_factor = 1.5
elif os.name == "mac":
self.win_osx_factor = 1.5
# if its a linux machine factor is 1
else:
self.win_osx_factor = 1
def createCoordSystem(self):
'''
This creates the coordinate system with a given max value for x,y axis.
'''
# Interval for the numbers
self.xInterval = 2
self.yInterval = 0.2
# delete all canvas with the tag "text"
self.canvas.delete("text")
# draw axis lines
self.canvas.create_line(self.sw-315, self.sh-150, 50, self.sh-150, fill = "black", width = 1)
self.canvas.create_line(70, self.sh-130, 70, 70, fill = "black", width = 1)
# text for Axis
y = 'Y-Axis'
x = 'X-Axis'
# write the text at the right position
self.canvas.create_text(70,40, text= y, tag = "text")
self.canvas.create_text(self.sw-315,self.sh-120, text= x, tag = "text")
# numbers for x and y axis
maximumx = ((self.xMax) + 2) / self.xInterval
maximumy = ((self.yMax) + 1) / self.yInterval
# loop to write the numbers under the axis line and draw the separation lines for the x-axis
for i in range(int(maximumx)):
x = 70 + (i * self.dist_x * self.xInterval)
self.canvas.create_line(x,self.sh-150,x,self.sh-155, width = 2)
self.canvas.create_text(x,self.sh-140, text='%d'% (i * self.xInterval), anchor=N, tag = "text")
# loop to write the numbers under the axis line and draw the separation lines for the x-axis
for i in range (int(maximumy)):
y = self.sh-150-(i * self.dist_y * self.yInterval) * self.win_osx_factor
self.canvas.create_line(70,y,75,y, width = 2)
self.canvas.create_text(45,y, text=str((i * self.yInterval)), anchor=W, tag = "text")
def createline (self, meta, values, idx, sel_idx, colors):
'''
Fist the given values are written in a list with the index number of the listbox and the selected items.
'''
# remove all lines with the tag "plot"
self.canvas.delete("plot")
# overwrite values with the given index with none
try:
self.value_list[idx][1] = None
except IndexError:
print "Index Error - List out of range"
# write values in the list
self.value_list[idx][1] = values
self.value_list[idx][2] = sel_idx
# The zero-point in the coordinate system
xZeroTotal = 70
yZeroTotal = self.sh-150
# get the max value
self.getMax(self.value_list)
# draw lines with the selected values
# read every row of the value_list
for row in self.value_list:
# write row to a different variable because I had to build a for loop like this (for row in row:)
values = row[1]
# get the value with the index 2 in each row
for item in row[2]:
for row in values:
endValue = row
# setting zeroTotal to zero
xZero = xZeroTotal
yZero = yZeroTotal
# setting point to zero for the reason the line begins at the zero point
xPoint = xZero
yPoint = yZero
# write xValue an yValue for the right selection
for row in endValue:
if item[0] == '1':
xValue = row[0]
yValue = row[6]
elif item[0] == '2':
xValue = row[0]
yValue = row[7]
elif item[0] == '3':
xValue = row[1]
yValue = row[6]
elif item[0] == '4':
xValue = row[1]
yValue = row[7]
elif item[0] == '5':
xValue = row[2]
yValue = row[6]
elif item[0] == '6':
xValue = row[2]
yValue = row[7]
else:
pass
# setting color for the line
color = colors[idx][int(item[0]) - 1]
# calculating x,y points on the screen
xPoint = (xValue * self.dist_x) + 70
yPoint = self.sh - ((yValue * self.dist_y) + 150) * self.win_osx_factor
# drawing line
self.canvas.create_line(xZero, yZero, xPoint, yPoint, fill=color, width = 3, tag = "plot")
self.canvas.create_oval(xPoint - 4, yPoint - 4, xPoint + 4, yPoint + 4, fill = color, outline = color, tag = "plot")
# setting x,y points as new zero points
xZero = xPoint
yZero = yPoint
def createlist(self, idx):
'''
adding new index to the list with two empty fields
'''
self.value_list.append([idx])
self.value_list[idx].append(None)
self.value_list[idx].append(None)
def getMax(self, value_list):
'''
This method is trying to find the max value for the scale grid.
'''
# setting max values to zero to find out the highest value
self.xMax = 0
self.yMax = 0
# get values
for row in value_list:
values = row[1]
for row in values:
endValue = row
for row in endValue:
# check for max value in the x-axis
for i in range(1,3):
if self.xMax < row[i]:
self.xMax = row[i]
# check for max value in the y-axis
for i in range(6,7):
if self.yMax < row[i]:
self.yMax = row[i]
# calculating the distance between
self.dist_x = (self.sw - 400) / self.xMax
self.dist_y = (self.sh - 500) / self.yMax
self.createCoordSystem()
class woyDraw:
def __init__(self,ww,wh,root=NONE):
self.xmin = 0
self.xmax = ww
self.ymin = wh
self.ymax = 0
if root==NONE:
self.tk=Tk()
else:
self.tk = Toplevel(root)
if ww <= 0.0:
raise "<woyDraw - init> Fehler - Breite der Zeichenfläche muss > 0 sein!"
else:
self.ww = ww
if wh <= 0.0:
raise "<woyDraw - init> Fehler - Höhe der Zeichenfläche muss > 0 sein!"
else:
self.wh = wh
def close(self):
self.tk.destroy()
def settitle(self, title):
self.title = title
def font(self, setfont):
self.font = setfont
def transform(self, myDraw):
for i in myDraw:
i[0] = self.ww * (i[0] - self.xmin)/(self.xmax-self.xmin)
i[1] = self.wh * (i[1] - self.ymax)/(self.ymin-self.ymax)
return myDraw
def area(self, xmin,xmax,ymin,ymax):
if xmin==xmax:
raise "<woyDraw - area> Fehler - xmin darf nicht gleich xmax sein!"
else:
self.xmin = xmin
self.xmax = xmax
if ymin==ymax:
raise "<woyDraw - area> Fehler - ymin darf nicht gleich ymax sein!"
else:
self.ymin = ymin
self.ymax = ymax
def show(self):
self.tk.wm_title(self.title)
self.board = Canvas(self.tk,relief=SUNKEN, bd=2, width=self.ww, height=self.wh)
self.board.pack(fill=BOTH)
Rectangle(self.board, (0,0), (self.ww,self.wh), fill="white", width=1)
b = Button(self.tk, text="Close", font=self.font, command = self.close )
b.pack()
def draw(self,myDraw,myColor,myWidth):
myDraw2 = self.transform(myDraw)
Line(self.board,myDraw2,width=myWidth,fill=myColor)
def rawdraw(self,myDraw,myColor,myWidth):
Line(self.board,myDraw,width=myWidth,fill=myColor)
def C_line(args):
global cursor_pos
nextposition = (cursor_pos[0]+int(args[0]), cursor_pos[1]+int(args[1]))
Canvas.create_line(cursor_pos[0], cursor_pos[1], nextposition[0], nextposition[1])
cursor_pos = nextposition
class MainWindow(Systray):
def __init__(self, app):
"""
Create a main window for the given application.
"""
defaultOptions["palette"] = app.palette()
Systray.__init__(self)
self.expansions = 0
self.client = None
self.server = None
self.running = False
self.recovery = False
mainWidgets["main"] = self
mainWidgets["app"] = app
self.canvas = Canvas(self)
mainWidgets["canvas"] = self.canvas
self.tabWidget = TabWidget(self)
mainWidgets["tab"] = self.tabWidget
self.setCentralWidget(self.tabWidget)
#self.setCentralWidget(self.canvas)
self.createActions()
self.createMenus()
self.createToolBars()
self.createStatusBar()
self.createDockWindows()
self.createConfigWindows()
self.createPopupWindows()
self.createProgressBar()
self.newScene()
self.debugWindow.hide()
self.tm.hide()
self.routes.hide()
self.setVisible(True)
self.center()
self.saveLayout(environ["config"] + "defaultLayout")
self.defaultLayout = True
if options["restore"]:
self.loadLayout()
self.defaultLayout = False
self.loadProject()
def center(self):
"""
Center the window.
"""
screen = QtGui.QDesktopWidget().screenGeometry()
rect = self.geometry()
self.move((screen.width()-rect.width())/2, (screen.height()-rect.height())/2)
self.show()
def getProject(self):
"""
Return the project.
"""
return self.project
def startTutorial(self):
"""
Start the interactive tutorial.
"""
if isinstance(mainWidgets["canvas"], Tutorial):
self.log.append("You are already doing the tutorial! If you would like to stop or restart, select 'Close' from the File menu now.")
return
if not self.closeTopology():
return
self.project = "Tutorial"
self.filename = ""
self.canvas = Tutorial(self)
mainWidgets["canvas"] = self.canvas
self.tabWidget.removeTab(0)
self.tabWidget.addTab(self.canvas, "Tutorial")
self.canvas.start()
for nodeType in nodeTypes.keys():
itemTypes = nodeTypes[nodeType]
itemTypes[nodeType] = 0
self.properties.clear()
self.interfaces.clear()
self.routes.clear()
self.resetLayout(True)
self.lockDocks()
def lockDocks(self):
"""
Lock the dock windows so they cannot be moved, closed or resized.
"""
self.tm.hide()
for dock in self.docks.values():
dock.setFeatures(dock.NoDockWidgetFeatures)
def unlockDocks(self):
"""
Unlock the dock windows.
"""
self.tm.show()
for dock in self.docks.values():
dock.setFeatures(dock.DockWidgetClosable | dock.DockWidgetMovable | dock.DockWidgetFloatable)
def faq(self):
"""
Open the FAQ in the default browser.
"""
olddir = os.getcwd()
os.chdir(environ["doc"])
loadpath = os.getcwd()
os.chdir(olddir)
if environ["os"] == "Windows":
url = QtCore.QUrl("file:///" + loadpath + "/FAQ.html")
else:
url = QtCore.QUrl("file://" + loadpath + "/FAQ.html")
QtGui.QDesktopServices.openUrl(url)
def closeTopology(self):
"""
Close the current topology.
"""
if self.running:
self.log.append("You cannot close a topology when one is still running!")
return False
scene = self.canvas.scene()
if scene and scene.items():
reply = QtGui.QMessageBox.warning(self, self.tr(Core.globals.PROG_NAME), self.tr("Save before closing?"), QtGui.QMessageBox.Yes | QtGui.QMessageBox.No | QtGui.QMessageBox.Cancel)
if reply == QtGui.QMessageBox.Yes:
if not self.saveTopology():
return False
elif reply == QtGui.QMessageBox.No:
pass
else:
return False
if isinstance(mainWidgets["canvas"], Tutorial):
self.canvas = Canvas(self)
mainWidgets["canvas"] = self.canvas
self.tabWidget.removeTab(0)
self.tabWidget.addTab(self.canvas, "Default Project")
self.project = ""
self.unlockDocks()
self.filename = ""
scene = Scene(self.canvas)
scene.setItemIndexMethod(QtGui.QGraphicsScene.NoIndex)
self.canvas.setScene(scene)
self.expansions = 0
for nodeType in nodeTypes.keys():
itemTypes = nodeTypes[nodeType]
itemTypes[nodeType] = 0
self.properties.clear()
self.interfaces.clear()
self.routes.clear()
return True
def sendFile(self):
"""
Start a process to select and send a file to the server.
"""
if not self.server or self.server.poll() != None:
self.log.append("Please start the server first!")
return
if not self.client or not self.client.isConnected():
self.startClient()
filename = self.loadFile("All Files (*.*)")
if not filename:
return
self.sendWindow.setFilename(filename)
self.sendWindow.show()
def newScene(self):
"""
Close the current topology and create a new one.
"""
if self.running:
self.log.append("You cannot create a new topology when one is still running!")
return
if isinstance(mainWidgets["canvas"], Tutorial):
self.log.append("You cannot create a new topology during the tutorial!")
return
if not self.closeTopology():
return
self.expandScene()
def expandScene(self):
"""
Expand the scene based on number of expansions.
"""
x = 175 + self.expansions * 30
y = 160 + self.expansions * 20
scene = self.canvas.scene()
item = QtGui.QGraphicsLineItem(-x, -y, x, y)
scene.addItem(item)
scene.removeItem(item)
self.expansions += 1
def newProject(self):
"""
Create a new project for device sharing.
"""
if self.running:
self.log.append("You cannot create a new project when one is still running!")
return
if isinstance(mainWidgets["canvas"], Tutorial):
self.log.append("You cannot create a new project during the tutorial!")
return
filename = self.saveFile("gproj")
if filename.isEmpty():
return
projectname = str(filename).split("/")[-1].strip(".gproj")
from Core.Item import nodeTypes
for nodeType in nodeTypes:
if projectname.startswith(nodeType + "_"):
self.popup.setWindowTitle("Invalid Project Name")
self.popup.setText("You cannot name a project starting with the name of a device and underscore!")
self.popup.show()
return
self.project = str(filename)
file = QtCore.QFile(filename)
if not file.open(QtCore.QFile.WriteOnly | QtCore.QFile.Text):
QtGui.QMessageBox.warning(self, self.tr("Save Error"),
self.tr("Cannot write file %1:\n%2.")
.arg(self.filename)
.arg(file.errorString()))
return
out = QtCore.QTextStream(file)
QtGui.QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)
if options["username"]:
out << "username="******"username"] + "\n"
else:
self.log.append("Warning, no username is specified!")
if options["session"]:
out << "session=" + options["session"] + "\n"
elif options["server"]:
out << "server=" + options["server"] + "\n"
else:
self.log.append("Warning, no server or session name is specified!")
QtGui.QApplication.restoreOverrideCursor()
self.tabWidget.addTab(self.canvas, projectname)
def openProject(self):
"""
Load an existing project for device sharing.
"""
if self.running:
self.log.append("You cannot open a project when one is still running!")
return
if isinstance(mainWidgets["canvas"], Tutorial):
self.log.append("You cannot open a project during the tutorial!")
return
filename = self.loadFile("GPROJ (*.gproj)")
if filename.isEmpty():
return
self.project = str(filename)
self.loadProject()
def loadProject(self):
"""
Load project file data into options.
"""
if not self.project:
self.tabWidget.addTab(self.canvas, "Default Project")
return
file = QtCore.QFile(self.project)
if not file.open(QtCore.QFile.ReadOnly | QtCore.QFile.Text):
QtGui.QMessageBox.warning(self, self.tr("Load Error"),
self.tr("Cannot read file %1:\n%2.")
.arg(self.project)
.arg(file.errorString()))
self.tabWidget.addTab(self.canvas, "Default Project")
return
_in = QtCore.QTextStream(file)
QtGui.QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)
while not _in.atEnd():
line = str(_in.readLine())
option, value = line.split("=", 1)
options[option] = value
self.configWindow.updateSettings()
QtGui.QApplication.restoreOverrideCursor()
projectname = self.project.split("/")[-1].strip(".gproj")
self.tabWidget.addTab(self.canvas, projectname)
def closeProject(self):
"""
Close the current project.
"""
if self.running:
self.log.append("You cannot close a project when it is still running!")
return
if isinstance(mainWidgets["canvas"], Tutorial):
self.log.append("You cannot close a project during the tutorial!")
return
if self.tabWidget.count() == 1:
self.tabWidget.addTab(self.canvas, "Default Project")
self.project = ""
else:
self.tabWidget.removeTab(0)
def export(self):
"""
Open an export window to generate an image from the canvas.
"""
self.exportWindow.show()
def startBackend(self):
"""
Start the backend server.
"""
self.startServer()
#self.startClient()
def setRecovery(self, recovery):
"""
Set the recovering state of the topology.
"""
self.recovery = recovery
def isRunning(self):
"""
Returns whether a topology is running or not.
"""
return self.running
def startServer(self):
"""
Start the server backend of gbuilder, which controls running topologies.
"""
if self.server and self.server.poll() == None:
self.log.append("A server is already running!")
return
base = "ssh -t "
if options["username"] :
base += options['username'] + "@"
base += options["server"]
tunnel = " -L " + options["localPort"] + ":localhost:" + options["remotePort"]
server = "bash -c -i 'gserver " + options["remotePort"] + "' || sleep 5"
command = ""
if environ["os"] == "Windows":
startpath = environ["tmp"] + "gserver.start"
try:
startFile = open(startpath, "w")
startFile.write("echo -ne \"\\033]0;gserver\\007\"\n")
startFile.write(server)
startFile.close()
except:
self.log.append("Failed to write to start file!")
return
command += "putty -"
if options["session"]:
command += "load " + options["session"] + " -l " + options["username"] + " -t"
else:
command += base
command += tunnel + " -m \"" + startpath + "\""
else:
command += "xterm -T gserver -e " + base + tunnel + " \" " + server + "\""
self.server = subprocess.Popen(str(command), shell=True)
def startClient(self):
"""
Start the client of gbuilder, which communicates with the server.
"""
self.client = Client(self)
self.client.connectTo("localhost", int(options["localPort"]), 10)
#self.client.start()
mainWidgets["client"] = self.client
def compile(self):
"""
Compile the current topology.
"""
if self.running:
self.log.append("You cannot compile a topology when one is still running!")
return False
if self.saveTopology() == False:
return False
scene = self.canvas.scene()
compiler = Compiler(scene.items(), self.filename)
xmlFile = compiler.compile()
self.properties.display()
self.interfaces.display()
self.routes.display()
if xmlFile:
self.statusBar().showMessage(self.tr("Compiled '%1'").arg(xmlFile), 2000)
return True
else:
self.statusBar().showMessage(self.tr("Compile failed"), 2000)
return False
def run(self):
"""
Run the current topology.
"""
if not self.server or self.server.poll() != None:
self.log.append("Please start the server first!")
return
if not self.client or not self.client.isConnected():
self.startClient()
if self.isRunning() and not self.recovery:
self.log.append("A topology is already running, please stop it first!")
return
scene = self.canvas.scene()
items = scene.items()
if items:
if self.recovery:
self.recovery = False
elif options["autocompile"] and not self.compile():
return
else:
self.log.append("Please create or load a topology first!")
return
options["elasticMode"] = False
xmlFile = self.filename.replace(".gsav", ".xml")
if not os.access(xmlFile, os.F_OK):
self.log.append("Please compile the topology first!")
return
self.tm.show()
#self.progressBar.setValue(0)
self.client.process("file . " + xmlFile)
self.client.send("init " + self.project.split("/")[-1].strip(".gproj"))
self.client.send("canvas %d,%d" % (scene.width(), scene.height()))
for item in items:
if item.type == "Mobile" or item.type == "Wireless_access_point":
x = item.pos().x()
y = item.pos().y()
self.client.send("mobile %s %d,%d" % (item.getName(), x, y))
self.client.process("start " + xmlFile)
self.running = True
self.canvas.setAcceptDrops(False)
scene = self.canvas.scene()
scene.startRefresh()
scene.clearSelection()
self.properties.clear()
self.interfaces.clear()
self.routes.clear()
def stop(self):
"""
Stop the current running topology.
"""
if not self.server or self.server.poll() != None:
self.log.append("Please start the server first!")
return
if not self.client or not self.client.isConnected():
self.startClient()
if self.recovery:
self.recovery = False
scene = self.canvas.scene()
activeDevices = False
from Core.Device import Device
for item in scene.items():
if not isinstance(item, Device):
continue
if item.type == "Router":
item.stop()
if item.status:
activeDevices = True
if not activeDevices:
self.stopped()
elif not scene.isRefreshing():
scene.startRefresh()
self.client.process("stop")
def stopped(self):
"""
Handle a fully stopped topology.
"""
self.running = False
self.canvas.scene().stopRefresh()
self.tm.hide()
self.canvas.setAcceptDrops(True)
olddir = os.getcwd()
os.chdir(environ["tmp"])
for tmpfile in os.listdir("."):
if tmpfile.startswith("."):
continue
try:
os.remove(tmpfile)
except:
continue
os.chdir(olddir)
def loadFile(self, filetype):
"""
Load a file through a file dialog.
"""
# Qt is very picky in the filename structure but python is not, so we use python
# to form the correct path which will work for both Windows and Linux
olddir = os.getcwd()
os.chdir(environ["sav"])
loadpath = os.getcwd()
os.chdir(olddir)
filename = QtGui.QFileDialog.getOpenFileName(self,
self.tr("Choose a file name"), loadpath,
self.tr(filetype))
return filename
def loadTopology(self):
"""
Load a topology.
"""
if self.running:
self.log.append("You cannot load a topology when one is still running!")
return
if isinstance(mainWidgets["canvas"], Tutorial):
self.log.append("You cannot load a topology during the tutorial!")
return
def loadIntoScene(line):
scene = self.canvas.scene()
itemType,arg = line.split(":")
args = str(arg).strip("()").split(",")
if itemType == "edge":
source = scene.findItem(args[0])
dest = scene.findItem(args[1])
if source.type == "Mobile" or dest.type == "Mobile":
item = Wireless_Connection(source, dest)
else:
item = Connection(source, dest)
scene.addItem(item)
else:
devType, index = str(itemType).rsplit("_", 1)
item = deviceTypes[devType]()
item.setIndex(int(index))
scene.addItem(item)
item.setPos(float(args[0]), float(args[1]))
item.nudge()
return item
def loadProperties(itemDict):
currentInterfaceTarget = None
currentRouteSubnet = None
for item, properties in itemDict.iteritems():
for line in properties:
count = 0
while line.find("\t") == 0:
line = line[1:]
count += 1
prop, value = line.split(":", 1)
if count == 1:
item.setProperty(prop, value)
elif count == 2:
currentInterfaceTarget = self.canvas.scene().findItem(value)
elif count == 3:
item.setInterfaceProperty(prop, value, currentInterfaceTarget)
elif count == 4:
currentRouteSubnet = value
item.addEntry("", "", value, currentInterfaceTarget)
elif count == 5:
item.setEntryProperty(prop, value, currentRouteSubnet, currentInterfaceTarget)
filename = self.loadFile("GSAV (*.gsav)")
if filename.isEmpty():
return
file = QtCore.QFile(filename)
if not file.open(QtCore.QFile.ReadOnly | QtCore.QFile.Text):
QtGui.QMessageBox.warning(self, self.tr("Load Error"),
self.tr("Cannot read file %1:\n%2.")
.arg(filename)
.arg(file.errorString()))
return
self.newScene()
self.filename = str(filename)
_in = QtCore.QTextStream(file)
QtGui.QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)
itemDict = {}
line = str(_in.readLine())
lines = []
while not _in.atEnd():
item = loadIntoScene(line)
line = str(_in.readLine())
while line.find("\t") == 0:
lines.append(line)
line = str(_in.readLine())
itemDict[item] = lines
lines = []
loadProperties(itemDict)
QtGui.QApplication.restoreOverrideCursor()
self.statusBar().showMessage(self.tr("Loaded '%1'").arg(filename), 2000)
def saveFile(self, filetype):
"""
Save a file through a file dialog.
"""
olddir = os.getcwd()
os.chdir(environ["sav"])
savepath = os.getcwd()
os.chdir(olddir)
filename = QtGui.QFileDialog.getSaveFileName(self,
self.tr("Choose a file name"), savepath,
self.tr(filetype.upper() + " (*.%s)" % filetype))
if filename.isEmpty():
return filename
if not filename.toLower().endsWith("." + filetype):
filename += "." + filetype
return filename
def saveTopologyAs(self):
"""
Save a topology under a given filename.
"""
if not self.canvas.scene().items():
self.log.append("There is nothing to save!")
return False
filename = self.saveFile("gsav")
if filename.isEmpty():
return False
self.filename = str(filename)
return self.saveTopology()
def saveTopology(self):
"""
Save a topology.
"""
if not self.canvas.scene().items():
self.log.append("There is nothing to save!")
return False
# for first time use
if not self.filename:
return self.saveTopologyAs()
file = QtCore.QFile(self.filename)
if not file.open(QtCore.QFile.WriteOnly | QtCore.QFile.Text):
QtGui.QMessageBox.warning(self, self.tr("Save Error"),
self.tr("Cannot write file %1:\n%2.")
.arg(self.filename)
.arg(file.errorString()))
return False
out = QtCore.QTextStream(file)
QtGui.QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)
scene = self.canvas.scene()
outstring = ""
for item in scene.items():
if isinstance(item, Node):
outstring += item.toString()
for item in scene.items():
if isinstance(item, Edge):
outstring += item.toString()
out << outstring
QtGui.QApplication.restoreOverrideCursor()
self.statusBar().showMessage(self.tr("Saved '%1'").arg(self.filename), 2000)
return True
def copy(self):
"""
Copy selected text from the log into the paste buffer.
"""
self.log.copy()
def config(self):
"""
Open the options window.
"""
self.configWindow.show()
def arrange(self):
"""
Rearrange the topology based on the distance between nodes.
"""
if self.isRunning():
self.log.append("Cannot arrange while running!")
return
if isinstance(mainWidgets["canvas"], Tutorial):
mainWidgets["log"].append("Cannot arrange during the tutorial!")
return
options["elasticMode"] = not options["elasticMode"]
def about(self):
"""
Show the about window.
"""
QtGui.QMessageBox.about(self,
self.tr("About %s %s"
% (Core.globals.PROG_NAME,
Core.globals.PROG_VERSION)),
self.tr("<b>%s %s</b><br>Written by Daniel Ng<br>under the supervision of Muthucumaru Maheswaran"
% (Core.globals.PROG_NAME,
Core.globals.PROG_VERSION)))
def createActions(self):
"""
Create the actions used in the menus and toolbars.
"""
self.newSceneAct = QtGui.QAction(QtGui.QIcon(environ["images"] + "new.png"), self.tr("&New"), self)
self.newSceneAct.setShortcut(self.tr("Ctrl+N"))
self.newSceneAct.setStatusTip(self.tr("Create a new topology"))
self.connect(self.newSceneAct, QtCore.SIGNAL("triggered()"), self.newScene)
self.closeAct = QtGui.QAction(QtGui.QIcon(environ["images"] + "close.png"), self.tr("&Close"), self)
self.closeAct.setShortcut(self.tr("Ctrl+W"))
self.closeAct.setStatusTip(self.tr("Close the current topology"))
self.connect(self.closeAct, QtCore.SIGNAL("triggered()"), self.closeTopology)
self.loadAct = QtGui.QAction(QtGui.QIcon(environ["images"] + "open.png"), self.tr("&Open..."), self)
self.loadAct.setShortcut(self.tr("Ctrl+O"))
self.loadAct.setStatusTip(self.tr("Load a topology"))
self.connect(self.loadAct, QtCore.SIGNAL("triggered()"), self.loadTopology)
self.saveAct = QtGui.QAction(QtGui.QIcon(environ["images"] + "save.png"), self.tr("&Save..."), self)
self.saveAct.setShortcut(self.tr("Ctrl+S"))
self.saveAct.setStatusTip(self.tr("Save the current topology"))
self.connect(self.saveAct, QtCore.SIGNAL("triggered()"), self.saveTopology)
self.saveAsAct = QtGui.QAction(QtGui.QIcon(environ["images"] + "save.png"), self.tr("&Save As..."), self)
self.saveAsAct.setShortcut(self.tr("Ctrl+Shift+S"))
self.saveAsAct.setStatusTip(self.tr("Save the current topology under a given filename"))
self.connect(self.saveAsAct, QtCore.SIGNAL("triggered()"), self.saveTopologyAs)
self.sendFileAct = QtGui.QAction(QtGui.QIcon(environ["images"] + "send.png"), self.tr("&Send File..."), self)
self.sendFileAct.setShortcut(self.tr("Ctrl+F"))
self.sendFileAct.setStatusTip(self.tr("Choose a file to send to the server"))
self.connect(self.sendFileAct, QtCore.SIGNAL("triggered()"), self.sendFile)
self.exportAct = QtGui.QAction(QtGui.QIcon(environ["images"] + "export.png"), self.tr("&Export..."), self)
self.exportAct.setShortcut(self.tr("Ctrl+P"))
self.exportAct.setStatusTip(self.tr("Export the current topology as an image"))
self.connect(self.exportAct, QtCore.SIGNAL("triggered()"), self.export)
self.copyAct = QtGui.QAction(QtGui.QIcon(environ["images"] + "copy.png"), self.tr("&Copy"), self)
self.copyAct.setShortcut(self.tr("Ctrl+C"))
self.copyAct.setStatusTip(self.tr("Copy the selected text"))
self.connect(self.copyAct, QtCore.SIGNAL("triggered()"), self.copy)
self.compileAct = QtGui.QAction(QtGui.QIcon(environ["images"] + "compile.png"), self.tr("&Compile"), self)
self.compileAct.setShortcut(self.tr("Ctrl+E"))
self.compileAct.setStatusTip(self.tr("Compile the current topology"))
self.connect(self.compileAct, QtCore.SIGNAL("triggered()"), self.compile)
self.runAct = QtGui.QAction(QtGui.QIcon(environ["images"] + "run.png"), self.tr("&Run"), self)
self.runAct.setShortcut(self.tr("Ctrl+R"))
self.runAct.setStatusTip(self.tr("Run the current topology"))
self.connect(self.runAct, QtCore.SIGNAL("triggered()"), self.run)
self.stopAct = QtGui.QAction(QtGui.QIcon(environ["images"] + "stop.png"), self.tr("&Stop"), self)
self.stopAct.setShortcut(self.tr("Ctrl+D"))
self.stopAct.setStatusTip(self.tr("Stop the current topology"))
self.connect(self.stopAct, QtCore.SIGNAL("triggered()"), self.stop)
self.startServerAct = QtGui.QAction(QtGui.QIcon(environ["images"] + "startServer.png"), self.tr("&Start Server"), self)
self.startServerAct.setShortcut(self.tr("Ctrl+T"))
self.startServerAct.setStatusTip(self.tr("Start the server"))
self.connect(self.startServerAct, QtCore.SIGNAL("triggered()"), self.startBackend)
self.optionsAct = QtGui.QAction(QtGui.QIcon(environ["images"] + "options.png"), self.tr("&Options"), self)
self.optionsAct.setShortcut(self.tr("F2"))
self.optionsAct.setStatusTip(self.tr("Show the options window"))
self.connect(self.optionsAct, QtCore.SIGNAL("triggered()"), self.config)
self.arrangeAct = QtGui.QAction(QtGui.QIcon(environ["images"] + "arrange.png"), self.tr("&Arrange"), self)
self.arrangeAct.setShortcut(self.tr("Ctrl+A"))
self.arrangeAct.setStatusTip(self.tr("Arranges the current topology"))
self.connect(self.arrangeAct, QtCore.SIGNAL("triggered()"), self.arrange)
self.resetLayoutAct = QtGui.QAction(QtGui.QIcon(environ["images"] + "layout.png"), self.tr("Reset Layout"), self)
self.resetLayoutAct.setStatusTip(self.tr("Reset dock windows to the saved layout"))
self.connect(self.resetLayoutAct, QtCore.SIGNAL("triggered()"), self.resetLayout)
self.expandSceneAct = QtGui.QAction(QtGui.QIcon(environ["images"] + "expand.png"), self.tr("Expand Scene"), self)
self.expandSceneAct.setStatusTip(self.tr("Expand the scene for more space"))
self.connect(self.expandSceneAct, QtCore.SIGNAL("triggered()"), self.expandScene)
self.quitAct = QtGui.QAction(QtGui.QIcon(environ["images"] + "exit.png"), self.tr("&Quit"), self)
self.quitAct.setShortcut(self.tr("Ctrl+Q"))
self.quitAct.setStatusTip(self.tr("Quit the application"))
self.connect(self.quitAct, QtCore.SIGNAL("triggered()"), self.quit)
self.newProjectAct = QtGui.QAction(QtGui.QIcon(environ["images"] + "new.png"), self.tr("&New"), self)
self.newProjectAct.setShortcut(self.tr("Ctrl+Shift+N"))
self.newProjectAct.setStatusTip(self.tr("Create a new project"))
self.connect(self.newProjectAct, QtCore.SIGNAL("triggered()"), self.newProject)
self.openProjectAct = QtGui.QAction(QtGui.QIcon(environ["images"] + "open.png"), self.tr("&Open"), self)
self.openProjectAct.setShortcut(self.tr("Ctrl+Shift+O"))
self.openProjectAct.setStatusTip(self.tr("Open an existing project"))
self.connect(self.openProjectAct, QtCore.SIGNAL("triggered()"), self.openProject)
self.closeProjectAct = QtGui.QAction(QtGui.QIcon(environ["images"] + "close.png"), self.tr("&Close"), self)
self.closeProjectAct.setShortcut(self.tr("Ctrl+Shift+W"))
self.closeProjectAct.setStatusTip(self.tr("Close the current project"))
self.connect(self.closeProjectAct, QtCore.SIGNAL("triggered()"), self.closeProject)
self.tutorialAct = QtGui.QAction(QtGui.QIcon(environ["images"] + "tutorial.png"), self.tr("&Tutorial"), self)
self.connect(self.tutorialAct, QtCore.SIGNAL("triggered()"), self.startTutorial)
self.faqAct = QtGui.QAction(QtGui.QIcon(environ["images"] + "help.png"), self.tr("&FAQ"), self)
self.connect(self.faqAct, QtCore.SIGNAL("triggered()"), self.faq)
self.aboutAct = QtGui.QAction(QtGui.QIcon(environ["images"] + "giniLogo.png"), self.tr("&About"), self)
self.aboutAct.setStatusTip(self.tr("Show the application's About box"))
self.connect(self.aboutAct, QtCore.SIGNAL("triggered()"), self.about)
self.aboutQtAct = QtGui.QAction(self.tr("About &Qt"), self)
self.aboutQtAct.setStatusTip(self.tr("Show the Qt library's About box"))
self.connect(self.aboutQtAct, QtCore.SIGNAL("triggered()"),
QtGui.qApp, QtCore.SLOT("aboutQt()"))
def createMenus(self):
"""
Create the menus with actions.
"""
self.fileMenu = self.menuBar().addMenu(self.tr("&File"))
self.fileMenu.setPalette(defaultOptions["palette"])
self.fileMenu.addAction(self.newSceneAct)
self.fileMenu.addAction(self.loadAct)
self.fileMenu.addAction(self.saveAct)
self.fileMenu.addAction(self.saveAsAct)
self.fileMenu.addAction(self.sendFileAct)
self.fileMenu.addAction(self.exportAct)
self.fileMenu.addAction(self.closeAct)
self.fileMenu.addSeparator()
self.fileMenu.addAction(self.quitAct)
self.projectMenu = self.menuBar().addMenu(self.tr("&Project"))
self.projectMenu.setPalette(defaultOptions["palette"])
self.projectMenu.addAction(self.newProjectAct)
self.projectMenu.addAction(self.openProjectAct)
self.projectMenu.addAction(self.closeProjectAct)
self.editMenu = self.menuBar().addMenu(self.tr("&Edit"))
self.editMenu.setPalette(defaultOptions["palette"])
self.editMenu.addAction(self.copyAct)
self.editMenu.addAction(self.arrangeAct)
self.editMenu.addAction(self.resetLayoutAct)
self.editMenu.addAction(self.expandSceneAct)
self.runMenu = self.menuBar().addMenu(self.tr("&Run"))
self.runMenu.setPalette(defaultOptions["palette"])
self.runMenu.addAction(self.compileAct)
self.runMenu.addAction(self.runAct)
self.runMenu.addAction(self.stopAct)
self.runMenu.addAction(self.startServerAct)
self.configMenu = self.menuBar().addMenu(self.tr("&Config"))
self.configMenu.setPalette(defaultOptions["palette"])
self.configMenu.addAction(self.optionsAct)
self.menuBar().addSeparator()
self.helpMenu = self.menuBar().addMenu(self.tr("&Help"))
self.helpMenu.setPalette(defaultOptions["palette"])
self.helpMenu.addAction(self.tutorialAct)
self.helpMenu.addAction(self.faqAct)
self.helpMenu.addAction(self.aboutAct)
self.helpMenu.addAction(self.aboutQtAct)
def createPopupMenu(self):
"""
Customize the popup menu so that it is visible.
"""
popupMenu = QtGui.QMainWindow.createPopupMenu(self)
popupMenu.setPalette(defaultOptions["palette"])
return popupMenu
def createToolBars(self):
"""
Create the toolbars with actions.
"""
self.fileToolBar = self.addToolBar(self.tr("File"))
self.fileToolBar.addAction(self.newSceneAct)
self.fileToolBar.addAction(self.loadAct)
self.fileToolBar.addAction(self.saveAct)
self.fileToolBar.addAction(self.sendFileAct)
self.fileToolBar.addAction(self.exportAct)
self.fileToolBar.addAction(self.closeAct)
self.editToolBar = self.addToolBar(self.tr("Edit"))
self.editToolBar.addAction(self.copyAct)
self.editToolBar.addAction(self.resetLayoutAct)
self.editToolBar.addAction(self.expandSceneAct)
self.runToolBar = self.addToolBar(self.tr("Run"))
self.runToolBar.addAction(self.compileAct)
self.runToolBar.addAction(self.runAct)
self.runToolBar.addAction(self.stopAct)
self.runToolBar.addAction(self.startServerAct)
def createStatusBar(self):
"""
Create the status bar.
"""
self.statusBar().showMessage(self.tr("Ready"))
def createProgressBar(self):
"""
Create the progress bar.
"""
self.progressBar = QtGui.QProgressBar()
self.progressBar.setRange(0, 10000)
self.progressBar.setValue(0)
self.statusBar().addPermanentWidget(self.progressBar)
self.progressBar.show()
def getDeviceCount(self, alive=False):
"""
Return the interfaceable device count, or the alive ones if alive=True.
"""
from Core.Interfaceable import Interfaceable
count = 0.0
for item in self.canvas.scene().items():
if isinstance(item, Interfaceable):
if alive and item.status in ("", "dead"):
continue
count += 1.0
return count
def updateProgressBar(self):
"""
Update the progress bar.
"""
maxVal = self.progressBar.maximum()
finalVal = (self.getDeviceCount(True) / self.getDeviceCount()) * maxVal
if finalVal < 0:
finalVal = 0
self.progressBar.setValue(finalVal)
if finalVal == 0:
return True
return False
def createConfigWindows(self):
"""
Create the options window.
"""
self.configWindow = ConfigDialog(self)
def createDockWindows(self):
"""
Create the dock windows: dropbar, log, properties, interfaces, routes.
"""
self.log = LogWindow(self.tr("Log"), self)
self.log.append("Welcome to %s %s!\n"
% (Core.globals.PROG_NAME, Core.globals.PROG_VERSION))
self.log.setGeometry(QtCore.QRect(0, 0, 800, 114))
mainWidgets["log"] = self.log
self.dropbar = DropBar(self.tr("Components"), self)
self.dropbar.setGeometry(QtCore.QRect(0, 0, 129, 390))
mainWidgets["drop"] = self.dropbar
self.properties = PropertiesWindow(self)
self.properties.setWindowTitle("Properties")
mainWidgets["properties"] = self.properties
self.interfaces = InterfacesWindow(self)
self.interfaces.setWindowTitle("Interfaces")
mainWidgets["interfaces"] = self.interfaces
self.routes = RoutesWindow(self.interfaces, self)
self.routes.setWindowTitle("Routes")
mainWidgets["routes"] = self.routes
self.tm = TaskManagerWindow(self)
self.tm.setWindowTitle("Task Manager")
mainWidgets["tm"] = self.tm
self.debugWindow = QtGui.QDockWidget(self.tr("Debug Window"))
self.debugWindow.setWidget(DebugWindow(self))
self.docks = {"Components":self.dropbar, "Log":self.log, "Properties":self.properties, "Interfaces":self.interfaces, "Routes":self.routes, "Task Manager":self.tm}
self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self.dropbar)
self.addDockWidget(QtCore.Qt.BottomDockWidgetArea, self.log)
self.addDockWidget(QtCore.Qt.RightDockWidgetArea, self.properties)
self.addDockWidget(QtCore.Qt.RightDockWidgetArea, self.interfaces)
self.addDockWidget(QtCore.Qt.RightDockWidgetArea, self.routes)
self.addDockWidget(QtCore.Qt.RightDockWidgetArea, self.tm)
self.tm.setFloating(True)
self.routes.setFloating(True)
self.debugWindow.setFloating(True)
def createPopupWindows(self):
"""
Create the different popup windows.
"""
self.exportWindow = ExportWindow(self)
self.sendWindow = SendDirectoryWindow(self)
self.popup = QtGui.QMessageBox(self)
self.popup.setIcon(QtGui.QMessageBox.Warning)
self.popup.setWindowIcon(QtGui.QIcon(environ["images"]+"giniLogo.png"))
mainWidgets["popup"] = self.popup
def keyPressEvent(self, event):
"""
Handle specific shortcut keys.
"""
key = event.key()
scene = self.canvas.scene()
if key == QtCore.Qt.Key_Escape:
scene.clearSelection()
elif key == QtCore.Qt.Key_Delete:
for item in scene.selectedItems():
item.delete()
elif key == QtCore.Qt.Key_C:
items = scene.items()
if not items:
return
selected = scene.selectedItems()
scene.clearSelection()
if selected:
index = items.index(selected[0])
items[index - 1].setSelected(True)
else:
items[0].setSelected(True)
elif key == QtCore.Qt.Key_H:
for dock in self.docks.values():
dock.setFloating(not dock.isFloating())
elif key == QtCore.Qt.Key_F10:
self.debugWindow.show()
k = fft(x)
# definition to calculat the kinetic energie in the k-room
def B(k,t):
return exp(t*complex(0.,1.)*k*k/2.)
# definition to calculate the potential in the real room
def pot(x):
return pow(abs(x*x-1),2)/2.
def A(x,t):
return exp(t*complex(0.,1.)*(pot(x))/2.)
screen = Tk()
wd,ht = screen.winfo_screenwidth(),screen.winfo_screenheight()
screen.geometry("%dx%d+0+0"%(wd,ht))
canv = Canvas(screen,height=ht,width=wd,background="black")
canv.pack()
# some scale factor to enlarge the animation
scaley = 150
scalex = 140
# define the time
for t in linspace(0.1,0.5,2000):
# calculate A and B
expA = map(lambda x: A(x,t),x)
expB = map(lambda k: B(k,t),k)
# tranform back the k-room into the real room
expB = ifft(expB)
# calculate the time depended hamiltonien
return (beta_gamma,alpha_gamma)
# in this definition is the repaint of the triangle and the decision if is a --
# green or red dot
def clicked_point(event):
canv.delete(ALL)
trian(a,b,c)
x0 = event.x
y0 = event.y
p = complex(x0,y0)
x = faktor(p)
if (( 1>= x[0][0] >=0) and (x[0][1]>=0)):
canv.create_oval(x0-4,y0-4,x0+4,y0+4,fill='green')
else:
if (( 1>= x[1][0] >=0) and (x[1][1]>=0)):
canv.create_oval(x0-4,y0-4,x0+4,y0+4,fill='green')
else:
canv.create_oval(x0-4,y0-4,x0+4,y0+4,fill='red')
root = Tk()
canv = Canvas(root,width=size,height=size)
trian(a,b,c)
canv.bind("<Button-1>",clicked_point)
canv.bind("<B1-Motion>",clicked)
canv.pack()
root.mainloop()
def __construct__(self): #extract and properly indent python content script = Canvas.normalize_python(node=self) #run th' junks try: exec script in self.parent.__dict__ except Exception, msg: Events.Error(self, msg, "bad syntax in python block")
