def update_font(self): font_desc = pango.FontDescription(self.font) self.pango_layout.set_font_description(font_desc) self.update_font_height()
def on_enter_frame(self, scene, context): g = graphics.Graphics(context) rowcount, keys = len(self.keys), self.keys start_hour = 0 if self.start_time: start_hour = self.start_time end_hour = 24 * 60 if self.end_time: end_hour = self.end_time # push graph to the right, so it doesn't overlap legend_width = self.legend_width or self.longest_label(keys) self.graph_x = legend_width self.graph_x += 8 #add another 8 pixes of padding self.graph_width = self.width - self.graph_x # TODO - should handle the layout business in graphics self.layout = context.create_layout() default_font = pango.FontDescription(self.get_style().font_desc.to_string()) default_font.set_size(8 * pango.SCALE) self.layout.set_font_description(default_font) #on the botttom leave some space for label self.layout.set_text("1234567890:") label_w, label_h = self.layout.get_pixel_size() self.graph_y, self.graph_height = 0, self.height - label_h - 4 if not self.data: #if we have nothing, let's go home return positions = {} y = 0 bar_width = min(self.graph_height / float(len(self.keys)), self.max_bar_width) for i, key in enumerate(self.keys): positions[key] = (y + self.graph_y, round(bar_width - 1)) y = y + round(bar_width) bar_width = min(self.max_bar_width, (self.graph_height - y) / float(max(1, len(self.keys) - i - 1))) max_bar_size = self.graph_width - 15 # now for the text - we want reduced contrast for relaxed visuals fg_color = self.get_style().fg[gtk.STATE_NORMAL].to_string() label_color = self.colors.contrast(fg_color, 80) self.layout.set_alignment(pango.ALIGN_RIGHT) self.layout.set_ellipsize(pango.ELLIPSIZE_END) # bars and labels self.layout.set_width(legend_width * pango.SCALE) factor = max_bar_size / float(end_hour - start_hour) # determine bar color bg_color = self.get_style().bg[gtk.STATE_NORMAL].to_string() base_color = self.colors.contrast(bg_color, 30) for i, label in enumerate(keys): g.set_color(label_color) self.layout.set_text(label) label_w, label_h = self.layout.get_pixel_size() context.move_to(0, positions[label][0] + (positions[label][1] - label_h) / 2) context.show_layout(self.layout) if isinstance(self.data[i], list) == False: self.data[i] = [self.data[i]] for row in self.data[i]: bar_x = round((row[0]- start_hour) * factor) bar_size = round((row[1] - start_hour) * factor - bar_x) g.fill_area(round(self.graph_x + bar_x), positions[label][0], bar_size, positions[label][1], base_color) #white grid and scale values self.layout.set_width(-1) context.set_line_width(1) pace = ((end_hour - start_hour) / 3) / 60 * 60 last_position = positions[keys[-1]] grid_color = self.get_style().bg[gtk.STATE_NORMAL].to_string() for i in range(start_hour + 60, end_hour, pace): x = round((i - start_hour) * factor) minutes = i % (24 * 60) self.layout.set_markup(dt.time(minutes / 60, minutes % 60).strftime("%H<small><sup>%M</sup></small>")) label_w, label_h = self.layout.get_pixel_size() context.move_to(self.graph_x + x - label_w / 2, last_position[0] + last_position[1] + 4) g.set_color(label_color) context.show_layout(self.layout) g.set_color(grid_color) g.move_to(round(self.graph_x + x) + 0.5, self.graph_y) g.line_to(round(self.graph_x + x) + 0.5, last_position[0] + last_position[1]) context.stroke()
def __init__(self): self.gameover = False self.word = self.getWord() self.lcaseword = self.word.lower() self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) self.window.set_title("Hangman") self.window.connect("delete_event", self.delete_event) self.window.connect("key_press_event", self.key_press_event) self.window.set_border_width(10) # 2 rows, 26 columns table = gtk.Table(2, 13, True) vbox = gtk.VBox(False, 10) self.window.add(vbox) # Hangman image hbox = gtk.HBox(False, 0) frame = gtk.Frame() self.image = gtk.Image() self.imageidx = 0 self.image.set_from_file(Hangman.imagebase + str(self.imageidx) + '.jpg') frame.add(self.image) hbox.pack_start(frame, True, False, 0) self.score = 0 self.msglabel = gtk.Label \ ('Score : ' + str(self.score) + ' ' * 9 + '\n\n\n\n') self.msglabel.modify_font(pango.FontDescription("sans 15")) hbox.pack_start(self.msglabel, True, False, 0) vbox.pack_start(hbox, False, False, 0) frame = gtk.Frame() self.mask = '' for c in self.word: if c == ' ': self.mask = self.mask + ' ' else: self.mask = self.mask + '-' self.masklabel = gtk.Label(self.mask) self.masklabel.modify_font(pango.FontDescription("sans 27")) vbox.pack_start(self.masklabel, False, False, 0) frame = gtk.Frame() left = 0 top = 0 i = 0 self.a_button = [] for letter in Hangman.ALPHABET.upper(): self.button1 = gtk.Button(letter) self.button1.connect("clicked", self.callback, letter) self.a_button.append(self.button1) if left == 13: left = 0 top += 1 table.attach(self.button1, left, left + 1, top, top + 1) left += 1 i += 1 frame.add(table) vbox.pack_start(frame, False, False, 0) hbox = gtk.HBox(True, 0) self.button = gtk.Button('Quit') self.button.connect("clicked", self.callback, 'Quit') hbox.pack_start(self.button, True, False, 0) self.button = gtk.Button('Play Again') self.button.connect("clicked", self.callback, 'PlayAgain') hbox.pack_start(self.button, False, False, 0) vbox.pack_start(hbox, True, False, 0) self.window.show_all()
def table_insert(self, iter_insert, table=None, table_justification=None, text_buffer=None): """Insert a Table at the Given Iter""" if not text_buffer: text_buffer = self.dad.curr_buffer if table != None: self.dad.table_columns = len(table['matrix'][0]) self.dad.table_rows = len(table['matrix']) - 1 headers = table['matrix'][-1] table_col_min = table['col_min'] table_col_max = table['col_max'] else: headers = [_("click me")] * self.dad.table_columns table_col_min = self.dad.table_col_min table_col_max = self.dad.table_col_max anchor = text_buffer.create_child_anchor(iter_insert) anchor.liststore = gtk.ListStore(*(str, ) * self.dad.table_columns) anchor.treeview = gtk.TreeView(anchor.liststore) for element in range(self.dad.table_columns): label = gtk.Label('<b>' + headers[element] + '</b>') label.set_use_markup(True) label.set_tooltip_text(_("Click to Edit the Column Settings")) label.show() renderer_text = gtk.CellRendererText() renderer_text.set_property('editable', True) renderer_text.set_property('wrap-width', table_col_max) renderer_text.set_property('wrap-mode', pango.WRAP_WORD_CHAR) renderer_text.set_property( 'font-desc', pango.FontDescription(self.dad.text_font)) renderer_text.connect('edited', self.on_table_cell_edited, anchor.liststore, element) renderer_text.connect('editing-started', self.on_table_cell_editing_started, anchor.liststore, element) column = gtk.TreeViewColumn("", renderer_text, text=element) column.set_min_width(table_col_min) column.set_clickable(True) column.set_widget(label) column.set_sizing(gtk.TREE_VIEW_COLUMN_AUTOSIZE) column.connect('clicked', self.table_column_clicked, anchor, element) anchor.treeview.append_column(column) anchor.headers = headers anchor.table_col_min = table_col_min anchor.table_col_max = table_col_max anchor.treeview.set_grid_lines(gtk.TREE_VIEW_GRID_LINES_BOTH) anchor.treeview.connect('button-press-event', self.on_mouse_button_clicked_treeview_table, anchor) anchor.treeview.connect('key_press_event', self.on_key_press_treeview_table, anchor) anchor.frame = gtk.Frame() anchor.frame.add(anchor.treeview) anchor.frame.set_shadow_type(gtk.SHADOW_NONE) anchor.eventbox = gtk.EventBox() anchor.eventbox.add(anchor.frame) self.dad.sourceview.add_child_at_anchor(anchor.eventbox, anchor) anchor.eventbox.show_all() for row in range(self.dad.table_rows): row_iter = anchor.liststore.append([""] * self.dad.table_columns) if table != None: for column in range(self.dad.table_columns): try: anchor.liststore[row_iter][column] = table['matrix'][ row][column] except: pass # there are cases when some rows have less columns if table_justification: text_iter = text_buffer.get_iter_at_child_anchor(anchor) self.dad.state_machine.apply_object_justification( text_iter, table_justification, text_buffer) elif self.dad.user_active: # if I apply a justification, the state is already updated self.dad.state_machine.update_state( self.dad.treestore[self.dad.curr_tree_iter][3])
for line in paras: k, v = line.split("': '") alarmlist_dict[k] = v self.alarmlist.append(alarmlist_dict) alarmlist_dict = {} else: self.alarmlist = self.settings['alarmlist'] self.min_for_alarm = '' self.time_txt = '' self.date_txt = '' self.lb_time = gtk.Label() self.lb_time.modify_font( pango.FontDescription(self.settings['time_font'])) self.lb_time.set_use_markup(True) self.lb_time.set_alignment(0.5, 0.5) self.box.pack_start(self.lb_time) if not self.settings['date'] == '': self.lb_date = gtk.Label() self.lb_date.modify_font( pango.FontDescription(self.settings['date_font'])) self.lb_date.set_use_markup(True) self.lb_date.set_alignment(0.5, 0.5) self.box.pack_start(self.lb_date) else: self.lb_date = None self.box.show_all()
def __init__(self, block): """ Properties dialog constructor. Args: block: a block instance """ self._hash = 0 gtk.Dialog.__init__(self, title='Properties: %s' % block.get_name(), buttons=(gtk.STOCK_OK, gtk.RESPONSE_ACCEPT, gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT, gtk.STOCK_APPLY, gtk.RESPONSE_APPLY)) self.set_response_sensitive(gtk.RESPONSE_APPLY, False) self.set_size_request(MIN_DIALOG_WIDTH, MIN_DIALOG_HEIGHT) self._block = block vpaned = gtk.VPaned() self.vbox.pack_start(vpaned) # Notebook to hold param boxes notebook = gtk.Notebook() notebook.set_show_border(False) notebook.set_scrollable(True) # scroll arrows for page tabs notebook.set_tab_pos(gtk.POS_TOP) vpaned.pack1(notebook, True) # Params boxes for block parameters self._params_boxes = list() for tab in block.get_param_tab_labels(): label = gtk.Label() vbox = gtk.VBox() scroll_box = gtk.ScrolledWindow() scroll_box.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) scroll_box.add_with_viewport(vbox) notebook.append_page(scroll_box, label) self._params_boxes.append((tab, label, vbox)) # Docs for the block self._docs_text_display = SimpleTextDisplay() self._docs_box = gtk.ScrolledWindow() self._docs_box.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self._docs_box.add_with_viewport(self._docs_text_display) notebook.append_page(self._docs_box, gtk.Label("Documentation")) # Generated code for the block if Actions.TOGGLE_SHOW_CODE_PREVIEW_TAB.get_active(): self._code_text_display = code_view = SimpleTextDisplay() code_view.set_wrap_mode(gtk.WRAP_NONE) code_view.get_buffer().create_tag('b', weight=pango.WEIGHT_BOLD) code_view.modify_font( pango.FontDescription('monospace %d' % FONT_SIZE)) code_box = gtk.ScrolledWindow() code_box.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) code_box.add_with_viewport(self._code_text_display) notebook.append_page(code_box, gtk.Label("Generated Code")) else: self._code_text_display = None # Error Messages for the block self._error_messages_text_display = SimpleTextDisplay() self._error_box = gtk.ScrolledWindow() self._error_box.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self._error_box.add_with_viewport(self._error_messages_text_display) vpaned.pack2(self._error_box) vpaned.set_position(int(0.65 * MIN_DIALOG_HEIGHT)) # Connect events self.connect('key-press-event', self._handle_key_press) self.connect('show', self.update_gui) self.connect('response', self._handle_response) self.show_all() # show all (performs initial gui update)
def __init__(self, buff, parent, appwin): # Save params self.appwin = appwin self.parwin = parent # Gather globals self.keyh = pedconfig.pedconfig.keyh #self.pedwin = pedconfig.pedconfig.pedwin # Init vars self.xpos = 0 self.ypos = 0 self.xsel = -1 self.ysel = -1 self.xsel2 = -1 self.ysel2 = -1 self.caret = [] self.caret.append(0) self.caret.append(0) self.maxlinelen = 0 self.focus = False # Init configurables self.scgap = SCROLLGAP self.pgup = PAGEUP # Process buffer into list self.text = str.split(buff, "\n") for aa in self.text: xlen = len(aa) if self.maxlinelen < xlen: self.maxlinelen = xlen # Parent widget gtk.DrawingArea.__init__(self) self.set_flags(gtk.CAN_FOCUS | gtk.SENSITIVE) self.pangolayout = self.create_pango_layout("a") # Set default background color '''colormap = gtk.widget_get_default_colormap() color = colormap.alloc_color("#d0d0d0") self.modify_bg(gtk.STATE_NORMAL, color)''' # Our font fd = pango.FontDescription() fd.set_size(14 * 1024) fd.set_family("mono") self.pangolayout.set_font_description(fd) # Get Pango steps self.cxx, self.cyy = self.pangolayout.get_pixel_size() # Set up scroll bars self.hadj = gtk.Adjustment(0, 0, 100, 1, 15, 25) self.vadj = gtk.Adjustment(0, 0, 100, 1, 15, 25) self.vscroll = gtk.VScrollbar(self.vadj) self.hscroll = gtk.HScrollbar(self.hadj) # We connect scrollers after construction self.hadj.connect("value-changed", self.hscroll_cb) self.vadj.connect("value-changed", self.vscroll_cb) #self.www = gtk.gdk.screen_width(); #self.hhh = gtk.gdk.screen_height(); # Start up with initial size #self.set_size_request(3*self.www/4, self.hhh/5) self.set_events(gtk.gdk.POINTER_MOTION_MASK | gtk.gdk.POINTER_MOTION_HINT_MASK | gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.BUTTON_RELEASE_MASK | gtk.gdk.KEY_PRESS_MASK | gtk.gdk.KEY_RELEASE_MASK) self.connect("expose-event", self.area_expose_cb) self.connect("motion-notify-event", self.area_motion) self.connect("button-press-event", self.area_button) self.connect("button-release-event", self.area_button) self.connect("key-press-event", self.area_key) self.connect("key-release-event", self.area_key) self.connect("focus", self.area_focus) self.connect("configure_event", self.configure_event) self.connect("size-request", self.size_request) self.connect("size-allocate", self.size_alloc) self.connect("scroll-event", self.scroll_event) #self.connect("enter-notify-event", self.area_enter) #self.connect("leave-notify-event", self.area_leave) self.connect("focus-in-event", self.focus_in_cb) self.connect("focus-out-event", self.focus_out_cb)
def change_listing_font(self, fontbutton): self.listing_font_name = fontbutton.get_font_name() self.prefs.putpref('listing_font', self.listing_font_name, str) self.listing_font = pango.FontDescription(self.listing_font_name) self.setfont()
def __init__(self, inifile): # System default Glade file: self.gladefile = os.path.join(datadir, "touchy.glade") if inifile: self.ini = linuxcnc.ini(inifile) alternate_gladefile = self.ini.find("DISPLAY", "GLADEFILE") if alternate_gladefile: self.gladefile = alternate_gladefile else: self.ini = None self.wTree = gtk.glade.XML(self.gladefile) for w in ['wheelinc1', 'wheelinc2', 'wheelinc3', 'wheelx', 'wheely', 'wheelz', 'wheela', 'wheelb', 'wheelc', 'wheelu', 'wheelv', 'wheelw']: self.wTree.get_widget(w).get_child().set_property('width-chars', 6) for widget in self.wTree.get_widget_prefix(''): widget.unset_flags(gtk.CAN_FOCUS) self.wTree.get_widget('MainWindow').set_flags(gtk.CAN_FOCUS) self.wTree.get_widget('MainWindow').grab_focus() self.num_mdi_labels = 11 self.num_filechooser_labels = 11 self.num_listing_labels = 20 self.wheelxyz = 0 self.wheelinc = 0 self.wheel = "fo" self.radiobutton_mask = 0 self.resized_wheelbuttons = 0 self.tab = 0 self.fo_val = 100 self.so_val = 100 self.g10l11 = 0 self.prefs = preferences.preferences() self.mv_val = self.prefs.getpref('maxvel', 100, int) self.control_font_name = self.prefs.getpref('control_font', 'Sans 18', str) self.dro_font_name = self.prefs.getpref('dro_font', 'Courier 10 Pitch Bold 16', str) self.error_font_name = self.prefs.getpref('error_font', 'Sans Bold 10', str) self.listing_font_name = self.prefs.getpref('listing_font', 'Sans 10', str) self.theme_name = self.prefs.getpref('gtk_theme', 'Follow System Theme', str) self.abs_textcolor = self.prefs.getpref('abs_textcolor', 'default', str) self.rel_textcolor = self.prefs.getpref('rel_textcolor', 'default', str) self.dtg_textcolor = self.prefs.getpref('dtg_textcolor', 'default', str) self.err_textcolor = self.prefs.getpref('err_textcolor', 'default', str) self.window_geometry = self.prefs.getpref('window_geometry', 'default', str) self.window_max = self.prefs.getpref('window_force_max', 'False', bool) # initial screen setup if os.path.exists(themedir): model = self.wTree.get_widget("theme_choice").get_model() model.clear() model.append(("Follow System Theme",)) temp = 0 names = os.listdir(themedir) names.sort() for search,dirs in enumerate(names): model.append((dirs,)) if dirs == self.theme_name: temp = search+1 self.wTree.get_widget("theme_choice").set_active(temp) if self.window_geometry == "default": self.wTree.get_widget("MainWindow").window.maximize() else: self.wTree.get_widget("MainWindow").parse_geometry(self.window_geometry) if self.window_max: self.wTree.get_widget("MainWindow").window.maximize() self.invisible_cursor = self.prefs.getpref('invisible_cursor', 0) if self.invisible_cursor: self.wTree.get_widget("MainWindow").window.set_cursor(invisible) else: self.wTree.get_widget("MainWindow").window.set_cursor(None) self.wTree.get_widget("controlfontbutton").set_font_name(self.control_font_name) self.control_font = pango.FontDescription(self.control_font_name) self.wTree.get_widget("drofontbutton").set_font_name(self.dro_font_name) self.dro_font = pango.FontDescription(self.dro_font_name) self.wTree.get_widget("errorfontbutton").set_font_name(self.error_font_name) self.error_font = pango.FontDescription(self.error_font_name) self.wTree.get_widget("listingfontbutton").set_font_name(self.listing_font_name) self.listing_font = pango.FontDescription(self.listing_font_name) settings = gtk.settings_get_default() self.system_theme = settings.get_property("gtk-theme-name") if not self.theme_name == "Follow System Theme": settings.set_string_property("gtk-theme-name", self.theme_name, "") # interactive mdi command builder and issuer mdi_labels = [] mdi_eventboxes = [] for i in range(self.num_mdi_labels): mdi_labels.append(self.wTree.get_widget("mdi%d" % i)) mdi_eventboxes.append(self.wTree.get_widget("eventbox_mdi%d" % i)) self.mdi_control = mdi.mdi_control(gtk, linuxcnc, mdi_labels, mdi_eventboxes) if self.ini: macros = self.ini.findall("TOUCHY", "MACRO") if len(macros) > 0: self.mdi_control.mdi.add_macros(macros) else: self.wTree.get_widget("macro").set_sensitive(0) listing_labels = [] listing_eventboxes = [] for i in range(self.num_listing_labels): listing_labels.append(self.wTree.get_widget("listing%d" % i)) listing_eventboxes.append(self.wTree.get_widget("eventbox_listing%d" % i)) self.listing = listing.listing(gtk, linuxcnc, listing_labels, listing_eventboxes) # emc interface self.linuxcnc = emc_interface.emc_control(linuxcnc, self.listing, self.wTree.get_widget("error")) self.linuxcnc.continuous_jog_velocity(self.mv_val) self.hal = hal_interface.hal_interface(self, self.linuxcnc, self.mdi_control, linuxcnc) # silly file chooser filechooser_labels = [] filechooser_eventboxes = [] for i in range(self.num_filechooser_labels): filechooser_labels.append(self.wTree.get_widget("filechooser%d" % i)) filechooser_eventboxes.append(self.wTree.get_widget("eventbox_filechooser%d" % i)) self.filechooser = filechooser.filechooser(gtk, linuxcnc, filechooser_labels, filechooser_eventboxes, self.listing) relative = ['xr', 'yr', 'zr', 'ar', 'br', 'cr', 'ur', 'vr', 'wr'] absolute = ['xa', 'ya', 'za', 'aa', 'ba', 'ca', 'ua', 'va', 'wa'] distance = ['xd', 'yd', 'zd', 'ad', 'bd', 'cd', 'ud', 'vd', 'wd'] relative = [self.wTree.get_widget(i) for i in relative] absolute = [self.wTree.get_widget(i) for i in absolute] distance = [self.wTree.get_widget(i) for i in distance] estops = ['estop_reset', 'estop'] estops = dict((i, self.wTree.get_widget(i)) for i in estops) machines = ['on', 'off'] machines = dict((i, self.wTree.get_widget("machine_" + i)) for i in machines) floods = ['on', 'off'] floods = dict((i, self.wTree.get_widget("flood_" + i)) for i in floods) mists = ['on', 'off'] mists = dict((i, self.wTree.get_widget("mist_" + i)) for i in mists) spindles = ['forward', 'off', 'reverse'] spindles = dict((i, self.wTree.get_widget("spindle_" + i)) for i in spindles) stats = ['file', 'file_lines', 'line', 'id', 'dtg', 'velocity', 'delay', 'onlimit', 'spindledir', 'spindlespeed', 'loadedtool', 'preppedtool', 'xyrotation', 'tlo', 'activecodes', 'spindlespeed2', 'label_g5xoffset', 'g5xoffset', 'g92offset', 'tooltable'] stats = dict((i, self.wTree.get_widget("status_" + i)) for i in stats) prefs = ['actual', 'commanded', 'inch', 'mm'] prefs = dict((i, self.wTree.get_widget("dro_" + i)) for i in prefs) opstop = ['on', 'off'] opstop = dict((i, self.wTree.get_widget("opstop_" + i)) for i in opstop) blockdel = ['on', 'off'] blockdel = dict((i, self.wTree.get_widget("blockdel_" + i)) for i in blockdel) self.status = emc_interface.emc_status(gtk, linuxcnc, self.listing, relative, absolute, distance, self.wTree.get_widget("dro_table"), self.wTree.get_widget("error"), estops, machines, self.wTree.get_widget("override_limits"), stats, floods, mists, spindles, prefs, opstop, blockdel) self.current_file = self.status.emcstat.file # check the ini file if UNITS are set to mm" # first check the global settings units=self.ini.find("TRAJ","LINEAR_UNITS") if units==None: units=self.ini.find("AXIS_X","UNITS") if units=="mm" or units=="metric" or units == "1.0": self.machine_units_mm=1 conversion=[1.0/25.4]*3+[1]*3+[1.0/25.4]*3 else: self.machine_units_mm=0 conversion=[25.4]*3+[1]*3+[25.4]*3 self.status.set_machine_units(self.machine_units_mm,conversion) if self.prefs.getpref('toolsetting_fixture', 0): self.g10l11 = 1 else: self.g10l11 = 0 if self.prefs.getpref('dro_mm', 0): self.status.dro_mm(0) else: self.status.dro_inch(0) if self.prefs.getpref('dro_actual', 0): self.status.dro_actual(0) else: self.status.dro_commanded(0) if self.prefs.getpref('blockdel', 0): self.linuxcnc.blockdel_on(0) else: self.linuxcnc.blockdel_off(0) if self.prefs.getpref('opstop', 1): self.linuxcnc.opstop_on(0) else: self.linuxcnc.opstop_off(0) self.linuxcnc.emccommand.program_open(empty_program.name) self.linuxcnc.max_velocity(self.mv_val) gobject.timeout_add(50, self.periodic_status) gobject.timeout_add(100, self.periodic_radiobuttons) # event bindings dic = { "quit" : self.quit, "on_pointer_show_clicked" : self.pointer_show, "on_pointer_hide_clicked" : self.pointer_hide, "on_opstop_on_clicked" : self.opstop_on, "on_opstop_off_clicked" : self.opstop_off, "on_blockdel_on_clicked" : self.blockdel_on, "on_blockdel_off_clicked" : self.blockdel_off, "on_reload_tooltable_clicked" : self.linuxcnc.reload_tooltable, "on_notebook1_switch_page" : self.tabselect, "on_controlfontbutton_font_set" : self.change_control_font, "on_drofontbutton_font_set" : self.change_dro_font, "on_dro_actual_clicked" : self.dro_actual, "on_dro_commanded_clicked" : self.dro_commanded, "on_dro_inch_clicked" : self.dro_inch, "on_dro_mm_clicked" : self.dro_mm, "on_errorfontbutton_font_set" : self.change_error_font, "on_listingfontbutton_font_set" : self.change_listing_font, "on_estop_clicked" : self.linuxcnc.estop, "on_estop_reset_clicked" : self.linuxcnc.estop_reset, "on_machine_off_clicked" : self.linuxcnc.machine_off, "on_machine_on_clicked" : self.linuxcnc.machine_on, "on_mdi_clear_clicked" : self.mdi_control.clear, "on_mdi_back_clicked" : self.mdi_control.back, "on_mdi_next_clicked" : self.mdi_control.next, "on_mdi_decimal_clicked" : self.mdi_control.decimal, "on_mdi_minus_clicked" : self.mdi_control.minus, "on_mdi_keypad_clicked" : self.mdi_control.keypad, "on_mdi_g_clicked" : self.mdi_control.g, "on_mdi_gp_clicked" : self.mdi_control.gp, "on_mdi_m_clicked" : self.mdi_control.m, "on_mdi_t_clicked" : self.mdi_control.t, "on_mdi_select" : self.mdi_control.select, "on_mdi_set_tool_clicked" : self.mdi_set_tool, "on_mdi_set_origin_clicked" : self.mdi_set_origin, "on_mdi_macro_clicked" : self.mdi_macro, "on_filechooser_select" : self.fileselect, "on_filechooser_up_clicked" : self.filechooser.up, "on_filechooser_down_clicked" : self.filechooser.down, "on_filechooser_reload_clicked" : self.filechooser.reload, "on_listing_up_clicked" : self.listing.up, "on_listing_down_clicked" : self.listing.down, "on_listing_previous_clicked" : self.listing.previous, "on_listing_next_clicked" : self.listing.next, "on_mist_on_clicked" : self.linuxcnc.mist_on, "on_mist_off_clicked" : self.linuxcnc.mist_off, "on_flood_on_clicked" : self.linuxcnc.flood_on, "on_flood_off_clicked" : self.linuxcnc.flood_off, "on_home_all_clicked" : self.linuxcnc.home_all, "on_unhome_all_clicked" : self.linuxcnc.unhome_all, "on_home_selected_clicked" : self.home_selected, "on_unhome_selected_clicked" : self.unhome_selected, "on_fo_clicked" : self.fo, "on_so_clicked" : self.so, "on_mv_clicked" : self.mv, "on_jogging_clicked" : self.jogging, "on_scrolling_clicked" : self.scrolling, "on_wheelx_clicked" : self.wheelx, "on_wheely_clicked" : self.wheely, "on_wheelz_clicked" : self.wheelz, "on_wheela_clicked" : self.wheela, "on_wheelb_clicked" : self.wheelb, "on_wheelc_clicked" : self.wheelc, "on_wheelu_clicked" : self.wheelu, "on_wheelv_clicked" : self.wheelv, "on_wheelw_clicked" : self.wheelw, "on_wheelinc1_clicked" : self.wheelinc1, "on_wheelinc2_clicked" : self.wheelinc2, "on_wheelinc3_clicked" : self.wheelinc3, "on_override_limits_clicked" : self.linuxcnc.override_limits, "on_spindle_forward_clicked" : self.linuxcnc.spindle_forward, "on_spindle_off_clicked" : self.linuxcnc.spindle_off, "on_spindle_reverse_clicked" : self.linuxcnc.spindle_reverse, "on_spindle_slower_clicked" : self.linuxcnc.spindle_slower, "on_spindle_faster_clicked" : self.linuxcnc.spindle_faster, "on_toolset_fixture_clicked" : self.toolset_fixture, "on_toolset_workpiece_clicked" : self.toolset_workpiece, "on_changetheme_clicked" : self.change_theme, } self.wTree.signal_autoconnect(dic) for widget in self.wTree.get_widget_prefix(''): if isinstance(widget, gtk.Button): widget.connect_after('released',self.hack_leave) self._dynamic_childs = {} atexit.register(self.kill_dynamic_childs) self.set_dynamic_tabs() atexit.register(self.save_maxvel_pref) self.setfont()
def __init__(self, uid, panel_id): self.network_handler = self.NetworkHandler() self.tokens = classes.Tokens() self.favicons = classes.Tokens(cache_index) #AWN Applet Configuration awn.AppletSimple.__init__(self, 'feeds', uid, panel_id) self.set_tooltip_text(_("Loading feeds...")) self.dialog = awn.Dialog(self) self.main_vbox = gtk.VBox(False, False) self.dialog.add(self.main_vbox) self.main_vbox.show() #Need icon theme self.icon_theme = gtk.icon_theme_get_default() self.icon_theme.connect('changed', self.icon_theme_changed) #Get a 16x16 icon representing the Internet/web self.web_image = self.icon_theme.load_icon('applications-internet', 16, 0) #Force a size of 16x16 if self.web_image.get_width() != 16 or self.web_image.get_height() != 16: self.web_image = self.web_image.scale_simple(16, 16, gtk.gdk.INTERP_BILINEAR) #Throbber overlay self.throbber = awn.OverlayThrobber() self.throbber.props.gravity = gtk.gdk.GRAVITY_SOUTH_WEST #Error icon overlay self.error_icon = awn.OverlayThemedIcon("gtk-dialog-error") self.error_icon.props.gravity = gtk.gdk.GRAVITY_SOUTH_WEST #First updated feed favicon (bottom right) self.favicon1 = awn.OverlayPixbuf(self.web_image) self.favicon1.props.gravity = gtk.gdk.GRAVITY_SOUTH_EAST #Second updated feed favicon (bottom) self.favicon2 = awn.OverlayPixbuf(self.web_image) self.favicon2.props.gravity = gtk.gdk.GRAVITY_SOUTH #Third updated feed favicon (right) self.favicon3 = awn.OverlayPixbuf(self.web_image) self.favicon3.props.gravity = gtk.gdk.GRAVITY_EAST for overlay in (self.throbber, self.error_icon, self.favicon1, self.favicon2, self.favicon3): if self.get_size() > 48: overlay.props.scale = 16.0 / self.get_size() else: overlay.props.scale = 0.33 overlay.props.apply_effects = True overlay.props.active = False self.add_overlay(overlay) #Magic at work. Position the 2nd and 3rd favicons adjacent to the icon if self.get_size() > 48: self.favicon2.props.x_adj = 0.5 - 24.0 / self.get_size() self.favicon3.props.y_adj = 0.5 - 24.0 / self.get_size() else: self.favicon2.props.x_adj = 0.0 self.favicon3.props.y_adj = 0.0 #"Loading feeds..." label self.loading_feeds = gtk.Label(_("Loading feeds...")) self.loading_feeds.modify_font(pango.FontDescription('bold')) self.main_vbox.pack_start(self.loading_feeds, False, False, 3) self.loading_feeds.show() self.loading_feeds.set_no_show_all(True) #No feeds label self.no_feeds = gtk.Label(_("You don't have any feeds.")) self.main_vbox.pack_start(self.no_feeds) self.no_feeds.set_no_show_all(True) #AwnConfigClient instance self.client = awn.config_get_default_for_applet(self) #Connect to signals self.connect('button-press-event', self.button_press) self.dialog.props.hide_on_unfocus = True self.get_urls() #TODO: put this and the similar code in add_feed() into a single, better place for url in self.urls: _base_url = '-'.join(url.split('-')[:-1]) username = url.split('-')[-1] if _base_url == 'google-reader': self.feeds[url] = classes.GoogleReader(self, username) elif _base_url == 'google-wave': self.feeds[url] = classes.GoogleWave(self, username) elif _base_url == 'reddit': self.feeds[url] = classes.Reddit(self, username) elif _base_url in ('twitter-timeline', 'twitter-both', 'twitter-replies'): self.feeds[url] = classes.Twitter(self, username, None, base_url=_base_url) else: self.feeds[url] = classes.WebFeed(self, url) #Set the icon only_greader = bool(len(self.urls)) for feed in self.feeds.values(): if not isinstance(feed, classes.GoogleReader): only_greader = False break self.set_icon_name(['awn-feeds', 'awn-feeds-greader'][only_greader]) self.setup_dialog() #Allow user to drag and drop feed URLs onto the applet icon #E.g. In a browser, user drags and drops a link to an Atom feed onto the applet self.get_icon().drag_dest_set(gtk.DEST_DEFAULT_DROP | gtk.DEST_DEFAULT_MOTION, \ [("STRING", 0, 0), ("text/plain", 0, 0), ("text/uri-list", 0, 0)], \ gtk.gdk.ACTION_COPY) self.get_icon().connect('drag_data_received', self.applet_drag_data_received) self.get_icon().connect('drag-motion', self.applet_drag_motion) self.get_icon().connect('drag-leave', self.applet_drag_leave) self.dialog.connect('scroll-event', self.scroll) self.connect('size-changed', self.size_changed) #Set up the D-Bus service self.service = classes.DBusService(self) self.update_feeds()
def set_font(self, font_name): font = pango.FontDescription(font_name) self.day_text_view.modify_font(font)
def __init__(self, application, parent): self._application = application self._parent = parent self._radius = 3 self._control_count = 0 self._state = gtk.STATE_NORMAL self._mode = Mode.NORMAL self._menu = None self._style = None self._toolbar_style = None self._box_spacing = 1 self._box_border_width = 4 self._super_user_colors = None self._breadcrumbs = None # get options options = self._application.options self._ubuntu_coloring = options.get('ubuntu_coloring') self._superuser_notification = options.get('superuser_notification') self._button_relief = options.get('button_relief') # determine whether we need to show breadcrumbs from plugin_base.item_list import ItemList section = options.section('item_list') is_list = isinstance(parent, ItemList) self._breadcrumb_type = section.get('breadcrumbs') self._show_breadcrumbs = self._breadcrumb_type != Breadcrumbs.TYPE_NONE and is_list # create container box self._hbox = gtk.HBox(homogeneous=False, spacing=self._box_spacing) # configure title bar self._hbox.set_border_width(self._box_border_width) self._container = gtk.EventBox() self._container.set_app_paintable(True) self._container.add_events(gtk.gdk.BUTTON_RELEASE_MASK) # connect signals self._container.connect('realize', self.__realize_event) self._container.connect('button-release-event', self.__button_release_event) self._hbox.connect('expose-event', self.__expose_event) # top folder icon as default self._icon = gtk.Image() # create plugin main menu button style = gtk.RcStyle() style.xthickness = 0 style.ythickness = 0 self._button_menu = gtk.Button() self._button_menu.add(self._icon) if not self._button_relief: self._button_menu.set_relief(gtk.RELIEF_NONE) self._button_menu.modify_style(style) self._button_menu.set_focus_on_click(False) self._button_menu.set_tooltip_text(_('Context menu')) self._button_menu.connect('clicked', self.show_menu) # create title box vbox = gtk.VBox(False, 1) if self._show_breadcrumbs: self._breadcrumbs = Breadcrumbs(self) vbox.pack_start(self._breadcrumbs, True, True, 0) else: self._title_label = gtk.Label() self._title_label.set_alignment(0, 0.5) self._title_label.set_use_markup(True) self._title_label.set_ellipsize(pango.ELLIPSIZE_MIDDLE) vbox.pack_start(self._title_label, True, True, 0) font = pango.FontDescription('8') self._subtitle_label = gtk.Label() self._subtitle_label.set_alignment(0, 0.5) self._subtitle_label.set_use_markup(False) self._subtitle_label.modify_font(font) # create spinner control if it exists self._spinner_counter = 0 if hasattr(gtk, 'Spinner'): self._spinner = gtk.Spinner() self._spinner.set_size_request(20, 20) self._spinner.set_property('no-show-all', True) else: self._spinner = None # pack interface vbox.pack_start(self._subtitle_label, False, False, 0) self._hbox.pack_start(self._button_menu, False, False, 0) self._hbox.pack_start(vbox, True, True, 4) if self._spinner is not None: self._hbox.pack_start(self._spinner, False, False, 5) self._container.add(self._hbox)
def __init__(self, glade_file=None, dialog_name='dialog', num_entry_name='num_entry', coord_buttons_name='coords', use_coord_buttons=True, theme_name=None): if (glade_file is None): glade_file = os.path.join(g_ui_dir, 'popupkeyboard.ui') fontname = 'sans 12 bold' self.use_coord_buttons = use_coord_buttons try: import gtk.glade except ImportError as detail: print('ImportError:', detail) except Exception as msg: print('Exception:', Exception) print(sys.exc_info()) sys.exit(1) self.builder = gtk.Builder() self.builder.add_from_file(glade_file) self.builder.connect_signals(self) self.dialog = self.builder.get_object(dialog_name) self.set_theme(theme_name) self.num_entry = self.builder.get_object(num_entry_name) try: self.coord_buttons = self.builder.get_object(coord_buttons_name) except: self.coord_buttons = None self.result = None self.location = None self.top = self.dialog.get_toplevel() self.top.set_title(glade_file) self.top.set_keep_above(True) if (not self.use_coord_buttons): if self.coord_buttons: self.coord_buttons.hide() # prevent closing of dialog by window manager, escape key , etc # http://faq.pygtk.org/index.py?file=faq10.013.htp&req=show self.top.connect("response", self.on_response) #reqd self.top.connect("delete-event", self.on_delete) #reqd self.top.connect("close", self.on_close) #probably not reqd # find buttons with labels XYZABCUVW or D # and show iff corresponding axis is in axis_mask self.label_to_btn = {} for btn in self.builder.get_objects(): if type(btn) is not gtk.Button: continue self.label_to_btn[btn.get_label().upper()] = btn if isinstance(btn.child, gtk.Label): lbl = btn.child lbl.modify_font(pango.FontDescription(fontname)) if use_coord_buttons: self.support_coord_buttons() # making it insensitive clears the initial selection region self.num_entry.set_state(gtk.STATE_INSENSITIVE) self.num_entry.modify_text(gtk.STATE_INSENSITIVE, gtk.gdk.color_parse('black')) self.num_entry.modify_font(pango.FontDescription(fontname))
def show_error_window(error_string, add_apport_button=False): """Displays an error dialog, and returns the response ID. error_string -- the error's output (usually a traceback) add_apport_button -- whether to add a 'report with apport' button Returns the response ID of the dialog, 1 for ignore, 2 for close and 3 for apport. """ # initialize dialog title = _("An error has occurred") global APP_NAME if APP_NAME: title = APP_NAME global dialog # Do not allow more than one error window if dialog is not None: return 1 dialog = gtk.Dialog(title) # title Label label = gtk.Label() label.set_markup("<b>%s</b>" % _("It looks like an error has occurred.")) label.set_alignment(0, 0.5) dialog.get_content_area().pack_start(label, False) # message Label global MESSAGE text_label = gtk.Label() text_label.set_markup(MESSAGE) text_label.set_alignment(0, 0.5) text_label.set_line_wrap(True) def text_label_size_allocate(widget, rect): """Lets label resize correctly while wrapping text.""" widget.set_size_request(rect.width, -1) text_label.connect("size-allocate", text_label_size_allocate) if not MESSAGE == "": dialog.get_content_area().pack_start(text_label, False) # TextView with error_string buffer = gtk.TextBuffer() buffer.set_text(error_string) textview = gtk.TextView() textview.set_buffer(buffer) textview.set_editable(False) try: textview.modify_font(pango.FontDescription("monospace 8")) except Exception: print >> sys.stderr, "gtkcrashhandler: modify_font raised an exception" # allow scrolling of textview scrolled = gtk.ScrolledWindow() scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) scrolled.add_with_viewport(textview) # hide the textview in an Expander widget expander = gtk.expander_new_with_mnemonic(_("_Details")) expander.add(scrolled) expander.connect('activate', on_expanded) dialog.get_content_area().pack_start(expander, True) # add buttons if add_apport_button: dialog.add_button(_("_Report this problem..."), 3) # If we're have multiple threads, or if we're in a GTK callback, # execution can continue normally in other threads, so add button if gtk.main_level() > 0 or threading.activeCount() > 1: dialog.add_button(_("_Ignore the error"), 1) dialog.add_button(("_Close the program"), 2) dialog.set_default_response(2) # set dialog aesthetic preferences dialog.set_border_width(12) dialog.get_content_area().set_spacing(4) dialog.set_resizable(False) # show the dialog and act on it dialog.show_all() res = dialog.run() dialog.destroy() if res < 0: res = 2 return res
def on_btn_font(widget, data=None): self.options.font_desc = widget.get_font_name() self.font = pango.FontDescription(self.options.font_desc) self.update_label()
def render(self): # create a pixmap self.colormap = gtk.gdk.colormap_get_system() self.pixmap = gtk.gdk.Pixmap(None, self.width, self.height, self.bpp) pangoc = self.widget.get_pango_context() # create a graphics context wgc = gtk.gdk.Drawable.new_gc( self.pixmap, self.colormap.alloc_color(gtk.gdk.Color(65535, 65535, 65535))) rgc = gtk.gdk.Drawable.new_gc( self.pixmap, self.colormap.alloc_color(gtk.gdk.Color(65535, 0, 0))) bgc = gtk.gdk.Drawable.new_gc( self.pixmap, self.colormap.alloc_color(gtk.gdk.Color(0, 0, 0))) ggc = gtk.gdk.Drawable.new_gc( self.pixmap, self.colormap.alloc_color(gtk.gdk.Color(0, 65535, 0))) lgc = gtk.gdk.Drawable.new_gc( self.pixmap, self.colormap.alloc_color(gtk.gdk.Color(0, 0, 65535))) ygc = gtk.gdk.Drawable.new_gc( self.pixmap, self.colormap.alloc_color(gtk.gdk.Color(65535, 65535, 0))) # white background self.pixmap.draw_rectangle(wgc, True, 0, 0, self.width, self.height) # font setup font = pango.FontDescription("normal 20") pgl = pango.Layout(pangoc) pgl.set_font_description(font) pgl.set_alignment(pango.ALIGN_CENTER) # test calibration x = 20 y = 300 imrgb = Image.open('gears.png') self.pixmap.draw_rgb_image(bgc, x, y, imrgb.size[0], imrgb.size[1], gtk.gdk.RGB_DITHER_NONE, imrgb.tostring()) self.test_calibration_box = [x, y, imrgb.size[0], imrgb.size[1]] # test display x = 20 y = 20 imrgb = Image.open('screen.png') self.pixmap.draw_rgb_image(bgc, x, y, imrgb.size[0], imrgb.size[1], gtk.gdk.RGB_DITHER_NONE, imrgb.tostring()) self.test_display_box = [x, y, imrgb.size[0], imrgb.size[1]] # cancel x = self.width - 100 y = 300 imrgb = Image.open('cancel.png') self.pixmap.draw_rgb_image(bgc, x, y, imrgb.size[0], imrgb.size[1], gtk.gdk.RGB_DITHER_NONE, imrgb.tostring()) self.cancel_box = [x, y, imrgb.size[0], imrgb.size[1]] # calibration instruction if self.calibration_step == 0: imrgb = Image.open('start-calibration.png') if self.calibration_step == 1: imrgb = Image.open('rotate-in-place.png') if self.calibration_step == 2: imrgb = Image.open('walk-upstairs.png') if self.calibration_step == 3: imrgb = Image.open('walk-downstairs.png') if self.calibration_step == 4: imrgb = Image.open('calibration-done.png') x = self.width / 2 - imrgb.size[0] / 2 y = 20 self.pixmap.draw_rgb_image(bgc, x, y, imrgb.size[0], imrgb.size[1], gtk.gdk.RGB_DITHER_NONE, imrgb.tostring()) self.main_box = [x, y, imrgb.size[0], imrgb.size[1]] # set widget from pixbuf if self.widget: self.widget.set_from_pixmap(self.pixmap, None)
# # Print the topology graphic. The graphic is already made with Cairo so the # same code can be used to draw on the print context. # # Print in color with highlighting, like NmapOutputViewer. # # Add a header to each page with the Nmap command and page number. # # Add options to the print dialog to control the font, coloring, and anything # else. This might go in a separate Print Setup dialog. import gtk import gobject import pango MONOSPACE_FONT_DESC = pango.FontDescription("Monospace 12") class PrintState(object): """This is the userdatum passed to gtk.PrintOperation callbacks.""" def __init__(self, inventory, entry): """entry is a ScansListStoreEntry.""" if entry.parsed: # Finished scan. output = entry.parsed.nmap_output else: # Still running, failed, or cancelled. output = entry.command.get_output() if not output: output = u"\n" self.lines = output.splitlines()
def render_table_row(self, tbl, row_index): XPADDING = 8 YPADDING = 15 # using "yoptions=gtk.SHRINK" in table.attach seems to do the trick # in not having the table cells expand vertically like nuts # Print source file diffs sd = self.start_timestamp.strftime('%Y-%m-%d') ed = self.end_timestamp.strftime('%Y-%m-%d') st = self.start_timestamp.strftime('%H:%M:%S') et = self.end_timestamp.strftime('%H:%M:%S') # If the days are the same, then don't duplicate: if sd == ed: date_str = '%s to %s (%s)' % (st, et, sd) else: date_str = '%s %s to %s %s' % (sd, st, ed, et) date_lab = gtk.Label(date_str) date_lab.modify_font(pango.FontDescription("sans 8")) date_lab_lalign = create_alignment(date_lab, pbottom=3) diff_result_str = self.diff() # TODO: adjust height based on existing height of row/column text_widget = create_simple_text_view_widget( diff_result_str, 450, 200) source_file_vbox = create_vbox([date_lab_lalign, text_widget]) tbl.attach(source_file_vbox, 0, 1, row_index, row_index + 1, xpadding=XPADDING + 5, ypadding=YPADDING, yoptions=gtk.SHRINK) # Print co-reads: # 1.) webpages visited # 2.) other vim files read # 3.) other non-vim files read co_read_widgets = [] # TODO: make these labels clickable with pop-up context menus for (fn, timestamp) in self.other_vim_files_read.items() + \ self.non_vim_files_read.items(): lab = gtk.Label(prettify_filename(fn)) lab.modify_font(pango.FontDescription("monospace 9")) lab.set_selectable(True) lab.show() lab_lalign = create_alignment(lab, pbottom=3) lab_lalign.show() co_read_widgets.append(lab_lalign) # de-dup: urls_seen = set() if self.webpages_visited: n = WebpageFeedEvent() for w in self.webpages_visited: if w.url not in urls_seen: urls_seen.add(w.url) n.add_webpage_chron_order(w) n_lalign = create_alignment(n.get_widget(), ptop=3) co_read_widgets.append(n_lalign) co_reads_vbox = create_vbox(co_read_widgets) co_reads_vbox_lalign = create_alignment(co_reads_vbox) tbl.attach(co_reads_vbox_lalign, 1, 2, row_index, row_index + 1, xpadding=XPADDING, ypadding=YPADDING, xoptions=gtk.SHRINK, yoptions=gtk.SHRINK) # Print co-writes # 1.) other vim files edited # 2.) doodle events # 3.) happy face events # 4.) sad face events # 5.) status update events co_write_widgets = [] for (fn, timestamp) in self.other_vim_files_edited.iteritems(): lab = gtk.Label(prettify_filename(fn)) lab.modify_font(pango.FontDescription("monospace 9")) lab.set_selectable(True) lab.show() lab_lalign = create_alignment(lab) lab_lalign.show() co_write_widgets.append(lab_lalign) all_feed_evts = [] for e in self.doodle_save_events: d = DoodleFeedEvent(e, self.fvm) d.load_thumbnail() # subtle but dumb!!! all_feed_evts.append(d) for e in self.happy_face_events: all_feed_evts.append(HappyFaceFeedEvent(e)) for e in self.sad_face_events: all_feed_evts.append(SadFaceFeedEvent(e)) for e in self.status_update_events: all_feed_evts.append(StatusUpdateFeedEvent(e)) for e in all_feed_evts: co_write_widgets.append(e.get_widget()) co_writes_vbox = create_vbox(co_write_widgets, [4 for e in co_write_widgets]) co_writes_vbox_lalign = create_alignment(co_writes_vbox) tbl.attach(co_writes_vbox_lalign, 2, 3, row_index, row_index + 1, xpadding=XPADDING, ypadding=YPADDING, xoptions=gtk.SHRINK, yoptions=gtk.SHRINK) # Print notes (annotations) # stick the annotation on the FINAL FileWriteEvent in this faux version: annotator = AnnotationComponent(300, self.get_last_write_event(), '<Click to enter a new note>') tbl.attach(annotator.get_widget(), 3, 4, row_index, row_index + 1, xpadding=XPADDING, ypadding=YPADDING, yoptions=gtk.SHRINK) show_all_local_widgets(locals())
def set_font(self, font): ''' Set the font for a label ''' self._fd = pango.FontDescription(font)
def __init__(self, target_filename, session_tag, fvm): self.fvm = fvm self.session_tag = session_tag self.target_filename = target_filename # MongoDB stuff c = Connection() self.db = c.burrito_db all_events = [] # Get GUI events for m in self.db.gui_trace.find({"session_tag": session_tag}): web_visit_evt = fetch_webpage_visit_event(m) if web_visit_evt: all_events.append(web_visit_evt) else: gui_evt = fetch_active_gui_window_event(m) if gui_evt: all_events.append(gui_evt) # Get file read/write events # Key: child PID # Value: parent PID # # TODO: assumes that there is no recycling of PIDs, which should be an # okay assumption if we're operating within one session but needs to be # revised when we're querying over multiple sessions pid_parents = {} # Key: PID # Value: process creation/exit time pid_creation_times = {} pid_exit_times = {} def get_pid_and_parents(pid): ret = [pid] try: parent = pid_parents[pid] while True: ret.append(parent) parent = pid_parents[parent] except KeyError: return ret for m in self.db.process_trace.find({"session_tag": session_tag}, { 'pid': 1, 'ppid': 1, 'uid': 1, 'phases': 1, 'creation_time': 1, 'exit_time': 1 }): pid_creation_times[m['pid']] = m['creation_time'] pid_exit_times[m['pid']] = m['exit_time'] pid_parents[m['pid']] = m['ppid'] prov_evts = fetch_file_prov_event_lst(m, session_tag) all_events.extend(prov_evts) # Get VIM edit events for m in self.db.apps.vim.find({"session_tag": session_tag}): vim_evt = fetch_active_vim_buffer_event(m) if vim_evt: all_events.append(vim_evt) # Get HappyFaceEvent, SadFaceEvent, and StatusUpdateEvent events all_events.extend(fetch_toplevel_annotation_events(session_tag)) # Key: PID # Value: set of files read by this process or by one of its children pid_to_read_files = defaultdict(set) # Key: PID # Value: VimFileEditSession # (each VimFileEditSession has a list of faux_versions) self.vim_sessions = {} # les means "latest edit session": # we are associating all events with the most recently-active vim session # (which is a reasonable simplifying assumption) les = None # massive chronological sort! all_events.sort(key=lambda e: e.timestamp) for (ind, e) in enumerate(all_events): if e.__class__ == FileReadEvent: # We want to associate GUI windows with files read by the application # that controls each window. For example, we want to associate an # ActiveGUIWindowEvent for the OpenOffice Calc app with some *.xls # spreadsheet file that the app is currently editing. # # incrementally build up this set in chronological order, # # and for simplicity, just have a whitelist of document extensions # that we're looking for: if document_extension_whitelisted(e.filename): for p in get_pid_and_parents(e.pid): pid_to_read_files[p].add(e.filename) if les: les.add_file_read_event(e) elif e.__class__ == FileWriteEvent: if les: les.add_file_save_event(e) elif e.__class__ == WebpageVisitEvent: if les: les.add_webpage_visit_event(e) elif e.__class__ == ActiveGUIWindowEvent: # Now associate each ActiveGUIWindowEvent with the ActiveVimBufferEvent # directly preceeding it if ... # ActiveVimBufferEvent.pid is a parent of ActiveVimBufferEvent.pid # # This forms a bond between an ActiveGUIWindowEvent and VIM by adding # a vim_event field to ActiveGUIWindowEvent # # go backwards ... for vim_event in reversed(all_events[:ind]): if vim_event.__class__ == ActiveVimBufferEvent: # the vim process will probably be a child of 'bash', which is # itself a child of 'gnome-terminal' (or whatever terminal app # controls the GUI window), so we need to match on parent # processes all the way up the chain candidate_pids = get_pid_and_parents(vim_event.pid) if e.active_app_pid in candidate_pids: e.vim_event = vim_event # establish a link break if not hasattr(e, 'vim_event'): # if this process of any of its children have read files, then add # the set of files as a new field called files_read_set if e.active_app_pid in pid_to_read_files: e.files_read_set = pid_to_read_files[e.active_app_pid] if les: les.add_other_gui_event(e) elif e.__class__ == ActiveVimBufferEvent: if e.pid not in self.vim_sessions: n = VimFileEditSession(self.target_filename, e.pid, pid_creation_times[e.pid], pid_exit_times[e.pid], self.fvm) self.vim_sessions[e.pid] = n les = self.vim_sessions[e.pid] # unconditionally add! les.add_vim_buffer_event(e) elif e.__class__ == DoodleSaveEvent: if les: les.add_doodle_save_event(e) elif e.__class__ == HappyFaceEvent: if les: les.add_happy_face_event(e) elif e.__class__ == SadFaceEvent: if les: les.add_sad_face_event(e) elif e.__class__ == StatusUpdateEvent: if les: les.add_status_update_event(e) else: assert False, e # SUPER important to finalize! for e in self.vim_sessions.values(): e.finalize() self.all_faux_versions = [] for e in self.vim_sessions.values(): self.all_faux_versions.extend(e.faux_versions) # reverse chronological order self.all_faux_versions.sort(key=lambda e: e.timestamp, reverse=True) ''' for e in sorted(self.vim_sessions.values(), key=lambda e:e.vim_start_time): e.printraw() print '---' for fv in e.faux_versions: fv.printme() print ''' # ok, now time for the GUI part! self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) self.window.set_title("Source file provenance viewer") self.window.set_border_width(0) set_white_background(self.window) self.window.resize(500, 500) self.window.maximize() tbl = gtk.Table(rows=len(self.all_faux_versions) + 1, columns=4) tbl_scroller = gtk.ScrolledWindow() tbl_scroller.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) tbl_scroller.add_with_viewport(tbl) set_white_background(tbl_scroller.get_children()[0]) self.window.add(tbl_scroller) # header row col1_label = gtk.Label(prettify_filename(self.target_filename)) col1_label.modify_font(pango.FontDescription("sans 12")) col2_label = gtk.Label("Co-reads") col2_label.modify_font(pango.FontDescription("sans 12")) col3_label = gtk.Label("Co-writes") col3_label.modify_font(pango.FontDescription("sans 12")) col4_label = gtk.Label("Notes") col4_label_lalign = create_alignment(col4_label, pleft=15) col4_label.modify_font(pango.FontDescription("sans 12")) tbl.attach(col1_label, 0, 1, 0, 1, ypadding=8) tbl.attach(col2_label, 1, 2, 0, 1, ypadding=8) tbl.attach(col3_label, 2, 3, 0, 1, ypadding=8) tbl.attach(col4_label_lalign, 3, 4, 0, 1, ypadding=8) # show the window and all widgets first!!! show_all_local_widgets(locals()) self.window.show() row_index = 1 for fv in self.all_faux_versions: # ... then use this trick to update the GUI between each loop # iteration, since each iteration takes a second or two # (this will make the GUI seem more responsive, heh) # # http://faq.pygtk.org/index.py?req=show&file=faq03.007.htp while gtk.events_pending(): gtk.main_iteration(False) print >> sys.stderr, "SourceFileProvViewer rendering row", \ row_index, "of", len(self.all_faux_versions) fv.render_table_row(tbl, row_index) row_index += 1
import locale import pango import random pygtk.require('2.0') FACE_DOWN = 'art_assets/black_joker.png' SEA_GREEN = gtk.gdk.Color(0.18, 0.55, 0.34) DARK_SLATE_BLUE = gtk.gdk.Color(0.28, 0.24, 0.55) GHOST_WHITE = gtk.gdk.Color(0.97, 0.97, 1.0) FIREBRICK = gtk.gdk.Color(0.7, 0.13, 0.13) PERU = gtk.gdk.Color(0.8, 0.52, 0.25) ROYAL_BLUE = gtk.gdk.Color(0.25, 0.41, 0.88) FOREST_GREEN = gtk.gdk.Color(0.13, 0.55, 0.13) SALOON_BROWN = gtk.gdk.Color(0.28, 0.14, 0.04) DARK_SLATE_GRAY = gtk.gdk.Color(0.18, 0.31, 0.31) BIG_FONT = pango.FontDescription('Monospace 14') DEFAULT_FONT = pango.FontDescription('Monospace 10') RankStrings = { 0: '2', 1: '3', 2: '4', 3: '5', 4: '6', 5: '7', 6: '8', 7: '9', 8: '10', 9: 'jack', 10: 'queen', 11: 'king', 12: 'ace'
def codebox_insert(self, iter_insert, codebox_dict, codebox_justification=None, text_buffer=None, cursor_pos=0): """Insert Code Box""" if not text_buffer: text_buffer = self.dad.curr_buffer anchor = text_buffer.create_child_anchor(iter_insert) self.curr_codebox_anchor = anchor anchor.frame_width = codebox_dict['frame_width'] anchor.frame_height = codebox_dict['frame_height'] anchor.width_in_pixels = codebox_dict['width_in_pixels'] anchor.syntax_highlighting = codebox_dict['syntax_highlighting'] anchor.highlight_brackets = codebox_dict['highlight_brackets'] anchor.show_line_numbers = codebox_dict['show_line_numbers'] anchor.sourcebuffer = gtksourceview2.Buffer() anchor.sourcebuffer.set_style_scheme( self.dad.sourcestyleschememanager.get_scheme( self.dad.style_scheme)) if anchor.syntax_highlighting != cons.PLAIN_TEXT_ID: self.dad.set_sourcebuffer_syntax_highlight( anchor.sourcebuffer, anchor.syntax_highlighting) anchor.sourcebuffer.set_highlight_matching_brackets( anchor.highlight_brackets) anchor.sourcebuffer.connect('insert-text', self.dad.on_text_insertion) anchor.sourcebuffer.connect('delete-range', self.dad.on_text_removal) anchor.sourcebuffer.connect('modified-changed', self.dad.on_modified_changed) if codebox_dict['fill_text']: anchor.sourcebuffer.set_text(codebox_dict['fill_text']) anchor.sourcebuffer.place_cursor( anchor.sourcebuffer.get_iter_at_offset(cursor_pos)) anchor.sourcebuffer.set_modified(False) anchor.sourceview = gtksourceview2.View(anchor.sourcebuffer) anchor.sourceview.set_smart_home_end( gtksourceview2.SMART_HOME_END_AFTER) anchor.sourceview.set_highlight_current_line( self.dad.pt_highl_curr_line) if self.dad.pt_show_white_spaces: anchor.sourceview.set_draw_spaces(DRAW_SPACES_FLAGS) if anchor.syntax_highlighting == cons.PLAIN_TEXT_ID: anchor.sourceview.modify_font( pango.FontDescription(self.dad.pt_font)) else: anchor.sourceview.modify_font( pango.FontDescription(self.dad.code_font)) anchor.sourceview.set_show_line_numbers(anchor.show_line_numbers) anchor.sourceview.set_insert_spaces_instead_of_tabs( self.dad.spaces_instead_tabs) anchor.sourceview.set_tab_width(self.dad.tabs_width) anchor.sourceview.connect('populate-popup', self.on_sourceview_populate_popup_codebox, anchor) anchor.sourceview.connect('key_press_event', self.on_key_press_sourceview_codebox, anchor) anchor.sourceview.connect('key_release_event', self.on_key_release_sourceview_codebox, anchor) anchor.sourceview.connect('button-press-event', self.on_mouse_button_clicked_codebox, anchor) anchor.sourceview.connect("event-after", self.on_sourceview_event_after_codebox, anchor) anchor.sourceview.connect( "motion-notify-event", self.on_sourceview_motion_notify_event_codebox) anchor.sourceview.connect("copy-clipboard", self.dad.clipboard_handler.copy, True) anchor.sourceview.connect("cut-clipboard", self.dad.clipboard_handler.cut, True) if self.dad.line_wrapping: anchor.sourceview.set_wrap_mode(gtk.WRAP_WORD) else: anchor.sourceview.set_wrap_mode(gtk.WRAP_NONE) anchor.scrolledwindow = gtk.ScrolledWindow() anchor.scrolledwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) anchor.scrolledwindow.add(anchor.sourceview) anchor.scrolledwindow.get_vscrollbar().connect( 'event-after', self.on_vscrollbar_event_after, anchor) anchor.scrolledwindow.get_hscrollbar().connect( 'event-after', self.on_hscrollbar_event_after, anchor) anchor.frame = gtk.Frame() self.codebox_apply_width_height(anchor) anchor.frame.add(anchor.scrolledwindow) anchor.frame.set_shadow_type(gtk.SHADOW_NONE) anchor.eventbox = gtk.EventBox() anchor.eventbox.add(anchor.frame) self.dad.sourceview.add_child_at_anchor(anchor.eventbox, anchor) anchor.eventbox.show_all() self.dad.widget_set_colors(anchor.sourceview, self.dad.rt_def_fg, self.dad.rt_def_bg, True) for win in [ gtk.TEXT_WINDOW_LEFT, gtk.TEXT_WINDOW_RIGHT, gtk.TEXT_WINDOW_TOP, gtk.TEXT_WINDOW_BOTTOM ]: anchor.sourceview.set_border_window_size(win, 1) if codebox_justification: text_iter = text_buffer.get_iter_at_child_anchor(anchor) self.dad.state_machine.apply_object_justification( text_iter, codebox_justification, text_buffer) elif self.dad.user_active: # if I apply a justification, the state is already updated self.dad.state_machine.update_state()
def __init__(self, handle): super(Sindiente, self).__init__(handle) #ventana self.nivel = None self.set_title(_('Sin Dientes')) self.carpeta_imagen = 'resources/personaje_' self.sugar_data = self.get_activity_root() + '/data/' self.connect('key-press-event', self._key_press_cb) #Barra de herramientas sugar toolbox = widgets.ActivityToolbox(self) self.set_toolbar_box(toolbox) toolbox.show() #general self.comprobar_interfaz = False self.modificar_text = pango.FontDescription("Bold 10") self._archivo_sugar() #contenedores self.contenedor = gtk.VBox() self.contenedor_superior = gtk.HBox() self.contenedor_inferior= gtk.HBox() self.contenedor.pack_start(self.contenedor_superior) self.contenedor.pack_start(self.contenedor_inferior, expand=False) self.subcontenedor= gtk.VBox() self.contenedor_nivel = gtk.VBox() self.contenedor_nivel_1 = gtk.VBox() self.contenedor_nivel_2 = gtk.VBox() self.contenedor_instruc = gtk.VBox() self.contenedor_instruc_1 = gtk.HBox() self.contenedor_instruc_2 = gtk.HBox() self.contenedor_instruc_3 = gtk.HBox() self.contenedor_instruc_4 = gtk.HBox() self.contenedor_np_v = gtk.VBox() self.contenedor_np_1 = gtk.HBox() self.contenedor_np_2 = gtk.HBox() #Elegir personaje self.elegir_personaje_v = gtk.VBox() self.elegir_personaje_1 = gtk.HBox() self.elegir_personaje_2 = gtk.HBox() self.boton_personaje_1 = gtk.HBox() self.boton_personaje_2 = gtk.HBox() self.text_boton_nino = _('Elegir') self.btn_nino_1 = gtk.Button(self.text_boton_nino) self.btn_nino_2 = gtk.Button(self.text_boton_nino) self.btn_nino_3 = gtk.Button(self.text_boton_nino) self.btn_nina_1 = gtk.Button(self.text_boton_nino) self.btn_nina_2 = gtk.Button(self.text_boton_nino) self.btn_nina_3 = gtk.Button(self.text_boton_nino) self.btn_nino_1.connect('clicked', self._btn_nino_1_cb) self.btn_nino_2.connect('clicked', self._btn_nino_2_cb) self.btn_nino_3.connect('clicked', self._btn_nino_3_cb) self.btn_nina_1.connect('clicked', self._btn_nina_1_cb) self.btn_nina_2.connect('clicked', self._btn_nina_2_cb) self.btn_nina_3.connect('clicked', self._btn_nina_3_cb) #niños self.personaje_label = gtk.Label(_("Elige un personaje")) self.personaje_label.modify_font(self.modificar_text) self.nino_1 = gtk.Image() self.nino_1.set_from_file('resources/personaje_1/00.png') self.nino_2 = gtk.Image() self.nino_2.set_from_file('resources/personaje_2/00.png') self.nino_3 = gtk.Image() self.nino_3.set_from_file('resources/personaje_3/00.png') self.nina_1 = gtk.Image() self.nina_1.set_from_file('resources/personaje_4/00.png') self.nina_2 = gtk.Image() self.nina_2.set_from_file('resources/personaje_5/00.png') self.nina_3 = gtk.Image() self.nina_3.set_from_file('resources/personaje_6/00.png') self.boton_personaje_1.pack_start(self.btn_nino_1, True, False) self.boton_personaje_1.pack_start(self.btn_nino_2, True, False) self.boton_personaje_1.pack_start(self.btn_nino_3, True, False) self.boton_personaje_2.pack_start(self.btn_nina_1, True, False) self.boton_personaje_2.pack_start(self.btn_nina_2, True, False) self.boton_personaje_2.pack_start(self.btn_nina_3, True, False) self.elegir_personaje_1.pack_start(self.nino_1) self.elegir_personaje_1.pack_start(self.nino_2) self.elegir_personaje_1.pack_start(self.nino_3) self.elegir_personaje_2.pack_start(self.nina_1) self.elegir_personaje_2.pack_start(self.nina_2) self.elegir_personaje_2.pack_start(self.nina_3) self.elegir_personaje_v.pack_start(self.personaje_label) self.elegir_personaje_v.pack_start(self.elegir_personaje_1) self.elegir_personaje_v.pack_start(self.boton_personaje_1, False) self.elegir_personaje_v.pack_start(self.elegir_personaje_2) self.elegir_personaje_v.pack_start(self.boton_personaje_2, False) self.elegir_personaje_v.show_all() self.set_canvas(self.elegir_personaje_v) #interface menu self.imagen_menu = gtk.Image() self.nivel_1 = gtk.Button(_('Animales')) self.nivel_1.connect('clicked', self._nivel_uno_cb, None) self.nivel_2 = gtk.Button(_('Plantas')) self.nivel_2.connect('clicked', self._nivel_dos_cb, None) self.nivel_3 = gtk.Button(_('Países')) self.nivel_3.connect('clicked', self._nivel_tres_cb, None) self.nivel_4 = gtk.Button(_('Sustantivos')) self.nivel_4.connect('clicked', self._nivel_cuatro_cb, None) self.nivel_5 = gtk.Button(_('Verbos')) self.nivel_5.connect('clicked', self._nivel_cinco_cb, None) self.nivel_6 = gtk.Button(_('Cosas')) self.nivel_6.connect('clicked', self._nivel_seis_cb, None) self.nivel_7 = gtk.Button(_('Valores Morales')) self.nivel_7.connect('clicked', self._nivel_siete_cb, None) self.importar_btn = gtk.Button(_('Agregar lista de palabra')) self.importar_btn.connect('clicked', self._importar_cb, None) self.instrucciones = gtk.Button(_('Instrucciones de juego')) self.instrucciones.connect('clicked', self._instrucciones_cb, None) self.nuevapalabra_btn = gtk.Button(_('Modo Versus')) self.nuevapalabra_btn.connect('clicked', self._nuevapalabra_cb, None) self.cambiar_personaje_btn = gtk.Button(_('Cambiar personaje')) self.cambiar_personaje_btn.connect('clicked', self._cambiar_personaje_cb) self.categoria_libre = gtk.Button(_('Categoría Personalizada')) self.categoria_libre.connect('clicked', self._categoria_personalizada_cb) self.bienvenida = gtk.Label(_('Bienvenido a \"Sin Diente\"')) self.bienvenida.modify_font(self.modificar_text) #agregando elementos de menú self.contenedor_nivel_h = gtk.HBox() self.contenedor_nivel.pack_start(self.bienvenida, False, padding = 15) self.contenedor_nivel.pack_start(self.imagen_menu, False, padding = 15) self.contenedor_nivel.pack_start(self.contenedor_nivel_h) self.contenedor_nivel_h.pack_start(self.contenedor_nivel_1, padding = 20) self.contenedor_nivel_h.pack_start(self.contenedor_nivel_2, padding = 20) self.contenedor_nivel_1.pack_start(self.nivel_1, False, padding = 10) self.contenedor_nivel_1.pack_start(self.nivel_2, False, padding = 10) self.contenedor_nivel_1.pack_start(self.nivel_3, False, padding = 10) self.contenedor_nivel_1.pack_start(self.nivel_4, False, padding = 10) self.contenedor_nivel_1.pack_start(self.cambiar_personaje_btn, False, padding = 10) self.contenedor_nivel_1.pack_start(self.instrucciones, False, padding = 10) self.contenedor_nivel_2.pack_start(self.nivel_5, False, padding = 10) self.contenedor_nivel_2.pack_start(self.nivel_6, False, padding = 10) self.contenedor_nivel_2.pack_start(self.nivel_7, False, padding = 10) self.contenedor_nivel_2.pack_start(self.nuevapalabra_btn, False, padding = 10) self.contenedor_nivel_2.pack_start(self.importar_btn, False, padding = 10) self.contenedor_nivel_2.pack_start(self.categoria_libre, False, padding = 10) self.contenedor_nivel.show_all() #interface juego self.imagen = gtk.Image() self.instrucciones_label = gtk.Label() #self.instrucciones_label.set_justify(gtk.JUSTIFY_FILL) self.instrucciones_label.modify_font(self.modificar_text) #self.aciertos_label = gtk.Label(_('Puntaje: 0')) self.errores_label = gtk.Label() self.errores_label_2 = gtk.Label() self.errores_label_2.modify_font(self.modificar_text) self.palabra_label = gtk.Label() self.definicion_label = gtk.Label() self.definicion_label.modify_font(self.modificar_text) self.definicion = gtk.Label() self.definicion.set_line_wrap(True) self.pista_label = gtk.Label() self.pista_label.modify_font(self.modificar_text) self.pista = gtk.Label() self.pista.set_line_wrap(True) #self.pista.set_max_width_chars(0) self.letrasusadas_label = gtk.Label() self.letrasusadas_label_2 = gtk.Label() self.letrasusadas_label_2.modify_font(self.modificar_text) self.palabra_entry = gtk.Entry() self.ok_btn = gtk.Button(_('Ingresar')) self.ok_btn.connect('clicked', self._ok_btn_clicked_cb, None) self.nuevojuego_btn = gtk.Button(_('Nuevo Juego')) self.nuevojuego_btn.connect('clicked', self._nuevojuego_btn_clicked_cb, None) self.atras_btn = gtk.Button(_('Atrás')) self.atras_btn.connect('clicked', self._atras_cb) self.aciertos = 0 #Cuenta los aciertos de letras en la palabra secreta #agregando elementos juego self.marco = gtk.Frame(_("Instrucciones")) self.marco.set_size_request(350, -1) self.contenedor_superior.pack_start(self.imagen) self.contenedor_superior.pack_start(self.marco) self.subcontenedor.pack_start(self.instrucciones_label) self.subcontenedor.pack_start(self.definicion_label, False, padding = 5) self.subcontenedor.pack_start(self.definicion, False, padding = 5) self.subcontenedor.pack_start(self.pista_label, False, padding = 5) self.subcontenedor.pack_start(self.pista, False, padding = 5) #self.subcontenedor.pack_start(self.aciertos_label) self.subcontenedor.pack_start(self.errores_label_2, False, padding = 5) self.subcontenedor.pack_start(self.errores_label, False, padding = 5) self.subcontenedor.pack_start(self.letrasusadas_label_2, False) self.subcontenedor.pack_start(self.letrasusadas_label, False) self.subcontenedor.pack_start(self.palabra_label) self.marco.add(self.subcontenedor) self.contenedor_inferior.pack_start(self.atras_btn, False, padding = 6) self.contenedor_inferior.pack_start(self.palabra_entry, padding = 1) self.contenedor_inferior.pack_start(self.ok_btn, False, padding = 1) self.contenedor_inferior.pack_start(self.nuevojuego_btn, False, padding = 1) #interface instrucciones self.area_instruc = gtk.ScrolledWindow() self.area_instruc.set_shadow_type(gtk.SHADOW_OUT) self.area_instruc.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC) self.imagen_1 = gtk.Image() self.imagen_1.set_from_file('resources/sindiente1.png') self.imagen_2 = gtk.Image() self.imagen_2.set_from_file('resources/sindiente2.png') self.imagen_3 = gtk.Image() self.imagen_3.set_from_file('resources/sindiente3.png') self.imagen_4 = gtk.Image() self.imagen_4.set_from_file('resources/sindiente4.png') self.instruc = gtk.Label(_('Instrucciones')) self.instruc.modify_font(self.modificar_text) self.instruc_1 = gtk.Label(_('Oprime el botón “Nuevo Juego” para empezar a \njugar.')) self.instruc_2 = gtk.Label(_('La lineas representan las letras de las palabras \nque están ocultas. Cuenta las letras se compone \nla palabra.')) self.instruc_3 = gtk.Label(_('Ingresa una letra en el espacio en blanco y oprime \nel botón “Ingresar”. Si descubres una letra esta \naparecerá sobre la linea y ganarás un punto.\nPero si fallas, tu amigo perderá un diente.')) self.instruc_4 = gtk.Label(_('Las letras que ya han sido ingresadas no podrán ser \nusada de nuevo y aparecerán en el área de "Letras Usadas"')) self.atras_btn_1 = gtk.Button(_('Atrás')) self.atras_btn_1.connect('clicked', self._atras_cb) #agregando elementos de instrucciones self.contenedor_instruc_1.pack_start(self.instruc_1) self.contenedor_instruc_1.pack_start(self.imagen_1) self.contenedor_instruc_2.pack_start(self.imagen_2) self.contenedor_instruc_2.pack_start(self.instruc_2) self.contenedor_instruc_3.pack_start(self.instruc_3) self.contenedor_instruc_3.pack_start(self.imagen_3) self.contenedor_instruc_4.pack_start(self.imagen_4) self.contenedor_instruc_4.pack_start(self.instruc_4) self.contenedor_instruc.pack_start(self.instruc, padding=25) self.contenedor_instruc.pack_start(self.contenedor_instruc_1, padding=50) self.contenedor_instruc.pack_start(self.contenedor_instruc_2, padding=50) self.contenedor_instruc.pack_start(self.contenedor_instruc_3, padding=50) self.contenedor_instruc.pack_start(self.contenedor_instruc_4, padding=15) self.contenedor_instruc.pack_start(self.atras_btn_1) self.area_instruc.add_with_viewport(self.contenedor_instruc) #interface nueva palabra self.nueva_palabra_label = gtk.Label(_('Ingresa una palabra para jugar')) self.nueva_palabra_label.modify_font(self.modificar_text) self.n_palabra_label = gtk.Label(_('Palabra')) self.nuevo_significado_label = gtk.Label(_('Significado')) self.nueva_pista_label = gtk.Label(_('Pista')) self.nueva_palabra = gtk.Entry() self.nuevo_significado = gtk.Entry() self.nueva_pista = gtk.Entry() self.boton_np = gtk.Button(_('Ingresar palabra')) self.boton_np.connect('clicked', self._nueva_p_cb) self.atras_imp = gtk.Button(_('Atrás')) self.atras_imp.connect('clicked', self._atras_cb) #agregando elementos de nueva palabra self.contenedor_np_v.pack_start(self.nueva_palabra_label, False, padding=80) self.contenedor_np_v.pack_start(self.n_palabra_label, False) self.contenedor_np_v.pack_start(self.nueva_palabra, False, padding=15) self.contenedor_np_v.pack_start(self.nueva_pista_label, False) self.contenedor_np_v.pack_start(self.nueva_pista, False, padding=15) self.contenedor_np_v.pack_start(self.nuevo_significado_label, False) self.contenedor_np_v.pack_start(self.nuevo_significado, False, padding=15) self.contenedor_np_v.pack_start(self.contenedor_np_1, False, False, 100) self.contenedor_np_1.pack_start(self.atras_imp, True, False) self.contenedor_np_1.pack_start(self.boton_np, True, False) self.contenedor_np_2.pack_start(self.contenedor_np_v, padding=100) #interface importar self.combo = self.combo = gtk.combo_box_new_text() self.combo.set_size_request(180, -1) self.combo.append_text(_('Animales')) self.combo.append_text(_('Plantas')) self.combo.append_text(_('Países')) self.combo.append_text(_('Sustantivos')) self.combo.append_text(_('Verbos')) self.combo.append_text(_('Cosas')) self.combo.append_text(_('Valores morales')) self.combo.append_text(_('Categoría Personalizada')) self.combo.set_active(0) self.atras_btn_imp = gtk.Button(_('Atrás')) self.atras_btn_imp.connect('clicked', self._atras_cb) self.boton_importar = gtk.Button(_('Importar')) self.boton_importar.connect('clicked', self._importar_archivo_cb) self.archivo = gtk.FileChooserWidget() self.archivo.set_current_folder('/media') self.niveles = gtk.Label(_('Categorías')) self.importar = gtk.HBox() self.importar.pack_start(self.atras_btn_imp, False, padding=5) self.importar.pack_start(self.niveles, False, padding=10) self.importar.pack_start(self.combo, False) self.importar.pack_start(self.boton_importar) self.archivo.set_extra_widget(self.importar) #interface categoria personalizada NONE self.sin_importar = gtk.Label(_('No se ha importado ninguna lista de palabras para crear una categoría personalizada')) self.show()
LOG_COLORS = { logging.DEBUG : '#5b606a', # grey logging.INFO : None, logging.WARNING : 'gold4', logging.ERROR : 'red', logging.CRITICAL : 'red', Operator.LOG_EXECUTE : '#286073', # blue Operator.LOG_SUCCESS : '#319331', # green Operator.LOG_FAILURE : '#B83D3D', # red ReplayLoop.COMMANDER_LOG_NAME : '#5b606a', } GLADE_FILE = os.path.join(CANVAS_ROOT, 'control', 'ui', 'log_box.glade') MONOSPACE_FONT = pango.FontDescription('monospace 9') class TreeStoreHandler(logging.Handler): """Writes logs to a gtk.TreeStore.""" def __init__(self, model, gui_call, commander=None): logging.Handler.__init__(self) self.gui_call = gui_call self.commander = commander self.model = model def emit(self, record): com = self.commander model = self.model columns = model._columns
def __init__(self, core, textviews, main): super(RightTextView, self).__init__(False, 1) ################################################################# # Right Textview ################################################################# self.uicore = core self.main = main self.textviews = textviews self.seek_index = 0 self.seeks = [] self.marks = [] self.press_coords = [] ################################################# # Move buttons self.move_buttons = self.create_seek_buttons() self.pack_start(self.move_buttons, False, False, 1) self.hbox = gtk.HBox(False, 0) # Use GtkSourceView to add eye candy :P # create buffer lm = gtksourceview2.LanguageManager() # Add ui dir to language paths paths = lm.get_search_path() paths.append(os.path.dirname(__file__) + os.sep + 'data' + os.sep) lm.set_search_path(paths) self.buffer = gtksourceview2.Buffer() self.buffer.create_tag("green-background", background="green", foreground="black") self.buffer.set_data('languages-manager', lm) self.view = gtksourceview2.View(self.buffer) self.view.connect("button-press-event", self._get_press) self.view.connect("button-release-event", self._get_release) # FIXME options must be user selectable (statusbar) self.view.set_editable(False) self.view.set_highlight_current_line(True) # posible values: gtk.WRAP_NONE, gtk.WRAP_CHAR, gtk.WRAP_WORD... self.view.set_wrap_mode(gtk.WRAP_NONE) # setup view font_desc = pango.FontDescription('monospace 9') if font_desc: self.view.modify_font(font_desc) self.buffer.set_highlight_syntax(True) manager = self.buffer.get_data('languages-manager') language = manager.get_language('asm') self.buffer.set_language(language) self.mgr = gtksourceview2.style_scheme_manager_get_default() # Scrolled Window self.right_scrolled_window = gtk.ScrolledWindow() self.right_scrolled_window.set_shadow_type(gtk.SHADOW_ETCHED_IN) self.right_scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.right_scrolled_window.show() # Add Textview to Scrolled Window self.right_scrolled_window.add(self.view) self.hbox.pack_start(self.right_scrolled_window, expand=True, fill=True) self.pack_start(self.hbox, expand=True, fill=True) # Create the search widget Searchable.__init__(self, self.view, small=True) # Used for code navidation on _search function self.match_start = None self.match_end = None self.search_string = '' self.view.connect("populate-popup", self._populate_comments_menu)
def __init__(self, active, latent, var_ops, modes, arg_str=None): super(PageWithVariableTable, self).__init__(False, 1) self.__drawing_suspended = True self.__var_ops = var_ops # Parse the given arguments to work out which variables to include in the table parser = optparse.OptionParser() parser.add_option('-n', '--nvar', action = "store", type = "string", dest = "nvar", default = "nvars") (args, vars) = parser.parse_args(arg_str.split() if arg_str else []) # Store the names for easy looking up later self.__var_names = [args.nvar] + vars # Work out which variables we will explicitly manage and which variables we will defer # to the default page self.__nvar = None self.__vars = [] for var in active[:]: if var.name == args.nvar: self.__nvar = var active.remove(var) for var in latent[:]: if var.name == args.nvar: self.__nvar = var latent.remove(var) for var_name in vars: for var in active[:]: if var.name == var_name: self.__vars.append(var) active.remove(var) for var in latent[:]: if var.name == var_name: self.__vars.append(var) latent.remove(var) # Correct the sizes of all the variables to match the current value of self.__nvar for var in self.__vars: value = self.__python_list_for_variable(var) self.__var_ops.set_var_value(var, ",".join([self.__value_to_string(var, v) for v in value])) # Build the default table for all the other variables and insert it as the first element self.__table = rose.config_editor.pagewidget.table.PageTable(active, latent, var_ops, modes, arg_str) self.pack_start(self.__table) # Add another panel to contain the table self.__table_panel = gtk.VBox(False, 0) self.pack_start(self.__table_panel) toolbar = gtk.HBox() error_panel = gtk.HBox() self.__error_icon = gtk.image_new_from_stock(gtk.STOCK_DIALOG_ERROR, gtk.ICON_SIZE_MENU) self.__error_icon.set_padding(5, 3) self.__error_icon.show() error_panel.pack_start(self.__error_icon, expand = False, fill = False) self.__error_label = gtk.Label() self.__error_label.set_alignment(xalign=0, yalign=0.5) self.__error_label.show() error_panel.pack_start(self.__error_label, expand = True, fill = True) error_panel.show() toolbar.pack_start(error_panel, expand = True, fill = True) add_button = gtk.Button(stock=gtk.STOCK_ADD) add_button.connect("clicked", self.__handle_add_row) toolbar.pack_end(add_button, expand = False, fill = False) self.__table_panel.pack_start(toolbar) add_button.show() toolbar.show() # Build the initial state of our store col_types = [] renderers = [] col_idx = 0 for var in self.__vars: if 'values' in var.metadata: col_types.append(str) values_store = gtk.ListStore(str) for item in var.metadata['values']: values_store.append([item]) renderer = gtk.CellRendererCombo() renderer.set_property('has-entry', False) renderer.set_property('editable', True) renderer.set_property('model', values_store) renderer.set_property("text-column", 0) renderer.connect("edited", self.__handle_text_edit, var, col_idx) else: type = var.metadata.get('type', None) if type == 'integer': col_types.append(int) renderer = gtk.CellRendererSpin() renderer.set_property('editable', True) renderer.set_property('adjustment', 1) renderer.connect("edited", self.__handle_text_edit, var, col_idx) elif type == 'boolean': col_types.append(bool) renderer = gtk.CellRendererToggle() renderer.set_property('active', 0) renderer.connect("toggled", self.__handle_toggle, var, col_idx) elif type == 'logical': col_types.append(bool) renderer = gtk.CellRendererToggle() renderer.set_property('active', 0) renderer.connect("toggled", self.__handle_toggle, var, col_idx) elif type == 'real': col_types.append(float) renderer = gtk.CellRendererText() renderer.set_property('editable', True) renderer.connect("edited", self.__handle_text_edit, var, col_idx) else: col_types.append(str) renderer = gtk.CellRendererText() renderer.set_property('editable', True) renderer.connect("edited", self.__handle_text_edit, var, col_idx) renderer.set_property("xpad", 8) renderer.set_property("ypad", 5) renderers.append(renderer) col_idx += 1 self.__store = gtk.ListStore(*col_types) treeview = gtk.TreeView(self.__store) self.__columns = [] for col in range(len(self.__vars)): var = self.__vars[col] title = var.metadata.get('title', var.name) # We have to create a separate label widget for the column headers to enable tooltips column = gtk.TreeViewColumn('', renderers[col], text = col, active = col) column_header = gtk.Label(title) column_header.modify_font(pango.FontDescription("bold")) column_header.show() column.set_widget(column_header) column.connect("clicked", self.__handle_header_click, var) if 'description' in var.metadata: tooltips = gtk.Tooltips() tooltips.set_tip(column_header, var.metadata['description']) self.__columns.append(column) treeview.append_column(column) treeview.set_headers_clickable(True) table_viewport = gtk.Viewport() table_viewport.set_shadow_type(gtk.SHADOW_OUT) table_viewport.add(treeview) self.__table_panel.pack_start(table_viewport) treeview.show() table_viewport.show() self.__table_panel.show() # Add the right click context menu to the treeview body treeview.connect("button-press-event", self.__handle_mouse_click) # Add the right click context menu to the treeview headers for col in range(len(self.__vars)): var = self.__vars[col] button = self.__columns[col].get_widget() while not isinstance(button, gtk.Button): button = button.get_parent() button.connect("button-press-event", self.__handle_header_button_press, var) self.__drawing_suspended = False self.__redraw() self.show()
# First pass, find image size to hold the text. mode = { "grey": -1, "bilevel": cairo.ANTIALIAS_NONE, "subpixel": cairo.ANTIALIAS_SUBPIXEL }[args.mode] pangocairo.cairo_font_map_get_default().set_resolution(72) surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 0, 0) context = pangocairo.CairoContext(cairo.Context(surface)) layout = context.create_layout() options = cairo.FontOptions() options.set_antialias(mode) pangocairo.context_set_font_options(layout.get_context(), options) layout.set_font_description(pango.FontDescription(args.font)) layout.set_markup(text) width = max(layout.get_pixel_size()[0] + args.pad * 2, args.width) height = max(layout.get_pixel_size()[1] + args.pad * 2, args.height) # Second pass, render actual image and save it. surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height) context = pangocairo.CairoContext(cairo.Context(surface)) layout = context.create_layout() options = cairo.FontOptions() options.set_antialias(mode) pangocairo.context_set_font_options(layout.get_context(), options) layout.set_font_description(pango.FontDescription(args.font)) layout.set_markup(text) context.set_source_rgba(
def __init__(self, logger, options, show_settings=False): gtk.Window.__init__(self, gtk.WINDOW_POPUP) self.timer_hide = None self.timer_min = None self.logger = logger defaults = Options({ 'no_systray': False, 'timeout': 2.5, 'recent_thr': 0.1, 'compr_cnt': 3, 'ignore': [], 'position': 'bottom', 'persist': False, 'font_desc': 'Sans Bold', 'font_size': 'medium', 'font_color': 'white', 'bg_color': 'black', 'opacity': 0.8, 'key_mode': 'composed', 'bak_mode': 'baked', 'mods_mode': 'normal', 'mods_only': False, 'multiline': False, 'vis_shift': False, 'vis_space': True, 'geometry': None, 'screen': 0 }) self.options = self.load_state() if self.options is None: self.options = defaults else: # copy missing defaults for k, v in defaults.iteritems(): if k not in self.options: self.options[k] = v if options is not None: # override with values from constructor for k, v in options.iteritems(): if v is not None: self.options[k] = v self.set_keep_above(True) self.set_accept_focus(False) self.set_focus_on_map(False) self.set_app_paintable(True) self.label = gtk.Label() self.label.set_attributes(pango.AttrList()) self.label.set_ellipsize(pango.ELLIPSIZE_START) self.label.set_justify(gtk.JUSTIFY_CENTER) self.label.show() self.add(self.label) self.font = pango.FontDescription(self.options.font_desc) self.update_colors() self.set_size_request(0, 0) self.set_gravity(gtk.gdk.GRAVITY_CENTER) self.connect("configure-event", self.on_configure) self.connect("expose-event", self.on_expose) scr = self.get_screen() scr.connect("size-changed", self.on_configure) scr.connect("monitors-changed", self.on_monitors_changed) self.set_active_monitor(self.options.screen) cmap = scr.get_rgba_colormap() if cmap is not None: self.set_colormap(cmap) self.labelmngr = None self.enabled = True self.on_change_mode() self.make_menu() self.make_about_dialog() self.make_preferences_dialog() if not self.options.no_systray: self.make_systray() self.connect("delete-event", self.quit) if show_settings: self.on_preferences_dialog() if self.options.persist: self.show()
families = font_map.list_families() # to see family names: print [f.get_name() for f in font_map.list_families()] # context.set_antialias(cairo.ANTIALIAS_SUBPIXEL) # Translates context so that desired text upperleft corner is at 0,0 context.translate(50, 25) pangocairo_context = pangocairo.CairoContext(context) pangocairo_context.set_antialias(cairo.ANTIALIAS_SUBPIXEL) layout = pangocairo_context.create_layout() fontname = sys.argv[1] if len(sys.argv) >= 2 else "Purisa" font = pango.FontDescription(fontname + " 25") layout.set_font_description(font) layout.set_text(u"Hello World\nasdsad") context.set_source_rgb(0, 0, 0) pangocairo_context.update_layout(layout) pangocairo_context.show_layout(layout) context.translate(50, 45) context.set_source_rgb(0, 0, 0) pangocairo_context.update_layout(layout) pangocairo_context.show_layout(layout) with open("cairo_text.png", "wb") as image_file: surf.write_to_png(image_file) #import Tools.phrases as Phrases
def _set_font(self, value): widget = self._color_widget() widget.modify_font(pango.FontDescription(value))