def recompute(self): h1, h2, h3, theta, p1, p2 = self.h1, self.h2, self.h3, self.theta, \ self.p1, self.p2 xvect = (p2 - p1).normalized() angle = (p2 - p1).polar()[1] + theta * pi / 180 yvect = Polar(1, angle) new = Sketch.CreatePath() newpaths = [new] new.AppendLine(p1) new.AppendLine(p1 + h1 * yvect) new = Sketch.CreatePath() newpaths.append(new) new.AppendLine(p1 + h3 * yvect) new.AppendLine(p2 + h3 * yvect) new = Sketch.CreatePath() newpaths.append(new) new.AppendLine(p2) new.AppendLine(p2 + h2 * yvect) for new in newpaths: new.Transform(self.trafo) if self.objects: self.objects[0].SetPaths(newpaths) else: lines = Sketch.PolyBezier(tuple(newpaths)) self.set_objects([lines])
def main(): Sketch.init_lib() if len(sys.argv) != 3: sys.stderr.write(__doc__) sys.exit(1) convert(sys.argv[1], sys.argv[2])
def recompute(self): h1, h2, n, p1, p2 = self.h1, self.h2, self.n, self.p1, self.p2 xvect = (p2 - p1).normalized() yvect = Point(xvect.y, -xvect.x) new = Sketch.CreatePath() newpaths = [new] new.AppendLine(p1) new.AppendLine(p2) new.Transform(self.trafo) for i in range(0, n + 1): new = Sketch.CreatePath() newpaths.append(new) p = p1 + (p2 - p1) / float(n) * i new.AppendLine(p - yvect * h1) new.AppendLine(p + yvect * h2) new.Transform(self.trafo) if self.objects: self.objects[0].SetPaths(newpaths) else: lines = Sketch.PolyBezier(tuple(newpaths)) self.set_objects([lines])
def recompute(self): new = Sketch.CreatePath() newpaths = [new] p1, p2, h, n = self.p1, self.p2, self.h, self.n y1 = f1 * h * uy y2 = f2 * h * uy y3 = h * uy x = (p2 - p1) / float(n) new.AppendLine(p1) new.AppendLine(p2) new.AppendLine(p2 + y3) p = p2 new.AppendLine(p + y1) for i in range(n): p = p - x new.AppendLine(p + y1) new.AppendLine(p + y2) new.AppendLine(p + y1) new.AppendLine(p1 + y1) new.AppendLine(p1 + y3) new.AppendLine(p1) new.Transform(self.trafo) if self.objects: self.objects[0].SetPaths(newpaths) else: obj = Sketch.PolyBezier(tuple(newpaths)) self.set_objects([obj])
def main(): import Sketch Sketch.init_lib() draw_printable = 1 draw_visible = 0 embed_fonts = 0 eps_for = util.get_real_username() eps_date = util.current_date() eps_title = None rotate = 0 import getopt opts, args = getopt.getopt(sys.argv[1:], 'hprved:f:t:', [ 'help', 'noprintable', 'rotate', 'visible', 'embed-fonts', 'for=', 'date=', 'title=' ]) for optchar, value in opts: if optchar == '-h' or optchar == '--help': print_usage() return -1 elif optchar == '-p' or optchar == '--noprintable': draw_printable = 0 elif optchar == '-v' or optchar == '--visible': draw_visible = 1 elif optchar == '-d' or optchar == '--date': eps_date = value elif optchar == '-f' or optchar == '--for': eps_for = value elif optchar == '-r' or optchar == '--rotate': rotate = 1 elif optchar == '-t' or optchar == '--title': eps_title = value elif optchar == '-e' or optchar == '--embed-fonts': embed_fonts = 1 if len(args) not in (1, 2): print_usage() return -1 filename = args[0] if len(args) > 1: psfile = args[1] else: psfile = sys.stdout if eps_title is None: eps_title = os.path.basename(filename) sk2ps(filename, psfile, printable=draw_printable, visible=draw_visible, For=eps_for, CreationDate=eps_date, Title=eps_title, rotate=rotate, embed_fonts=embed_fonts)
def init_tk(self, screen_name=None, geometry=None): TkApplication.init_tk(self, screen_name=screen_name, geometry=geometry) root = self.root Sketch.init_modules_from_widget(root) root.iconbitmap(pixmaps.Icon) root.iconmask(pixmaps.Icon_mask) root.iconname('Skencil') root.group(root) config.add_options(root)
def init_tk(self, screen_name = None, geometry = None): TkApplication.init_tk(self, screen_name = screen_name, geometry = geometry) root = self.root Sketch.init_modules_from_widget(root) root.iconbitmap(pixmaps.Icon) root.iconmask(pixmaps.Icon_mask) root.iconname('Skencil') root.group(root) config.add_options(root)
def main(): import Sketch Sketch.init_lib() draw_printable = 1 draw_visible = 0 embed_fonts = 0 eps_for = util.get_real_username() eps_date = util.current_date() eps_title = None rotate = 0 import getopt opts, args = getopt.getopt(sys.argv[1:], 'hprved:f:t:', ['help', 'noprintable', 'rotate', 'visible', 'embed-fonts', 'for=', 'date=', 'title=']) for optchar, value in opts: if optchar == '-h' or optchar == '--help': print_usage() return -1 elif optchar == '-p' or optchar == '--noprintable': draw_printable = 0 elif optchar == '-v' or optchar == '--visible': draw_visible = 1 elif optchar == '-d' or optchar == '--date': eps_date = value elif optchar == '-f' or optchar == '--for': eps_for = value elif optchar == '-r' or optchar == '--rotate': rotate = 1 elif optchar == '-t' or optchar == '--title': eps_title = value elif optchar == '-e' or optchar == '--embed-fonts': embed_fonts = 1 if len(args) not in (1, 2): print_usage() return -1 filename = args[0] if len(args) > 1: psfile = args[1] else: psfile = sys.stdout if eps_title is None: eps_title = os.path.basename(filename) sk2ps(filename, psfile, printable= draw_printable, visible = draw_visible, For = eps_for, CreationDate = eps_date, Title = eps_title, rotate = rotate, embed_fonts = embed_fonts)
def recompute(self): new = Sketch.CreatePath() newpaths = [new] p1, p2 = self.p1, self.p2 new.AppendLine(p1) new.AppendLine(p2) new.Transform(self.trafo) if self.objects: self.objects[0].SetPaths(newpaths) else: obj = Sketch.PolyBezier(tuple(newpaths)) self.set_objects([obj])
def recompute(self): h1, h2, w1, w2 = self.GetData() new = Sketch.CreatePath() newpaths = [new] for p in ((-w1, 0), (0, -h2 - h1), (0, -h1), (w2, -h1), (w2, -h2 - h1), (w2 + w1, 0), (w2, h2 + h1), (w2, h1), (0, h1), (0, h2 + h1), (-w1, 0)): new.AppendLine(p) new.Transform(self.trafo) if self.objects: self.objects[0].SetPaths(newpaths) else: obj = Sketch.PolyBezier(tuple(newpaths)) self.set_objects([obj])
def recompute(self): w1, w2, p1, p2 = self.w1, self.w2, self.p1, self.p2 xvect = (p2 - p1).normalized() new = Sketch.CreatePath() newpaths = [new] new.AppendLine(p1 - w1 * xvect) new.AppendLine(p2 + w2 * xvect) new.Transform(self.trafo) if self.objects: self.objects[0].SetPaths(newpaths) else: lines = Sketch.PolyBezier(tuple(newpaths)) self.set_objects([lines])
def loadfromschooldata(string): # init an empty sketch sketch = Sketch.Sketch(sketch_id='shape', strokes=[]) # find lines lines = string.splitlines() laststroke = -1 pointid = 0 strokelist = [] # for each line for line in lines: # obtain point parameters numbers = line.split('\t') # if a new stroke is found if int(numbers[2]) > laststroke: # init a new empty stroke laststroke = laststroke + 1 strokelist.append(Stroke.Stroke(str(laststroke))) # add the point to its corresponding stroke strokelist[laststroke].addPoint( Point.Point('p' + str(pointid), float(numbers[3]), float(numbers[0]), float(numbers[1]))) pointid = pointid + 1 # finally add the strokes to the sketch for stroke in strokelist: sketch.addStrokes(stroke) return sketch
def loadURL(url): global rgba if Skribbler.width == 0 or Skribbler.height == 0: print("Canvas is not initialized! Try running 'init'") return rgba = Sketch.getRGBAFrom(cmd.replace("url ", ""), Skribbler.width, Skribbler.height) print("Loaded image successfully!")
def recompute(self): path = Sketch.CreatePath() newpaths = [path] h = self.h path.AppendLine((5, 5)) path.AppendBezier((7, 5 + h / 2.), (12, 5 + h), (15, 5 + h)) path.AppendBezier((18, 5 + h), (22, 5 + h / 2), (25, 5)) path.Transform(self.trafo) if self.objects: self.objects[1].SetPaths(tuple(newpaths)) else: skull = Sketch.Ellipse(Scale(22)) skull.Transform(Translation(15, 16)) mouth = Sketch.PolyBezier(tuple(newpaths)) r_eye = Sketch.Ellipse(Scale(3)) l_eye = Sketch.Ellipse(Scale(3)) l_eye.Transform(Translation(7, 21)) r_eye.Transform(Translation(22, 21)) self.set_objects([skull, mouth, r_eye, l_eye])
def main(): import Sketch, Sketch.config Sketch.Issue(None, Sketch.const.INITIALIZE) #plugins.load_plugin_configuration(config.plugin_path) use_bbox = 0 resolution = 72.0 steps = alpha = None import getopt opts, args = getopt.getopt( sys.argv[1:], 'bhr:s:A:', ['help', 'bbox', 'resolution=', 'gradient-steps=', 'alpha-bits=']) for optchar, value in opts: if optchar == '-h' or optchar == '--help': print_usage() return -1 elif optchar == '-b' or optchar == '--bbox': use_bbox = 1 elif optchar == '-r' or optchar == '--resolution': resolution = float(value) elif optchar == '-s' or optchar == '--gradient-steps': steps = float(value) elif optchar == '-A' or optchar == '--alpha-bits': alpha = int(value) if alpha not in (1, 2, 4): sys.stderr.write("sk2ppm: alpha-bits value must be one of" " 1, 2 or 4\n") return -1 if len(args) not in (1, 2): print_usage() return -1 if steps is not None: Sketch.config.preferences.gradient_steps_print = steps filename = args[0] if len(args) > 1: ppmfile = args[1] else: ppmfile = sys.stdout doc = load.load_drawing(filename) context = Context() context.document = doc export_raster(context, ppmfile, resolution, use_bbox, format="ppm", antialias=alpha)
def main(): global application try: options = process_args(sys.argv[1:]) except getopt.error: sys.stderr.write(Sketch._(usage)) sys.exit(1) if options.args: filename = options.args[0] else: filename = '' Sketch.init_ui() from Sketch.UI.skapp import SketchApplication application = SketchApplication(filename, options.display, options.geometry, options.participant, options.f1, options.f2, options.f3,options.f4,run_script = options.run_script) Sketch.Issue(None, Sketch.const.APP_INITIALIZED, application) application.Run() application.SavePreferences()
def recompute(self): p1, p2, p3, p4 = self.p1, self.p2, self.p3, self.p4 new = Sketch.CreatePath() newpaths = [new] new.AppendLine(p1) new.AppendLine(p2) new.Transform(self.trafo) new = Sketch.CreatePath() newpaths.append(new) new.AppendLine(p3) new.AppendLine(p4) new.Transform(self.trafo) if self.objects: self.objects[0].SetPaths(newpaths) else: lines = Sketch.PolyBezier(tuple(newpaths)) self.set_objects([lines])
def recompute(self): r1 = self.r1 r2 = self.r2 theta1 = self.theta1 theta2 = self.theta2 if theta2 < theta1: theta2 = theta2+360 ring2 = Sketch.Ellipse(start_angle=theta1*pi/180, end_angle=theta2*pi/180, arc_type=0).Paths()[0] ring1 = ring2.Duplicate() ring2.Transform(Scale(r2)) ring1.Transform(Scale(r1)) new = Sketch.CreatePath() newpaths = [new] new.AppendLine(Polar(r1, theta1*pi/180.)) for i in range(ring2.len): segment = ring2.Segment(i) new.AppendSegment(*segment) new.AppendLine(Polar(r2, theta2*pi/180.)) new.AppendLine(Polar(r1, theta2*pi/180.)) ring1.Transform(Scale(-1,1)) ring1.Transform(Rotation((180+theta1+theta2)*pi/180.)) for i in range(ring1.len): s = ring1.Segment(i) new.AppendSegment(*s) for path in newpaths: path.Transform(self.trafo) if self.objects: self.objects[0].SetPaths(newpaths) else: obj = Sketch.PolyBezier(tuple(newpaths)) self.set_objects([obj])
def recompute(self): path = Sketch.CreatePath() top = [path] h = self.h dh = 0.55197 * h d = l = width dd = 0.55197 * d / 2. c = d / 2. path.AppendLine((0, l)) path.AppendBezier((0, l + dh), (c - dd, l + h), (c, l + h)) path.AppendBezier((c + dd, h + l), (d, l + dh), (d, l)) path.AppendBezier((d, l - dh), (c + dd, l - h), (c, l - h)) path.AppendBezier((c - dd, l - h), (0, l - dh), (0, l)) path.Transform(self.trafo) path = Sketch.CreatePath() hull = [path] path.AppendLine((d, l)) path.AppendLine((d, 0)) path.AppendBezier((d, -dh), (c + dd, -h), (c, -h)) path.AppendBezier((c - dd, -h), (0, -dh), (0, 0)) path.AppendLine((0, l)) path.AppendBezier((0, l - dh), (c - dd, l - h), (c, l - h)) path.AppendBezier((c + dd, l - h), (d, l - dh), (d, l)) path.Transform(self.trafo) if self.objects: self.objects[0].SetPaths(hull) self.objects[1].SetPaths(top) else: obj_hull = Sketch.PolyBezier(tuple(hull)) obj_hull.SetProperties(line_join=Sketch.const.JoinRound) obj_top = Sketch.PolyBezier(tuple(top)) self.set_objects([obj_hull, obj_top])
def recompute(self): l1, l2, d1, d2, d3 = self.l1, self.l2, self.d1, self.d2, self.d3 new = Sketch.CreatePath() newpaths = [new] #draw the arrow head for p in ((0,-d1), (0, -d1-d2), (-l1,0), (0, d1+d2), (0, d1)): new.AppendLine(Point(p)) # the rounded part k = 1.2 new.AppendBezier(Point(l2,d1), Point(l2, d1-d3/k), Point(l2,d1-d3)) new.AppendLine(Point(l2, -d1-d3)) new.AppendBezier(Point(l2,-d1-d3/k), Point(l2,-d1), Point(0,-d1)) for path in newpaths: path.Transform(self.trafo) if self.objects: self.objects[0].SetPaths(newpaths) else: obj = Sketch.PolyBezier(tuple(newpaths)) self.set_objects([obj])
def recompute(self): p1 = Polar(self.l1, self.theta1 * pi / 180) p2 = Polar(self.l2, self.theta2 * pi / 180) new = Sketch.CreatePath() newpaths = [new] new.AppendLine(p1) new.AppendLine((0, 0)) new.AppendLine(p2) new.Transform(self.trafo) alpha = p1.polar()[1] beta = p2.polar()[1] if self.objects: self.objects[0].SetPaths(newpaths) self.objects[1].SetAngles(alpha, beta) trafo = self.trafo(Scale(self.r, self.r)) self.objects[1].set_transformation(trafo) else: lines = Sketch.PolyBezier(tuple(newpaths)) circle = Sketch.Ellipse(start_angle=alpha, end_angle=beta) circle.Transform(Scale(self.r, self.r)) self.set_objects([lines, circle])
def reload_image(context): image = context.document.CurrentObject() if image is not None and isinstance(image, external.ExternalGraphics): # Don't try this at home :) It pokes around in the internals of # Sketch! olddata = image.data filename = olddata.Filename() oldrect = image.bounding_rect # first, remove the old object from the cache. if olddata.stored_in_cache \ and external.instance_cache.has_key(filename): del external.instance_cache[filename] olddata.stored_in_cache = 0 # now we can load the data again the normal way because it's not # in the cache anymore. if image.is_Eps: data = eps.load_eps(filename) else: data = Sketch.load_image(filename) # replace the old data object with the new one. Normally we # would have to handle the undo info returned. Here we just # discard it so that the reload won't be in the history. image.SetData(data) # some house keeping tasks that are necessary because the sort # of thing we're doing here, i.e. modifying an object without # undo information etc., wasn't anticipated: # to make sure that the bboxes get recomputed etc, call the # _changed method. SetData should probably do that # automatically, but currently it doesn't image._changed() # make sure the object itself is properly redrawn context.document.AddClearRect(oldrect) context.document.AddClearRect(image.bounding_rect) # make sure the selection's idea of the bounding rect is updated # too and have the canvas update the handles context.document.selection.ResetRectangle() context.main_window.canvas.update_handles()
def PythonPrompt(prompt='>>>', prompt2='...'): # try to import readline in Python 1.5 have_readline = 0 try: import readline have_readline = 1 Sketch.Issue(None, Sketch.const.INIT_READLINE) except ImportError: pass globals = {} # put all of Sketch.main and Sketch into the globals exec 'from Sketch.main import *' in globals exec 'from Sketch import *' in globals # put all sketch specific modules into the globals for module in get_sketch_modules(): globals[module.__name__] = module add_sketch_objects(globals) if have_readline: from Sketch.Lib import skcompleter skcompleter.install(globals, locals) while 1: try: cmd = raw_input(prompt) #cmd = string.strip(cmd) if cmd: if cmd[-1] == ':': # a compound statement lines = [] while string.strip(cmd): lines.append(cmd) cmd = raw_input(prompt2) cmd = string.join(lines + [''], '\n') kind = 'exec' else: kind = 'single' c = compile(cmd, '<string>', kind) exec c in globals, locals except EOFError: print '----- returning to Sketch' return except: import traceback traceback.print_tb(sys.exc_traceback) print 'Exception %s: %s' % (sys.exc_type, sys.exc_value)
def jsonshape(string): # parse json string shapejson = json.loads(string) # init an empty sketch sketch = Sketch.Sketch(sketch_id=shapejson['id'], strokes=[]) # for each stroke for stroke in shapejson['strokes']: # init an empty stroke st = Stroke.Stroke(stroke['id']) # for each point in a stroke for point in stroke['points']: # add the point to the stroke st.addPoint( Point.Point(point['pid'], float(point['time']), float(point['x']), float(point['y']))) # add the stroke to the sketch sketch.addStrokes(st) return sketch
def main(): import Sketch global doc global tbase_style Sketch.init_lib() draw_printable = 1 draw_visible = 0 embed_fonts = 0 eps_for = util.get_real_username() eps_date = util.current_date() eps_title = None rotate = 0 #doc = load.load_drawing('') # from mainwindow.py: self.SetDocument(Document(create_layer = 1)) doc = Document(create_layer = 1) # get font info first Graphics.font.read_font_dirs() # indicate start of coord system first # coord system:: + goes upward / rightward # from RectangleCreator: trafo = Trafo(off.x, 0, 0, off.y, end.x, end.y) # actually, there 'end' seems to correspond to start (llc: lower left corner of rectangle) - and 'off' to the length extended in each direction (i.e. width, height - but can be negative) ; so instead of 'end' - calling it 'start' start_x = 5 start_y = 5 off_x = -10 off_y = -10 trec = Rectangle(trafo = Trafo(off_x, 0, 0, off_y, start_x, start_y)) trec.update_rects() doc.Insert(trec) # from create_text.py textfld = SimpleText(Translation(50, 50), "xyzzy") textfld.SetProperties(fill_pattern = SolidPattern(StandardColors.green), font = GetFont('Courier-Bold'),#('Times-Bold'), font_size = 36) #copy textfld textfld2 = textfld.Duplicate() textfld2.SetProperties(fill_pattern = SolidPattern(StandardColors.blue)) # change color only # rotate textfld angleDeg = 45 angleRad = pi*(angleDeg/180.0) # ensure float op - could use math.radians instead textfld.Transform(Rotation(angleRad)) # Rotation(angle, center) textfld.update_rects() # probably a good idea # change textfld's text with the current width (that we see) # get bounding box of text a = textfld.properties llx, lly, urx, ury = a.font.TextBoundingBox(textfld.text, a.font_size) # calculate width - its of UNTRANSFORMED text twidth = urx - llx # insert this width as text in textbox now: #~ textfld.text = str(twidth) #~ textfld.update_rects() # probably a good idea - again # get textfield as bezier textbez = textfld.AsBezier() #~ print textbez # returns Sketch.Graphics.group.Group; subclass of EditableCompound # the bounding rectangle - from Compound (type is Rect): textbez_bRect = textbez.bounding_rect # calc width now t2width = textbez_bRect.right - textbez_bRect.left # insert this width as text in textbox now: textfld.text = str(t2width) textfld.update_rects() # probably a good idea - again #~ doc.Insert(textfld) # create a line # using create_spiral.py technique below (see syntax note #(A1)) tpath = CreatePath() # Note - apparently, the first appended point is "moveTo"; # .. the ubsequent ones being "LineTo" tp = Point(textbez_bRect.left,textbez_bRect.bottom) tpath.AppendLine(tp) # moveto tp = Point(textbez_bRect.left,textbez_bRect.top) tpath.AppendLine(tp) # lineto tp = Point(textbez_bRect.right,textbez_bRect.top) tpath.AppendLine(tp) # lineto tp = Point(textbez_bRect.right,textbez_bRect.bottom) tpath.AppendLine(tp) # lineto tline = PolyBezier((tpath,)) tline.AddStyle(tbase_style) # of Graphics.properties (also in compound, document) - seems to add a 'layer' if dynamic; else seems to 'replace' ?! #~ doc.Insert(tline) # group tline and textfld ... # footprints.py has Group(foot_prints = []) tgrp = Group([textfld, textfld2, tline]) tgrp.update_rects() doc.Insert(tgrp) # add a box.. around textfld2 # use radius1, radius2 != 0 AND 1 (logarithmic) to get RoundedRectangle (best between 0.0 and 1.0) tfbr = textfld2.bounding_rect start_x = tfbr.left start_y = tfbr.bottom off_x = tfbr.right - tfbr.left off_y = tfbr.top - tfbr.bottom twid = abs(off_x - start_x) thei = abs(off_y - start_y) radfact = 1.2*twid/thei tradius = 0.05 # if we want to specify a single one, then the actual look will depend on the dimesions of the rectangle - so must 'smooth' it with radfact... trec = Rectangle(trafo = Trafo(off_x, 0, 0, off_y, start_x, start_y), radius1 = tradius, radius2 = tradius*radfact) trec.update_rects() doc.Insert(trec) # add another box - any where start_x = 100.0 start_y = 100.0 off_x = 50.0 off_y = 50.0 trec2 = Rectangle(trafo = Trafo(off_x, 0, 0, off_y, start_x, start_y)) trec2.update_rects() doc.Insert(trec2) # try change props post insert - OK trec2.SetProperties(fill_pattern = SolidPattern(StandardColors.yellow), line_width = 2.0, line_pattern = SolidPattern(CreateRGBColor(0.5, 0.5, 0.7))) # try move the group as a whole (Translate - syntax: spread.py) # say, align the right edge of tline to left edge of trec2 (x direction) # NOTE: group does not define own .AsBezier(self); # but it has tgrp.bounding_rect (although python doesn't show it in dir(tgrp)) # also there is Rectangle.bounding_rect # NOTE though - it seems bounding_rect is somehow padded, with (at least) 10 units in each direction! (also, bounding rect of line will include the arrow) xmove = (trec2.bounding_rect.left+10)-(tline.bounding_rect.right-10) #~ print xmove, trec2.bounding_rect.left, tline.bounding_rect.right tgrp.Translate(Point(xmove, 0)) tgrp.update_rects() # add temporary line to indicate bounding boxes # and effect of padding (may cover the very first trec) tmpbr = trec2.bounding_rect doc.Insert( getQuickLine( (0,0), (trec2.bounding_rect.left+10, tline.bounding_rect.top-10) ) ) # end of draw - generate output file filename = '' psfile = 'vectorout.ps' sk2ps(filename, psfile, printable= draw_printable, visible = draw_visible, For = eps_for, CreationDate = eps_date, Title = eps_title, rotate = rotate, embed_fonts = embed_fonts)
elif opt == "--keep": Options.keep = 1 elif opt == "--preload": Options.preload = 1 elif opt == "--fit": Options.fit = 1 elif opt in ("-h", "--help"): sys.stderr.write(__doc__) sys.exit(0) Options.files = args parse_options() import Sketch Sketch.init_ui() import Sketch.UI.skapp, Sketch.UI.view, Sketch.load from Tkinter import BOTH class ShowView(Sketch.UI.view.SketchView): def __init__(self, master=None, toplevel = None, double_buffer = 1, show_page_outline = 0, **kw): apply(Sketch.UI.view.SketchView.__init__, (self, master), kw) self.double_buffer = double_buffer self.show_page_outline = show_page_outline def do_clear(self, region):
def extractFromXML(string): root = ET.fromstring(string) points = getPoints(root) strokes = getStrokes(points, root) sketch = Sketch.Sketch(root.get('id'), strokes) return sketch
def init_tk(self, screen_name = None, geometry = None): Sketch.UI.skapp.TkApplication.init_tk(self, screen_name = screen_name, geometry = geometry) Sketch.init_modules_from_widget(self.root)
def process_args(args): # Read options from the command line. Return an instance object with the # instance variables: # display name of the X-display or None # geometry geometry of the main window or None # args rest of the arguments after the last option # # To behave more like other X-programs, sketch should accept the options # -display and -geometry with a single hyphen and no `='... # recognize a standard X geometry specification... (hack) if '-geometry' in args: try: idx = args.index('-geometry') geo = args[idx:idx + 2] if len(geo) == 2: del args[idx:idx + 2] geo[0] = '-g' args[0:0] = geo except: pass opts, args = getopt.getopt(args, 'd:g:hi', ['display=', 'geometry=', 'help', 'run-script=', 'version', 'participant=','f1=','f2=','f3=','f4=']) # the option -i is a hack to allow sketch to be used as a `python # interpreter' in the python shell in python-mode.el options = util.Empty(args = args, display = None, geometry = None, participant = None, f1 = None, f2 = None, f3 = None, f4 = None,#changed by shumon June , 2009 run_script = None) for optchar, value in opts: #print "opts=", opts, "optchar=", optchar,"value=",value if optchar == '-d' or optchar == '--display': options.display = value elif optchar == '-g' or optchar == '--geometry': options.geometry = value elif optchar == '--run-script': options.run_script = value elif optchar == '-h' or optchar == '--help': print Sketch._(usage) sys.exit(0) elif optchar == '--version': print Sketch._(version) % Sketch.SketchVersion sys.exit(0) elif optchar == '--participant': print "participant=", value options.participant = value elif optchar == '--f1': print "f1=",value options.f1 = value elif optchar == '--f2': print "f2=",value options.f2 = value elif optchar == '--f3': print "f3=",value options.f3 = value elif optchar == '--f4': print "f4=",value options.f4 = value return options