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))
