def init_assignment(ass, name):
assignment_dir = dir_name(ass)
os.mkdir(assignment_dir)
course_dir = config_dir(".", "canvas.yaml")
with open(os.path.join(course_dir, "canvas.yaml"), "r") as f:
conf = yaml.load(f)
course_id = conf['id']
# with open(os.path.join(course_dir, "token"), "r") as f:
# api_token = f.read().strip()
assignment = Canvas().course(id=course_id).assignment(name=ass)
subs = assignment.submissions()
# get the ids of the students in
# group set <assignment name>, group <instructor name>
#members = get_members(name, assignment, course_id, api_token)
#student_ids = [m['id'] for m in members]
#subs = [sub for sub in subs if sub['user_id'] in student_ids]
make_sub_dirs(assignment_dir, subs)
return subs
class CreateGUI(tk.Tk):
"""The main class for the program
Instance variables:
edof: An noe x 7 array on the form array([[el_1, dof1, dof2...dof6],
[el_noe, dof1, dof2...dof6]])
"""
def __init__(self):
tk.Tk.__init__(self)
self.title("Frame 2000")
self.state('zoomed')
self.iconbitmap('icon_beam_2000.ico')
self.resizable(False, False)
# Create a list for storing instances of the element class
self.element_list = []
# Create a dictionary to store the topology information
self.edof = np.empty((0, 7), float)
# Create instances of window content
self.menubar = Menubar(self)
self.canvas = Canvas(self)
self.main_menu = MainMenu(self)
# Place the instances in the window
self.canvas.pack(side="left", fill="both", expand=1, pady=20, padx=20)
self.main_menu.pack(side="right", fill=tk.Y, padx=10)
class RenderWin(QMainWindow):
def __init__(self, loc, img, w, h, r, parent=None):
super(RenderWin, self).__init__(parent)
self.parent = parent
self.setWindowTitle(" ")
self.setGeometry(loc)
self.move(parent.x() + parent.width() / 2,
parent.y() + parent.height() / 2)
self.canvas = Canvas(img, w, h, r, self)
self.scrollview = QScrollArea(self)
bar_w = self.scrollview.style().subControlRect(
QStyle.CC_ScrollBar, QStyleOptionSlider(),
QStyle.SC_ScrollBarGroove, self).x()
self.scrollview.setWidget(self.canvas)
self.setCentralWidget(self.scrollview)
default_max_w, default_max_h = 300, 300
self.setFixedSize(
QSize(clip(w + bar_w, 0, default_max_w),
clip(h + bar_w, 0, default_max_h)))
self.setMaximumSize(QSize(w + bar_w, h + bar_w))
self.canvas.update()
def closeEvent(self, event):
self.parent.on_finish_editing()
self.parent.on_child_destroyed()
self.canvas.reset_mask()
event.accept()
self.destroy()
def __init__(self, loc, img, w, h, r, parent=None):
super(RenderWin, self).__init__(parent)
self.parent = parent
self.setWindowTitle(" ")
self.setGeometry(loc)
self.move(parent.x() + parent.width() / 2,
parent.y() + parent.height() / 2)
self.canvas = Canvas(img, w, h, r, self)
self.scrollview = QScrollArea(self)
bar_w = self.scrollview.style().subControlRect(
QStyle.CC_ScrollBar, QStyleOptionSlider(),
QStyle.SC_ScrollBarGroove, self).x()
self.scrollview.setWidget(self.canvas)
self.setCentralWidget(self.scrollview)
default_max_w, default_max_h = 300, 300
self.setFixedSize(
QSize(clip(w + bar_w, 0, default_max_w),
clip(h + bar_w, 0, default_max_h)))
self.setMaximumSize(QSize(w + bar_w, h + bar_w))
self.canvas.update()
def __init__(self, themefile, styleconfig, activation_event):
super().__init__()
self.setWindowTitle('fckthms and not in a good way')
self.themefile = themefile
validate_theme(themefile, styleconfig)
activation_event.connect(self.reload_data)
layout = QtGui.QHBoxLayout(self)
common.kill_theming(layout)
paintstack = generate_paintstack(themefile)
self.listwidget = ColorList(self, paintstack)
self.canvas = Canvas(self, paintstack, self.listwidget.get_color)
self.listwidget.request_repaint.connect(self.canvas.update)
layout.addWidget(self.canvas, stretch=1)
listlayout = QtGui.QVBoxLayout()
common.kill_theming(listlayout)
listlayout.addWidget(self.listwidget)
highlightbtn = QtGui.QPushButton('Highlight items')
highlightbtn.setCheckable(True)
highlightbtn.toggled.connect(self.listwidget.set_highlight)
listlayout.addWidget(highlightbtn)
colorbtn = QtGui.QPushButton('Set color')
colorbtn.clicked.connect(self.listwidget.set_color)
listlayout.addWidget(colorbtn)
resetbtn = QtGui.QPushButton('Reset color')
resetbtn.clicked.connect(self.listwidget.reset_color)
listlayout.addWidget(resetbtn)
layout.addLayout(listlayout)
self.show()
def initUI(self):
QToolTip.setFont(QFont('Lato', 12))
# WINDOW
homeWidget = QWidget()
self.setCentralWidget(homeWidget)
self.resize(800, 600)
self.center()
self.setWindowTitle('Bezier Program!')
self.canvas = Canvas(self)
# MENU
menuBar = self.menuBar()
showLinesMenu = menuBar.addMenu(' ')
self.guideBox = QCheckBox('Show guide', self)
bezierMenu = menuBar.addMenu('Bezier menu')
bezierAction = QAction('Bézier curve', self)
bezierMenu.addAction(bezierAction)
bezierAction.triggered.connect(self.canvas.addBCurve)
self.guideBox.stateChanged.connect(self.canvas.toggleGuide)
# AREA DE DESENHO
mainLayout = QHBoxLayout()
self.canvas.setStyleSheet("QWidget { background-color: %s }" %
QColor(255, 255, 255).name())
self.canvas.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
mainLayout.addWidget(self.canvas)
homeWidget.setLayout(mainLayout)
self.show()
class MainWidget(QtGui.QScrollArea): """ La clase MainWidget es una derivada de la clase QScrollArea. En este widget se pone, centrado, el lienzo del dibujo (Canvas). Además, éste es el widget alrededor del cual se centra la MainWindow. """ def __init__(self, w, h, image, com, color, Parent=None): super(MainWidget,self).__init__() self.canvas = Canvas(w, h, image, com, color, self) self.setWidget(self.canvas) def resizeEvent(self, event): super(MainWidget,self).resizeEvent(event) self.calcNewCanvasGeometry() def paintEvent(self, event): super(MainWidget,self).paintEvent(event) self.calcNewCanvasGeometry() def calcNewCanvasGeometry(self): g = self.frameGeometry() w = g.width() h = g.height() self.canvas.move( (w-self.canvas.width*self.canvas.zoom)/2, (h-self.canvas.height*self.canvas.zoom)/2 ); print self.frameGeometry()
def __init__(self, master):
self.width = int(config['window']['width'])
self.height = int(config['window']['height'])
self.fps = int(config['frame']['fps'])
self.currentScreenID = ScreenID.START
self.beforeScreenID = None
self.canControl = False
self.chatUI = None
self.actions = {}
self.shot1Image = tkinter.PhotoImage(
file='resources/shots/explosive.gif')
self.shot2Image = tkinter.PhotoImage(file='resources/shots/fish.gif')
self.shot1ID = None
self.shot2ID = None
self.help = False
super().__init__(master=master, width=self.width, height=self.height)
self.bind("<Key>", self.key) # listen keyborad
self.pack()
# create a canvas to draw all item
self.canvas = Canvas(self, self.width, self.height)
self.startPage()
self.focus_set() # focus on this frame
self.run() # this function handler all game event logic
self.mainloop()
def __init__(self, width=300, height=300):
if not glfw.init():
print("Init failed")
# This trick borrowed from `cmu_112_graphics`
self._callersGlobals = inspect.stack()[1][0].f_globals
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, GL_TRUE)
self.window = glfw.create_window(width, height, "Hello, world", None,
None)
glfw.make_context_current(self.window)
self.width, self.height = width, height
self.timerDelay = 200
self.lastTimer = time.time()
glEnable(GL_DEPTH_TEST)
glEnable(GL_CULL_FACE)
glFrontFace(GL_CW)
glEnable(GL_BLEND)
self.canvas = Canvas(self.width, self.height)
self.run()
def test_unknown_method(self):
# EXEC
canvas = Canvas()
with self.assertRaisesRegex(
AttributeError,
"(Canvas instance|'Canvas' object) has no attribute 'create_wirple'"):
canvas.create_wirple(1, 'floop')
def __init__(self, parent=None):
wx.Frame.__init__ ( self, parent, id = wx.ID_ANY, title = wx.EmptyString, pos = wx.DefaultPosition, size = wx.Size( -1,-1 ), style = wx.DEFAULT_FRAME_STYLE|wx.TAB_TRAVERSAL )
self.SetSizeHintsSz( wx.DefaultSize, wx.DefaultSize )
self.SetBackgroundColour( wx.Colour( 255, 255, 255 ) )
sizer = wx.BoxSizer( wx.VERTICAL )
self.txt_info = wx.StaticText( self, wx.ID_ANY, u'500*500 pixels 173k', wx.DefaultPosition, wx.DefaultSize, 0 )
self.txt_info.Wrap( -1 )
sizer.Add( self.txt_info, 0, wx.ALL, 0 )
self.canvas = Canvas(self)
self.canvas.fit = self
sizer.Add( self.canvas, 1, wx.EXPAND |wx.ALL, 0 )
self.page = wx.ScrollBar( self, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.SB_HORIZONTAL)
self.page.SetScrollbar(0,0,0,0, refresh=True)
sizer.Add( self.page, 0, wx.ALL|wx.EXPAND, 0 )
#self.page.Hide()
self.SetSizer(sizer)
self.Layout()
self.Bind(wx.EVT_IDLE, self.on_idle)
self.Bind(wx.EVT_SCROLL_THUMBTRACK, self.on_scroll)
self.Bind(wx.EVT_ACTIVATE, self.on_valid)
self.Bind(wx.EVT_CLOSE, self.on_close)
self.canvas.Bind(wx.EVT_CHAR, self.on_key)
self.canvas.SetFocus()
# panel.Bind(wx.EVT_CHAR, self.OnKeyDown)
self.opage = 0
self.Fit()
WindowsManager.add(self)
def run(self):
print 'RUNNING'
r = lambda: random.randint(0, 255)
while True:
Canvas.clear()
Canvas.draw_rect((0, 0), (200, 200), fill_style='#%02X%02X%02X' % (r(), r(), r()))
sleep(random.uniform(0.03, 1))
def init_docks(self):
'''初始化的一部分，执行浮动子窗口和canvas的初始化，单列一个函数以提升可读性'''
self.database_widget = DatabaseWidget()
self.dataset_tree_dock.setWidget(self.database_widget)
self.menuView.addAction(self.dataset_tree_dock.toggleViewAction())
self.series_list_widget = SeriesListWidget()
self.series_list_dock.setWidget(self.series_list_widget)
self.menuView.addAction(self.series_list_dock.toggleViewAction())
self.annotations_list_widget = AnnotationsListWidget()
self.annotations_list_dock.setWidget(self.annotations_list_widget)
self.menuView.addAction(self.annotations_list_dock.toggleViewAction())
self.label_edit_widget = LabelEditWidget()
self.label_edit_dock.setWidget(self.label_edit_widget)
self.menuView.addAction(self.label_edit_dock.toggleViewAction())
self.canvas_area = QScrollArea()
# TODO: 原理？看了文档还是不懂，需要进行更多研究
self.canvas_area.setWidgetResizable(True)
self.scroll_bars = {
Qt.Vertical: self.canvas_area.verticalScrollBar(),
Qt.Horizontal: self.canvas_area.horizontalScrollBar()
}
self.canvas_widget = Canvas()
self.canvas_area.setWidget(self.canvas_widget)
self.setCentralWidget(self.canvas_area)
def __init__(self, cfg_game, screen):
# arguments
self.cfg_game = cfg_game
self.screen = screen
# colors
self.color_bag = ColorBag()
# canvas
self.canvas = Canvas(self.screen)
# game logic
self.game_logic = MenuGameLogic(self)
# actual up down click
self.ud_click = 0
self.lr_click = 0
# click
self.click = False
# selection
self.button_state = 0
# button dict, selection: button in canvas
self.button_state_dict = {'start_button': 0, 'help_button': 1, 'end_button': 2}
# set button state
self.button_state = self.button_state_dict['start_button']
def main(**args):
ventana = Ventana((800, 600))
canvas = Canvas((800, 450), (0, 150))
particula = Particula()
canvas.add_particula(particula, 0)
ventana.add_canvas(canvas, "0")
ventana.run()
def __init__(self):
self.gladefile = os.path.join(__location__, "pt3.glade")
self.builder = Gtk.Builder()
self.builder.add_from_file(self.gladefile)
#Create & Link canvas
self.canvas_box = self.builder.get_object("canvasBox")
self.canvas = Canvas()
self.watcher = VarWatcher(self.canvas)
self.canvas.show()
self.canvas_box.pack_start(self.canvas, True, True, 0)
# Automatically connect signals to functions defined above
# as specified in the glade file
self.builder.connect_signals(self)
# Get the main window
self.window = self.builder.get_object("ptWindow")
self.window.show()
self.window.connect("key-press-event", self.key_press)
#Ctrl+C handling
def handler(signum, frame):
self.log.warning("INTERRUPT: exiting gracefully")
self.window_destroy()
signal.signal(signal.SIGTERM, handler)
signal.signal(signal.SIGINT, handler)
#Fire up the main window
self.log.info("Launching GUI. Welcome to PT3! Press %s for help" %
conf.key_binds["help"])
Gtk.main()
def search():
if request.method == "POST":
RESULTS_ARRAY = []
# get url
f = request.files["img"]
f.save(f.filename)
image_url = f.filename
try:
c = Canvas()
results = c.search(image_url)
for (_, image) in results:
RESULTS_ARRAY.append({"image": image})
return jsonify(results=RESULTS_ARRAY[:20])
except:
# return error
jsonify({"sorry": "Sorry, no results! Please try again."}), 500
def __init__(self,parent,dpi=100.0):
Canvas.__init__(self,parent,dpi)
self.has_data = False
self.sqplot = None
self.cb = None
self.colormap = customcolormap.make_colormap("mymap", 1.0, 0.001, 10)
self.cmaplimits = 2.0
def test_canvas_draw_point():
width, height = 50, 50
canvas = Canvas(width, height)
x, y = 2, 3
point = Point(x, y)
canvas._draw_point(point)
assert canvas.cells[x][y] == (CanvasCellContentType.Line, 'x')
def initUI(self):
mainLay = widgets.QVBoxLayout()
self.mainLay = mainLay
mainLay.setContentsMargins(0, 0, 0, 0)
mainLay.setSpacing(0)
self.optionslay = widgets.QVBoxLayout()
self.optionslay.setContentsMargins(0, 0, 0, 0)
self.optionslay.setSpacing(0)
self.optionswidget = widgets.QWidget()
self.optionswidget.setLayout(self.optionslay)
self.optionswidget.setMaximumHeight(220)
self.canvas = Canvas()
self.canvas.setPointsData(self.pages.getPage())
self.connectCanvas()
mainLay.addWidget(self.canvas)
self.genHideBar()
mainLay.addWidget(self.optionswidget)
self.genDoUndoBar()
self.genPageBar()
self.genSliderGrid()
self.generateColorPicker()
self.genColorPickerGrid()
self.generateStrokeWidthSlider()
self.genSaveBar()
self.setLayout(mainLay)
self.optionswidget.setVisible(not self.optionsHidden)
self.setGeometry(300, 300, 800, 600)
self.setWindowTitle('Hand Writing Notes')
self.show()
def paned_window(self):
self.panedwindow = ttk.Panedwindow(self.parent, orient = tk.HORIZONTAL)
self.panedwindow.pack(expand = True, fill = tk.BOTH)
self.left_pane = ttk.Frame(self.panedwindow, height = root.winfo_screenheight() - 140, relief = tk.SUNKEN)
self.middle_pane = ttk.Frame(self.panedwindow, height = (root.winfo_screenheight() - 140), relief = tk.SUNKEN)
self.right_pane = ttk.Frame(self.panedwindow, height = (root.winfo_screenheight() - 140), relief = tk.SUNKEN)
self.panedwindow.add(self.left_pane, weight = 1)
self.panedwindow.add(self.middle_pane, weight = 1)
self.panedwindow.add(self.right_pane, weight = 10)
self.panedwindow_left = ttk.Panedwindow(self.left_pane, orient = tk.VERTICAL)
self.panedwindow_left.pack(expand = True, fill = tk.BOTH)
self.pane_projects = ttk.Frame(self.panedwindow_left, height = (root.winfo_screenheight() - 140) / 2, relief = tk.SUNKEN)
self.pane_actions = ttk.Frame(self.panedwindow_left, height = (root.winfo_screenheight() - 140) / 2, relief = tk.SUNKEN)
self.panedwindow_left.add(self.pane_projects, weight = 1)
self.panedwindow_left.add(self.pane_actions, weight = 1)
self.panewindow_middle = ttk.PanedWindow(self.middle_pane, orient = tk.VERTICAL)
self.panewindow_middle.pack(expand = True, fill = tk.BOTH)
self.pane_canvas = ttk.Frame(self.panewindow_middle, relief = tk.SUNKEN)
self.pane_resources = ttk.Frame(self.panewindow_middle, width = 100, relief = tk.SUNKEN)
self.panewindow_middle.add(self.pane_canvas, weight = 5)
self.panewindow_middle.add(self.pane_resources, weight = 1)
self.menubar = Menubar(self.parent)
self.properties = Properties(self.right_pane)
self.canvas = Canvas(self.properties)
self.toolbar = Toolbar(self.pane_canvas, self.canvas)
self.project_explorer = ProjectExplorer(self.pane_projects)
self.canvas.create_Ui(self.pane_canvas)
self.actions = Actions(self.pane_actions, self.canvas, self.properties)
self.resources = Resources(self.pane_resources)
def __init__(self, parent, *args, **kwargs):
tk.Frame.__init__(self, parent, *args, **kwargs)
self.parent = parent
self.defaultVideoCapture = VideoCapture(0)
self.webcamCanvas = Canvas(self.parent, self.defaultVideoCapture)
self.maskCanvas = Canvas(self.parent, self.defaultVideoCapture)
self.lowHueSlider = Slider(self.parent, "Low Hue", 10, 0, 180)
self.highHueSlider = Slider(self.parent, "High Hue", 25, 0, 180)
self.lowSaturationSlider = Slider(self.parent, "Low Saturation", 100,
0, 255)
self.highSaturationSlider = Slider(self.parent, "High Saturation", 255,
0, 255)
self.lowValueSlider = Slider(self.parent, "Low Value", 20, 0, 255)
self.highValueSlider = Slider(self.parent, "High Value", 255, 0, 255)
self.button = tk.Button(self.parent,
text="Get histogram",
fg="blue",
command=self.drawHSVHHistogram)
self.button.pack(anchor=tk.CENTER)
self.updateFrame()
def refresh(self):
text = self.get_displayed_text()
c = Canvas(self.o)
self.draw_text(text, c, self.v_scrollbar.width)
self.v_scrollbar.draw(c)
self.h_scrollbar.draw(c)
self.o.display_image(c.get_image())
def refresh(self):
self.update_throbber_angle()
c = Canvas(self.o)
self.draw_throbber(c)
if self.message:
self.draw_message(c)
self.o.display_image(c.get_image())
def test_unknown_method(self):
# EXEC
canvas = Canvas()
with self.assertRaisesRegexp(
AttributeError,
"(Canvas instance|'Canvas' object) has no attribute 'create_wirple'"
):
canvas.create_wirple(1, 'floop')
def modify_image_if_needed(self, ui_el, image):
n = ui_el.name
if not self.uie[n].active:
return image
c = Canvas(ui_el.o, base_image=image)
self.draw_text(c, ui_el)
image = c.get_image()
return image
def test_create_empty_matrix(self):
expected = [['O', 'O', 'O'], ['O', 'O', 'O'], ['O', 'O', 'O']]
c = Canvas(3, 3)
self.assertEqual(expected, c.area)
c = Canvas(3, 4)
expected.append(['O', 'O', 'O'])
self.assertEqual(expected, c.area)
def test_drawline_inverted_ok(self):
canvas = Canvas()
canvas.create(8, 4)
canvas.draw_line(5, 1, 5, 3)
canvas2 = Canvas()
canvas2.create(8, 4)
canvas2.draw_line(5, 3, 5, 1)
self.assertTrue((canvas.data == canvas2.data).all())
def test_canvas_add_stem():
dwg = svgwrite.Drawing("foo")
canvas = Canvas(dwg)
stem = Stem('acguacgu', [[1, 8], [2, 7], [3, 6], [4, 5]])
canvas.add_stem(stem)
assert (len(canvas.nucleotides) == 8)
def new(self):
# Start a new game
self.all_sprites = pg.sprite.Group()
self.canvas = Canvas()
self.all_sprites.add(self.canvas)
self.playing = True
#self.painting = False
self.run()
def test_set_line_out_of_bounds_high(self):
c = 10
out_start = Pixel(x=600, y=600, c_flag=c)
end = Pixel(x=100, y=100, c_flag=c)
result = Canvas(width=500, height=500).set_line(out_start, end)
for i in range(100, 500):
self.assertEqual(result.get_pixel(x=i, y=i).c_flag, c)
self.assertNotEqual(result.get_pixel(x=100, y=101).c_flag, c)
def __init__(self, renderer, max_update_delay=0.2, *args, **keys):
''' Inits this canvas.
Things setupped: background color, default camera, node factory,
model/view/primitve renderer registries, adapter registry and
render/update policies.
'''
if 'name' not in keys:
keys['name'] = 'unnamed canvas'
self.renderer = renderer
if 'backgroundColor' in keys:
self.backgroundColor = keys['backgroundColor']
del keys['backgroundColor']
else:
self.backgroundColor = None
if 'renderPolicy' in keys:
self.renderPolicy = keys['renderPolicy']
del keys['renderPolicy']
else:
#self.renderPolicy = DefaultRenderPolicy()
self.renderPolicy = CullingRenderPolicy()
Canvas.__init__(self, self.renderer, False, None, None, None, None,
observables.ObservableLinearTransform2D(), *args,
**keys)
self.camera = observables.ObservableCamera(
observables.ObservableLinearTransform2D(), name='default camera')
self.addChild(self.camera)
self.model_kinds = [
'Rectangle', 'RoundedRectangle', 'Circle', 'Ellipse', 'Arc',
'Text', 'Line', 'LineLength', 'Lines', 'LinesList', 'LineSegments',
'LineSegmentsSeparate', 'Bitmap', 'CubicSpline', 'QuadraticSpline',
'Polygon', 'PolygonList', 'Arrow', 'AngleArrow'
]
self.primitive_kinds = [
'Rectangle', 'RoundedRectangle', 'Ellipse', 'Arc', 'Text',
'LinesList', 'LineSegmentsSeparate', 'Bitmap', 'CubicSpline',
'QuadraticSpline', 'PolygonList', 'Arrow'
]
self._setupRegistries()
self._setupNodeFactory()
self._setupAdapters()
if 'updatePolicy' in keys:
self.updatePolicy = keys['updatePolicy']
del keys['updatePolicy']
else:
self.updatePolicy = DefaultUpdatePolicy(self, max_update_delay)
self.controllers = []
self.subscribe(self.onDirty, 'attribChanged')
def do_I(self, line):
M, N = (int(x) for x in line.split(' '))
limits = LimitValidator()
try:
limits.validate(M, N)
except ValueError as e:
print(str(e))
return False
self.canvas = Canvas(M, N)
def prepareString(self, str, font):
"""Returns a Canvas object with the rasterized string"""
tmpCanvas = Canvas(8*len(str), 8)
offset = 0
for char in str:
glyph = font.getChar(char)
tmpCanvas.fromBytes(glyph, offset)
offset += font.getCharSize(char) + font.getLetterSpace(char)
return tmpCanvas
def __init__(self, varname, player_1='human', player_2='random', id=None, width=300, height=300):
valid_players = ('human', 'random', 'alphabeta')
if player_1 not in valid_players or player_2 not in valid_players:
raise TypeError("Players must be one of {}".format(valid_players))
Canvas.__init__(self, varname, id, width, height)
self.ttt = TicTacToe()
self.state = self.ttt.initial
self.turn = 0
self.strokeWidth(5)
self.players = (player_1, player_2)
self.draw_board()
self.font("Ariel 30px")
def test_bounds(self):
# SETUP
expected_width = 800
expected_height = 600
# EXEC
canvas = Canvas(expected_width, expected_height)
width = canvas.cget('width')
height = canvas.cget('height')
# VERIFY
self.assertEqual(expected_width, width)
self.assertEqual(expected_height, height)
def __init__(self, parent):
Canvas.__init__(self, parent)
self.pen_cadre_1 = Pen((0,0,250), 2)
self.pen_cadre_2 = Pen(width=3)
self.pen_aiguille_1 = Pen(width=6)
self.pen_aiguille_2 = Pen(width=5)
self.pen_aiguille_3 = Pen(width=2, color=(255,0,0))
self.bind(size=self.on_size)
#self._draw_cadre()
self.aiguille_draw_op = CombineDrawOperation(self, [])
self.scheduler = Thread(target=self.schedule)
self.scheduler.start()
class Window(object):
def __init__(self, width: int, height: int, pixels: ndarray):
self.pixels = pixels
self.width = width
self.height = height
self.canvas = Canvas(width, height, pixels)
# setup key handlers
key_esc = 27
self.handlers = {
key_esc: self.exit
}
# self.v1 = Vertex(Vector(0, 0), Color.cyan())
# self.v2 = Vertex(Vector(300, 100), Color.red())
# self.v3 = Vertex(Vector(200, 300), Color.green())
model_path = "illidan.model"
texture_path = "illidan.texture"
self.mesh = Mesh(model_path, texture_path)
def clear(self):
self.canvas.clear()
pass
def update(self, dt):
pass
def draw(self):
# self.canvas.draw_triangle(self.v1, self.v2, self.v3)
self.canvas.draw_mesh(self.mesh)
def mouse_event(self, button, state, x, y):
print('mouse event', button, state, x, y)
# 0, left button
# 2, right button
# 0, state press
# 1, state release
def exit(self):
sys.exit(0)
def cmd404(self):
pass
def key_event(self, key, key_is_down):
print('key event', key, key_is_down)
cmd = self.handlers.get(key, self.cmd404)
cmd()
def main():
global screen
pygame.init()
pygame.mixer.quit()
pygame.mixer.init(frequency=22050, size=-16, channels=2, buffer=128)
can = Canvas()
for c in can.channels:
can.channels[c].set_volume(0.1)
screen = pygame.display.set_mode((640, 200))
while True:
screen.fill((0, 0, 0))
can.update(screen)
pygame.display.update()
clock.tick(30)
class Window(object):
def __init__(self, pixels, width, height):
self.pixels = pixels
self.width = width
self.height = height
self.canvas = Canvas(width, height, pixels)
# setup key handlers
key_esc = 27
self.handlers = {
key_esc: self.exit
}
self.v1 = Vertex(Vector(0, 0), Color.cyan())
self.v2 = Vertex(Vector(300, 100), Color.red())
self.v3 = Vertex(Vector(200, 300), Color.white())
self.v4 = Vertex(Vector(300, 0), Color.green())
def clear(self):
self.canvas.clear()
pass
def update(self, dt):
pass
def draw(self):
self.canvas.draw_triangle(self.v1, self.v2, self.v4)
self.canvas.draw_triangle(self.v1, self.v2, self.v3)
def mouse_event(self, button, state, x, y):
print('mouse event', button, state, x, y)
# 0, left button
# 2, right button
# 0, state press
# 1, state release
def exit(self):
sys.exit(0)
def cmd404(self):
pass
def key_event(self, key, key_is_down):
print('key event', key, key_is_down)
cmd = self.handlers.get(key, self.cmd404)
cmd()
class MainWindow(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self._create_actions()
self._create_toolbar()
self._canvas = Canvas()
self._canvas.scale(16, 16)
self.setCentralWidget(self._canvas)
def _create_actions(self):
self._delete_action = QAction("Delete", None)
self._delete_action.setShortcuts(QKeySequence.Delete)
self._delete_action.triggered.connect(self._delete)
self._select_action = QAction("Select", None)
self._select_action.setCheckable(True)
self._select_action.triggered.connect(self._use_select_tool)
self._pen_action = QAction("Pen", None)
self._pen_action.setCheckable(True)
self._pen_action.setChecked(True)
self._pen_action.triggered.connect(self._use_pen_tool)
self._new_shape_action = QAction("New Shape", None)
self._new_shape_action.triggered.connect(self._new_shape)
self._tool_group = QActionGroup(None)
self._tool_group.addAction(self._select_action)
self._tool_group.addAction(self._pen_action)
def _create_toolbar(self):
toolbar = self.addToolBar("Tools")
toolbar.addAction(self._delete_action)
toolbar.addAction(self._select_action)
toolbar.addAction(self._pen_action)
toolbar.addAction(self._new_shape_action)
def _use_select_tool(self):
self._canvas.use_tool(SelectTool)
def _use_pen_tool(self):
self._canvas.use_tool(PenTool)
def _new_shape(self):
self._canvas.new_shape()
def _delete(self):
self._canvas.delete_selection()
class Filler(object):
def __init__(self, bits, starting_pixel_count):
self.colorset = Colorset(bits)
# This is technically only correct for an even number of bits, but
# it rounds down for an odd number of bits, and there are simply some colors
# that we never use. Shrug.
height = width = int(math.sqrt(self.colorset.size()))
self.canvas = Canvas(width, height)
self.starting_pixel_count = starting_pixel_count
self.add_starting_pixels()
self.start_time = time.time()
self.last_save_time = time.time()
self.time_color = 0.0
self.time_point = 0.0
def add_starting_pixels(self):
# Grab some random starting colors just by making a randomly-sorted
# list of all the colors and taking the first few.
# Not the most efficient, but doesn't really matter.
colors = [x for x in self.colorset.iterate()]
random.shuffle(colors)
height = width = self.canvas.height
self.starting_pixel_list = []
for i in xrange(self.starting_pixel_count):
starting_color = self.colorset.get_nearest(colors[i])
x = random.randint(0, width-1)
y = random.randint(0, height-1)
self.starting_pixel_list.append((x, y))
self.canvas.set(x, y, starting_color)
def write_image(self, i):
bits = self.colorset.bits
name = '/tmp/colors-%s.%d.%d.%d.png' % (self.__class__.__name__,
bits,
self.starting_pixel_count,
i)
avg_rate = i / (time.time() - self.start_time)
print (name,
time.time() - self.last_save_time,
int(avg_rate),
int(self.time_color),
int(self.time_point))
self.canvas.save(name)
self.last_save_time = time.time()
def test_create_line(self):
# SETUP
expected_report = """\
create_line
1
2
100
200"""
# EXEC
canvas = Canvas()
canvas.create_line(1, 2, 100, 200)
report = canvas.report
# VERIFY
self.assertEqual(expected_report.splitlines(), report)
def __init__(self, matrixobject, positioninmatrix, weatherdefinition, hours_from_now, update_interval, getweatherobject):
logging.info('Creating new Weather instance')
self.__Matrix = matrixobject
self.__MatrixPosition = positioninmatrix
self.__WeatherDefinition = weatherdefinition
self.__HoursFromNow = hours_from_now
self.__UpdateInterval = update_interval
self.__WeatherCanvas = Canvas(weatherdefinition['Size'])
self.__ImageChanged = True
self.__GetWeatherObject = getweatherobject
self.__WeatherData = []
self.__WeatherForecast = {}
self.__CurrentWeatherIcon = ''
self.__CurrentWeatherWind = -1
self.__CurrentWeatherRain = -1.0
self.__CurrentWeatherSnow = -1.0
self.__CurrentWeatherMaxTemp = 999.0
self.__CurrentWeatherMinTemp = -999.0
self.__CurrentWeatherTime = -1
self.__WeatherReadError = False
self.__LastUpdateTime = 0
self.__WindSpeedIcon = -1
self.__RainSnowIcon = ''
def __init__(self):
self.gladefile = os.path.join(__location__, "pt3.glade")
self.builder = Gtk.Builder()
self.builder.add_from_file(self.gladefile)
#Create & Link canvas
self.canvas_box = self.builder.get_object("canvasBox")
self.canvas = Canvas()
self.watcher = VarWatcher(self.canvas)
self.canvas.show()
self.canvas_box.pack_start(self.canvas, True, True, 0)
# Automatically connect signals to functions defined above
# as specified in the glade file
self.builder.connect_signals(self)
# Get the main window
self.window = self.builder.get_object("ptWindow")
self.window.show()
self.window.connect("key-press-event", self.key_press)
#Ctrl+C handling
def handler(signum, frame):
self.log.warning("INTERRUPT: exiting gracefully")
self.window_destroy()
signal.signal(signal.SIGTERM, handler)
signal.signal(signal.SIGINT, handler)
#Fire up the main window
self.log.info("Launching GUI. Welcome to PT3! Press %s for help" % conf.key_binds["help"])
Gtk.main()
def __init__(self, parent, name,
height=0):
Pathetic.__init__(self, parent, name)
self.height = height
self.canvas = Canvas(height)
self.fields = {}
self.boxes = []
class Shelf(Pathetic):
def __init__(self, parent, name,
height=0):
Pathetic.__init__(self, parent, name)
self.height = height
self.canvas = Canvas(height)
self.fields = {}
self.boxes = []
def add_box(self, *args, **kw):
for k, v in {'line': 0, 'column': 0, 'width': 0, 'height': 0,
'align': -1, 'vfill': 0, 'raw': 0, 'wrap': 0}.items():
kw.setdefault(k, v)
kw['parent'] = self
box = Box(*args, **kw)
self.boxes.append(box)
self.canvas(box)
return box
def add_fields(self, *maybefields):
for i in maybefields:
if isinstance(i, Field):
self.fields[i.name] = i
def render(self, **kw):
self.canvas.height = self.height
self(**kw)
return self.canvas.render()
def __call__(self, **kw):
for k, v in kw.items():
try:
self.fields[k].value = v
except KeyError, msg:
raise UnknownFieldError, msg
def __init__(self):
QMainWindow.__init__(self)
self._create_actions()
self._create_toolbar()
self._canvas = Canvas()
self._canvas.scale(16, 16)
self.setCentralWidget(self._canvas)
def __init__(self):
self.width = 800
self.height = 600
self.window = window.Window(self.width-1, self.height-1)
self.window.register_event_type('on_update')
pyglet.clock.schedule(self.update)
self.canvas = Canvas(self.width, self.height, "Filename", "Path")
#Create event handlers
self.on_mouse_drag = self.window.event(self.on_mouse_drag)
self.on_draw = self.window.event(self.on_draw)
self.on_mouse_press = self.window.event(self.on_mouse_press)
self.on_mouse_release = self.window.event(self.on_mouse_release)
#Import theme
self.cobalt = kytten.Theme(os.path.join(os.getcwd(), 'theme'), override={
"font_size": 10
})
self.bg_group = pyglet.graphics.OrderedGroup(0)
self.fg_group = pyglet.graphics.OrderedGroup(500)
#Create GUI
self.mainDialog()
self.layerDialog()
def __init__(self):
self.current_step = 0
self.molecules = MoleculeGenerator.generate()
print self.molecules
self.canvas = Canvas()
self.canvas.setup_timer(self.do_movement)
self.verlet = Verlet()
class MaxDraw():
def __init__(self, display_count=1, spi_port=0, spi_clock=1000000):
self.__displayCount = display_count
self._displayCanvas = Canvas(8*display_count, 8)
self._max = Max7219(spi_port, spi_clock, display_count)
self.width = self._displayCanvas.getWidth()
self.height = self._displayCanvas.getHeight()
#self._displayCanvas = self._max._displayCanvas
def __del__(self):
#self.stop()
pass
def init(self):
"""Initializes the display"""
self._max.init(0x00)
def stop(self):
"""Stops using the display"""
self._max.shutdown()
def prepareString(self, str, font):
"""Returns a Canvas object with the rasterized string"""
tmpCanvas = Canvas(8*len(str), 8)
offset = 0
for char in str:
glyph = font.getChar(char)
tmpCanvas.fromBytes(glyph, offset)
offset += font.getCharSize(char) + font.getLetterSpace(char)
return tmpCanvas
def paintCanvas(self):
"""Sends _displayCanvas to the MAX7219 to be displayed"""
for d in range(self._max.getDisplayCount()):
self._max.setDisplay(d+1)
for x in range(8):
#print "X: " + str(x) + " - COL: " + str(d*8+x) + " - BIN: " + str(self._displayCanvas.getCol(d*8 + x))
self._max.send(self._max.DIGIT_0 + x, ord(self._displayCanvas.getCol(d*8 + x).tobytes()))
def paintNoise(self, ratio):
"""Returns a canvas filled with random noise using ratio as threshold."""
tmpCanvas = Canvas(self.width, self.height)
for b in range(tmpCanvas.getSize()):
tmpCanvas._c[b] = False if random.random() > ratio else True
return tmpCanvas
class MainWindow(GladeWindow):
glade_file = os.path.join("gui", "pybotlearn.glade")
def __init__(self):
super(MainWindow, self).__init__()
self.canvas = Canvas()
self.canvas.connect("key-press-event", self.on_key)
self.robot = self.canvas.robot
execution.robot = self.robot
self.canvas_sw.add(self.canvas)
self.console = PythonConsole(execution.namespace)
self.main_paned.pack2(self.console)
self.show_all()
self.canvas.get_hadjustment().connect("value-changed", self.on_scroll)
self.canvas.get_vadjustment().connect("value-changed", self.on_scroll)
def on_up(self, *args):
self.console.eval("move_up()", True)
def on_down(self, *args):
self.console.eval("move_down()", True)
def on_right(self, *args):
self.console.eval("move_right()", True)
def on_left(self, *args):
self.console.eval("move_left()", True)
def on_key(self, sender, event):
if event.keyval == gtk.keysyms.Up:
self.on_up()
return True
elif event.keyval == gtk.keysyms.Down:
self.on_down()
return True
elif event.keyval == gtk.keysyms.Left:
self.on_left()
return True
elif event.keyval == gtk.keysyms.Right:
self.on_right()
return True
def on_say(self, button):
text = self.say_textview.get_buffer()
text = text.get_text(text.get_start_iter(), text.get_end_iter())
self.console.eval("say(%s)" % repr(text), True)
def on_scroll(self, *args):
scroll_x = self.canvas.get_hadjustment()
scroll_y = self.canvas.get_vadjustment()
robot_x = self.robot.get_pixel_x()
robot_y = self.robot.get_pixel_y()
self.hruler.set_range(scroll_x.value, scroll_x.value + scroll_x.page_size, robot_x, self.canvas.width)
self.vruler.set_range(scroll_y.value, scroll_y.value + scroll_y.page_size, robot_y, self.canvas.height)
def __init__(self, input = {'rows':[[]], 'cols':[[]]}, max_iterations=10):
self.cols = input['cols']
self.width = len(self.cols)
self.rows = input['rows']
self.height = len(self.rows)
self.grid = Canvas(self.width, self.height, self.unknown_char)
self.input = input
self.max_iterations = max_iterations
def __init__(self, renderer, max_update_delay = 0.2, *args, **keys):
''' Inits this canvas.
Things setupped: background color, default camera, node factory,
model/view/primitve renderer registries, adapter registry and
render/update policies.
'''
if 'name' not in keys:
keys['name'] = 'unnamed canvas'
self.renderer = renderer
if 'backgroundColor' in keys:
self.backgroundColor = keys['backgroundColor']
del keys['backgroundColor']
else:
self.backgroundColor = None
if 'renderPolicy' in keys:
self.renderPolicy = keys['renderPolicy']
del keys['renderPolicy']
else:
#self.renderPolicy = DefaultRenderPolicy()
self.renderPolicy = CullingRenderPolicy()
Canvas.__init__(self, self.renderer, False, None, None, None, None, observables.ObservableLinearTransform2D(), *args, **keys)
self.camera = observables.ObservableCamera( observables.ObservableLinearTransform2D(), name = 'default camera' )
self.addChild( self.camera )
self.model_kinds = [ 'Rectangle', 'RoundedRectangle', 'Circle', 'Ellipse', 'Arc', 'Text', 'Line', 'LineLength', 'Lines', 'LinesList', 'LineSegments', 'LineSegmentsSeparate', 'Bitmap', 'CubicSpline', 'QuadraticSpline', 'Polygon', 'PolygonList', 'Arrow', 'AngleArrow' ]
self.primitive_kinds = [ 'Rectangle', 'RoundedRectangle', 'Ellipse', 'Arc', 'Text', 'LinesList', 'LineSegmentsSeparate', 'Bitmap', 'CubicSpline', 'QuadraticSpline', 'PolygonList', 'Arrow' ]
self._setupRegistries()
self._setupNodeFactory()
self._setupAdapters()
if 'updatePolicy' in keys:
self.updatePolicy = keys['updatePolicy']
del keys['updatePolicy']
else:
self.updatePolicy = DefaultUpdatePolicy( self, max_update_delay )
self.controllers = []
self.subscribe( self.onDirty, 'attribChanged' )
def new_tab(self):
canvas = Canvas(self.data_singleton)
self.mUndoStackGroup.addStack(canvas.getUndoStack())
canvas.send_cursor_pos.connect(self.send_cursor_pos)
canvas.send_new_image_size.connect(self.send_new_image_size)
canvas.send_change_edited.connect(self.update_states)
scroll_area = QScrollArea()
scroll_area.setWidget(canvas)
scroll_area.setBackgroundRole(QPalette.Dark)
file_name = canvas.get_file_name()
title = self.data_singleton.UNTITLED if file_name is None else file_name
self.ui.tabWidget.addTab(scroll_area, title)
self.update_states()
def __init__(self, width, height):
self.canvas = Canvas();
handler = MeterEventHandler(self);
self.canvas.setup("below", handler);
self.canvas.set_size(width, height);
self.width = width;
self.height = height;
self.widgets = [];
def main():
"""Set up a screen for a good entity named a
to walk around randomly on. Until we tell him
what moves are valid (because we have electro-
shock boarders on right now (and always))
he will die always!"""
c = Canvas()
a = Entity(15,15,c)
c.start()
screen = c()
for i in range(10000):
a.move()
screen.addch(a.y,a.x,a.char())
screen.refresh()
if c is ord('q'):
c.stop()
def _create_canvas(self, canvas_name):
canvas = Canvas()
canvas.set_size_request(self.DEFAULT_CANVAS_WIDTH, self.DEFAULT_CANVAS_WIDTH)
canvas.connect("button-press-event", self._on_canvas_button_press, canvas_name)
canvas.connect("drawing-stopped", self._on_canvas_drawing_stopped, canvas_name)
canvas.connect("stroke-added", self._on_canvas_stroke_added, canvas_name)
setattr(self, canvas_name, canvas)
frame = gtk.Frame()
frame.add(canvas)
setattr(self, canvas_name + "_frame", frame)
def __init__(self):
pygame.init()
self.imgs = Images()
self.canvas = Canvas()
self.netw = Network()
self.fonts = Fonts()
self.events = PCEvents()
self.buttons = Buttons()
self.screen = pygame.display.set_mode(SCREEN_SIZE)
