rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
if event.type != gdk.BUTTON_PRESS: | if event.type == gdk._2BUTTON_PRESS or (event.type == gdk.BUTTON_PRESS and event.state & gdk.SHIFT_MASK): | def button_press_cb(self, widget, event): group = self.group_at(event.x, event.y) if event.type != gdk.BUTTON_PRESS: # Double-click if not group: return self.bm.active_groups = [group] for f in self.bm.groups_observers: f() elif event.button == 1: if not group: return if group in self.bm.active_groups: self.bm.active_g... |
m = [] N = 21 for i in range(N): | max_mem = 0 max_mem_stable = 0 no_leak = False m1 = 0 for i in range(options.max_iterations): | def leakTest_generic(func): print 'memory leak test', func.__name__ check_garbage() doc = document.Document() #gc.set_debug(gc.DEBUG_LEAK) m = [] N = 21 for i in range(N): func(doc, i) if options.debug: if i == 3: check_garbage() helpers.record_memory_leak_status() if i == 4: helpers.record_memory_leak_status(print_d... |
if i == 4: | if i == 4 or i == 5: | def leakTest_generic(func): print 'memory leak test', func.__name__ check_garbage() doc = document.Document() #gc.set_debug(gc.DEBUG_LEAK) m = [] N = 21 for i in range(N): func(doc, i) if options.debug: if i == 3: check_garbage() helpers.record_memory_leak_status() if i == 4: helpers.record_memory_leak_status(print_d... |
m.append(m2) print 'iteration %02d/%02d: %d pages used' % (i+1, N, m2) | print 'iteration %02d/%02d: %d pages used (%+d)' % (i+1, options.max_iterations, m2, m2-m1) m1 = m2 if m2 > max_mem: max_mem = m2 max_mem_stable = 0 else: max_mem_stable += 1 if max_mem_stable == options.required: print 'maximum was stable for', max_mem_stable, 'iterations' no_leak = True break | def leakTest_generic(func): print 'memory leak test', func.__name__ check_garbage() doc = document.Document() #gc.set_debug(gc.DEBUG_LEAK) m = [] N = 21 for i in range(N): func(doc, i) if options.debug: if i == 3: check_garbage() helpers.record_memory_leak_status() if i == 4: helpers.record_memory_leak_status(print_d... |
print m cmp_1st = m[N*1/3:N*2/3] cmp_2nd = m[N*2/3:N*3/3] diff = abs(max(cmp_1st) - max(cmp_2nd)) if diff != 0: print 'looks like a memory leak in ' + func.__name__ | if no_leak: print 'no leak found' else: print 'memory leak in ' + func.__name__ | def leakTest_generic(func): print 'memory leak test', func.__name__ check_garbage() doc = document.Document() #gc.set_debug(gc.DEBUG_LEAK) m = [] N = 21 for i in range(N): func(doc, i) if options.debug: if i == 3: check_garbage() helpers.record_memory_leak_status() if i == 4: helpers.record_memory_leak_status(print_d... |
print 'no leak found' | def leakTest_generic(func): print 'memory leak test', func.__name__ check_garbage() doc = document.Document() #gc.set_debug(gc.DEBUG_LEAK) m = [] N = 21 for i in range(N): func(doc, i) if options.debug: if i == 3: check_garbage() helpers.record_memory_leak_status() if i == 4: helpers.record_memory_leak_status(print_d... | |
@leaktest def paint(doc, iteration): | def paint(doc): | def surface_alloc(doc, iteration): tiledsurface.Surface() |
@leaktest def provoke_leak(doc, iteration): setattr(gc, 'my_test_leak_%d' % iteration, zeros(50000)) def leakTest_slow(): leakTest_generic(paint_and_clear) leakTest_generic(repeated_saving) leakTest_generic(repeated_loading) leakTest_generic(paint_save_clear) | def paint_save_clear(doc, iteration): paint(doc) doc.save('test_leak.ora') doc.clear() | |
return file_format, filename | result = (file_format, filename) | def open_dialog(title, window, filters): """ filters should be a list of tuples: (filter title, glob pattern). Returns a tuple: (file format, filename). Here "file format" is index of filter that matches filename (None if no matches). filename is None if no file was selected. """ dialog = gtk.FileChooserDialog(title, w... |
return None, None | return result | def open_dialog(title, window, filters): """ filters should be a list of tuples: (filter title, glob pattern). Returns a tuple: (file format, filename). Here "file format" is index of filter that matches filename (None if no matches). filename is None if no file was selected. """ dialog = gtk.FileChooserDialog(title, w... |
default_group = self.groups.get(DEFAULT_STARTUP_GROUP, None) if group is not None: try: b = default_group[(i+9) % 10] b.clone_into(c, name) except IndexError: pass | group = self.groups.get(DEFAULT_STARTUP_GROUP, []) idx = (i+9) % 10 if idx < len(group): b = group[idx] b.clone_into(c, name) | def listbrushes(path): # Return a list of brush names relative to path, using # slashes for subirectories on all platforms. path += '/' l = [] assert isinstance(path, unicode) # make sure we get unicode filenames for name in os.listdir(path): assert isinstance(name, unicode) if name.endswith('.myb'): l.append(name[:-4]... |
self.app.ui_manager.add_ui_from_file(menupath) | menubar_xml = open(menupath).read() self.app.ui_manager.add_ui_from_string(menubar_xml) self._init_popupmenu(menubar_xml) | def __init__(self, app): windowing.MainWindow.__init__(self, app) self.app = app |
self.menubar.connect("selection-done", self.menu_done_cb) self.menubar.connect("deactivate", self.menu_done_cb) self.menubar.connect("cancel", self.menu_done_cb) | def __init__(self, app): windowing.MainWindow.__init__(self, app) self.app = app | |
('ShowMenu', None, _('Show Menu'), 'Menu', None, self.menu_show_cb), | ('ShowMenu', None, _('Show Menu'), 'Menu', None, self.popupmenu_show_cb), | def init_actions(self): actions = [ # name, stock id, label, accelerator, tooltip, callback ('FileMenu', None, _('File')), ('Quit', gtk.STOCK_QUIT, _('Quit'), '<control>q', None, self.quit_cb), |
def menu_show_cb(self, action): if self.fullscreen: self.menubar.show() self.menubar.select_first(False) def menu_done_cb(self, *a, **kw): if self.fullscreen: self.menubar.hide() | def popupmenu_show_cb(self, action): self.menubar.set_sensitive(False) self.popupmenu.popup(None, None, None, 1, 0) if self.popupmenu_last_active is None: self.popupmenu.select_first(True) else: self.popupmenu.select_item(self.popupmenu_last_active) def popupmenu_done_cb(self, *a, **kw): self.menubar.set_sensitive... | def menu_show_cb(self, action): if self.fullscreen: self.menubar.show() self.menubar.select_first(False) |
self.stroke_to(60.0, x[0], y[0], 0.0) | self.stroke_to(60.0, x[0], y[0], 0.0, 0.0, 0.0) | def straight_line(self, src, dst): self.split_stroke() # TODO: undo last stroke if it was very short... (but not at document level?) real_brush = self.brush self.brush = brush.Brush() self.brush.copy_settings_from(real_brush) |
self.stroke_to(duration/N, x[i], y[i], pressure) | self.stroke_to(duration/N, x[i], y[i], pressure, 0.0, 0.0) | def straight_line(self, src, dst): self.split_stroke() # TODO: undo last stroke if it was very short... (but not at document level?) real_brush = self.brush self.brush = brush.Brush() self.brush.copy_settings_from(real_brush) |
if val: | if val is not None: | def readline (lno=[lineno], *args): if args: print args try: return linecache.getline (fname, lno[0]) finally: lno[0] += 1 |
c_floats = [float(c.red)/65535, float(c.green)/65535, float(c.blue)/65535] cr.set_source_rgb(*c_floats) | cr.set_source_rgb(c.red_float, c.green_float, c.blue_float) | def expose_cb(self, widget, event): cr = self.window.cairo_create() width, height = self.window.get_size() |
if keyval != event.keyval: | if keyval != event.keyval and not event.get_state() & gdk.LOCK_MASK: | def key_press_cb(self, widget, event): if not self.enabled: return # See gtk sourcecode in gtkmenu.c function gtk_menu_key_press, # which uses the same code as below when changing an accelerator. keymap = gdk.keymap_get_default() # figure out what modifiers went into determing the keyval res = keymap.translate_keyboard... |
surface = pixbufsurface.Surface(x1, y1, x2-x1+1, y2-y1+1) | surface = pixbufsurface.Surface(x1, y1, x2-x1+1, y2-y1+1, alpha=True) | def repaint(self, device_bbox=None): if device_bbox is None: w, h = self.window.get_size() device_bbox = (0, 0, w, h) #print 'device bbox', tuple(device_bbox) |
pattern.set_extend(cairo.EXTEND_PAD) | def repaint(self, device_bbox=None): if device_bbox is None: w, h = self.window.get_size() device_bbox = (0, 0, w, h) #print 'device bbox', tuple(device_bbox) | |
target_path = join(target_path, target_name) | target_path = join(target_path, basename(target_name)) | def new_name(name): if name.startswith('brushes/'): target_name = name[8:] else: target_name = name if '/' in target_name: dir = os.path.dirname(target_name) target_path = join(self.user_brushpath, dir) if not isdir(target_path): os.makedirs(target_path) target_path = join(target_path, target_name) else: target_path = ... |
while dir: | while dir not in ['', '/']: | def show_about_cb(self, window): b = self.bm.selected_brush path = b.get_fileprefix() dir = os.path.dirname(path) found = False while dir: for name in ["README", "LICENSE", "LEGAL", "COPYRIGHT"]: for another_name in [name, name + '.txt', name + '.TXT', name.lower(), name.lower() + '.txt']: filename = os.path.join(dir, ... |
layers = self.doc.layers if not self.show_layers_above: layers = self.doc.layers[0:self.doc.layer_idx+1] | layers = self.get_visible_layers() | def repaint(self, device_bbox=None): if device_bbox is None: w, h = self.window.get_size() device_bbox = (0, 0, w, h) #print 'device bbox', tuple(device_bbox) |
print 'b', len(tmp) | def load_strokemap_from_file(self, f, translate_x, translate_y): assert not self.strokes brushes = [] while True: t = f.read(1) if t == 'b': length, = struct.unpack('>I', f.read(4)) tmp = f.read(length) brushes.append(zlib.decompress(tmp)) print 'b', len(tmp) elif t == 's': brush_id, length = struct.unpack('>II', f.rea... | |
print 's', len(tmp) | def load_strokemap_from_file(self, f, translate_x, translate_y): assert not self.strokes brushes = [] while True: t = f.read(1) if t == 'b': length, = struct.unpack('>I', f.read(4)) tmp = f.read(length) brushes.append(zlib.decompress(tmp)) print 'b', len(tmp) elif t == 's': brush_id, length = struct.unpack('>II', f.rea... | |
self.app = application.Application(datapath='..', confpath=self.tempdir, filenames=[]) | self.app = application.Application(datapath=u'..', confpath=unicode(self.tempdir), filenames=[]) | def setup(self): self.tempdir = tempfile.mkdtemp() from gui import application os.system('cp -a brushes ' + self.tempdir) self.app = application.Application(datapath='..', confpath=self.tempdir, filenames=[]) |
finally: f.close() | def load_window_position(self, name, window): geometry, visible = WINDOW_DEFAULTS.get(name, (None, False)) using_default = True try: f = open(self.config_file_path) for line in f: if line.startswith(name): parts = line.split() visible = parts[1] == 'True' x, y, w, h = [int(i) for i in parts[2:2+4]] geometry = '%dx%d+%d... | |
f.add_pattern(pat) | f.add_pattern(get_case_insensitive_glob(pat)) | def init_save_dialog(self): dialog = gtk.FileChooserDialog(_("Save.."), self.app.drawWindow, gtk.FILE_CHOOSER_ACTION_SAVE, (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_SAVE, gtk.RESPONSE_OK)) self.save_dialog = dialog dialog.set_default_response(gtk.RESPONSE_OK) dialog.set_do_overwrite_confirmation(True) |
f.add_pattern(p) | f.add_pattern(get_case_insensitive_glob(p)) | def open_cb(self, action): if not self.confirm_destructive_action(): return dialog = gtk.FileChooserDialog(_("Open..."), self.app.drawWindow, gtk.FILE_CHOOSER_ACTION_OPEN, (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN, gtk.RESPONSE_OK)) dialog.set_default_response(gtk.RESPONSE_OK) |
try: self.preferencesWindow.update_ui() except AttributeError: pass | prefs_win = self.windowmanager.get_window('preferencesWindow') prefs_win.update_ui() | def apply_settings(self): """Applies the current settings.""" self.update_input_mapping() self.update_input_devices() try: self.preferencesWindow.update_ui() except AttributeError: pass |
def init_brush_adjustments(self, ): """Initializes all the brush adjustments for the current brush""" self.brush_adjustment = {} from brushlib import brushsettings for i, s in enumerate(brushsettings.settings_visible): adj = gtk.Adjustment(value=s.default, lower=s.min, upper=s.max, step_incr=0.01, page_incr=0.1) self.b... | def init_brush_adjustments(self, ): """Initializes all the brush adjustments for the current brush""" self.brush_adjustment = {} from brushlib import brushsettings for i, s in enumerate(brushsettings.settings_visible): adj = gtk.Adjustment(value=s.default, lower=s.min, upper=s.max, step_incr=0.01, page_incr=0.1) self.b... | |
def apply_setting(self): pass | def apply_setting(self): pass | |
res = keymap.translate_keyboard_state(event.hardware_keycode, event.state, event.group) | res = keymap.translate_keyboard_state(event.hardware_keycode, event.state & ~gdk.LOCK_MASK, event.group) | def key_press_cb(self, widget, event): if not self.enabled: return # See gtk sourcecode in gtkmenu.c function gtk_menu_key_press, # which uses the same code as below when changing an accelerator. keymap = gdk.keymap_get_default() # figure out what modifiers went into determing the keyval res = keymap.translate_keyboard... |
trash1, trash2, trash3, consumed_modifiers = res | keyval, trash2, trash3, consumed_modifiers = res | def key_press_cb(self, widget, event): if not self.enabled: return # See gtk sourcecode in gtkmenu.c function gtk_menu_key_press, # which uses the same code as below when changing an accelerator. keymap = gdk.keymap_get_default() # figure out what modifiers went into determing the keyval res = keymap.translate_keyboard... |
keyval = gdk.keyval_to_lower(event.keyval) if keyval != event.keyval and not event.get_state() & gdk.LOCK_MASK: | keyval_lower = gdk.keyval_to_lower(keyval) if keyval_lower != keyval: | def key_press_cb(self, widget, event): if not self.enabled: return # See gtk sourcecode in gtkmenu.c function gtk_menu_key_press, # which uses the same code as below when changing an accelerator. keymap = gdk.keymap_get_default() # figure out what modifiers went into determing the keyval res = keymap.translate_keyboard... |
action = self.keymap.get((keyval, modifiers)) | action = self.keymap.get((keyval_lower, modifiers)) | def key_press_cb(self, widget, event): if not self.enabled: return # See gtk sourcecode in gtkmenu.c function gtk_menu_key_press, # which uses the same code as below when changing an accelerator. keymap = gdk.keymap_get_default() # figure out what modifiers went into determing the keyval res = keymap.translate_keyboard... |
action = self.keymap2.get((keyval, modifiers)) | action = self.keymap2.get((keyval_lower, modifiers)) | def key_press_cb(self, widget, event): if not self.enabled: return # See gtk sourcecode in gtkmenu.c function gtk_menu_key_press, # which uses the same code as below when changing an accelerator. keymap = gdk.keymap_get_default() # figure out what modifiers went into determing the keyval res = keymap.translate_keyboard... |
pressure = event.get_axis(gdk.AXIS_PRESSURE) if (event.state & gdk.BUTTON1_MASK) or pressure: | if event.state & gdk.BUTTON1_MASK: | def button_press_cb(self, win, event): #print event.device, event.button if event.type != gdk.BUTTON_PRESS: # ignore the extra double-click event return if event.button == 2: # check whether we are painting (accidental) pressure = event.get_axis(gdk.AXIS_PRESSURE) if (event.state & gdk.BUTTON1_MASK) or pressure: # do n... |
self.connect("motion-notify-event", self.motion_notify_cb) self.connect("button-press-event", self.button_press_cb) | def __init__(self, document): gtk.DrawingArea.__init__(self) self.connect("expose-event", self.expose_cb) self.connect("motion-notify-event", self.motion_notify_cb) self.connect("button-press-event", self.button_press_cb) self.connect("enter-notify-event", self.enter_notify_cb) self.connect("leave-notify-event", self.l... | |
if pressure is not None and (pressure > 1.0 or pressure < 0.0): | if pressure is not None and (pressure > 1.0 or pressure < 0.0 or not isfinite(pressure)): | def motion_notify_cb(self, widget, event, button1_pressed=None): if not self.is_sensitive: return |
if pressure > 1000.0 or pressure < -1000.0: | if not isfinite(pressure): | def motion_notify_cb(self, widget, event, button1_pressed=None): if not self.is_sensitive: return |
if xtilt is None or ytilt is None or \ xtilt > 1000.0 or xtilt < -1000.0 or \ ytilt > 1000.0 or ytilt < -1000.0: | if xtilt is None or ytilt is None or not isfinite(xtilt+ytilt): | def motion_notify_cb(self, widget, event, button1_pressed=None): if not self.is_sensitive: return |
dst_brush = brushmanager.ManagedBrush(self.bm) dst_brush.load(dst_name) | dst_brush = brushmanager.ManagedBrush(self.bm, dst_name, persistent=True) dst_brush.load() | def rename_brush_cb(self, window): src_brush = self.bm.selected_brush if not src_brush.name: dialogs.error(self, _('No brush selected!')) return |
self.show_layers_above = True | def __init__(self, document): gtk.DrawingArea.__init__(self) self.connect("expose-event", self.expose_cb) self.connect("motion-notify-event", self.motion_notify_cb) self.connect("button-press-event", self.button_press_cb) self.connect("enter-notify-event", self.enter_notify_cb) self.connect("leave-notify-event", self.l... | |
def get_layers(self): | def get_visible_layers(self): | def get_layers(self): # FIXME: tileddrawwidget should not need to know whether the document has layers layers = filter(lambda l: l.visible, self.doc.layers[:]) |
layers = filter(lambda l: l.visible, self.doc.layers[:]) | layers = self.doc.layers if not self.show_layers_above: layers = self.doc.layers[0:self.doc.layer_idx+1] layers = [l for l in layers if l.visible] | def get_layers(self): # FIXME: tileddrawwidget should not need to know whether the document has layers layers = filter(lambda l: l.visible, self.doc.layers[:]) |
layers = self.get_layers() | layers = self.get_visible_layers() | def repaint(self, device_bbox=None): if device_bbox is None: w, h = self.window.get_size() device_bbox = (0, 0, w, h) #print 'device bbox', tuple(device_bbox) |
for layer in self.doc.layers: if layer is self.doc.layer: break layer.visible = not layer.visible | self.show_layers_above = not self.show_layers_above | def toggle_show_layers_above(self): for layer in self.doc.layers: if layer is self.doc.layer: break layer.visible = not layer.visible |
expander = self.expander = gtk.Expander(label='') expander.set_expanded(False) | is_expanded = bool(app.preferences.get(self.EXPANDER_PREFS_KEY, False)) expander = self.expander = gtk.Expander(label=None) expander.set_expanded(is_expanded) | def __init__(self, app): windowing.SubWindow.__init__(self, app) self.last_selected_brush = None |
def response_cb(window, resp): if resp == 2: details = gtk.Dialog (_("Bug Details"), dialog, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, (gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE, )) details.set_property ("has-separator", False) textview = gtk.TextView(); textview.show() textview.set_editable (False) textview.modif... | dialog.connect('response', _dialog_response_cb, trace) | def response_cb(window, resp): if resp == 2: # Show details... details = gtk.Dialog (_("Bug Details"), dialog, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, (gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE, )) details.set_property ("has-separator", False) |
load(filename) | try: load(filename) except gobject.GError, e: traceback.print_exc() raise SaveLoadError, _('Error while loading: GError %s') % e except IOError, e: traceback.print_exc() raise SaveLoadError, _('Error while loading: IOError %s') % e | def load(self, filename): if not os.path.isfile(filename): raise SaveLoadError, _('File does not exist: %s') % repr(filename) if not os.access(filename,os.R_OK): raise SaveLoadError, _('You do not have the necessary permissions to open file: %s') % repr(filename) trash, ext = os.path.splitext(filename) ext = ext.lower(... |
if xtilt is None or ytilt is None: | if xtilt is None or ytilt is None or \ xtilt > 1000.0 or xtilt < -1000.0 or \ ytilt > 1000.0 or ytilt < -1000.0: | def motion_notify_cb(self, widget, event, button1_pressed=None): if not self.is_sensitive: return |
gdk.ACTION_COPY) | gdk.ACTION_COPY|gdk.ACTION_MOVE) | def __init__(self, app): gtk.DrawingArea.__init__(self) |
c = style.bg[bg_state] | c = style_bg[bg_state] | def expose_cb(self, widget, event): cr = self.window.cairo_create() width, height = self.window.get_size() |
c = style.fg[fg_state] | c = style_fg[fg_state] | def expose_cb(self, widget, event): cr = self.window.cairo_create() width, height = self.window.get_size() |
if brush in target: | changed = [] if context.action == gdk.ACTION_MOVE: | def drag_data_received_cb(self, widget, context, x, y, selection, targetType, time): group = self.group_at(x,y) source = context.get_source_widget() # ensure, that drop comes from BrushList and targets some group if not group or not isinstance(source, BrushList): context.finish(False, False, time) return target = self.... |
target.append(brush) changed = target | context.finish(False, False, time) | def drag_data_received_cb(self, widget, context, x, y, selection, targetType, time): group = self.group_at(x,y) source = context.get_source_widget() # ensure, that drop comes from BrushList and targets some group if not group or not isinstance(source, BrushList): context.finish(False, False, time) return target = self.... |
elif d == gdk.SCROLL_LEFT: | elif d == gdk.SCROLL_RIGHT: | def scroll_cb(self, win, event): d = event.direction if d == gdk.SCROLL_UP: if event.state & gdk.SHIFT_MASK: self.app.doc.rotate('RotateLeft') else: self.app.doc.zoom('ZoomIn') elif d == gdk.SCROLL_DOWN: if event.state & gdk.SHIFT_MASK: self.app.doc.rotate('RotateRight') else: self.app.doc.zoom('ZoomOut') elif d == gdk... |
widget.window.set_type_hint(gdk.WINDOW_TYPE_HINT_UTILITY) | if not sys.platform == 'darwin': widget.window.set_type_hint(gdk.WINDOW_TYPE_HINT_UTILITY) | def on_realize(self, widget): # Mark subwindows as utility windows: many X11 WMs handle this sanely widget.window.set_type_hint(gdk.WINDOW_TYPE_HINT_UTILITY) # Win32 is responsive to the following: keeps the utility # window above the main window in fullscreen. widget.set_transient_for(self.app.drawWindow) |
dialog.set_filename(filename) | dialog.set_current_name(filename) | def save_dialog(title, window, filters, default_format=None): """ filters should be a list of tuples: (filter title, glob pattern). default_format may be a pair (format id, suffix). That suffix will be added to filename if it does not match any of filters. Returns a tuple: (file format, filename). Here "file format" is... |
try: color, is_hsv = self.get_color_at(x,y) except TypeError: | color, is_hsv = self.get_color_at(x,y) if color is None: | def select_color_at(self, x,y): try: color, is_hsv = self.get_color_at(x,y) except TypeError: return if is_hsv: self.hsv = color self.color = hsv_to_rgb(*color) else: self.color = color self.hsv = rgb_to_hsv(*color) if self.device_pressed: selected_color = self.color # Potential device change, therefore brush & colour ... |
if from_area == AREA_CIRCLE: return to_area not in (AREA_SQUARE, AREA_INSIDE) elif from_area == AREA_SQUARE: return to_area not in (AREA_CIRCLE, AREA_OUTSIDE) else: return False | return from_area in (AREA_CIRCLE, AREA_SQUARE) | def test_move(self, x, y): from_area = self.area_at(self.press_x,self.press_y) to_area = self.area_at(x, y) if from_area == AREA_CIRCLE: return to_area not in (AREA_SQUARE, AREA_INSIDE) elif from_area == AREA_SQUARE: return to_area not in (AREA_CIRCLE, AREA_OUTSIDE) else: return False #return from_area == to_area # ... |
tx = self.rd*x1 ty = self.rd*y1 m = self.m-1.0 rx = self.x0 + clamp(tx, -m, +m) ry = self.y0 + clamp(ty, -m, +m) | m = self.m dx = clamp(dx, -m, m) dy = clamp(dy, -m, m) rx = self.x0 + dx ry = self.y0 + dy | def nearest_move_target(self, x,y): """ Returns the nearest (x, y) the selection indicator can move to during a move with the button held down. """ area_source = self.area_at(self.press_x, self.press_y) area = self.area_at(x,y) if area == area_source and area in [AREA_CIRCLE, AREA_SQUARE]: return x,y dx = x-self.x0 dy ... |
elif self.r2 < d < self.r3: | elif self.r2 < d <= self.r3: | def area_at(self, x,y): dx = x-self.x0 dy = y-self.y0 d = sqrt(dx*dx+dy*dy) sq2 = sqrt(2.0) cmp_M = self.M/2.0 cmp_r = (sq2-1)*cmp_M/(2*sq2) cmp_x0 = self.x0+cmp_M-cmp_r cmp_y0 = self.y0+cmp_M-cmp_r cmp_dx = x - cmp_x0 cmp_dy = y - cmp_y0 if cmp_r > sqrt(cmp_dx*cmp_dx + cmp_dy*cmp_dy): return AREA_COMPARE elif d > self... |
elif self.rd < d < self.r2: | elif abs(dx)<ceil(self.m) and abs(dy)<ceil(self.m): return AREA_SQUARE elif self.rd < d <= self.r2: | def area_at(self, x,y): dx = x-self.x0 dy = y-self.y0 d = sqrt(dx*dx+dy*dy) sq2 = sqrt(2.0) cmp_M = self.M/2.0 cmp_r = (sq2-1)*cmp_M/(2*sq2) cmp_x0 = self.x0+cmp_M-cmp_r cmp_y0 = self.y0+cmp_M-cmp_r cmp_dx = x - cmp_x0 cmp_dy = y - cmp_y0 if cmp_r > sqrt(cmp_dx*cmp_dx + cmp_dy*cmp_dy): return AREA_COMPARE elif d > self... |
elif abs(dx)<self.m and abs(dy)<self.m: return AREA_SQUARE | def area_at(self, x,y): dx = x-self.x0 dy = y-self.y0 d = sqrt(dx*dx+dy*dy) sq2 = sqrt(2.0) cmp_M = self.M/2.0 cmp_r = (sq2-1)*cmp_M/(2*sq2) cmp_x0 = self.x0+cmp_M-cmp_r cmp_y0 = self.y0+cmp_M-cmp_r cmp_dx = x - cmp_x0 cmp_dy = y - cmp_y0 if cmp_r > sqrt(cmp_dx*cmp_dx + cmp_dy*cmp_dy): return AREA_COMPARE elif d > self... | |
if not area: return | def get_color_at(self, x,y): area = self.area_at(x,y) if not area: return if area == AREA_CIRCLE: h,s,v = self.hsv h = 0.5 + 0.5*atan2(y-self.y0, self.x0-x)/pi return (h,s,v), True elif area == AREA_SAMPLE: a = pi+atan2(y-self.y0, self.x0-x) for i,a1 in enumerate(self.angles): if a1-2*pi/CIRCLE_N < a < a1: clr = self.s... | |
l3 = gtk.Label('%.2f' % -self.scale_y_adj.get_value()) self.negative_scale_label = l3 | l3 = gtk.Label() def update_negative_scale(*trash): l3.set_text('%.2f' % -self.scale_y_adj.get_value()) self.scale_y_adj.connect('value-changed', update_negative_scale) update_negative_scale() | def __init__(self, app, input, setting): gtk.VBox.__init__(self) |
self.negative_scale_label.set_text('%.2f' % -scale_y) | def user_changes_cb(self, widget): if self.block_user_changes_cb: return | |
imshow(im_b[:,:,3]) | imshow(im_b[:,:,3], interpolation='nearest') | def pngs_equal(a, b, exact=True): if files_equal(a, b): print a, 'and', b, 'are perfectly equal' return True im_a = imread(a)*255.0 im_b = imread(b)*255.0 if im_a.shape != im_b.shape: print a, 'and', b, 'have different size:', im_a.shape, im_b.shape return False diff = im_b - im_a alpha = im_a.shape[-1] == 4 if alpha: ... |
imshow(diff[:,:,1]) | imshow(diff[:,:,1], interpolation='nearest') | def pngs_equal(a, b, exact=True): if files_equal(a, b): print a, 'and', b, 'are perfectly equal' return True im_a = imread(a)*255.0 im_b = imread(b)*255.0 if im_a.shape != im_b.shape: print a, 'and', b, 'have different size:', im_a.shape, im_b.shape return False diff = im_b - im_a alpha = im_a.shape[-1] == 4 if alpha: ... |
imshow(diff_alpha) | imshow(diff_alpha, interpolation='nearest') | def pngs_equal(a, b, exact=True): if files_equal(a, b): print a, 'and', b, 'are perfectly equal' return True im_a = imread(a)*255.0 im_b = imread(b)*255.0 if im_a.shape != im_b.shape: print a, 'and', b, 'have different size:', im_a.shape, im_b.shape return False diff = im_b - im_a alpha = im_a.shape[-1] == 4 if alpha: ... |
zip.write(myb, basename(preview)) | zip.write(myb, basename(myb)) | def export_group(self, group, filename): zip = zipfile.ZipFile(filename, mode='w') brushes = self.get_group_brushes(group) for brush in brushes: prefix = brush.get_fileprefix() preview = prefix + '_prev.png' myb = prefix + '.myb' zip.write(preview, basename(preview)) zip.write(myb, basename(preview)) zip.close() |
('PrevScrap', None, _('Open Previous Scrap'), 'F5', None, self.open_scrap_cb), ('NextScrap', None, _('Open Next Scrap'), 'F6', None, self.open_scrap_cb), | ('PrevScrap', None, _('Open Previous Scrap'), 'F6', None, self.open_scrap_cb), ('NextScrap', None, _('Open Next Scrap'), 'F7', None, self.open_scrap_cb), | def __init__(self, app): self.app = app #NOTE: filehandling and drawwindow are very tightly coupled self.save_dialog = None |
dir = dirname(target_name) | dir = os.path.dirname(target_name) | def new_name(name): if name.startswith('brushes/'): target_name = name[8:] else: target_name = name if '/' in target_name: dir = dirname(target_name) target_path = join(self.user_brushpath, dir) if not isdir(target_path): makedirs(target_path) target_path = join(target_path, target_name) else: target_path = join(self.u... |
makedirs(target_path) | os.makedirs(target_path) | def new_name(name): if name.startswith('brushes/'): target_name = name[8:] else: target_name = name if '/' in target_name: dir = dirname(target_name) target_path = join(self.user_brushpath, dir) if not isdir(target_path): makedirs(target_path) target_path = join(target_path, target_name) else: target_path = join(self.u... |
w.show_all() | w.present() | def show(self): "Shows all of the user's subwindows reversibly." self._in_command = True for w in self.windows: w.show_all() self.hidden = False self._in_command = False |
self.tdw.scroll(-dx*2, -dy*2) | self.tdw.scroll(-dx, -dy) | def dragfunc_translate(self, dx, dy): self.tdw.scroll(-dx*2, -dy*2) |
dst[:N,:N,:] = rgb.astype('uint32') * 255 / (1<<15) | mypaintlib.tile_convert_rgb16_to_rgb8(rgb, dst) | def blit_tile_into(self, dst, tx, ty, mipmap_level=0): if self.mipmap_level < mipmap_level: return self.mipmap.blit_tile_into(dst, tx, ty, mipmap_level) rgb = self.get_tile_memory(tx, ty) # render solid or tiled background #dst[:] = rgb # 13 times slower than below, with some bursts having the same speed as below (huh?... |
if is_eraser(new_device): | if self.device_is_eraser(new_device): | def device_changed_cb(self, old_device, new_device): # small problem with this code: it doesn't work well with brushes that have (eraser not in [1.0, 0.0]) print 'device change:', new_device.name, new_device.source |
def motion_notify_cb(self, widget, event): | def motion_notify_cb(self, widget, event, button1_pressed=None): | def motion_notify_cb(self, widget, event): if self.last_event_time: dtime = (event.time - self.last_event_time)/1000.0 dx = event.x - self.last_event_x dy = event.y - self.last_event_y else: dtime = None if event.device != self.last_event_device: for f in self.device_observers: f(self.last_event_device, event.device) s... |
if event.state & gdk.BUTTON1_MASK: | self.last_event_had_pressure_info = False if button1_pressed is None: button1_pressed = event.state & gdk.BUTTON1_MASK if button1_pressed: | def motion_notify_cb(self, widget, event): if self.last_event_time: dtime = (event.time - self.last_event_time)/1000.0 dx = event.x - self.last_event_x dy = event.y - self.last_event_y else: dtime = None if event.device != self.last_event_device: for f in self.device_observers: f(self.last_event_device, event.device) s... |
self.doc.stroke_to(dtime, x, y, pressure, xtilt, ytilt) | if dtime < 0.0: print 'Time is running backwards, dtime=%f' % dtime dtime = 0.0 data = (x, y, pressure, xtilt, ytilt) if dtime == 0.0: self.motions.append(data) elif dtime > 0.0: if self.motions: if dtime > 0.1: step = 0.1 else: step = dtime step /= len(self.motions)+1 for data_old in self.motions: self.doc.stroke_to... | def motion_notify_cb(self, widget, event, button1_pressed=None): if not self.is_sensitive: return |
b.load_settings() b.persistent = False | b.load_settings(retain_parent=True) | def listbrushes(path): # Return a list of brush names relative to path, using # slashes for subirectories on all platforms. path += '/' l = [] assert isinstance(path, unicode) # make sure we get unicode filenames for name in os.listdir(path): assert isinstance(name, unicode) if name.endswith('.myb'): l.append(name[:-4]... |
brushinfo.pop("parent_brush_name", None) | def save(self): prefix = self.get_fileprefix(saving=True) if self.preview is None: self.preview = gdk.Pixbuf(gdk.COLORSPACE_RGB, False, 8, preview_w, preview_h) self.preview.fill(0xffffffff) # white self.preview.save(prefix + '_prev.png', 'png') brushinfo = self.brushinfo.clone() brushinfo.pop("parent_brush_name", None... | |
def load(self): | def load(self, retain_parent=False): """Loads the brush's preview and settings from disk.""" | def load(self): self.load_preview() self.load_settings() |
self.load_settings() | self.load_settings(retain_parent) | def load(self): self.load_preview() self.load_settings() |
def load_settings(self): | def load_settings(self, retain_parent=False): | def load_settings(self): """Loads the brush settings/dynamics from disk.""" prefix = self.get_fileprefix() filename = prefix + '.myb' brushinfo_str = open(filename).read() self.brushinfo.parse(brushinfo_str) self.brushinfo.pop("parent_brush_name", None) self.remember_mtimes() self.settings_loaded = True self.persistent... |
self.brushinfo.pop("parent_brush_name", None) | def load_settings(self): """Loads the brush settings/dynamics from disk.""" prefix = self.get_fileprefix() filename = prefix + '.myb' brushinfo_str = open(filename).read() self.brushinfo.parse(brushinfo_str) self.brushinfo.pop("parent_brush_name", None) self.remember_mtimes() self.settings_loaded = True self.persistent... | |
guid01 = guids["user01"] | largeGuid = guids[largeCalendarUser] | def addLargeCalendars(hostname, docroot): calendars = ("calendar.10", "calendar.100", "calendar.1000",) guid01 = guids["user01"] path = os.path.join( docroot, "calendars", "__uids__", guid01[0:2], guid01[2:4], guid01, ) result = cmd("curl --digest -u user01:user01 'http://%s:8008/calendars/users/user01/'" % (hostname,... |
guid01[0:2], guid01[2:4], guid01, | largeGuid[0:2], largeGuid[2:4], largeGuid, | def addLargeCalendars(hostname, docroot): calendars = ("calendar.10", "calendar.100", "calendar.1000",) guid01 = guids["user01"] path = os.path.join( docroot, "calendars", "__uids__", guid01[0:2], guid01[2:4], guid01, ) result = cmd("curl --digest -u user01:user01 'http://%s:8008/calendars/users/user01/'" % (hostname,... |
result = cmd("curl --digest -u user01:user01 'http://%s:8008/calendars/users/user01/'" % (hostname,), raiseOnFail=False) | result = cmd("curl --digest -u %s:%s 'http://%s:8008/calendars/users/%s/'" % ( largeCalendarUser, largeCalendarUser, hostname, largeCalendarUser, ), raiseOnFail=False) | def addLargeCalendars(hostname, docroot): calendars = ("calendar.10", "calendar.100", "calendar.1000",) guid01 = guids["user01"] path = os.path.join( docroot, "calendars", "__uids__", guid01[0:2], guid01[2:4], guid01, ) result = cmd("curl --digest -u user01:user01 'http://%s:8008/calendars/users/user01/'" % (hostname,... |
self.postgresResult(postgresCount, indent=4) | if postgresCount is not None: self.postgresResult(postgresCount, indent=4) | def run_test_suite( self, suite, label = "" ): descriptor = " Test Suite: %s" % suite.name descriptor += " " * max(1, STATUSTXT_WIDTH - len(descriptor)) self.manager.log(manager.LOG_HIGH, "%s" % (descriptor,), before=1, after=0) ok = 0 failed = 0 ignored = 0 if suite.ignore: self.manager.log(manager.LOG_HIGH, "[IGNO... |
result = self.dorequests( "Executing Start Requests...", self.start_requests, False, True ) | result = self.dorequests( "Executing Start Requests...", self.start_requests, False, True, label="%s | %s" % (self.name, "START_REQUESTS") ) | def run( self ): if len(self.missingFeatures()) != 0: self.manager.log(manager.LOG_HIGH, "----- Ignoring Tests from \"%s\"... -----" % self.name, before=1) self.manager.log(manager.LOG_HIGH, " Missing features: %s" % (", ".join(sorted(self.missingFeatures())),)) return 0, 0, 1 try: self.manager.log(manager.LOG_HI... |
ok, failed, ignored = self.run_tests() self.doenddelete( "Deleting Requests..." ) self.dorequests( "Executing End Requests...", self.end_requests, False ) | ok, failed, ignored = self.run_tests(label=self.name) self.doenddelete( "Deleting Requests...", label="%s | %s" % (self.name, "END_DELETE")) self.dorequests( "Executing End Requests...", self.end_requests, False, label="%s | %s" % (self.name, "END_REQUESTS")) | def run( self ): if len(self.missingFeatures()) != 0: self.manager.log(manager.LOG_HIGH, "----- Ignoring Tests from \"%s\"... -----" % self.name, before=1) self.manager.log(manager.LOG_HIGH, " Missing features: %s" % (", ".join(sorted(self.missingFeatures())),)) return 0, 0, 1 try: self.manager.log(manager.LOG_HI... |
def run_tests( self ): | def run_tests( self, label = "" ): | def run_tests( self ): ok = 0 failed = 0 ignored = 0 for suite in self.suites: o, f, i = self.run_test_suite( suite ) ok += o failed += f ignored += i return (ok, failed, ignored) |
o, f, i = self.run_test_suite( suite ) | o, f, i = self.run_test_suite( suite, label="%s | %s" % (label, suite.name) ) | def run_tests( self ): ok = 0 failed = 0 ignored = 0 for suite in self.suites: o, f, i = self.run_test_suite( suite ) ok += o failed += f ignored += i return (ok, failed, ignored) |
def run_test_suite( self, suite ): | def run_test_suite( self, suite, label = "" ): | def run_test_suite( self, suite ): descriptor = " Test Suite: %s" % suite.name descriptor += " " * max(1, STATUSTXT_WIDTH - len(descriptor)) self.manager.log(manager.LOG_HIGH, "%s" % (descriptor,), before=1, after=0) ok = 0 failed = 0 ignored = 0 if suite.ignore: self.manager.log(manager.LOG_HIGH, "[IGNORED]") ignor... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.