def __create_left_ui(self, box):
# Device selector
frame = BoxFrame('Devices')
box.pack_start(frame, expand=False)
self.__device_liststore = gtk.ListStore(str, object)
self.__device_selector = gtk.ComboBox(self.__device_liststore)
cell = gtk.CellRendererText()
self.__device_selector.pack_start(cell, True)
self.__device_selector.add_attribute(cell, 'text', 0)
self.__device_selector.connect('changed', self.__on_device_changed)
frame.pack_start(self.__device_selector)
# NAND partition selector
frame = BoxFrame('NAND Partitions')
box.pack_start(frame, expand=False)
self.__partition_liststore = gtk.ListStore(str, int, int)
self.__partition_selector = gtk.ComboBox(self.__partition_liststore)
cell = gtk.CellRendererText()
self.__partition_selector.pack_start(cell, True)
self.__partition_selector.add_attribute(cell, 'text', 0)
self.__partition_selector.connect('changed', self.__refresh_buttons)
frame.pack_start(self.__partition_selector)
# Image file selector
frame = BoxFrame('Image File to Flash')
box.pack_start(frame, expand=False)
self.__image_entry = gtk.Entry()
self.__image_entry.connect('changed', self.__refresh_buttons)
frame.pack_start(self.__image_entry)
self.__image_select_button = gtk.Button('Choose')
self.__image_select_button.connect('clicked', self.__choose_image_file)
frame.pack_start(self.__image_select_button, expand=False, fill=False)
# Action buttons
frame = BoxFrame('Actions', opt_hbox=False, spacing=20)
box.pack_start(frame, expand=False)
self.__flash_button = gtk.Button('Flash image')
self.__flash_button.connect('clicked', self.__flash_image_file)
frame.pack_start(self.__flash_button, expand=False, fill=False)
self.__cmp_button = gtk.Button('Compare partition with image file')
self.__cmp_button.connect('clicked', self.__cmp_part_with_file)
frame.pack_start(self.__cmp_button, expand=False, fill=False)
self.__backup_button = gtk.Button('Backup Partition')
self.__backup_button.connect('clicked', self.__backup_partition)
frame.pack_start(self.__backup_button, expand=False, fill=False)
self.__erase_button = gtk.Button('Erase Partition')
self.__erase_button.connect('clicked', self.__erase_partition)
frame.pack_start(self.__erase_button, expand=False, fill=False)
self.__reboot_button = gtk.Button('Reboot Device')
self.__reboot_button.connect('clicked', self.__reboot_device)
frame.pack_start(self.__reboot_button, expand=False, fill=False)
self.__clear_log_button = gtk.Button('Clear Log')
self.__clear_log_button.connect('clicked', self.__clear_log)
frame.pack_start(self.__clear_log_button, expand=False, fill=False)
def selectInstallNetDeviceDialog(network, devices=None):
devs = devices or network.netdevices.keys()
if not devs:
return None
devs.sort()
dialog = gtk.Dialog(_("Select network interface"))
dialog.add_button('gtk-cancel', gtk.RESPONSE_CANCEL)
dialog.add_button('gtk-ok', 1)
dialog.set_position(gtk.WIN_POS_CENTER)
gui.addFrame(dialog)
dialog.vbox.pack_start(
gui.WrappingLabel(
_("This requires that you have an active "
"network connection during the installation "
"process. Please configure a network interface.")))
combo = gtk.ComboBox()
cell = gtk.CellRendererText()
combo.pack_start(cell, True)
combo.set_attributes(cell, text=0)
cell.set_property("wrap-width", 525)
combo.set_size_request(480, -1)
store = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_STRING)
combo.set_model(store)
ksdevice = network.getKSDevice()
if ksdevice:
ksdevice = ksdevice.get('DEVICE')
preselected = None
for dev in devices:
i = store.append(None)
if not preselected:
preselected = i
desc = network.netdevices[dev].description
if desc:
desc = "%s - %s" % (dev, desc)
else:
desc = "%s" % (dev, )
hwaddr = network.netdevices[dev].get("HWADDR")
if hwaddr:
desc = "%s - %s" % (
desc,
hwaddr,
)
if ksdevice and ksdevice == dev:
preselected = i
store[i] = (desc, dev)
combo.set_active_iter(preselected)
dialog.vbox.pack_start(combo)
dialog.show_all()
rc = dialog.run()
if rc in [gtk.RESPONSE_CANCEL, gtk.RESPONSE_DELETE_EVENT]:
install_device = None
else:
active = combo.get_active_iter()
install_device = combo.get_model().get_value(active, 1)
dialog.destroy()
return install_device
class PyApp(gtk.Window):
data = pd.read_csv("Crimes_commited_ipc2.csv")
combobox_district = gtk.ComboBox()
combobox_year = gtk.ComboBox()
combobox_state = gtk.ComboBox()
combobox_crime = gtk.ComboBox()
combobox_state1 = gtk.ComboBox()
combobox_state2 = gtk.ComboBox()
combobox_yearc = gtk.ComboBox()
button_show_graph = gtk.Button("Show Graph")
compare_button = gtk.Button("Compare")
filtered_data = df()
store_dist = gtk.ListStore(str)
def __init__(self):
super(PyApp, self).__init__()
self.set_title("Crimes in India")
self.set_size_request(700, 500)
#self.set_icon_from_file("/home/prasadgadde/BigData/Project/icon.png")
# Set window background image
pixbuf = gtk.gdk.pixbuf_new_from_file(
"vector-grunge-texture-background.jpg")
pixmap, mask = pixbuf.render_pixmap_and_mask()
width, height = pixmap.get_size()
#del pixbuf
self.set_app_paintable(gtk.TRUE)
self.resize(width, height)
self.realize()
self.window.set_back_pixmap(pixmap, gtk.FALSE)
#del pixmap
nb = gtk.Notebook()
nb.set_tab_pos(gtk.POS_TOP)
vbox = gtk.VBox(False, 5)
vb = gtk.VBox()
hbox = gtk.HBox(True, 3)
hlabelsbox = gtk.HBox(True, 120)
hbuttonbox = gtk.HBox(True, 10)
# Horizontal box for labels
label_state = gtk.Label("State")
label_district = gtk.Label("District")
label_year = gtk.Label("Year")
label_crime = gtk.Label("Crime")
hlabelsbox.pack_start(label_state, True, True, 10)
hlabelsbox.pack_start(label_district, True, True, 10)
hlabelsbox.pack_start(label_year, True, True, 10)
hlabelsbox.pack_start(label_crime, True, True, 10)
valign = gtk.Alignment(0.25, 0.10, 0, 0)
valign1 = gtk.Alignment(0, 1, 0, 0)
valign2 = gtk.Alignment(0, 0, 1, 0)
store = gtk.ListStore(str)
cell = gtk.CellRendererText()
self.combobox_state.pack_start(cell)
self.combobox_state.set_title("States")
self.combobox_state.add_attribute(cell, 'text', 0)
hbox.pack_start(self.combobox_state, True, True, 10)
store.append(["ANDHRA PRADESH"])
store.append(["ARUNACHAL PRADESH"])
store.append(["ASSAM"])
store.append(["BIHAR"])
store.append(["GOA"])
store.append(["GUJARAT"])
store.append(["HARYANA"])
store.append(["HIMACHAL PRADESH"])
store.append(["JAMMU & KASHMIR"])
store.append(["JHARKHAND"])
store.append(["KARNATAKA"])
store.append(["KERALA"])
store.append(["MADHYA PRADESH"])
store.append(["MAHARASHTRA"])
store.append(["MANIPUR"])
store.append(["MEGHALAYA"])
store.append(["MIZORAM"])
store.append(["NAGALAND"])
store.append(["ODISHA"])
store.append(["MIZORAM"])
store.append(["PUNJAB"])
store.append(["RAJASTHAN"])
store.append(["TAMIL NADU"])
store.append(["TRIPURA"])
store.append(["UTTAR PRADESH"])
store.append(["UTTARAKHAND"])
store.append(["WEST BENGAL"])
store.append(["A & N ISLANDS"])
store.append(["CHANDIGARH"])
store.append(["D & N HAVELI"])
store.append(["DAMAN & DIU"])
store.append(["DELHI UT"])
store.append(["LAKSHADWEEP"])
store.append(["PUDUCHERRY"])
self.combobox_state.set_model(store)
self.combobox_state.connect('changed', self.on_changed)
self.combobox_state.set_active(0)
self.store_dist = gtk.ListStore(str)
cell_dist = gtk.CellRendererText()
self.combobox_district.pack_start(cell_dist)
self.combobox_district.add_attribute(cell_dist, 'text', 0)
self.combobox_district.connect('changed', self.on_changed_district)
hbox.pack_start(self.combobox_district, True, True, 10)
#Year dropbox
store_year = gtk.ListStore(str)
cell_year = gtk.CellRendererText()
self.combobox_year.pack_start(cell_year)
self.combobox_year.add_attribute(cell_year, 'text', 0)
hbox.pack_start(self.combobox_year, True, True, 10)
district = self.data[(self.data['STATEorUT'] == 'ANDHRA PRADESH') | (
self.data['STATEorUT'] == 'Andhra Pradesh')].filter(
items=['STATE/UT', 'DISTRICT', 'YEAR'])
year = s(district['YEAR']).unique().tolist()
store_year.append(["All"])
for i in year:
store_year.append([i])
self.combobox_year.set_model(store_year)
#combobox.connect('changed', self.on_changed)
self.combobox_year.set_active(0)
self.combobox_year.connect('changed', self.on_changed_year)
# Crime dropbox
store_crime = gtk.ListStore(str)
cell_crime = gtk.CellRendererText()
self.combobox_crime.pack_start(cell_crime)
self.combobox_crime.add_attribute(cell_crime, 'text', 0)
self.combobox_crime.connect('changed', self.on_changed_crime)
hbox.pack_start(self.combobox_crime, True, True, 10)
store_crime.append(["MURDER"])
store_crime.append(["RAPE"])
store_crime.append(["KIDNAPPING"])
store_crime.append(["RIOTS"])
store_crime.append(["ROBBERY"])
store_crime.append(["BURGLARY"])
store_crime.append(["DOWRY DEATHS"])
store_crime.append(["TOTAL IPC CRIMES"])
self.combobox_crime.set_model(store_crime)
#combobox.connect('changed', self.on_changed)
self.combobox_crime.set_active(0)
valign.add(hbox)
valign1.add(hlabelsbox)
button_disp_data = gtk.Button("Display Data")
button_disp_data.connect("clicked", self.display_data)
self.button_show_graph.connect("clicked", self.display_graph)
self.button_show_graph.set_sensitive(False)
hbuttonbox.pack_start(button_disp_data, True, True, 10)
hbuttonbox.pack_start(self.button_show_graph, True, True, 10)
valign2.add(hbuttonbox)
vbox.pack_start(valign1)
vbox.pack_start(valign)
vbox.pack_start(valign2)
nb.append_page(vbox)
nb.set_tab_label_text(vbox, "District wise crimes")
# Code for 2nd TAB
state1lbl = gtk.Label("State 1")
state2lbl = gtk.Label("State 2")
self.compare_button.connect("clicked", self.compare_states)
self.compare_button.set_sensitive(False)
table = gtk.Table(8, 4, True)
table.set_col_spacings(7)
states = [
"ANDHRA PRADESH", "ARUNACHAL PRADESH", "ASSAM", "BIHAR",
"CHHATTISGARH", "GOA", "GUJARAT", "HARYANA", "HIMACHAL PRADESH",
"JAMMU & KASHMIR", "JHARKHAND", "KARNATAKA", "KERALA",
"MADHYA PRADESH", "MAHARASHTRA", "MANIPUR", "MEGHALAYA", "MIZORAM",
"NAGALAND", "ODISHA", "PUNJAB", "RAJASTHAN", "SIKKIM",
"TAMIL NADU", "TRIPURA", "UTTAR PRADESH", "UTTARAKHAND",
"WEST BENGAL", "A & N ISLANDS", "CHANDIGARH", "D & N HAVELI",
"DAMAN & DIU", "DELHI UT", "LAKSHADWEEP", "PUDUCHERRY"
]
storestate1 = gtk.ListStore(str)
cellstate1 = gtk.CellRendererText()
self.combobox_state1.pack_start(cellstate1)
self.combobox_state1.add_attribute(cellstate1, 'text', 0)
self.combobox_state1.set_active(0)
for i in states:
storestate1.append([i])
self.combobox_state1.set_model(storestate1)
storestate2 = gtk.ListStore(str)
cellstate2 = gtk.CellRendererText()
self.combobox_state2.pack_start(cellstate2)
self.combobox_state2.add_attribute(cellstate2, 'text', 0)
self.combobox_state2.set_active(0)
for i in states:
storestate2.append([i])
self.combobox_state2.set_model(storestate2)
store_yearc = gtk.ListStore(str)
cell_yearc = gtk.CellRendererText()
self.combobox_yearc.pack_start(cell_yearc)
self.combobox_yearc.add_attribute(cell_yearc, 'text', 0)
self.combobox_yearc.set_active(0)
for i in year:
store_yearc.append([i])
self.combobox_yearc.set_model(store_yearc)
self.combobox_state1.connect('changed', self.on_changed_state1)
self.combobox_state2.connect('changed', self.on_changed_state2)
self.combobox_yearc.connect('changed', self.on_changed_yearc)
table.attach(state1lbl, 0, 1, 3, 4)
table.attach(state2lbl, 2, 3, 3, 4)
table.attach(self.combobox_state1, 0, 1, 4, 5, xpadding=8, ypadding=9)
table.attach(self.combobox_state2, 2, 3, 4, 5, xpadding=8, ypadding=9)
table.attach(self.combobox_yearc, 1, 2, 4, 5, xpadding=8, ypadding=9)
table.attach(self.compare_button, 1, 2, 6, 7, xpadding=8, ypadding=9)
nb.append_page(table)
nb.set_tab_label_text(table, "Comparison of states")
tv = gtk.TextView()
nb.append_page(tv)
nb.set_tab_label_text(tv, "About")
self.add(nb)
self.connect("destroy", gtk.main_quit)
self.show_all()
def on_changed_state1(self, widget):
if (widget.get_active_text() == self.combobox_state2.get_active_text()
):
self.compare_button.set_sensitive(False)
else:
self.compare_button.set_sensitive(True)
return
def on_changed_state2(self, widget):
if (widget.get_active_text() == self.combobox_state1.get_active_text()
):
self.compare_button.set_sensitive(False)
else:
self.compare_button.set_sensitive(True)
return
def on_changed_yearc(self, widget):
return
def on_changed(self, widget):
#data = pd.read_csv("/home/prasadgadde/BigData/Project/crime-in-india/crime/01_District_wise_crimes_committed_IPC_2013.csv"
district = s(self.data[
self.data['STATEorUT'] == widget.get_active_text()].filter(
items=['DISTRICT'])['DISTRICT']).unique().tolist()
self.store_dist.clear()
self.store_dist.append(["All"])
for i in district:
self.store_dist.append([i])
self.combobox_district.set_model(self.store_dist)
#combobox.connect('changed', self.on_changed)
self.combobox_district.set_active(0)
def display_data(self, widget):
#print self.combobox_state.get_active_text(), self.combobox_year.get_active_text(), self.combobox_district.get_active_text(), self.combobox_crime.get_active_text()
#filtered_data = self.data[((self.data['STATE.UT']==self.combobox_state.get_active_text()) & (self.data['DISTRICT']==self.combobox_district.get_active_text()) & (self.data['YEAR']==self.combobox_year.get_active_text()))].filter(items=['STATE/UT','DISTRICT','YEAR', self.combobox_crime.get_active_text()])
dialog = gtk.Dialog("My dialog", self,
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
(gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
dialog.set_size_request(400, 700)
liststore = gtk.ListStore(str, str, str, str)
treeview = gtk.TreeView(liststore)
tvcolumn = gtk.TreeViewColumn("STATE/UT")
tvcolumn1 = gtk.TreeViewColumn("DISTRICT")
tvcolumn2 = gtk.TreeViewColumn("YEAR")
tvcolumn3 = gtk.TreeViewColumn(self.combobox_crime.get_active_text())
for i in self.filtered_data.values.tolist():
liststore.append(i)
#liststore.append(['Open', gtk.STOCK_OPEN, 'Open a File', True])
treeview.append_column(tvcolumn)
treeview.append_column(tvcolumn1)
treeview.append_column(tvcolumn2)
treeview.append_column(tvcolumn3)
cell = gtk.CellRendererText()
cell1 = gtk.CellRendererText()
cell2 = gtk.CellRendererText()
cell3 = gtk.CellRendererText()
cell.set_property('cell-background', 'yellow')
cell1.set_property('cell-background', 'cyan')
cell2.set_property('cell-background', 'pink')
cell3.set_property('cell-background', 'red')
tvcolumn.pack_start(cell, False)
tvcolumn1.pack_start(cell1, True)
tvcolumn2.pack_start(cell2, True)
tvcolumn3.pack_start(cell3, True)
tvcolumn.set_attributes(cell, text=0)
tvcolumn1.set_attributes(cell1, text=1)
tvcolumn2.set_attributes(cell2, text=2)
tvcolumn3.set_attributes(cell3, text=3)
scrolled_window = gtk.ScrolledWindow()
scrolled_window.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
scrolled_window.add(treeview)
scrolled_window.set_border_width(10)
#scrolled_window.set_min_content_height(200)
scrolled_window.add(treeview)
treeview.set_search_column(0)
dialog.vbox.add(scrolled_window)
treeview.show()
scrolled_window.show()
res = dialog.run()
dialog.destroy()
return
def display_graph(self, widget):
dialog = gtk.Dialog("My dialog", self,
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
(gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
dialog.set_size_request(1300, 500)
# Crime name filter
if " " not in self.combobox_crime.get_active_text():
crime = self.combobox_crime.get_active_text()
else:
crime = ".".join(self.combobox_crime.get_active_text().split(" "))
fig = Figure(figsize=(12, 10), dpi=100)
sales = [{
'Groups': '0-9',
'Counts': 38
}, {
'Groups': '10-19',
'Counts': 41
}, {
'Groups': '20-29',
'Counts': 77
}, {
'Groups': '30-39',
'Counts': 73
}, {
'Groups': '40-49',
'Counts': 77
}]
df = pd.DataFrame(sales)
ax = fig.add_subplot(111)
if (self.combobox_year.get_active_text() == "All"
and self.combobox_district.get_active_text() != "All"):
self.filtered_data = self.filtered_data.reset_index(drop=True)
ypos = np.arange(len(self.filtered_data['YEAR'].tolist()))
p1 = ax.bar(ypos, self.filtered_data[crime], width=0.6, color='r')
ax.set_title(crime.lower() + 's in ' +
self.combobox_district.get_active_text() +
' - Yearwise')
ax.set_xticks(ypos + 0.3)
ax.set_xticklabels(self.filtered_data.YEAR)
elif (self.combobox_district.get_active_text() == "All"
and self.combobox_year.get_active_text() != "All"):
fd_total_removed = self.filtered_data[
self.filtered_data.DISTRICT != 'TOTAL']
ypos = np.arange(len(fd_total_removed['DISTRICT'].tolist()))
p1 = ax.bar(ypos, fd_total_removed[crime], width=0.3, color='r')
fontx = {
'fontsize': 7,
'fontweight': 2,
'verticalalignment': 'center',
'horizontalalignment': 'center'
}
ax.set_title(crime + 's in ' +
self.combobox_state.get_active_text() + '(' +
self.combobox_state.get_active_text() + ' )' +
' - Districtwise')
ax.set_xticks(ypos + 0.15)
ax.set_xticklabels(fd_total_removed.DISTRICT, fontdict=fontx)
else:
print(df.index)
p1 = ax.bar(df.index, df.Counts, width=0.8, color='r')
ax.set_title('Scores by group and gender')
ax.set_xticks(df.index + 0.4)
ax.set_xticklabels(df.Groups)
canvas = FigureCanvas(fig) # a gtk.DrawingArea
canvas.set_size_request(800, 600)
dialog.vbox.pack_start(canvas)
toolbar = NavigationToolbar(canvas, dialog)
dialog.vbox.pack_start(toolbar, False, False)
canvas.show()
dialog.run()
dialog.destroy()
return
def on_changed_district(self, widget):
if (self.combobox_year.get_active_text() != 'All'):
intyear = int(self.combobox_year.get_active_text())
# Check crime field
if " " not in self.combobox_crime.get_active_text():
crime = self.combobox_crime.get_active_text()
else:
crime = ".".join(self.combobox_crime.get_active_text().split(" "))
if (self.combobox_district.get_active_text() == 'All'
and self.combobox_year.get_active_text() == 'All'):
self.filtered_data = self.data.query(
'STATEorUT == @self.combobox_state.get_active_text()').filter(
items=['STATEorUT', 'DISTRICT', 'YEAR', crime])
self.button_show_graph.set_sensitive(False)
elif (self.combobox_district.get_active_text() == 'All'):
self.filtered_data = self.data.query(
'STATEorUT == @self.combobox_state.get_active_text() and YEAR == @intyear'
).filter(items=['STATEorUT', 'DISTRICT', 'YEAR', crime])
self.button_show_graph.set_sensitive(True)
elif (self.combobox_year.get_active_text() == "All"):
self.filtered_data = self.data.query(
'STATEorUT == @self.combobox_state.get_active_text() and DISTRICT == @self.combobox_district.get_active_text()'
).filter(items=['STATEorUT', 'DISTRICT', 'YEAR', crime])
self.button_show_graph.set_sensitive(True)
else:
self.button_show_graph.set_sensitive(False)
self.filtered_data = self.data.query(
'STATEorUT == @self.combobox_state.get_active_text() and DISTRICT == @self.combobox_district.get_active_text() and YEAR == @intyear'
).filter(items=['STATEorUT', 'DISTRICT', 'YEAR', crime])
return
def on_changed_year(self, widget):
if (self.combobox_year.get_active_text() != 'All'):
intyear = int(self.combobox_year.get_active_text())
# Check crime field
if " " not in self.combobox_crime.get_active_text():
crime = self.combobox_crime.get_active_text()
else:
crime = ".".join(self.combobox_crime.get_active_text().split(" "))
if (self.combobox_district.get_active_text() == 'All'
and self.combobox_year.get_active_text() == 'All'):
self.filtered_data = self.data.query(
'STATEorUT == @self.combobox_state.get_active_text()').filter(
items=['STATEorUT', 'DISTRICT', 'YEAR', crime])
self.button_show_graph.set_sensitive(False)
elif (self.combobox_district.get_active_text() == 'All'):
self.filtered_data = self.data.query(
'STATEorUT == @self.combobox_state.get_active_text() and YEAR == @intyear'
).filter(items=['STATEorUT', 'DISTRICT', 'YEAR', crime])
self.button_show_graph.set_sensitive(True)
elif (self.combobox_year.get_active_text() == "All"):
self.filtered_data = self.data.query(
'STATEorUT == @self.combobox_state.get_active_text() and DISTRICT == @self.combobox_district.get_active_text()'
).filter(items=['STATEorUT', 'DISTRICT', 'YEAR', crime])
self.button_show_graph.set_sensitive(True)
else:
self.button_show_graph.set_sensitive(False)
self.filtered_data = self.data.query(
'STATEorUT == @self.combobox_state.get_active_text() and DISTRICT == @self.combobox_district.get_active_text() and YEAR == @intyear'
).filter(items=['STATEorUT', 'DISTRICT', 'YEAR', crime])
return
def on_changed_crime(self, widget):
if (self.combobox_year.get_active_text() != 'All'):
intyear = int(self.combobox_year.get_active_text())
# Check crime field
if " " not in self.combobox_crime.get_active_text():
crime = self.combobox_crime.get_active_text()
else:
crime = ".".join(self.combobox_crime.get_active_text().split(" "))
if (self.combobox_district.get_active_text() == 'All'
and self.combobox_year.get_active_text() == 'All'):
self.filtered_data = self.data.query(
'STATEorUT == @self.combobox_state.get_active_text()').filter(
items=['STATEorUT', 'DISTRICT', 'YEAR', crime])
elif (self.combobox_district.get_active_text() == 'All'):
self.filtered_data = self.data.query(
'STATEorUT == @self.combobox_state.get_active_text() and YEAR == @intyear'
).filter(items=['STATEorUT', 'DISTRICT', 'YEAR', crime])
elif (self.combobox_year.get_active_text() == "All"):
self.filtered_data = self.data.query(
'STATEorUT == @self.combobox_state.get_active_text() and DISTRICT == @self.combobox_district.get_active_text()'
).filter(items=['STATEorUT', 'DISTRICT', 'YEAR', crime])
else:
self.filtered_data = self.data.query(
'STATEorUT == @self.combobox_state.get_active_text() and DISTRICT == @self.combobox_district.get_active_text() and YEAR == @intyear'
).filter(items=['STATEorUT', 'DISTRICT', 'YEAR', crime])
return
def compare_states(self, widget):
crimes = [
"MURDER", "RAPE", "KIDNAPPING.ABDUCTION", "RIOTS", "ROBBERY",
"BURGLARY", "DOWRY.DEATHS"
]
intyear = int(self.combobox_yearc.get_active_text())
state1_data = self.data.query(
'STATEorUT == @self.combobox_state1.get_active_text() and YEAR == @intyear'
).filter(items=[
'STATEorUT', 'DISTRICT', 'YEAR', crimes[0], crimes[1], crimes[2],
crimes[3], crimes[4], crimes[5], crimes[6]
])[self.data.DISTRICT == 'TOTAL']
state2_data = self.data.query(
'STATEorUT == @self.combobox_state2.get_active_text() and YEAR == @intyear'
).filter(items=[
'STATEorUT', 'DISTRICT', 'YEAR', crimes[0], crimes[1], crimes[2],
crimes[3], crimes[4], crimes[5], crimes[6]
])[self.data.DISTRICT == 'TOTAL']
print(state1_data.iloc[0]['MURDER'])
state1_total = [
state1_data.iloc[0][crimes[0]], state1_data.iloc[0][crimes[1]],
state1_data.iloc[0][crimes[2]], state1_data.iloc[0][crimes[3]],
state1_data.iloc[0][crimes[4]], state1_data.iloc[0][crimes[5]],
state1_data.iloc[0][crimes[6]]
]
state2_total = [
state2_data.iloc[0][crimes[0]], state2_data.iloc[0][crimes[1]],
state2_data.iloc[0][crimes[2]], state2_data.iloc[0][crimes[3]],
state2_data.iloc[0][crimes[4]], state2_data.iloc[0][crimes[5]],
state2_data.iloc[0][crimes[6]]
]
print(state1_total)
dialog = gtk.Dialog("My dialog", self,
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
(gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
fig = Figure(figsize=(5, 4), dpi=100)
dialog.set_size_request(1300, 500)
ax = fig.add_subplot(111)
ypos = np.arange(len(crimes))
print(ypos)
p1 = ax.bar(ypos - 0.4,
state1_total,
width=0.4,
color='r',
align='center')
p2 = ax.bar(ypos, state2_total, width=0.4, color='b', align='center')
ax.set_title("Comparison of " +
self.combobox_state1.get_active_text() + " and " +
self.combobox_state2.get_active_text())
ax.set_xticks(ypos - 0.2)
ax.set_xticklabels(crimes)
ax.set_ylabel('Total Crimes')
ax.legend((p1[0], p2[0]), (self.combobox_state1.get_active_text(),
self.combobox_state2.get_active_text()))
canvas = FigureCanvas(fig) # a gtk.DrawingArea
canvas.set_size_request(800, 600)
dialog.vbox.pack_start(canvas)
toolbar = NavigationToolbar(canvas, dialog)
dialog.vbox.pack_start(toolbar, False, False)
canvas.show()
dialog.run()
dialog.destroy()
return
def create_ui(self):
self.set_border_width(5)
app_vbox = gtk.VBox(spacing=5)
self.module_hbox = gtk.HBox(spacing=5)
app_vbox.pack_start(self.module_hbox, fill=False, expand=False)
label = gtk.Label()
label.set_markup('<b>%s</b>' % _('Choose Module:'))
self.module_hbox.pack_start(label, fill=False, expand=False)
self.module_combo = gtk.ComboBox(self.modules_list_model)
cell = gtk.CellRendererText()
self.module_combo.pack_start(cell, True)
self.module_combo.add_attribute(cell, 'text', 0)
self.module_combo.changed_signal_id = self.module_combo.connect(
'changed', self.on_module_selection_changed_cb)
self.module_combo.set_row_separator_func(lambda x, y: x.get(y, 1)[0])
self.module_hbox.pack_start(self.module_combo, fill=True)
separator = gtk.VSeparator()
self.module_hbox.pack_start(separator, fill=False, expand=False)
preferences = gtk.Button(stock=gtk.STOCK_PREFERENCES)
preferences.connect('clicked', self.on_preferences_cb)
self.module_hbox.pack_start(preferences, fill=False, expand=False)
self.progressbar = gtk.ProgressBar()
self.progressbar.set_text(_('Build Progress'))
app_vbox.pack_start(self.progressbar, fill=False, expand=False)
expander = gtk.Expander(_('Terminal'))
expander.set_expanded(False)
app_vbox.pack_start(expander, fill=False, expand=False)
sclwin = gtk.ScrolledWindow()
sclwin.set_size_request(-1, 300)
sclwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_ALWAYS)
expander.add(sclwin)
if vte:
self.terminal = vte.Terminal()
self.terminal.connect('child-exited', self.on_vte_child_exit_cb)
else:
os.environ['TERM'] = 'dumb' # avoid commands printing vt sequences
self.terminal = gtk.TextView()
self.terminal.set_size_request(800, -1)
textbuffer = self.terminal.get_buffer()
terminal_bold_tag = textbuffer.create_tag('bold')
terminal_bold_tag.set_property('weight', pango.WEIGHT_BOLD)
terminal_mono_tag = textbuffer.create_tag('mono')
terminal_mono_tag.set_property('family', 'Monospace')
terminal_stdout_tag = textbuffer.create_tag('stdout')
terminal_stdout_tag.set_property('family', 'Monospace')
terminal_stderr_tag = textbuffer.create_tag('stderr')
terminal_stderr_tag.set_property('family', 'Monospace')
terminal_stderr_tag.set_property('foreground', 'red')
terminal_stdin_tag = textbuffer.create_tag('stdin')
terminal_stdin_tag.set_property('family', 'Monospace')
terminal_stdin_tag.set_property('style', pango.STYLE_ITALIC)
self.terminal.set_editable(False)
self.terminal.set_wrap_mode(gtk.WRAP_CHAR)
sclwin.add(self.terminal)
self.terminal_sclwin = sclwin
self.error_hbox = self.create_error_hbox()
app_vbox.pack_start(self.error_hbox, fill=False, expand=False)
buttonbox = gtk.HButtonBox()
buttonbox.set_layout(gtk.BUTTONBOX_END)
app_vbox.pack_start(buttonbox, fill=False, expand=False)
# Translators: This is a button label (to start build)
self.build_button = gtk.Button(_('Start'))
self.build_button.connect('clicked', self.on_build_cb)
buttonbox.add(self.build_button)
button = gtk.Button(stock=gtk.STOCK_HELP)
button.connect('clicked', self.on_help_cb)
buttonbox.add(button)
buttonbox.set_child_secondary(button, True)
app_vbox.show_all()
self.error_hbox.hide()
self.add(app_vbox)
def __init__(self):
# Before anything, parse command line options if any present...
opt_parser = optparse.OptionParser()
opt_parser.add_option("-H",
"--start-hidden",
action="store_true",
default=False,
dest="hidden",
help="Start iconified in tray")
opt_parser.add_option(
"-F",
"--favorite",
dest="favorite",
help="Load the specified favorite and connect to UPS")
(cmd_opts, args) = opt_parser.parse_args()
self.__glade_file = os.path.join(os.path.dirname(sys.argv[0]),
"gui-1.3.glade")
self.__widgets["interface"] = gtk.glade.XML(self.__glade_file,
"window1", APP)
self.__widgets["main_window"] = self.__widgets["interface"].get_widget(
"window1")
self.__widgets["status_bar"] = self.__widgets["interface"].get_widget(
"statusbar2")
self.__widgets["ups_host_entry"] = self.__widgets[
"interface"].get_widget("entry1")
self.__widgets["ups_port_entry"] = self.__widgets[
"interface"].get_widget("spinbutton1")
self.__widgets["ups_refresh_button"] = self.__widgets[
"interface"].get_widget("button1")
self.__widgets["ups_authentication_check"] = self.__widgets[
"interface"].get_widget("checkbutton1")
self.__widgets["ups_authentication_frame"] = self.__widgets[
"interface"].get_widget("hbox1")
self.__widgets["ups_authentication_login"] = self.__widgets[
"interface"].get_widget("entry2")
self.__widgets["ups_authentication_password"] = self.__widgets[
"interface"].get_widget("entry3")
self.__widgets["ups_list_combo"] = self.__widgets[
"interface"].get_widget("combobox1")
self.__widgets["ups_commands_button"] = self.__widgets[
"interface"].get_widget("button8")
self.__widgets["ups_connect"] = self.__widgets["interface"].get_widget(
"button2")
self.__widgets["ups_disconnect"] = self.__widgets[
"interface"].get_widget("button7")
self.__widgets["ups_params_box"] = self.__widgets[
"interface"].get_widget("vbox6")
self.__widgets["ups_infos"] = self.__widgets["interface"].get_widget(
"notebook1")
self.__widgets["ups_vars_tree"] = self.__widgets[
"interface"].get_widget("treeview1")
self.__widgets["ups_vars_refresh"] = self.__widgets[
"interface"].get_widget("button9")
self.__widgets["ups_status_image"] = self.__widgets[
"interface"].get_widget("image1")
self.__widgets["ups_status_left"] = self.__widgets[
"interface"].get_widget("label10")
self.__widgets["ups_status_right"] = self.__widgets[
"interface"].get_widget("label11")
self.__widgets["ups_status_time"] = self.__widgets[
"interface"].get_widget("label15")
self.__widgets["menu_favorites_root"] = self.__widgets[
"interface"].get_widget("menuitem3")
self.__widgets["menu_favorites"] = self.__widgets[
"interface"].get_widget("menu2")
self.__widgets["menu_favorites_add"] = self.__widgets[
"interface"].get_widget("menuitem4")
self.__widgets["menu_favorites_del"] = self.__widgets[
"interface"].get_widget("menuitem5")
self.__widgets["progress_battery_charge"] = self.__widgets[
"interface"].get_widget("progressbar1")
self.__widgets["progress_battery_load"] = self.__widgets[
"interface"].get_widget("progressbar2")
# Create the tray icon and connect it to the show/hide method...
self.__widgets["status_icon"] = gtk.StatusIcon()
self.__widgets["status_icon"].set_from_file(
os.path.join(os.path.dirname(sys.argv[0]), "pixmaps",
"on_line.png"))
self.__widgets["status_icon"].set_visible(True)
self.__widgets["status_icon"].connect("activate", self.tray_activated)
self.__widgets["ups_status_image"].set_from_file(
os.path.join(os.path.dirname(sys.argv[0]), "pixmaps",
"on_line.png"))
# Define interface callbacks actions
self.__callbacks = {
"on_window1_destroy": self.quit,
"on_imagemenuitem1_activate": self.gui_about_dialog,
"on_imagemenuitem5_activate": self.quit,
"on_entry1_changed": self.__check_gui_fields,
"on_entry2_changed": self.__check_gui_fields,
"on_entry3_changed": self.__check_gui_fields,
"on_checkbutton1_toggled": self.__check_gui_fields,
"on_spinbutton1_value_changed": self.__check_gui_fields,
"on_button1_clicked": self.__update_ups_list,
"on_button2_clicked": self.connect_to_ups,
"on_button7_clicked": self.disconnect_from_ups,
"on_button9_clicked": self.__gui_update_ups_vars_view,
"on_menuitem4_activate": self.__gui_add_favorite,
"on_menuitem5_activate": self.__gui_delete_favorite,
"on_treeview1_button_press_event": self.__gui_ups_vars_selected
}
# Connect the callbacks
self.__widgets["interface"].signal_autoconnect(self.__callbacks)
# Remove the dummy combobox entry on UPS List and Commands
self.__widgets["ups_list_combo"].remove_text(0)
# Set UPS vars treeview properties -----------------------------
store = gtk.ListStore(gtk.gdk.Pixbuf, gobject.TYPE_STRING,
gobject.TYPE_STRING)
self.__widgets["ups_vars_tree"].set_model(store)
self.__widgets["ups_vars_tree"].set_headers_visible(True)
# Column 0
cr = gtk.CellRendererPixbuf()
column = gtk.TreeViewColumn('', cr)
column.add_attribute(cr, 'pixbuf', 0)
self.__widgets["ups_vars_tree"].append_column(column)
# Column 1
cr = gtk.CellRendererText()
cr.set_property('editable', False)
column = gtk.TreeViewColumn(_('Var name'), cr)
column.set_sort_column_id(1)
column.add_attribute(cr, 'text', 1)
self.__widgets["ups_vars_tree"].append_column(column)
# Column 2
cr = gtk.CellRendererText()
cr.set_property('editable', False)
column = gtk.TreeViewColumn(_('Value'), cr)
column.add_attribute(cr, 'text', 2)
self.__widgets["ups_vars_tree"].append_column(column)
self.__widgets["ups_vars_tree"].get_model().set_sort_column_id(
1, gtk.SORT_ASCENDING)
self.__widgets["ups_vars_tree_store"] = store
self.__widgets["ups_vars_tree"].set_size_request(-1, 50)
#---------------------------------------------------------------
# UPS Commands combo box creation ------------------------------
container = self.__widgets["ups_commands_button"].get_parent()
self.__widgets["ups_commands_button"].destroy()
self.__widgets["ups_commands_combo"] = gtk.ComboBox()
list_store = gtk.ListStore(gobject.TYPE_STRING)
self.__widgets["ups_commands_combo"].set_model(list_store)
cell_renderer = gtk.CellRendererText()
cell_renderer.set_property("xalign", 0)
self.__widgets["ups_commands_combo"].pack_start(cell_renderer, True)
self.__widgets["ups_commands_combo"].add_attribute(
cell_renderer, "markup", 0)
container.pack_start(self.__widgets["ups_commands_combo"], True)
self.__widgets["ups_commands_combo"].set_active(0)
self.__widgets["ups_commands_combo"].show_all()
self.__widgets["ups_commands_button"] = gtk.Button(
stock=gtk.STOCK_EXECUTE)
container.pack_start(self.__widgets["ups_commands_button"], True)
self.__widgets["ups_commands_button"].show()
self.__widgets["ups_commands_button"].connect(
"clicked", self.__gui_send_ups_command)
self.__widgets["ups_commands_combo_store"] = list_store
#---------------------------------------------------------------
if (cmd_opts.hidden != True):
self.__widgets["main_window"].show()
# Define favorites path and load favorites
if (platform.system() == "Linux"):
self.__favorites_path = os.path.join(os.environ.get("HOME"),
".nut-monitor")
elif (platform.system() == "Windows"):
self.__favorites_path = os.path.join(os.environ.get("USERPROFILE"),
"Application Data",
"NUT-Monitor")
self.__favorites_file = os.path.join(self.__favorites_path,
"favorites.ini")
self.__parse_favorites()
self.gui_status_message(_("Welcome to NUT Monitor"))
if (cmd_opts.favorite != None):
if (self.__favorites.has_key(cmd_opts.favorite)):
self.__gui_load_favorite(fav_name=cmd_opts.favorite)
self.connect_to_ups()
else:
# Try to scan localhost for available ups and connect to it if there is only one
self.__widgets["ups_host_entry"].set_text("localhost")
self.__update_ups_list()
if (len(self.__widgets["ups_list_combo"].get_model()) == 1):
self.connect_to_ups()
def __init__(self, parent, profile_store, profiles, callback):
self.profiles = profiles
self.current_database = None
self.old_profile, self.current_profile = None, None
self.db_cache = None
self.updating_db = False
# GTK Stuffs
self.parent = parent
self.dialog = gtk.Dialog(title=_(u'Profile Editor'), parent=parent,
flags=gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT)
self.ok_button = self.dialog.add_button(gtk.STOCK_OK,
gtk.RESPONSE_ACCEPT)
self.dialog.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
self.dialog.set_icon(TRYTON_ICON)
hpaned = gtk.HPaned()
vbox_profiles = gtk.VBox(homogeneous=False, spacing=6)
self.cell = gtk.CellRendererText()
self.cell.set_property('editable', True)
self.cell.connect('editing-started', self.edit_started)
self.profile_tree = gtk.TreeView()
self.profile_tree.set_model(profile_store)
self.profile_tree.insert_column_with_attributes(-1, _(u'Profile'),
self.cell, text=0)
self.profile_tree.connect('cursor-changed', self.profile_selected)
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scroll.add(self.profile_tree)
self.add_button = gtk.Button(_(u'_Add'), use_underline=True)
self.add_button.connect('clicked', self.profile_create)
add_image = gtk.Image()
add_image.set_from_stock('gtk-add', gtk.ICON_SIZE_BUTTON)
self.add_button.set_image(add_image)
self.remove_button = gtk.Button(_(u'_Remove'), use_underline=True)
self.remove_button.connect('clicked', self.profile_delete)
remove_image = gtk.Image()
remove_image.set_from_stock('gtk-remove', gtk.ICON_SIZE_BUTTON)
self.remove_button.set_image(remove_image)
vbox_profiles.pack_start(scroll, expand=True, fill=True)
vbox_profiles.pack_start(self.add_button, expand=False, fill=True)
vbox_profiles.pack_start(self.remove_button, expand=False, fill=True)
hpaned.add1(vbox_profiles)
table = gtk.Table(4, 2, homogeneous=False)
table.set_row_spacings(3)
table.set_col_spacings(3)
host = gtk.Label(_(u'Host:'))
host.set_alignment(1, 0.5)
host.set_padding(3, 3)
self.host_entry = gtk.Entry()
self.host_entry.connect('focus-out-event', self.display_dbwidget)
self.host_entry.connect('changed', self.update_profiles, 'host')
self.host_entry.set_activates_default(True)
host.set_mnemonic_widget(self.host_entry)
table.attach(host, 0, 1, 1, 2, yoptions=False, xoptions=gtk.FILL)
table.attach(self.host_entry, 1, 2, 1, 2, yoptions=False)
database = gtk.Label(_(u'Database:'))
database.set_alignment(1, 0.5)
database.set_padding(3, 3)
self.database_entry = gtk.Entry()
self.database_entry.connect('changed', self.dbentry_changed)
self.database_entry.connect('changed', self.update_profiles,
'database')
self.database_entry.set_activates_default(True)
self.database_label = gtk.Label()
self.database_label.set_use_markup(True)
self.database_label.set_alignment(0, 0.5)
self.database_combo = gtk.ComboBox()
dbstore = gtk.ListStore(gobject.TYPE_STRING)
cell = gtk.CellRendererText()
self.database_combo.pack_start(cell, True)
self.database_combo.add_attribute(cell, 'text', 0)
self.database_combo.set_model(dbstore)
self.database_combo.connect('changed', self.dbcombo_changed)
self.database_progressbar = gtk.ProgressBar()
self.database_progressbar.set_text(_(u'Fetching databases list'))
image = gtk.Image()
image.set_from_stock('tryton-new', gtk.ICON_SIZE_BUTTON)
db_box = gtk.VBox(homogeneous=True)
db_box.pack_start(self.database_entry)
db_box.pack_start(self.database_combo)
db_box.pack_start(self.database_label)
db_box.pack_start(self.database_progressbar)
# Compute size_request of box in order to prevent "form jumping"
width, height = 0, 0
for child in db_box.get_children():
cwidth, cheight = child.size_request()
width, height = max(width, cwidth), max(height, cheight)
db_box.set_size_request(width, height)
table.attach(database, 0, 1, 2, 3, yoptions=False, xoptions=gtk.FILL)
table.attach(db_box, 1, 2, 2, 3, yoptions=False)
username = gtk.Label(_(u'Username:'******'changed', self.update_profiles,
'username')
username.set_mnemonic_widget(self.username_entry)
self.username_entry.set_activates_default(True)
table.attach(username, 0, 1, 3, 4, yoptions=False, xoptions=gtk.FILL)
table.attach(self.username_entry, 1, 2, 3, 4, yoptions=False)
hpaned.add2(table)
hpaned.set_position(250)
self.dialog.vbox.pack_start(hpaned)
self.dialog.set_default_size(640, 350)
self.dialog.set_default_response(gtk.RESPONSE_ACCEPT)
self.dialog.connect('close', lambda *a: False)
self.dialog.connect('response', self.response)
self.callback = callback
def __init__(self, parent, application):
SettingsPage.__init__(self, parent, application, 'view_and_edit',
_('View & Edit'))
# viewer options
frame_view = gtk.Frame(_('View'))
label_not_implemented = gtk.Label(
'This option is not implemented yet.')
label_not_implemented.set_sensitive(False)
# editor options
frame_edit = gtk.Frame(_('Edit'))
vbox_edit = gtk.VBox(False, 0)
vbox_edit.set_border_width(5)
# installed application
self._radio_application = gtk.RadioButton(
label=_('Use installed application'))
self._radio_application.connect('toggled', self._parent.enable_save)
align_application = gtk.Alignment(xscale=1)
align_application.set_padding(0, 10, 15, 15)
vbox_application = gtk.VBox(False, 0)
vbox_application.set_border_width(5)
self._store = gtk.ListStore(str, str, str)
self._combobox_application = gtk.ComboBox(model=self._store)
self._combobox_application.connect('changed', self._parent.enable_save)
cell_icon = gtk.CellRendererPixbuf()
cell_name = gtk.CellRendererText()
self._combobox_application.pack_start(cell_icon, False)
self._combobox_application.pack_start(cell_name, True)
self._combobox_application.add_attribute(cell_icon, 'icon-name',
Column.ICON)
self._combobox_application.add_attribute(cell_name, 'text',
Column.NAME)
# external options
self._radio_external = gtk.RadioButton(group=self._radio_application,
label=_('Use external command'))
self._radio_external.connect('toggled', self._parent.enable_save)
align_external = gtk.Alignment(xscale=1)
align_external.set_padding(0, 10, 15, 15)
vbox_external = gtk.VBox(False, 0)
vbox_external.set_border_width(5)
label_editor = gtk.Label(_('Command line:'))
label_editor.set_alignment(0, 0.5)
label_editor.set_use_markup(True)
self._entry_editor = gtk.Entry()
self._entry_editor.connect('changed', self._parent.enable_save)
self._checkbox_terminal_command = gtk.CheckButton(
_('Execute command in terminal tab'))
self._checkbox_terminal_command.connect('toggled',
self._parent.enable_save)
# pack ui
vbox_application.pack_start(self._combobox_application, False, False,
0)
align_application.add(vbox_application)
vbox_external.pack_start(label_editor, False, False, 0)
vbox_external.pack_start(self._entry_editor, False, False, 0)
vbox_external.pack_start(self._checkbox_terminal_command, False, False,
0)
align_external.add(vbox_external)
vbox_edit.pack_start(self._radio_application, False, False, 0)
vbox_edit.pack_start(align_application, False, False, 0)
vbox_edit.pack_start(self._radio_external, False, False, 0)
vbox_edit.pack_start(align_external, False, False, 0)
frame_view.add(label_not_implemented)
frame_edit.add(vbox_edit)
self.pack_start(frame_view, False, False, 0)
self.pack_start(frame_edit, False, False, 0)
def __init__(self, parent, application):
SettingsPage.__init__(self, parent, application, 'terminal',
_('Terminal'))
# create vte terminal options
align_vte = gtk.Alignment(xscale=1)
align_vte.set_padding(0, 10, 15, 15)
self._vbox_vte = gtk.VBox(False, 0)
self._radio_vte = gtk.RadioButton(label=_('VTE based terminal'))
self._radio_vte.connect('toggled', self._parent.enable_save)
# option for showing scrollbars
self._checkbox_scrollbars_visible = gtk.CheckButton(
_('Show scrollbars when needed'))
self._checkbox_scrollbars_visible.connect('toggled',
self._parent.enable_save)
# option for custom font
self._align_font = gtk.Alignment()
self._align_font.set_padding(0, 0, 15, 15)
hbox_font = gtk.HBox(False, 5)
self._checkbox_system_font = gtk.CheckButton(
_('Use the system fixed width font'))
self._checkbox_system_font.connect('toggled',
self.__toggled_system_font)
label_font = gtk.Label(_('Font:'))
label_font.set_alignment(0, 0.5)
self._button_font = gtk.FontButton()
self._button_font.connect('font-set', self._parent.enable_save)
# option for cursor shape
hbox_cursor_shape = gtk.HBox(False, 5)
label_cursor_shape = gtk.Label(_('Cursor shape:'))
label_cursor_shape.set_alignment(0, 0.5)
list_cursor_shape = gtk.ListStore(str, int)
list_cursor_shape.append((_('Block'), CursorShape.BLOCK))
list_cursor_shape.append((_('I-Beam'), CursorShape.IBEAM))
list_cursor_shape.append((_('Underline'), CursorShape.UNDERLINE))
cell_cursor_shape = gtk.CellRendererText()
self._combobox_cursor_shape = gtk.ComboBox(list_cursor_shape)
self._combobox_cursor_shape.connect('changed',
self._parent.enable_save)
self._combobox_cursor_shape.pack_start(cell_cursor_shape)
self._combobox_cursor_shape.add_attribute(cell_cursor_shape, 'text', 0)
# option for allowing bold text in terminal
self._checkbox_allow_bold = gtk.CheckButton(_('Allow bold text'))
self._checkbox_allow_bold.connect('toggled', self._parent.enable_save)
# option for automatically hiding mouse when typing
self._checkbox_autohide_mouse = gtk.CheckButton(
_('Automatically hide mouse when typing'))
self._checkbox_autohide_mouse.connect('toggled',
self._parent.enable_save)
# create external terminal options
align_external = gtk.Alignment(xscale=1)
align_external.set_padding(0, 0, 15, 15)
self._vbox_external = gtk.VBox(False, 5)
self._radio_external = gtk.RadioButton(group=self._radio_vte,
label=_('External terminal'))
vbox_command = gtk.VBox(False, 0)
label_command = gtk.Label(_('Command line:'))
label_command.set_alignment(0, 0.5)
self._entry_command = gtk.Entry()
self._entry_command.connect('changed', self._parent.enable_save)
vbox_command2 = gtk.VBox(False, 0)
label_command2 = gtk.Label(
_('Command line for executing specific program:'))
label_command2.set_alignment(0, 0.5)
self._entry_command2 = gtk.Entry()
self._entry_command2.connect('changed', self._parent.enable_save)
label_note = gtk.Label(
_('<small><i>Note:'
'\n\tOmitting {0} will open new terminal application instead of tab.'
'\n\t{0} will be replaced with socket/window id.'
'\n\t{1} will be replaced with specified command and its parameters.'
'\n\t{2} will be replaced with current working directory.'
'</i></small>'))
label_note.set_alignment(0, 0)
label_note.set_use_markup(True)
# pack interface
hbox_font.pack_start(label_font, False, False, 0)
hbox_font.pack_start(self._button_font, True, True, 0)
self._align_font.add(hbox_font)
hbox_cursor_shape.pack_start(label_cursor_shape, False, False, 0)
hbox_cursor_shape.pack_start(self._combobox_cursor_shape, False, False,
0)
vbox_command.pack_start(label_command, False, False, 0)
vbox_command.pack_start(self._entry_command, False, False, 0)
vbox_command2.pack_start(label_command2, False, False, 0)
vbox_command2.pack_start(self._entry_command2, False, False, 0)
self._vbox_vte.pack_start(self._checkbox_scrollbars_visible, False,
False, 0)
self._vbox_vte.pack_start(self._checkbox_system_font, False, False, 0)
self._vbox_vte.pack_start(self._align_font, False, False, 0)
self._vbox_vte.pack_start(hbox_cursor_shape, False, False, 5)
self._vbox_vte.pack_start(self._checkbox_allow_bold, False, False, 0)
self._vbox_vte.pack_start(self._checkbox_autohide_mouse, False, False,
0)
self._vbox_external.pack_start(vbox_command, False, False, 0)
self._vbox_external.pack_start(vbox_command2, False, False, 0)
self._vbox_external.pack_start(label_note, False, False, 0)
align_vte.add(self._vbox_vte)
align_external.add(self._vbox_external)
self.pack_start(self._radio_vte, False, False, 0)
self.pack_start(align_vte, False, False, 0)
self.pack_start(self._radio_external, False, False, 0)
self.pack_start(align_external, False, False, 0)
def Populate(self):
"""
Creates all the widgets for intruments and devices that compose the
InstrumentConnectionsDialog and then adds them to the dialog.
"""
self.devices_list = []
liststore = gtk.ListStore(gobject.TYPE_STRING)
#Find out how many channels a device offers
for device, deviceName in AudioBackend.ListCaptureDevices():
#Don't want the default device twice (once as 'default' and once as its actual hw ref)
# Default will always be the first one, and have no name.
if not self.devices_list and not deviceName:
if device == "default":
display = _("Default")
else:
display = _("Default (%s)") % device
self.devices_list.append((device, display, -1))
liststore.append((display, ))
else:
num_channels = AudioBackend.GetChannelsOffered(device)
for input in xrange(num_channels):
if num_channels > 1:
s = _("%(device)s (%(id)s), input %(input)d")
display = s % {
"device": deviceName,
"id": device,
"input": input
}
else:
display = _("%(device)s (%(id)s)") % {
"device": deviceName,
"id": device
}
self.devices_list.append((device, deviceName, input))
liststore.append((display, ))
if self.devices_list:
for instr in self.project.instruments:
instrument = instr
row = gtk.HBox()
row.set_spacing(10)
image = gtk.Image()
image.set_from_pixbuf(instrument.pixbuf)
label = gtk.Label(instrument.name)
combobox = gtk.ComboBox(liststore)
cell = gtk.CellRendererText()
combobox.pack_start(cell, True)
combobox.add_attribute(cell, 'text', 0)
if instr.input is None:
# None means default; default is first in combobox
combobox.set_active(0)
else:
currentItem = 0
for device, deviceName, input in self.devices_list:
if instr.input == device and input == instr.inTrack:
combobox.set_active(currentItem)
currentItem += 1
combobox.connect("changed", self.OnSelected, instr)
row.pack_start(combobox, True, True)
row.pack_start(image, False, False)
row.pack_start(label, False, False)
self.vbox.add(row)
else:
audiosrc = Globals.settings.recording["audiosrc"]
sound_system = None
for name, element in Globals.CAPTURE_BACKENDS:
if element == audiosrc:
sound_system = name
if sound_system:
msg = _(
"The %(sound-system-name)s sound system does not support device selection."
)
msg %= {"sound-system-name": sound_system}
else:
msg = _(
'The "%(custom-pipeline)s" sound system does not support device selection.'
)
msg %= {"custom-pipeline": audiosrc}
self.gtk_builder.get_object("explainLabel").set_text(msg)
self.vbox.hide()
def __init__(self):
self.saved_views = {}
self.gtk = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.gtk.set_title('Demo of a Mockup of OOF3D Interface')
self.gtk.set_default_size(initial_width, initial_height)
self.gtk.connect("destroy", self.destroy)
self.gtk.connect("delete_event", self.destroy)
self.cubeActor = None
# set up areas
self.panes = gtk.HPaned()
self.gtk.add(self.panes)
self.canvas = Canvas3D(self)
self.panes.add2(self.canvas)
self.toolboxframe = gtk.Frame()
self.toolboxframe.set_shadow_type(gtk.SHADOW_IN)
self.panes.add1(self.toolboxframe)
self.scroll = gtk.ScrolledWindow()
self.scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.toolboxframe.add(self.scroll)
self.mainbox = gtk.VBox()
self.scroll.add_with_viewport(self.mainbox)
# viewer widgets
viewerframe = gtk.Frame("Viewer Widgets")
viewerframe.set_shadow_type(gtk.SHADOW_IN)
self.mainbox.pack_start(viewerframe)
viewerbox = gtk.VBox()
viewerframe.add(viewerbox)
self.tooltips = gtk.Tooltips()
# camera position
infoframe = gtk.Frame("Camera Info")
infoframe.set_shadow_type(gtk.SHADOW_IN)
viewerbox.pack_start(infoframe, fill=0, expand=0)
infobox = gtk.VBox()
infoframe.add(infobox)
positionlabel = gtk.Label("Camera Position:")
#self.tooltips.set_tip(positionlabel, "The position of the camera in world coordinates (pixel units)")
infobox.pack_start(positionlabel,fill=0, expand=0)
positiontable = gtk.Table(columns=3, rows=1)
infobox.pack_start(positiontable,fill=0, expand=0)
self.camera_x = gtk.Entry()
self.camera_x.set_size_request(90,-1)
self.camera_x.set_editable(0)
positiontable.attach(self.camera_x,0,1,0,1)
self.camera_y = gtk.Entry()
self.camera_y.set_size_request(90,-1)
self.camera_y.set_editable(0)
positiontable.attach(self.camera_y,1,2,0,1)
self.camera_z = gtk.Entry()
self.camera_z.set_size_request(90,-1)
self.camera_z.set_editable(0)
positiontable.attach(self.camera_z,2,3,0,1)
focalpointlabel = gtk.Label("Focal Point:")
#self.tooltips.set_tip(focalpointlabel, "The position of the focal point in world coordinates (pixel units)")
infobox.pack_start(focalpointlabel,fill=0, expand=0)
focalpointtable = gtk.Table(columns=3, rows=1)
infobox.pack_start(focalpointtable,fill=0, expand=0)
self.fp_x = gtk.Entry()
self.fp_x.set_size_request(90,-1)
self.fp_x.set_editable(0)
focalpointtable.attach(self.fp_x,0,1,0,1)
self.fp_y = gtk.Entry()
self.fp_y.set_size_request(90,-1)
self.fp_y.set_editable(0)
focalpointtable.attach(self.fp_y,1,2,0,1)
self.fp_z = gtk.Entry()
self.fp_z.set_size_request(90,-1)
self.fp_z.set_editable(0)
focalpointtable.attach(self.fp_z,2,3,0,1)
viewuplabel = gtk.Label("View Up Vector:")
#self.tooltips.set_tip(viewuplabel, "The vector that points up in the viewport")
infobox.pack_start(viewuplabel,fill=0, expand=0)
viewuptable = gtk.Table(columns=3, rows=1)
infobox.pack_start(viewuptable,fill=0, expand=0)
self.viewup_x = gtk.Entry()
self.viewup_x.set_size_request(90,-1)
self.viewup_x.set_editable(0)
viewuptable.attach(self.viewup_x,0,1,0,1)
self.viewup_y = gtk.Entry()
self.viewup_y.set_size_request(90,-1)
self.viewup_y.set_editable(0)
viewuptable.attach(self.viewup_y,1,2,0,1)
self.viewup_z = gtk.Entry()
self.viewup_z.set_size_request(90,-1)
self.viewup_z.set_editable(0)
viewuptable.attach(self.viewup_z,2,3,0,1)
distancetable = gtk.Table(columns=2, rows=1)
infobox.pack_start(distancetable,fill=0, expand=0)
distancelabel = gtk.Label("Distance:")
#self.tooltips.set_tip(distancelabel, "The distance from the camera to the focal point")
distancetable.attach(distancelabel,0,1,0,1)
self.distance = gtk.Entry()
self.distance.set_size_request(90,-1)
self.distance.set_editable(0)
distancetable.attach(self.distance,1,2,0,1)
angletable = gtk.Table(columns=2, rows=1)
infobox.pack_start(angletable,fill=0, expand=0)
anglelabel = gtk.Label("View Angle:")
#self.tooltips.set_tip(anglelabel, "The angle between the vectors from the camera to the focal point and from the camera to the top of the microstructure")
angletable.attach(anglelabel,0,1,0,1)
self.viewangle = gtk.Entry()
self.viewangle.set_size_request(90,-1)
self.viewangle.set_editable(0)
angletable.attach(self.viewangle,1,2,0,1)
printinfo = gtk.Button("Print Camera Info")
gtklogger.connect(printinfo, 'clicked', self.printcam)
self.tooltips.set_tip(printinfo, "Print the camera information in the console")
infobox.pack_start(printinfo,fill=0, expand=0)
# zoom - as in changing the viewing angle
zoomframe = gtk.Frame("Zoom")
zoomframe.set_shadow_type(gtk.SHADOW_IN)
viewerbox.pack_start(zoomframe, fill=0, expand=0)
zoombox = gtk.VBox()
zoomframe.add(zoombox)
buttonrow = gtk.HBox(homogeneous=1, spacing=2)
zoombox.pack_start(buttonrow, expand=0, fill=1, padding=2)
zinbutton = gtk.Button('Zoom In')
self.tooltips.set_tip(zinbutton,"Decrease view angle to by given factor")
buttonrow.pack_start(zinbutton, expand=0, fill=1)
gtklogger.connect(zinbutton, 'clicked', self.zoomin)
zoutbutton = gtk.Button('Zoom Out')
self.tooltips.set_tip(zoutbutton, "Increase view angle by given factor")
buttonrow.pack_start(zoutbutton, expand=0, fill=1)
gtklogger.connect(zoutbutton, 'clicked', self.zoomout)
zfillbutton = gtk.Button('Fill')
self.tooltips.set_tip(zfillbutton, "Set view angle such that microstructure approximately fills viewport")
buttonrow.pack_start(zfillbutton, expand=0, fill=1)
gtklogger.connect(zfillbutton, 'clicked', self.zoomfill)
factorrow = gtk.HBox()
zoombox.pack_start(factorrow, expand=0, fill=0, padding=2)
factorrow.pack_start(gtk.Label("Factor: "), expand=0, fill=0)
self.zoomfactor = gtk.Entry()
self.zoomfactor.set_editable(1)
self.zoomfactor.set_size_request(80, -1)
self.zoomfactor.set_text("1.5")
self.tooltips.set_tip(self.zoomfactor, "Factor by which to shrink or magnify image")
factorrow.pack_start(self.zoomfactor, expand=1, fill=1)
# Translation
# dolly
transframe = gtk.Frame("Translation")
transframe.set_shadow_type(gtk.SHADOW_IN)
viewerbox.pack_start(transframe, fill=0, expand=0)
transbox = gtk.VBox()
transframe.add(transbox)
dollyrow = gtk.HBox(homogeneous=1, spacing=2)
transbox.pack_start(dollyrow, expand=0, fill=1, padding=2)
inbutton = gtk.Button('Dolly In')
self.tooltips.set_tip(inbutton,"Translate camera towards focal point by given factor")
dollyrow.pack_start(inbutton, expand=0, fill=1)
gtklogger.connect(inbutton, 'clicked', self.dollyin)
outbutton = gtk.Button('Dolly Out')
self.tooltips.set_tip(outbutton, "Translate camera away from focal point by given factor")
dollyrow.pack_start(outbutton, expand=0, fill=1)
gtklogger.connect(outbutton, 'clicked', self.dollyout)
fillbutton = gtk.Button('Fill')
self.tooltips.set_tip(fillbutton, "Set camera position such that microstructure approximately fills viewport")
dollyrow.pack_start(fillbutton, expand=0, fill=1)
gtklogger.connect(fillbutton, 'clicked', self.dollyfill)
factorrow = gtk.HBox()
transbox.pack_start(factorrow, expand=0, fill=0, padding=2)
factorrow.pack_start(gtk.Label("Factor: "), expand=0, fill=0)
self.dollyfactor = gtk.Entry()
self.dollyfactor.set_editable(1)
self.dollyfactor.set_size_request(80, -1)
self.dollyfactor.set_text("1.5")
self.tooltips.set_tip(self.dollyfactor, "Factor by which to multiply distance from camera to focal point")
factorrow.pack_start(self.dollyfactor, expand=1, fill=1)
# track
trackrow = gtk.HBox(homogeneous=1, spacing=2)
transbox.pack_start(trackrow, expand=0, fill=1, padding=2)
horizbutton = gtk.Button('Horizontal')
self.tooltips.set_tip(horizbutton,"Shift camera and focal point horizontally")
trackrow.pack_start(horizbutton, expand=0, fill=1)
gtklogger.connect(horizbutton, 'clicked', self.trackh)
vertbutton = gtk.Button('Vertical')
self.tooltips.set_tip(vertbutton, "Shift camera and focal point vertically")
trackrow.pack_start(vertbutton, expand=0, fill=1)
gtklogger.connect(vertbutton, 'clicked', self.trackv)
recenterbutton = gtk.Button('Recenter')
self.tooltips.set_tip(recenterbutton, "Recenter the microstructure in the viewport")
trackrow.pack_start(recenterbutton, expand=0, fill=1)
gtklogger.connect(recenterbutton, 'clicked', self.recenter)
distrow = gtk.HBox()
transbox.pack_start(distrow, expand=0, fill=0, padding=2)
distrow.pack_start(gtk.Label("Distance: "), expand=0, fill=0)
self.trackdist = gtk.Entry()
self.trackdist.set_editable(1)
self.trackdist.set_size_request(80, -1)
self.trackdist.set_text("10.0")
self.tooltips.set_tip(self.trackdist, "Distance by which to track camera in units of pixels")
distrow.pack_start(self.trackdist, expand=1, fill=1)
label = gtk.Label("Dolly: Right Mouse Button\nTrack: Middle Mouse Button")
transbox.pack_start(label)
#rotate
rotateframe = gtk.Frame("Rotation")
rotateframe.set_shadow_type(gtk.SHADOW_IN)
viewerbox.pack_start(rotateframe, fill=0, expand=0)
rotatebox = gtk.VBox()
rotateframe.add(rotatebox)
rotobjrow = gtk.HBox(homogeneous=1, spacing=2)
rotatebox.pack_start(rotobjrow, expand=0, fill=1, padding=2)
rollbutton = gtk.Button('Roll')
self.tooltips.set_tip(rollbutton,"Rotate about direction of projection")
rotobjrow.pack_start(rollbutton, expand=0, fill=1)
gtklogger.connect(rollbutton, 'clicked', self.roll)
azbutton = gtk.Button('Azimuth')
self.tooltips.set_tip(azbutton, "Rotate about view up vector centered at focal point")
rotobjrow.pack_start(azbutton, expand=0, fill=1)
gtklogger.connect(azbutton, 'clicked', self.azimuth)
elbutton = gtk.Button('Elevation')
self.tooltips.set_tip(elbutton, "Rotate about cross product of direction of projection and view up vector centered at focal point")
rotobjrow.pack_start(elbutton, expand=0, fill=1)
gtklogger.connect(elbutton, 'clicked', self.elevation)
rotcamrow = gtk.HBox(homogeneous=1, spacing=2)
rotatebox.pack_start(rotcamrow, expand=0, fill=1, padding=2)
yawbutton = gtk.Button('Yaw')
self.tooltips.set_tip(yawbutton,"Rotate about view up vector centered at camera position")
rotcamrow.pack_start(yawbutton, expand=0, fill=1)
gtklogger.connect(yawbutton, 'clicked', self.yaw)
pitchbutton = gtk.Button('Pitch')
self.tooltips.set_tip(pitchbutton,"Rotate about cross product of direction of projection and view up vector centered at camera position")
rotcamrow.pack_start(pitchbutton, expand=0, fill=1)
gtklogger.connect(pitchbutton, 'clicked', self.pitch)
anglerow = gtk.HBox()
rotatebox.pack_start(anglerow, expand=0, fill=0, padding=2)
anglerow.pack_start(gtk.Label("Angle: "), expand=0, fill=0)
self.angle = gtk.Entry()
self.angle.set_editable(1)
self.angle.set_size_request(80, -1)
self.angle.set_text("10.0")
self.tooltips.set_tip(self.angle,"Angle in degrees by which to rotate by")
anglerow.pack_start(self.angle, expand=1, fill=1)
#clipping planes
clippingframe = gtk.Frame("Clipping Range")
clippingframe.set_shadow_type(gtk.SHADOW_IN)
viewerbox.pack_start(clippingframe, fill=0, expand=0)
clippingbox = gtk.VBox()
clippingframe.add(clippingbox)
self.clippingadj = gtk.Adjustment(value=100, lower=0, upper=100, step_incr=-1, page_incr=-5, page_size=0)
gtklogger.connect(self.clippingadj, 'value_changed', self.setclipping)
clippingscale = gtk.HScale(self.clippingadj)
clippingscale.set_update_policy(gtk.UPDATE_DELAYED)
self.tooltips.set_tip(clippingscale,"Adjust the near clipping plane to view cross section")
clippingbox.pack_start(clippingscale)
#opacity
opacityframe = gtk.Frame("Opacity")
opacityframe.set_shadow_type(gtk.SHADOW_IN)
viewerbox.pack_start(opacityframe, fill=0, expand=0)
opacitybox = gtk.VBox()
opacityframe.add(opacitybox)
self.opacityadj = gtk.Adjustment(value=100, lower=0, upper=100, step_incr=-1, page_incr=-5, page_size=0)
gtklogger.connect(self.opacityadj, 'value_changed', self.setopacity)
opacityscale = gtk.HScale(self.opacityadj)
opacityscale.set_update_policy(gtk.UPDATE_DELAYED)
self.tooltips.set_tip(opacityscale,"Adjust the opacity of the microstructure")
opacitybox.pack_start(opacityscale)
# save and restore
saverestoreframe = gtk.Frame("Save and Restore Views")
saverestoreframe.set_shadow_type(gtk.SHADOW_IN)
viewerbox.pack_start(saverestoreframe, fill=0, expand=0)
saverestorebox = gtk.VBox()
saverestoreframe.add(saverestorebox)
viewtable = gtk.Table(columns=2, rows=2)
saverestorebox.pack_start(viewtable, fill=0, expand=0)
saveviewbutton = gtk.Button("Save View:")
self.tooltips.set_tip(saveviewbutton,"Save the current view settings")
gtklogger.connect(saveviewbutton, 'clicked', self.saveview)
viewtable.attach(saveviewbutton, 0,1,0,1)
self.viewname = gtk.Entry()
self.viewname.set_editable(1)
self.viewname.set_size_request(80,-1)
self.tooltips.set_tip(self.viewname,"Enter a name for the current view")
viewtable.attach(self.viewname,1,2,0,1)
setviewlabel = gtk.Label("Set View:")
viewtable.attach(setviewlabel, 0,1,1,2)
liststore = gtk.ListStore(gobject.TYPE_STRING)
self.viewmenu = gtk.ComboBox(liststore)
cell = gtk.CellRendererText()
self.viewmenu.pack_start(cell, True)
self.viewmenu.add_attribute(cell, 'text', 0)
#self.tooltips.set_tip(self.viewmenu,"Restore a saved view")
# menu items filled in later when saved_views is initialized
self.signal = gtklogger.connect(self.viewmenu, 'changed',
self.setview)
viewtable.attach(self.viewmenu, 1,2,1,2)
# end viewer widgets
# voxel info widgets
voxelinfoframe = gtk.Frame("Voxel Info Widgets")
voxelinfoframe.set_shadow_type(gtk.SHADOW_IN)
self.mainbox.pack_start(voxelinfoframe)
voxelinfobox = gtk.VBox()
voxelinfoframe.add(voxelinfobox)
voxelinfotable = gtk.Table(rows=7,columns=2)
voxelinfobox.pack_start(voxelinfotable)
label = gtk.Label('x=')
label.set_alignment(1.0, 0.5)
voxelinfotable.attach(label, 0,1, 0,1, xpadding=5, xoptions=gtk.FILL)
self.xtext = gtk.Entry()
self.xtext.set_size_request(80, -1)
voxelinfotable.attach(self.xtext, 1,2, 0,1,
xpadding=5, xoptions=gtk.EXPAND|gtk.FILL)
label = gtk.Label('y=')
label.set_alignment(1.0, 0.5)
voxelinfotable.attach(label, 0,1, 1,2, xpadding=5, xoptions=gtk.FILL)
self.ytext = gtk.Entry()
self.ytext.set_size_request(80, -1)
voxelinfotable.attach(self.ytext, 1,2, 1,2,
xpadding=5, xoptions=gtk.EXPAND|gtk.FILL)
label = gtk.Label('z=')
label.set_alignment(1.0, 0.5)
voxelinfotable.attach(label, 0,1, 2,3, xpadding=5, xoptions=gtk.FILL)
self.ztext = gtk.Entry()
self.ztext.set_size_request(80, -1)
voxelinfotable.attach(self.ztext, 1,2, 2,3,
xpadding=5, xoptions=gtk.EXPAND|gtk.FILL)
self.xtsignal = gtklogger.connect(self.xtext, 'changed',
self.voxinfoChanged)
self.ytsignal = gtklogger.connect(self.ytext, 'changed',
self.voxinfoChanged)
self.ztsignal = gtklogger.connect(self.ztext, 'changed',
self.voxinfoChanged)
box = gtk.HBox(homogeneous=True, spacing=2)
self.updatebutton = gtk.Button(gtk.STOCK_REFRESH) #gtkutils.stockButton(gtk.STOCK_REFRESH, 'Update')
box.pack_start(self.updatebutton, expand=1, fill=1)
gtklogger.connect(self.updatebutton, 'clicked', self.updateVoxButtonCB)
self.clearbutton = gtk.Button(gtk.STOCK_CLEAR) #gtkutils.stockButton(gtk.STOCK_CLEAR, 'Clear')
box.pack_start(self.clearbutton, expand=1, fill=1)
gtklogger.setWidgetName(self.clearbutton, "Clear")
gtklogger.connect(self.clearbutton, 'clicked', self.clearVoxButtonCB)
voxelinfotable.attach(box, 0,2,3,4,
xpadding=5, xoptions=gtk.EXPAND|gtk.FILL, yoptions=0)
label = gtk.Label('red=')
label.set_alignment(1.0, 0.5)
voxelinfotable.attach(label, 0,1, 4,5, xpadding=5, xoptions=gtk.FILL)
self.redtext = gtk.Entry()
self.redtext.set_size_request(80, -1)
voxelinfotable.attach(self.redtext, 1,2, 4,5,
xpadding=5, xoptions=gtk.EXPAND|gtk.FILL)
label = gtk.Label('green=')
label.set_alignment(1.0, 0.5)
voxelinfotable.attach(label, 0,1, 5,6, xpadding=5, xoptions=gtk.FILL)
self.greentext = gtk.Entry()
self.greentext.set_size_request(80, -1)
voxelinfotable.attach(self.greentext, 1,2, 5,6,
xpadding=5, xoptions=gtk.EXPAND|gtk.FILL)
label = gtk.Label('blue=')
label.set_alignment(1.0, 0.5)
voxelinfotable.attach(label, 0,1, 6,7, xpadding=5, xoptions=gtk.FILL)
self.bluetext = gtk.Entry()
self.bluetext.set_size_request(80, -1)
voxelinfotable.attach(self.bluetext, 1,2, 6,7,
xpadding=5, xoptions=gtk.EXPAND|gtk.FILL)
currentVoxel = None
# voxel select widgets
## voxelselectframe = gtk.Frame("Voxel Select Widgets")
## voxelselectframe.set_shadow_type(gtk.SHADOW_IN)
## self.mainbox.pack_start(voxelselectframe)
## voxelselectbox = gtk.VBox()
## voxelselectframe.add(voxelselectbox)
## button = gtk.Button("Hello World")
## voxelselectbox.pack_start(button)
self.saveimage = gtk.Button("save image")
gtklogger.connect(self.saveimage, 'clicked', self.saveimageCB)
self.mainbox.pack_start(self.saveimage)
def build_storage_entry(self, disk, storage_box):
origpath = disk[STORAGE_INFO_ORIG_PATH]
devtype = disk[STORAGE_INFO_DEVTYPE]
size = disk[STORAGE_INFO_SIZE]
can_clone = disk[STORAGE_INFO_CAN_CLONE]
do_clone = disk[STORAGE_INFO_DO_CLONE]
can_share = disk[STORAGE_INFO_CAN_SHARE]
is_default = disk[STORAGE_INFO_DO_DEFAULT]
definfo = disk[STORAGE_INFO_DEFINFO]
failinfo = disk[STORAGE_INFO_FAILINFO]
target = disk[STORAGE_INFO_TARGET]
orig_name = self.orig_vm.get_name()
disk_label = os.path.basename(origpath)
info_label = None
if not can_clone:
info_label = gtk.Label()
info_label.set_alignment(0, .5)
info_label.set_markup("<span size='small'>%s</span>" % failinfo)
if not is_default:
disk_label += (definfo and " (%s)" % definfo or "")
# Build icon
icon = gtk.Image()
if devtype == virtinst.VirtualDisk.DEVICE_FLOPPY:
iconname = "media-floppy"
elif devtype == virtinst.VirtualDisk.DEVICE_CDROM:
iconname = "media-optical"
else:
iconname = "drive-harddisk"
icon.set_from_icon_name(iconname, gtk.ICON_SIZE_MENU)
disk_name_label = gtk.Label(disk_label)
disk_name_label.set_alignment(0, .5)
disk_name_box = gtk.HBox(spacing=9)
disk_name_box.pack_start(icon, False)
disk_name_box.pack_start(disk_name_label, True)
def sep_func(model, it, combo):
ignore = combo
return model[it][2]
# [String, sensitive, is sep]
model = gtk.ListStore(str, bool, bool)
option_combo = gtk.ComboBox(model)
text = gtk.CellRendererText()
option_combo.pack_start(text)
option_combo.add_attribute(text, "text", 0)
option_combo.add_attribute(text, "sensitive", 1)
option_combo.set_row_separator_func(sep_func, option_combo)
option_combo.connect("changed", self.storage_combo_changed, target)
vbox = gtk.VBox(spacing=1)
if can_clone or can_share:
model.insert(STORAGE_COMBO_CLONE,
[(_("Clone this disk") +
(size and " (%s)" % size or "")), can_clone, False])
model.insert(
STORAGE_COMBO_SHARE,
[_("Share disk with %s") % orig_name, can_share, False])
model.insert(STORAGE_COMBO_SEP, ["", False, True])
model.insert(STORAGE_COMBO_DETAILS, [_("Details..."), True, False])
if (can_clone and is_default) or do_clone:
option_combo.set_active(STORAGE_COMBO_CLONE)
else:
option_combo.set_active(STORAGE_COMBO_SHARE)
else:
model.insert(
STORAGE_COMBO_CLONE,
[_("Storage cannot be shared or cloned."), False, False])
option_combo.set_active(STORAGE_COMBO_CLONE)
vbox.pack_start(disk_name_box, False, False)
vbox.pack_start(option_combo, False, False)
if info_label:
vbox.pack_start(info_label, False, False)
storage_box.pack_start(vbox, False, False)
disk[STORAGE_INFO_COMBO] = option_combo
def _create_widgets(self):
def create_label(label):
l = gtk.Label(label)
l.set_alignment(0, 0.5)
l.set_use_markup(True)
return l
self.LP_spinner = gtk.SpinButton()
self.LP_spinner.set_range(0.0, 10.0)
self.LP_spinner.set_digits(2)
self.LP_spinner.set_increments(0.01, 0.1)
self.C_label = create_label(_("Concentration (mg/ml):"))
self.C_spinner = gtk.SpinButton()
self.C_spinner.set_range(0.0, 50.0)
self.C_spinner.set_digits(4)
self.C_spinner.set_increments(0.01, 0.1)
self.MW_spinner = gtk.SpinButton()
self.MW_spinner.set_range(1.0, 1000000000000.0)
self.MW_spinner.set_digits(2)
self.MW_spinner.set_increments(10.0, 100.0)
self.Rn_spinner = gtk.SpinButton()
self.Rn_spinner.set_range(1.0, 1000000000000.0)
self.Rn_spinner.set_digits(0)
self.Rn_spinner.set_increments(1.0, 10.0)
self.factor_entry = gtk.Entry()
self.factor_entry.props.editable = False
self.factor_entry.set_text("%f" % 0.0)
self.c_units_list = gtk.ListStore(str)
self.c_units_list.append(["m:v (mg/ml)"])
self.c_units_list.append(["micromolar"])
self.c_units_list.append(["milimolar"])
cell = gtk.CellRendererText()
self.c_units_combo = gtk.ComboBox(self.c_units_list)
self.c_units_combo.pack_start(cell, True)
self.c_units_combo.add_attribute(cell, 'text', 0)
self.c_units_combo.set_active(0)
self.copy_to_clipboard_btn = gtk.Button(stock=gtk.STOCK_COPY)
self.copy_to_clipboard_btn.connect("clicked",
self._copy_to_clipboard_cb)
table = gtk.Table(6, 2)
table.set_row_spacings(3)
table.set_col_spacings(3)
table.attach(create_label(_("Light path (cm):")), 0, 1, 0, 1, gtk.FILL,
gtk.EXPAND | gtk.FILL)
table.attach(self.LP_spinner, 1, 2, 0, 1, gtk.EXPAND | gtk.FILL,
gtk.EXPAND | gtk.FILL)
table.attach(self.c_units_combo, 0, 2, 1, 2, gtk.EXPAND | gtk.FILL,
gtk.EXPAND | gtk.FILL)
table.attach(self.C_label, 0, 1, 2, 3, gtk.FILL, gtk.EXPAND | gtk.FILL)
table.attach(self.C_spinner, 1, 2, 2, 3, gtk.EXPAND | gtk.FILL,
gtk.EXPAND | gtk.FILL)
table.attach(create_label(_("Molecular weight (g/mol):")), 0, 1, 3, 4,
gtk.FILL, gtk.EXPAND | gtk.FILL)
table.attach(self.MW_spinner, 1, 2, 3, 4, gtk.EXPAND | gtk.FILL,
gtk.EXPAND | gtk.FILL)
table.attach(create_label(_("Residue number:")), 0, 1, 4, 5, gtk.FILL,
gtk.EXPAND | gtk.FILL)
table.attach(self.Rn_spinner, 1, 2, 4, 5, gtk.EXPAND | gtk.FILL,
gtk.EXPAND | gtk.FILL)
table.attach(create_label(_("<b>Correction factor:</b>")), 0, 1, 5, 6,
gtk.FILL, gtk.EXPAND | gtk.FILL, 0, 5)
table.attach(self.factor_entry, 1, 2, 5, 6, gtk.EXPAND | gtk.FILL,
gtk.EXPAND | gtk.FILL, 0, 5)
self.vbox.pack_start(table, False, False, 4)
self.action_area.pack_end(self.copy_to_clipboard_btn, False, False, 0)
self.set_border_width(2)
self.show_all()
def __init__(self, parent, filename, claimtable=None):
logging.debug("Launching ClaimTableWizard")
self.filename = filename
self.parent = parent
if not claimtable:
self.re_import = False
self.claimtable = self.parent.on_new_table(self,
data=self.filename)
_, fil = os.path.split(self.filename)
self.claimtable.set_tab_text(fil)
else:
self.re_import = True
self.claimtable = claimtable
# Build the dialog
self.dialog = gtk.Dialog(title="Import as...")
self.dialog.connect("delete-event", self.on_cancel)
# Open the file
try:
self.f = open(self.filename, "rb")
except (OSError, IOError) as e:
logging.error("ClaimTableWizard: unable to open csv file " +
self.filename)
logging.error(e)
error_msg = gtk.MessageDialog(self.parent.window, 0, gtk.MESSAGE_ERROR, gtk.BUTTONS_OK, \
"Can not open csv file")
error_msg.format_secondary_text("Make sure %s is readable and try again." \
% self.filename)
error_msg.run()
error_msg.destroy()
self.claimtable.destroy()
return
# Build the treeview model
self.reader = csv.reader(self.f)
try:
self.liststore = gtk.ListStore(str, str)
headers = self.reader.next()
for h in headers:
self.liststore.append([h, "Not imported"])
treeview = gtk.TreeView(self.liststore)
treeview.set_grid_lines(gtk.TREE_VIEW_GRID_LINES_BOTH)
except StopIteration:
logging.error("ClaimTableWizard: unable to parse file " +
self.filename)
error_msg = gtk.MessageDialog(self.parent.window, 0, gtk.MESSAGE_ERROR, gtk.BUTTONS_OK, \
"Unable to parse file")
error_msg.format_secondary_text(
"Please select another file and try again.")
error_msg.run()
error_msg.destroy()
self.claimtable.destroy()
return
# Open the file with the options file mapping settings
if not claimtable and self.claimtable.options.items("Mapping"):
self.open_w_mapping()
return
else:
self.open_w_mapping() # Re-import the table
# Build column one
cell = gtk.CellRendererText()
column_one = gtk.TreeViewColumn("Column", cell, text=0)
treeview.append_column(column_one)
# Build column two, a combo box to select the appropriate header
combo = gtk.CellRendererCombo()
combolist = gtk.ListStore(
*[str for t in tables.table_layout["header"]])
combobox = gtk.ComboBox(combolist)
combobox.append_text("Not imported")
for h in tables.table_layout["header"]:
combobox.append_text(h)
combo.set_property("editable", True)
combo.set_property("model", combolist)
combo.set_property("text-column", 0)
combo.set_property("has-entry", False)
combo.connect("edited", self.on_combo_changed)
column_two = gtk.TreeViewColumn("Import as", combo, text=1)
treeview.append_column(column_two)
# Build the province selector radiobuttons
provinces = list(self.claimtable.claimtable.supported().keys())
def change_province(button):
self.claimtable.options.set("Settings", "province",
button.get_label())
province_frame = gtk.HBox()
label = gtk.Label("Province/State: ")
button_zero = gtk.RadioButton(label=provinces[0])
button_zero.connect("pressed", change_province)
province_frame.pack_end(button_zero, False, False, 0)
for p in provinces[1:]:
button = gtk.RadioButton(label=p, group=button_zero)
if self.claimtable.options.get("Settings", "province") == p:
button.set_active(True)
button.connect("pressed", change_province)
province_frame.pack_end(button, False, False, 0)
province_frame.pack_end(label, False, False, 0)
# Build the bottom frame that holds the apply/cancel buttons and the province radiobuttons
bottom_frame = gtk.HBox()
cancel_button = gtk.Button(label="Cancel", stock=gtk.STOCK_CANCEL)
cancel_button.connect("clicked", self.on_cancel)
apply_button = gtk.Button(label="Import", stock=gtk.STOCK_APPLY)
apply_button.connect("clicked", self.on_apply)
bottom_frame.pack_end(apply_button, False, False, 0)
bottom_frame.pack_end(cancel_button, False, False, 0)
bottom_frame.pack_end(province_frame, False, False, 20)
# Pack the dialog
self.dialog.vbox.pack_start(treeview, True, True, 0)
self.dialog.vbox.pack_end(bottom_frame, True, True, 0)
self.dialog.show_all()
height = treeview.get_cell_area(0, column_one).height
self.dialog.resize(320, height * len(headers))
response = self.dialog.run()
self.dialog.destroy()
if response == gtk.RESPONSE_CANCEL: # Hit the 'Cancel' button...
if not claimtable:
self.claimtable.destroy()
def __init__(self, data=None, more=None):
# Load configuration file
try:
configfile = open(self.Section, 'r')
self.section = configfile.readline()
configfile.close()
except:
self.section = ''
if self.section == '':
self.section = 'default'
# Initialize parameters
self.selectedMac = None
self.selectedSessionId = None
self.config = ConfigParser.RawConfigParser()
if os.path.exists(self.Ini):
self.config.read(self.Ini)
else:
self.config.read(self.DefIni)
# Setup the sections store and selection boxes
self.sectionStore = gtk.ListStore(gobject.TYPE_STRING)
self.sectionBox = gtk.ComboBox(self.sectionStore)
self.sectionBox2 = gtk.ComboBox(self.sectionStore)
cell = gtk.CellRendererText()
self.sectionBox.pack_start(cell, True)
self.sectionBox.add_attribute(cell, 'text', 0)
self.sectionBox2.pack_start(cell, True)
self.sectionBox2.add_attribute(cell, 'text', 0)
for section in self.config.sections():
self.sectionStore.append([section])
self.sessionsStore = gtk.ListStore(gobject.TYPE_STRING,
gobject.TYPE_STRING)
self.sessionsView = gtk.TreeView(self.sessionsStore)
cell = gtk.CellRendererText()
col = gtk.TreeViewColumn("MAC", cell, text=0)
self.sessionsView.append_column(col)
cell = gtk.CellRendererText()
col = gtk.TreeViewColumn("IP", cell, text=1)
self.sessionsView.append_column(col)
self.sessionsView.connect("cursor-changed", self.row1,
"cursor-changed")
self.vboxSessions = gtk.VBox()
self.vboxSessionBtns = gtk.HBox(homogeneous=True)
self.sesRefresh = gtk.Button("Refresh")
self.sesAuth = gtk.Button("Auth")
self.sesRelease = gtk.Button("Release")
self.sesBlock = gtk.Button("Block")
self.sesAuth.set_sensitive(False)
self.sesRelease.set_sensitive(False)
self.sesBlock.set_sensitive(False)
self.sessionView = gtk.Label("")
self.vboxSessions.pack_start(self.sessionsView)
self.vboxSessions.pack_start(self.sessionView, False)
self.vboxSessionBtns.pack_start(self.sesRefresh)
self.vboxSessionBtns.pack_start(self.sesAuth)
self.vboxSessionBtns.pack_start(self.sesRelease)
self.vboxSessionBtns.pack_start(self.sesBlock)
self.vboxSessions.pack_start(self.vboxSessionBtns, False)
self.sesRefresh.connect("clicked", self.chilliQuery)
self.sesRelease.connect("clicked", self.sessionRelease)
self.sesBlock.connect("clicked", self.sessionBlock)
self.sesAuth.connect("clicked", self.sessionAuthorize)
self.vboxSessions.show()
self.sesRefresh.show()
self.sesAuth.show()
self.sesRelease.show()
self.sesBlock.show()
self.sessionView.show()
self.sessionsView.show()
self.vboxSessionBtns.show()
self.btnStart = gtk.Button("Start")
self.btnStop = gtk.Button("Stop")
self.btnStart.set_sensitive(False)
self.btnStop.set_sensitive(False)
self.btnStart.connect("clicked", self.startCoovaChilli)
self.btnStop.connect("clicked", self.stopCoovaChilli)
def __init__(self, prefs):
melddoc.MeldDoc.__init__(self, prefs)
gnomeglade.Component.__init__(self, paths.ui_dir("vcview.ui"),
"vcview")
actions = (
("VcCompare", gtk.STOCK_DIALOG_INFO, _("_Compare"), None,
_("Compare selected files"),
self.on_button_diff_clicked),
("VcCommit", "vc-commit-24", _("Co_mmit..."), None,
_("Commit changes to version control"),
self.on_button_commit_clicked),
("VcUpdate", "vc-update-24", _("_Update"), None,
_("Update working copy from version control"),
self.on_button_update_clicked),
("VcPush", "vc-push-24", _("_Push"), None,
_("Push local changes to remote"),
self.on_button_push_clicked),
("VcAdd", "vc-add-24", _("_Add"), None,
_("Add to version control"),
self.on_button_add_clicked),
("VcRemove", "vc-remove-24", _("_Remove"), None,
_("Remove from version control"),
self.on_button_remove_clicked),
("VcResolved", "vc-resolve-24", _("Mar_k as Resolved"), None,
_("Mark as resolved in version control"),
self.on_button_resolved_clicked),
("VcRevert", gtk.STOCK_REVERT_TO_SAVED, _("Re_vert"), None,
_("Revert working copy to original state"),
self.on_button_revert_clicked),
("VcDeleteLocally", gtk.STOCK_DELETE, None, None,
_("Delete from working copy"),
self.on_button_delete_clicked),
)
toggleactions = (
("VcFlatten", gtk.STOCK_GOTO_BOTTOM, _("_Flatten"), None,
_("Flatten directories"),
self.on_button_flatten_toggled, False),
("VcShowModified", "filter-modified-24", _("_Modified"), None,
_("Show modified files"),
self.on_filter_state_toggled, False),
("VcShowNormal", "filter-normal-24", _("_Normal"), None,
_("Show normal files"),
self.on_filter_state_toggled, False),
("VcShowNonVC", "filter-nonvc-24", _("Un_versioned"), None,
_("Show unversioned files"),
self.on_filter_state_toggled, False),
("VcShowIgnored", "filter-ignored-24", _("Ignored"), None,
_("Show ignored files"),
self.on_filter_state_toggled, False),
)
self.ui_file = paths.ui_dir("vcview-ui.xml")
self.actiongroup = gtk.ActionGroup('VcviewActions')
self.actiongroup.set_translation_domain("meld")
self.actiongroup.add_actions(actions)
self.actiongroup.add_toggle_actions(toggleactions)
for action in ("VcCompare", "VcFlatten", "VcShowModified",
"VcShowNormal", "VcShowNonVC", "VcShowIgnored"):
self.actiongroup.get_action(action).props.is_important = True
for action in ("VcCommit", "VcUpdate", "VcPush", "VcAdd", "VcRemove",
"VcShowModified", "VcShowNormal", "VcShowNonVC",
"VcShowIgnored", "VcResolved"):
button = self.actiongroup.get_action(action)
button.props.icon_name = button.props.stock_id
self.model = VcTreeStore()
self.widget.connect("style-set", self.model.on_style_set)
self.treeview.set_model(self.model)
selection = self.treeview.get_selection()
selection.set_mode(gtk.SELECTION_MULTIPLE)
selection.connect("changed", self.on_treeview_selection_changed)
self.treeview.set_headers_visible(1)
self.treeview.set_search_equal_func(self.model.treeview_search_cb)
self.current_path, self.prev_path, self.next_path = None, None, None
self.column_name_map = {}
column = gtk.TreeViewColumn(_("Name"))
column.set_resizable(True)
renicon = emblemcellrenderer.EmblemCellRenderer()
rentext = gtk.CellRendererText()
column.pack_start(renicon, expand=0)
column.pack_start(rentext, expand=1)
col_index = self.model.column_index
column.set_attributes(renicon,
icon_name=col_index(tree.COL_ICON, 0),
icon_tint=col_index(tree.COL_TINT, 0))
column.set_attributes(rentext,
text=col_index(tree.COL_TEXT, 0),
foreground_gdk=col_index(tree.COL_FG, 0),
style=col_index(tree.COL_STYLE, 0),
weight=col_index(tree.COL_WEIGHT, 0),
strikethrough=col_index(tree.COL_STRIKE, 0))
column_index = self.treeview.append_column(column) - 1
self.column_name_map[vc.DATA_NAME] = column_index
def addCol(name, num, data_name=None):
column = gtk.TreeViewColumn(name)
column.set_resizable(True)
rentext = gtk.CellRendererText()
column.pack_start(rentext, expand=0)
column.set_attributes(rentext,
markup=self.model.column_index(num, 0))
column_index = self.treeview.append_column(column) - 1
if data_name:
self.column_name_map[data_name] = column_index
return column
self.treeview_column_location = addCol(_("Location"), COL_LOCATION)
addCol(_("Status"), COL_STATUS, vc.DATA_STATE)
addCol(_("Revision"), COL_REVISION, vc.DATA_REVISION)
addCol(_("Options"), COL_OPTIONS, vc.DATA_OPTIONS)
self.state_filters = []
for s in self.state_actions:
if s in self.prefs.vc_status_filters:
action_name = self.state_actions[s][0]
self.state_filters.append(s)
self.actiongroup.get_action(action_name).set_active(True)
self.consolestream = ConsoleStream(self.consoleview)
self.location = None
self.treeview_column_location.set_visible(self.actiongroup.get_action("VcFlatten").get_active())
if not self.prefs.vc_console_visible:
self.on_console_view_toggle(self.console_hide_box)
self.vc = None
self.valid_vc_actions = tuple()
# VC ComboBox
self.combobox_vcs = gtk.ComboBox()
self.combobox_vcs.lock = True
self.combobox_vcs.set_model(gtk.ListStore(str, object, bool))
cell = gtk.CellRendererText()
self.combobox_vcs.pack_start(cell, False)
self.combobox_vcs.add_attribute(cell, 'text', 0)
self.combobox_vcs.add_attribute(cell, 'sensitive', 2)
self.combobox_vcs.lock = False
self.hbox2.pack_end(self.combobox_vcs, expand=False)
self.combobox_vcs.show()
self.combobox_vcs.connect("changed", self.on_vc_change)
def __init__(self):
self.sw = gtk.ScrolledWindow()
self.sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
self.sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.treeView = None
'''Create a new window'''
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
uimanager = gtk.UIManager()
accelgroup = uimanager.get_accel_group()
self.window.add_accel_group(accelgroup)
self.actiongroup = gtk.ActionGroup("uimanager")
self.actiongroup.add_actions([
("User authentication", None, "_User authentication", "<control>A",
None, lambda x: self.changeTable(1)),
("Save as HTML", gtk.STOCK_SAVE, "_Save as HTML", "<control>S",
None, self.do_save_as),
("Save in a text format", None, "_Save in a text format", None,
None, self.do_save_as_text),
("Close", gtk.STOCK_QUIT, "_Close", None, "Quit the Application",
lambda w: gtk.main_quit()), ("Report type", None, "_Report type"),
("Help", None, "_Help", "F1", None, about_help._help),
("About program", None, "_About program", None, None,
about_help.about_program), ("Reference", None, "_Reference")
])
uimanager.insert_action_group(self.actiongroup, 0)
uimanager.add_ui_from_string(self.interface)
menubar = uimanager.get_widget("/MenuBar")
self.window.set_size_request(1000, 500)
self.window.set_border_width(10)
self.window.set_position(gtk.WIN_POS_CENTER_ALWAYS)
self.window.set_title("The event log")
self.window.connect("destroy", self.destroy)
main_vbox = gtk.VBox(False, 10)
main_hbox = gtk.HBox(False, 10)
self.window.add(main_hbox)
main_hbox.pack_start(main_vbox, True, True, 0)
self.calendar = gtk.Calendar()
self.calendar2 = gtk.Calendar()
self._connect_signals()
self._connect_signals2()
frame = gtk.Frame("Report time")
vbox = gtk.VBox(False, 0)
frame.add(vbox)
hbox = gtk.HBox(False, 0)
vbox.pack_start(hbox, False, False, 10)
label = gtk.Label("with: ")
label.set_alignment(0, 0.5)
hbox.pack_start(label, False, False, 10)
self.entry = gtk.Entry()
self.entry.set_editable(True)
hbox.pack_start(self.entry, False, False, 0)
self.button = gtk.Button(label='^')
hbox.pack_start(self.button, False, False, 0)
self.clicked_handle = self.button.connect('clicked', self.show_widget)
currentDate = datetime.date(year, month, day)
text = currentDate.strftime("%d.%m.%Y")
teeext = currentDate.strftime("%Y, %m, %d")
self.entry.set_text(text)
label = gtk.Label("time: ")
label.set_alignment(0, 0.5)
hbox.pack_start(label, False, False, 10)
self.entryTime1 = gtk.Entry()
hbox.pack_start(self.entryTime1, False, False, 0)
label = gtk.Label("to: ")
label.set_alignment(0, 0.5)
hbox.pack_start(label, False, False, 10)
self.entry2 = gtk.Entry()
self.entry2.set_editable(False)
hbox.pack_start(self.entry2, False, False, 0)
self.button2 = gtk.Button(label='^')
hbox.pack_start(self.button2, False, False, 0)
self.clicked_handle = self.button2.connect('clicked',
self.show_widget2)
self.entry2.set_text(text)
label = gtk.Label("time: ")
label.set_alignment(0, 0.5)
hbox.pack_start(label, False, False, 10)
self.entryTime2 = gtk.Entry()
hbox.pack_start(self.entryTime2, False, False, 10)
frameUser = gtk.Frame("Users")
vbox = gtk.VBox(False, 0)
frameUser.add(vbox)
hbox = gtk.HBox(False, 0)
vbox.pack_start(hbox, False, False, 10)
#User selection
File = open(file_tmp, "rb")
self.combobox = gtk.ComboBox()
self.liststore = gtk.ListStore(str)
cell = gtk.CellRendererText()
self.combobox.pack_start(cell)
self.combobox.add_attribute(cell, 'text', 0)
self.combobox.set_wrap_width(5)
for leng in File.xreadlines():
integ_simple.buf.append(leng)
m = re.match(
"type=([\w]+).*msg=audit.(\d+\.\d+\.\d+) (\d+:\d+:\d+).*pid=([\w]+).*uid=([\w]+).*auid=([\w]+).*exe=([^\s]+)",
leng)
if m:
uid = m.group(5)
syscall = [uid]
for p in syscall:
integ_simple.typesss.append(p)
for st in ['All users']:
self.liststore.append([st])
for l in set(integ_simple.typesss):
self.liststore.append([l])
self.combobox.set_model(self.liststore)
self.combobox.connect('changed', self.changed_cb)
self.combobox.set_active(0)
hbox.pack_start(self.combobox, False, False, 20)
main_vbox.pack_start(menubar, False, True, 0)
main_vbox.pack_start(frame, False, False, 0)
main_vbox.pack_start(frameUser, False, False, 0)
main_vbox.pack_start(self.sw, True, True, 0)
self.window.show_all()
#для календаря №1
self.cwindow = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.cwindow.set_position(gtk.WIN_POS_MOUSE)
self.cwindow.set_decorated(False)
self.cwindow.set_modal(True)
self.cwindow.add(self.calendar)
#для календаря №2
self.ccwindow = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.ccwindow.set_position(gtk.WIN_POS_MOUSE)
self.ccwindow.set_decorated(False)
self.ccwindow.set_modal(True)
self.ccwindow.add(self.calendar2)
menubar.show()
def __init__(self, w3af):
super(VulnAddDialog,
self).__init__("Add new vulnerability", None,
gtk.MESSAGE_QUESTION,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_ADD, gtk.RESPONSE_OK))
self.set_icon_from_file(W3AF_ICON)
self.w3af = w3af
# Main hbox
hbox = gtk.HBox()
hbox.show()
image = gtk.Image()
image.set_from_stock(gtk.STOCK_DIALOG_QUESTION, gtk.ICON_SIZE_DIALOG)
image.set_padding(20, 20)
image.show()
hbox.pack_start(image)
# Vbox with all the information for the right section of the dialog
vbox = gtk.VBox()
# Add a label
align = gtk.Alignment()
align.set_padding(10, 0, 0, 10)
label = gtk.Label('Choose the vulnerability template to use:')
align.add(label)
vbox.pack_start(align)
template_long_names = get_template_long_names()
template_names = get_template_names()
self.vuln_template = None
# A list store with the following columns:
# * Long template name (show)
# * Template name (code internals)
liststore = gtk.ListStore(str, str)
self.combobox = gtk.ComboBox(liststore)
cell = gtk.CellRendererText()
self.combobox.pack_start(cell, True)
self.combobox.add_attribute(cell, 'text', 0)
self.combobox.connect("changed", self._changed_combo)
for i, long_name in enumerate(template_long_names):
liststore.append((long_name, template_names[i]))
vbox.pack_start(self.combobox, False, False)
vbox.pack_start(gtk.Label())
# the Cancel button
but = self.action_area.get_children()[1]
but.connect("clicked", lambda x: self.destroy())
self.connect("delete-event", lambda x, y: self.destroy())
# the Ok button
self.ok_but = self.action_area.get_children()[0]
self.ok_but.connect("clicked", self._ok)
self.ok_but.set_sensitive(False)
hbox.pack_start(vbox)
self.vbox.pack_start(hbox)
self.show_all()
def GetArgv(optionlist=None,
commandlist=None,
addoldfile=1,
addnewfile=1,
addfolder=1,
id=ARGV_ID):
dialog = gtk.Dialog(
"", None, gtk.DIALOG_MODAL,
(gtk.STOCK_OK, gtk.RESPONSE_OK, gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL))
# Optionlist panel
opanel = gtk.Table(4, 2, True)
olabel = gtk.Label("Option: ")
olabel.set_justify(gtk.JUSTIFY_LEFT)
opanel.attach(olabel, 0, 1, 0, 1)
olabel1 = gtk.Label()
olabel1.set_name("ARGV_OPTION_EXPLAIN")
olabel1.set_justify(gtk.JUSTIFY_LEFT)
opanel.attach(olabel1, 0, 2, 1, 2)
oentry = gtk.Entry()
oentry.set_name("ARGV_OPTION_VALUE")
opanel.attach(oentry, 0, 2, 2, 3)
obutton = gtk.Button("Add")
obutton.set_name("ARGV_OPTION_ADD")
obutton.connect("clicked", _action, dialog, optionlist)
opanel.attach(obutton, 1, 2, 3, 4, 0, gtk.FILL)
optionl = gtk.ComboBox()
ocell = gtk.CellRendererText()
optionl.pack_start(ocell, True)
optionl.add_attribute(ocell, 'text', 0)
opanel.attach(optionl, 1, 2, 0, 1)
optionl.set_name("ARGV_OPTION_GROUP")
for i in opanel.get_children():
if type(i) == gtk.Label:
i.set_alignment(0.1, 0.5)
# Commandlist panel
cpanel = gtk.Table(3, 2, True)
clabel1 = gtk.Label()
clabel1.set_name("ARGV_COMMAND_EXPLAIN")
clabel1.set_justify(gtk.JUSTIFY_LEFT)
cpanel.attach(clabel1, 0, 1, 1, 2)
clabel = gtk.Label("Command: ")
clabel.set_justify(gtk.JUSTIFY_LEFT)
cpanel.attach(clabel, 0, 1, 0, 1)
cbutton = gtk.Button("Add")
cbutton.set_name("ARGV_COMMAND_ADD")
cbutton.connect("clicked", _action, dialog, commandlist)
cpanel.attach(cbutton, 1, 2, 2, 3, 0, gtk.FILL)
cptionl = gtk.ComboBox()
cptionl.set_name("ARGV_COMMAND_GROUP")
ccell = gtk.CellRendererText()
cptionl.pack_start(ccell, True)
cptionl.add_attribute(ccell, 'text', 0)
cpanel.attach(cptionl, 1, 2, 0, 1)
for i in cpanel.get_children():
if type(i) == gtk.Label:
i.set_alignment(0.1, 0.5)
# ButtonBox
bbox = gtk.Table(2, 2)
bbox.attach(gtk.Button("Add file..."), 0, 1, 0, 1, gtk.FILL, 0)
bbox.attach(gtk.Button("Add new file..."), 1, 2, 0, 1, gtk.FILL, 0)
bbox.attach(gtk.Button("Add folder..."), 0, 1, 1, 2, gtk.FILL, 0)
bbox.get_children()[0].set_name("ARGV_ADD_FOLDER")
bbox.get_children()[0].connect("clicked", _action, dialog, None)
bbox.get_children()[1].set_name("ARGV_ADD_NEWFILE")
bbox.get_children()[1].connect("clicked", _action, dialog, None)
bbox.get_children()[2].set_name("ARGV_ADD_OLDFILE")
bbox.get_children()[2].connect("clicked", _action, dialog, None)
# Command Line
cl = gtk.Table(2, 1)
cllabel = gtk.Label("Command line: ")
cllabel.set_alignment(0.1, 0.1)
cl.attach(cllabel, 0, 1, 0, 1, gtk.FILL, 0)
clentry = gtk.Entry()
clentry.set_text("")
clentry.set_name("ARGV_CMDLINE_DATA")
cl.attach(clentry, 0, 2, 1, 2)
# Add into dialog
dialog.vbox.pack_start(opanel, False, False, 5)
dialog.vbox.pack_start(gtk.HSeparator(), True, True, 10)
dialog.vbox.pack_start(cpanel, False, False, 5)
dialog.vbox.pack_start(gtk.HSeparator(), True, True, 10)
dialog.vbox.pack_start(bbox, False, False, 5)
dialog.vbox.pack_start(gtk.HSeparator(), True, True, 10)
dialog.vbox.pack_start(cl, False, False, 5)
dialog.set_size_request(340, 450)
dialog.show_all()
oentry.hide()
if optionlist:
_setmenu(optionl, optionlist)
optionl.set_active(0)
_action(optionl, dialog, optionlist)
else:
opanel.set_state(gtk.STATE_INSENSITIVE)
optionl.connect("changed", _action, dialog, optionlist)
if commandlist:
_setmenu(cptionl, commandlist)
cptionl.set_active(0)
if type(commandlist[0]) == type(()) and len(commandlist[0]) > 1:
help = commandlist[0][-1]
clabel1.set_label(help)
else:
cpanel.set_state(gtk.STATE_INSENSITIVE)
cptionl.connect("changed", _action, dialog, commandlist)
if not addoldfile:
bbox.get_children()[2].set_state(gtk.STATE_INSENSITIVE)
if not addnewfile:
bbox.get_children()[1].set_state(gtk.STATE_INSENSITIVE)
if not addfolder:
bbox.get_children()[0].set_state(gtk.STATE_INSENSITIVE)
res = dialog.run()
dialog.hide()
if res == gtk.RESPONSE_CANCEL:
dialog.destroy()
sys.exit(1)
if res == gtk.RESPONSE_DELETE_EVENT:
dialog.destroy()
sys.exit(1)
if res == gtk.RESPONSE_OK:
return _action(clentry, dialog, None)
def __init__(self, helper):
gtk.VBox.__init__(self)
# ftp params
ff = gtk.Table(2,4)
ff.set_row_spacings(2); ff.set_col_spacings(5);
ff.attach(gtk.Label('Host'),0,1,0,1,False,False);
ff.attach(gtk.Label('User'),0,1,1,2,False,False);
ff.attach(gtk.Label('Pass'),2,3,1,2,False,False);
#ff.attach(gtk.Label('Filter'),0,1,3,4,False,False);
self.url = gtk.Entry()
self.url.set_size_request(10,-1)
self.user = gtk.Entry()
self.user.set_size_request(10,-1)
self.pasw = gtk.Entry()
self.pasw.set_size_request(10,-1)
self.pasw.set_visibility(False)
self.filt = gtk.Entry()
self.filt.set_size_request(10,-1)
ff.attach(self.url,1,4,0,1);
ff.attach(self.user,1,2,1,2);
ff.attach(self.pasw,3,4,1,2);
#ff.attach(self.filt,1,2,3,4);
self.pack_start(ff, False, False)
# buttons
#b = gtk.HBox(False)
i=gtk.Image()
i.set_from_stock('gtk-home',gtk.ICON_SIZE_BUTTON)
#b.pack_start(i)
#b.pack_start(gtk.Label('Connect'))
btn_connect = gtk.Button()
btn_connect.add(i)
btn_connect.set_tooltip_text("Connect to FTP server")
btn_connect.connect("clicked", helper.on_connect)
#b = gtk.HBox(False)
i=gtk.Image()
i.set_from_stock('gtk-refresh',gtk.ICON_SIZE_BUTTON)
#b.pack_start(i)
#b.pack_start(gtk.Label('Refresh'))
btn_refresh = gtk.Button()
btn_refresh.add(i)
btn_refresh.set_tooltip_text("Refresh remote directory list")
btn_refresh.connect("clicked", helper.on_refresh)
i=gtk.Image()
i.set_from_stock('gtk-go-up',gtk.ICON_SIZE_BUTTON)
btn_parent = gtk.Button()
btn_parent.add(i)
btn_parent.set_tooltip_text("Go up to parent directory")
btn_parent.connect("clicked", helper.on_parent)
#list for combo box (Active/Passive FTP)
self.list = gtk.ListStore(int, str)
iter = self.list.append( (False, "Active FTP",) )
self.list.set(iter)
iter = self.list.append( (True, "Passive FTP",) )
self.list.set(iter)
# save as button for adding new file
i=gtk.Image()
i.set_from_stock('gtk-save-as',gtk.ICON_SIZE_BUTTON)
btn_save_as = gtk.Button()
btn_save_as.add(i)
btn_save_as.set_tooltip_text("Save new file to FTP server")
btn_save_as.connect("clicked", helper.on_save_as)
#Combo box
self.combo_pasv_mode = gtk.ComboBox()
cell = gtk.CellRendererText()
self.combo_pasv_mode.pack_start(cell, True)
self.combo_pasv_mode.add_attribute(cell, 'text', 1)
self.combo_pasv_mode.set_model(self.list)
self.combo_pasv_mode.set_active(True) #default: passive mode=True
#pack buttons and combo box (active/passive FTP) on same row
buttonsAndCombo=gtk.HBox(False)
buttonsAndCombo.pack_start(btn_connect,False,False)
buttonsAndCombo.pack_start(btn_refresh,False,False)
buttonsAndCombo.pack_start(btn_parent,False,False)
buttonsAndCombo.pack_start(btn_save_as,False,False)
buttonsAndCombo.pack_start(self.combo_pasv_mode,False,False)
self.pack_start(buttonsAndCombo,False,False)
#location label
self.location = gtk.Label(helper.ftp_cwd)
self.location.set_ellipsize(pango.ELLIPSIZE_MIDDLE)
self.location.set_line_wrap(True)
self.location.set_justify(gtk.JUSTIFY_LEFT)
self.location.set_alignment(0,0.5)
self.pack_start(self.location, False, False)
# add a treeview
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw.set_shadow_type(gtk.SHADOW_IN)
self.browser_model = gtk.ListStore(gtk.gdk.Pixbuf, str, str)
self.browser = gtk.TreeView(self.browser_model)
self.browser.set_headers_visible(True)
sw.add(self.browser)
self.pack_start(sw)
self.dir_icon = self.browser.render_icon('gtk-directory', gtk.ICON_SIZE_MENU)
self.file_icon = self.browser.render_icon('gtk-file', gtk.ICON_SIZE_MENU)
# add columns to the treeview
col = gtk.TreeViewColumn()
render_pixbuf = gtk.CellRendererPixbuf()
col.pack_start(render_pixbuf, expand=False)
col.add_attribute(render_pixbuf, 'pixbuf', 0)
self.browser.append_column(col)
col = gtk.TreeViewColumn('Filename')
render_text = gtk.CellRendererText()
col.pack_start(render_text, expand=True)
col.add_attribute(render_text, 'text', 1)
self.browser.append_column(col)
# connect stuff
self.browser.connect("row-activated",helper.on_list_row_activated)
self.show_all()
def __init__(self, image, layer, *args):
mwin = gtk.Window.__init__(self, *args)
self.set_border_width(10)
#internal arguments
self.img = image
self.layer = layer
self.numblursteps = BLURSTEPS
self.blurdir = 0 #will be reinitialized in GUI construction
self.savepath = os.getcwd() #will be updated by user choice
self.frametime = FRAMETIME
self.bidblur = BIDIRBLUR
#Obey the window manager quit signal:
self.connect("destroy", gtk.main_quit)
#Designing the interface
vbx = gtk.VBox(spacing=10, homogeneous=False)
self.add(vbx)
hbxini = gtk.HBox(spacing=10, homogeneous=False)
vbx.add(hbxini)
topmess = "You should have maximum two layers. The first one will be animated.\n"
topmess += "If there is a second one, will be the unanimated background.\n"
topmess += "In this case, be sure that the first one has some transparency."
labini = gtk.Label(topmess)
hbxini.add(labini)
hbxa = gtk.HBox(spacing=10, homogeneous=False)
vbx.add(hbxa)
laba = gtk.Label("Blurring steps")
hbxa.add(laba)
butaadj = gtk.Adjustment(BLURSTEPS, 2, 10, 1, 5)
spbuta = gtk.SpinButton(butaadj, 0, 0)
spbuta.connect("output", self.on_blurstep_change)
hbxa.add(spbuta)
hbxc = gtk.HBox(spacing=10, homogeneous=False)
vbx.add(hbxc)
labc = gtk.Label("Delay between frames")
hbxc.add(labc)
butcadj = gtk.Adjustment(FRAMETIME, 50, 2000, 1, 20)
spbutc = gtk.SpinButton(butcadj, 0, 0)
spbutc.connect("output", self.on_frametime_change)
hbxc.add(spbutc)
hbxb = gtk.HBox(spacing=10, homogeneous=False)
vbx.add(hbxb)
labb = gtk.Label("Blur direction")
hbxb.add(labb)
boxmodel = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_INT)
#filling the model for the combobox
for i, j in zip(BLURDIR, range(len(BLURDIR))):
irow = boxmodel.append(None, [i, j])
if (j == DEFBLURDIR):
self.blurdir = j
cbox = gtk.ComboBox(boxmodel)
rendtext = gtk.CellRendererText()
cbox.pack_start(rendtext, True)
cbox.add_attribute(rendtext, "text", 0)
cbox.set_entry_text_column(0)
cbox.set_active(self.blurdir)
cbox.connect("changed", self.on_cbox_changed)
hbxb.add(cbox)
butch = gtk.CheckButton("Bidirectional blurring")
vbx.add(butch)
butch.set_active(BIDIRBLUR)
butch.connect("toggled", self.on_butch_toggled)
butok = gtk.Button("OK")
vbx.add(butok)
butok.connect("clicked", self.on_butok_clicked)
self.show_all()
return mwin
def __init__(self, callback, args=None):
gtk.Alignment.__init__(self, xalign=0.5, yalign=0.5, xscale=0.0,
yscale=1.0)
self.dialog = extension.get_default('dialog')
Avatar = extension.get_default('avatar')
NiceBar = extension.get_default('nice bar')
self.liststore = gtk.ListStore(gobject.TYPE_STRING, gtk.gdk.Pixbuf)
completion = gtk.EntryCompletion()
completion.set_model(self.liststore)
pixbufcell = gtk.CellRendererPixbuf()
completion.pack_start(pixbufcell)
completion.add_attribute(pixbufcell, 'pixbuf', 1)
completion.set_text_column(0)
completion.set_inline_selection(True)
self.pixbuf = utils.safe_gtk_pixbuf_load(gui.theme.image_theme.user)
self.cmb_account = gtk.ComboBoxEntry(self.liststore, 0)
self.cmb_account.set_tooltip_text(_('Account'))
self.cmb_account.get_children()[0].set_completion(completion)
self.cmb_account.get_children()[0].connect('key-press-event',
self._on_account_key_press)
self.cmb_account.connect('changed',
self._on_account_changed)
self.cmb_account.connect('key-release-event',
self._on_account_key_release)
self.btn_status = StatusButton.StatusButton()
self.btn_status.set_tooltip_text(_('Status'))
self.btn_status.set_status(e3.status.ONLINE)
self.btn_status.set_size_request(34, -1)
self.txt_password = gtk.Entry()
self.txt_password.set_tooltip_text(_('Password'))
self.txt_password.set_visibility(False)
self.txt_password.connect('key-press-event',
self._on_password_key_press)
self.txt_password.connect('changed', self._on_password_changed)
self.txt_password.set_sensitive(False)
pix_account = utils.safe_gtk_pixbuf_load(gui.theme.image_theme.user)
pix_password = utils.safe_gtk_pixbuf_load(gui.theme.image_theme.password)
self.avatar = Avatar()
self.remember_account = gtk.CheckButton(_('Remember me'))
self.remember_password = gtk.CheckButton(_('Remember password'))
self.auto_login = gtk.CheckButton(_('Auto-login'))
self.remember_account.connect('toggled',
self._on_remember_account_toggled)
self.remember_password.connect('toggled',
self._on_remember_password_toggled)
self.auto_login.connect('toggled',
self._on_auto_login_toggled)
self.remember_account.set_sensitive(False)
self.remember_password.set_sensitive(False)
self.auto_login.set_sensitive(False)
self.forget_me = gtk.Button()
self.forget_me.set_tooltip_text(_('Delete user'))
forget_img = gtk.image_new_from_stock(gtk.STOCK_CANCEL, gtk.ICON_SIZE_MENU)
self.forget_me.set_image(forget_img)
self.forget_me.set_relief(gtk.RELIEF_NONE)
self.forget_me.set_border_width(0)
self.forget_me.set_size_request(34, -1)
self.forget_me.connect('clicked', self._on_forget_me_clicked)
self.forget_me.set_sensitive(False)
hboxremember = gtk.HBox(spacing=2)
hboxremember.pack_start(self.remember_account, False)
vbox_remember = gtk.VBox(spacing=4)
vbox_remember.set_border_width(8)
vbox_remember.pack_start(hboxremember)
vbox_remember.pack_start(self.remember_password)
vbox_remember.pack_start(self.auto_login)
vbox_remember.pack_start(gtk.Label())
self.b_connect = gtk.Button(stock=gtk.STOCK_CONNECT)
self.b_connect.set_sensitive(False)
self.b_cancel = gtk.Button(stock=gtk.STOCK_CANCEL)
self.b_cancel.connect('clicked', self._on_cancel_clicked)
vbuttonbox = gtk.VButtonBox()
vbuttonbox.set_spacing(8)
vbuttonbox.pack_start(self.b_connect)
vbuttonbox.pack_start(self.b_cancel)
vbox_content = gtk.VBox()
hbox_account = gtk.HBox(spacing=6)
img_accountpix = gtk.Image()
img_accountpix.set_from_pixbuf(utils.scale_nicely(pix_account))
hbox_account.pack_start(img_accountpix, False)
hbox_account.pack_start(self.cmb_account)
hbox_account.pack_start(self.forget_me, False)
hbox_password = gtk.HBox(spacing=6)
img_password = gtk.Image()
img_password.set_from_pixbuf(utils.scale_nicely(pix_password))
hbox_password.pack_start(img_password, False)
hbox_password.pack_start(self.txt_password)
hbox_password.pack_start(self.btn_status, False)
session_combo_store = gtk.ListStore(gtk.gdk.Pixbuf, str)
crp = gtk.CellRendererPixbuf()
crt = gtk.CellRendererText()
crp.set_property("xalign", 0)
crt.set_property("xalign", 0)
self.session_combo = gtk.ComboBox()
self.session_combo.set_tooltip_text(_('Choose your network'))
self.session_combo.set_model(session_combo_store)
self.session_combo.pack_start(crp)
self.session_combo.pack_start(crt)
self.session_combo.add_attribute(crp, "pixbuf", 0)
self.session_combo.add_attribute(crt, "text", 1)
self.b_preferences = gtk.Button()
self.b_preferences.set_tooltip_text(_('Preferences'))
self.img_preferences = gtk.image_new_from_stock(gtk.STOCK_PREFERENCES,
gtk.ICON_SIZE_MENU)
self.img_preferences.set_sensitive(False)
self.b_preferences.set_image(self.img_preferences)
self.b_preferences.set_relief(gtk.RELIEF_NONE)
self.b_preferences.connect('enter-notify-event',
self._on_preferences_enter)
self.b_preferences.connect('leave-notify-event',
self._on_preferences_leave)
self.b_preferences.connect('clicked',
self._on_preferences_selected)
self.b_preferences.set_size_request(34, -1)
img_sessionpix = gtk.image_new_from_stock(gtk.STOCK_CONNECT, gtk.ICON_SIZE_MENU)
img_sessionpix.set_size_request(20, -1)
img_sessionpix.set_sensitive(False)
hbox_session = gtk.HBox(spacing=6)
hbox_session.pack_start(img_sessionpix, False)
hbox_session.pack_start(self.session_combo)
hbox_session.pack_start(self.b_preferences, False)
vbox_entries = gtk.VBox(spacing=12)
vbox_entries.set_border_width(8)
vbox_entries.pack_start(hbox_account)
vbox_entries.pack_start(hbox_password)
vbox_entries.pack_start(hbox_session)
self.nicebar = NiceBar()
th_pix = utils.safe_gtk_pixbuf_load(gui.theme.image_theme.throbber, None,
animated=True)
self.throbber = gtk.image_new_from_animation(th_pix)
self.label_timer = gtk.Label()
self.label_timer.set_markup(_('<b>Connection error!\n </b>'))
al_label_timer = gtk.Alignment(xalign=0.5, yalign=0.5, xscale=0.0,
yscale=0.0)
al_throbber = gtk.Alignment(xalign=0.5, yalign=0.5, xscale=0.1,
yscale=0.1)
al_vbox_entries = gtk.Alignment(xalign=0.5, yalign=0.5, xscale=0.2,
yscale=0.0)
al_vbox_remember = gtk.Alignment(xalign=0.5, yalign=0.5, xscale=0.0,
yscale=0.2)
al_button = gtk.Alignment(xalign=0.5, yalign=0.5, xscale=0.2)
al_account = gtk.Alignment(xalign=0.5, yalign=0.5, xscale=0.0,
yscale=0.3)
al_label_timer.add(self.label_timer)
al_throbber.add(self.throbber)
al_vbox_entries.add(vbox_entries)
al_vbox_remember.add(vbox_remember)
al_button.add(vbuttonbox)
al_account.add(self.avatar)
vbox = gtk.VBox()
vbox_top = gtk.VBox()
vbox_far_bottom = gtk.VBox()
vbox_bottom = gtk.VBox(False)
vbox_content.pack_start(gtk.Label(""), True, True)
vbox_content.pack_start(al_account, True, False)
vbox_content.pack_start(gtk.Label(""), True, True)
vbox_content.pack_start(al_vbox_entries, False)
vbox_content.pack_start(al_vbox_remember, True, False)
vbox_bottom.set_size_request(-1, 100)
vbox_bottom.pack_start(al_label_timer, True, False)
vbox_bottom.pack_start(al_throbber, False)
vbox_bottom.pack_start(gtk.Label(""), True, True)
vbox_bottom.pack_start(al_button)
vbox_content.pack_start(vbox_bottom)
vbox_content.pack_start(gtk.Label(""), True, True)
vbox.pack_start(self.nicebar, False)
vbox.pack_start(vbox_top)
vbox.pack_start(vbox_content)
vbox.pack_start(vbox_far_bottom)
self.add(vbox)
vbox.show_all()
def __init__(self):
# GTK Stuffs
self.parent = common.get_toplevel_window()
self.dialog = gtk.Dialog(title=_('Login'), parent=self.parent,
flags=gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT)
self.dialog.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
self.dialog.set_icon(TRYTON_ICON)
tooltips = common.Tooltips()
button_cancel = gtk.Button(_('_Cancel'), use_underline=True)
img_cancel = gtk.Image()
img_cancel.set_from_stock('gtk-cancel', gtk.ICON_SIZE_BUTTON)
button_cancel.set_image(img_cancel)
tooltips.set_tip(button_cancel,
_('Cancel connection to the Tryton server'))
self.dialog.add_action_widget(button_cancel, gtk.RESPONSE_CANCEL)
self.button_connect = gtk.Button(_('C_onnect'), use_underline=True)
img_connect = gtk.Image()
img_connect.set_from_stock('tryton-connect', gtk.ICON_SIZE_BUTTON)
self.button_connect.set_image(img_connect)
self.button_connect.set_can_default(True)
tooltips.set_tip(self.button_connect, _('Connect the Tryton server'))
self.dialog.add_action_widget(self.button_connect, gtk.RESPONSE_OK)
self.dialog.set_default_response(gtk.RESPONSE_OK)
alignment = gtk.Alignment(yalign=0, yscale=0, xscale=1)
self.table_main = gtk.Table(3, 3, False)
self.table_main.set_border_width(0)
self.table_main.set_row_spacings(3)
self.table_main.set_col_spacings(3)
alignment.add(self.table_main)
self.dialog.vbox.pack_start(alignment, True, True, 0)
image = gtk.Image()
image.set_from_file(os.path.join(PIXMAPS_DIR, 'tryton.png'))
image.set_alignment(0.5, 1)
ebox = gtk.EventBox()
ebox.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("#1b2019"))
ebox.add(image)
self.table_main.attach(ebox, 0, 3, 0, 1, ypadding=2)
self.profile_store = gtk.ListStore(gobject.TYPE_STRING,
gobject.TYPE_BOOLEAN)
self.combo_profile = gtk.ComboBox()
cell = gtk.CellRendererText()
self.combo_profile.pack_start(cell, True)
self.combo_profile.add_attribute(cell, 'text', 0)
self.combo_profile.add_attribute(cell, 'sensitive', 1)
self.combo_profile.set_model(self.profile_store)
self.combo_profile.connect('changed', self.profile_changed)
self.profile_label = gtk.Label(_(u'Profile:'))
self.profile_label.set_justify(gtk.JUSTIFY_RIGHT)
self.profile_label.set_alignment(1, 0.5)
self.profile_label.set_padding(3, 3)
self.profile_button = gtk.Button(_('_Manage profiles'),
use_underline=True)
self.profile_button.connect('clicked', self.profile_manage)
self.table_main.attach(self.profile_label, 0, 1, 1, 2,
xoptions=gtk.FILL)
self.table_main.attach(self.combo_profile, 1, 2, 1, 2)
self.table_main.attach(self.profile_button, 2, 3, 1, 2,
xoptions=gtk.FILL)
image = gtk.Image()
image.set_from_stock('gtk-edit', gtk.ICON_SIZE_BUTTON)
self.profile_button.set_image(image)
self.expander = gtk.Expander()
self.expander.set_label(_('Host / Database information'))
self.expander.connect('notify::expanded', self.expand_hostspec)
self.table_main.attach(self.expander, 0, 3, 3, 4)
self.label_host = gtk.Label(_('Host:'))
self.label_host.set_justify(gtk.JUSTIFY_RIGHT)
self.label_host.set_alignment(1, 0.5)
self.label_host.set_padding(3, 3)
self.entry_host = gtk.Entry()
self.entry_host.connect_after('focus-out-event',
self.clear_profile_combo)
self.entry_host.set_activates_default(True)
self.label_host.set_mnemonic_widget(self.entry_host)
self.table_main.attach(self.label_host, 0, 1, 4, 5, xoptions=gtk.FILL)
self.table_main.attach(self.entry_host, 1, 3, 4, 5)
self.label_database = gtk.Label(_('Database:'))
self.label_database.set_justify(gtk.JUSTIFY_RIGHT)
self.label_database.set_alignment(1, 0.5)
self.label_database.set_padding(3, 3)
self.entry_database = gtk.Entry()
self.entry_database.connect_after('focus-out-event',
self.clear_profile_combo)
self.entry_database.set_activates_default(True)
self.label_database.set_mnemonic_widget(self.entry_database)
self.table_main.attach(self.label_database, 0, 1, 5, 6,
xoptions=gtk.FILL)
self.table_main.attach(self.entry_database, 1, 3, 5, 6)
self.entry_login = gtk.Entry()
self.entry_login.set_activates_default(True)
self.table_main.attach(self.entry_login, 1, 3, 6, 7)
label_username = gtk.Label(_("User name:"))
label_username.set_alignment(1, 0.5)
label_username.set_padding(3, 3)
label_username.set_mnemonic_widget(self.entry_login)
self.table_main.attach(label_username, 0, 1, 6, 7, xoptions=gtk.FILL)
# Profile informations
self.profile_cfg = os.path.join(get_config_dir(), 'profiles.cfg')
self.profiles = ConfigParser.SafeConfigParser({'port': '8000'})
if not os.path.exists(self.profile_cfg):
short_version = '.'.join(__version__.split('.', 2)[:2])
name = 'demo%s.tryton.org' % short_version
self.profiles.add_section(name)
self.profiles.set(name, 'host', name)
self.profiles.set(name, 'port', '8000')
self.profiles.set(name, 'database', 'demo%s' % short_version)
self.profiles.set(name, 'username', 'demo')
else:
self.profiles.read(self.profile_cfg)
for section in self.profiles.sections():
active = all(self.profiles.has_option(section, option)
for option in ('host', 'port', 'database'))
self.profile_store.append([section, active])
def create_build_gui(self):
vbox = gtk.VBox(False, 12)
vbox.set_border_width(6)
vbox.show()
hbox = gtk.HBox(False, 12)
hbox.show()
vbox.pack_start(hbox, expand=False, fill=False)
label = gtk.Label("Machine:")
label.show()
hbox.pack_start(label, expand=False, fill=False, padding=6)
self.machine_combo = gtk.combo_box_new_text()
self.machine_combo.show()
self.machine_combo.set_tooltip_text(
"Selects the architecture of the target board for which you would like to build an image."
)
hbox.pack_start(self.machine_combo,
expand=False,
fill=False,
padding=6)
label = gtk.Label("Base image:")
label.show()
hbox.pack_start(label, expand=False, fill=False, padding=6)
self.image_combo = gtk.ComboBox()
self.image_combo.show()
self.image_combo.set_tooltip_text(
"Selects the image on which to base the created image")
image_combo_cell = gtk.CellRendererText()
self.image_combo.pack_start(image_combo_cell, True)
self.image_combo.add_attribute(image_combo_cell, 'text',
self.model.COL_NAME)
hbox.pack_start(self.image_combo, expand=False, fill=False, padding=6)
self.progress = gtk.ProgressBar()
self.progress.set_size_request(250, -1)
hbox.pack_end(self.progress, expand=False, fill=False, padding=6)
ins = gtk.Notebook()
vbox.pack_start(ins, expand=True, fill=True)
ins.set_show_tabs(True)
label = gtk.Label("Packages")
label.show()
ins.append_page(self.pkgsaz(), tab_label=label)
label = gtk.Label("Package Collections")
label.show()
ins.append_page(self.tasks(), tab_label=label)
ins.set_current_page(0)
ins.show_all()
hbox = gtk.HBox(False, 1)
hbox.show()
label = gtk.Label("Estimated image contents:")
self.model.connect("contents-changed", self.update_package_count_cb,
label)
label.set_property("xalign", 0.00)
label.show()
hbox.pack_start(label, expand=False, fill=False, padding=6)
info = gtk.Button("?")
info.set_tooltip_text("What does this mean?")
info.show()
info.connect("clicked", self.info_button_clicked_cb)
hbox.pack_start(info, expand=False, fill=False, padding=6)
vbox.pack_start(hbox, expand=False, fill=False, padding=6)
con = self.contents()
con.show()
vbox.pack_start(con, expand=True, fill=True)
bbox = gtk.HButtonBox()
bbox.set_spacing(12)
bbox.set_layout(gtk.BUTTONBOX_END)
bbox.show()
vbox.pack_start(bbox, expand=False, fill=False)
reset = gtk.Button("Reset")
reset.connect("clicked", self.reset_clicked_cb)
reset.show()
bbox.add(reset)
bake = gtk.Button("Bake")
bake.connect("clicked", self.bake_clicked_cb)
bake.show()
bbox.add(bake)
return vbox
def __init__(self, core, main):
super(TopButtons,self).__init__(False, 1)
self.main = main
self.uicore = core
self.toolbox = self
self.dependency_check = self.main.dependency_check
self.img_path = os.path.dirname(__file__) + os.sep + 'data' + os.sep
self.options_dict = {'Hexadecimal':'x', 'String':'s', 'String no case':'i', 'Regexp':'r', 'Unicode':'u', 'Unicode no case':'U'}
self.main_tb = gtk.Toolbar()
self.main_tb.set_style(gtk.TOOLBAR_ICONS)
# New file button
self.new_tb = gtk.MenuToolButton(gtk.STOCK_NEW)
self.new_tb.set_label("New")
self.new_tb.set_tooltip_text('Open new file')
self.new_tb.connect("clicked", self.new_file)
self.main_tb.insert(self.new_tb, 0)
# Rcent files menu
self.manager = gtk.recent_manager_get_default()
self.recent_menu = gtk.RecentChooserMenu(self.manager)
self.new_tb.set_menu(self.recent_menu)
self.new_tb.set_arrow_tooltip_text('Recent opened files')
self.recent_menu.connect('item-activated', self.recent_kb)
# Separator
self.sep = gtk.SeparatorToolItem()
self.main_tb.insert(self.sep, 1)
# PDF Streams search
self.streams_tb = gtk.ToolButton(gtk.STOCK_INDEX)
self.streams_tb.set_tooltip_text('Find PDF streams')
self.streams_tb.connect("clicked", self.search_pdfstreams)
self.streams_tb.set_sensitive(False)
self.main_tb.insert(self.streams_tb, 2)
# Separator
self.sep = gtk.SeparatorToolItem()
self.main_tb.insert(self.sep, 3)
# URL related buttons
i = gtk.Image()
pixbuf = gtk.gdk.pixbuf_new_from_file(self.img_path + 'response-headers.png')
scaled_buf = pixbuf.scale_simple(24,24,gtk.gdk.INTERP_BILINEAR)
i.set_from_pixbuf(scaled_buf)
self.urls = gtk.MenuToolButton(i, 'URL')
#self.urls.set_icon_widget(i)
self.urls.set_tooltip_text('URL plugins')
self.urls_menu = gtk.Menu()
i = gtk.Image()
pixbuf = gtk.gdk.pixbuf_new_from_file(self.img_path + 'response-headers.png')
scaled_buf = pixbuf.scale_simple(16,16,gtk.gdk.INTERP_BILINEAR)
i.set_from_pixbuf(scaled_buf)
item = gtk.ImageMenuItem('Search for URL')
item.set_image(i)
item.connect("activate", self.show_urls)
self.urls_menu.append(item)
i = gtk.Image()
pixbuf = gtk.gdk.pixbuf_new_from_file(self.img_path + 'response-body.png')
scaled_buf = pixbuf.scale_simple(16,16,gtk.gdk.INTERP_BILINEAR)
i.set_from_pixbuf(scaled_buf)
item = gtk.ImageMenuItem('Check URL')
item.set_image(i)
item.connect("activate", self.check_urls)
self.urls_menu.append(item)
i = gtk.Image()
pixbuf = gtk.gdk.pixbuf_new_from_file(self.img_path + 'request-body.png')
scaled_buf = pixbuf.scale_simple(16,16,gtk.gdk.INTERP_BILINEAR)
i.set_from_pixbuf(scaled_buf)
item = gtk.ImageMenuItem('Check bad URL')
item.set_image(i)
item.connect("activate", self.check_bad_urls)
self.urls_menu.append(item)
self.urls_menu.show_all()
self.urls.set_menu(self.urls_menu)
self.urls_menu.show_all()
self.main_tb.insert(self.urls, 4)
# Separator
self.sep = gtk.SeparatorToolItem()
self.main_tb.insert(self.sep, 5)
# Visualizatin buttons
self.visbin_tb = gtk.ToolButton(gtk.STOCK_ZOOM_FIT)
self.visbin_tb.connect("clicked", self.execute, 'binvi')
self.visbin_tb.set_tooltip_text('Visualize binary')
self.visbin_tb.set_sensitive(False)
self.main_tb.insert(self.visbin_tb, 6)
# Separator
self.sep = gtk.SeparatorToolItem()
self.main_tb.insert(self.sep, 7)
# Binary analysis buttons
self.vtotal_tb = gtk.ToolButton(gtk.STOCK_CONNECT)
self.vtotal_tb.connect("clicked", self.send_to_virustotal)
self.vtotal_tb.set_tooltip_text('Send to VirusTotal')
self.vtotal_tb.set_sensitive(False)
self.main_tb.insert(self.vtotal_tb, 8)
self.threat_tb = gtk.ToolButton(gtk.STOCK_JUMP_TO)
self.threat_tb.connect("clicked", self.execute, 'threat')
self.threat_tb.set_tooltip_text('Search in Threat Expert')
self.threat_tb.set_sensitive(False)
self.main_tb.insert(self.threat_tb, 9)
self.shellcode_tb = gtk.ToolButton(gtk.STOCK_FIND)
self.shellcode_tb.connect("clicked", self.search_shellcode)
self.shellcode_tb.set_tooltip_text('Search for Shellcode')
self.shellcode_tb.set_sensitive(False)
self.main_tb.insert(self.shellcode_tb, 10)
# not yet working properly
self.antivm_tb = gtk.ToolButton(gtk.STOCK_FIND_AND_REPLACE)
self.antivm_tb.connect("clicked", self.search_antivm)
self.antivm_tb.set_tooltip_text('Search for antivm tricks')
self.antivm_tb.set_sensitive(False)
self.main_tb.insert(self.antivm_tb, 11)
self.packed_tb = gtk.ToolButton(gtk.STOCK_CONVERT)
self.packed_tb.connect("clicked", self.check_packer)
self.packed_tb.set_tooltip_text('Check if the PE file is packed')
self.packed_tb.set_sensitive(False)
self.main_tb.insert(self.packed_tb, 12)
# Separator
self.sep = gtk.SeparatorToolItem()
self.main_tb.insert(self.sep, 13)
# Search components
self.search_combo_tb = gtk.ToolItem()
self.search_combo_align = gtk.Alignment(yalign=0.5)
store = gtk.ListStore(gtk.gdk.Pixbuf, str)
self.search_combo = gtk.ComboBox(store)
rendererText = gtk.CellRendererText()
rendererPix = gtk.CellRendererPixbuf()
self.search_combo.pack_start(rendererPix, False)
self.search_combo.pack_start(rendererText, True)
self.search_combo.add_attribute(rendererPix, 'pixbuf', 0)
self.search_combo.add_attribute(rendererText, 'text', 1)
options = {
'String':gtk.gdk.pixbuf_new_from_file(os.path.dirname(__file__) + os.sep + 'data' + os.sep + 'icon_string_16.png'),
'String no case':gtk.gdk.pixbuf_new_from_file(os.path.dirname(__file__) + os.sep + 'data' + os.sep + 'icon_string_no_case_16.png'),
'Hexadecimal':gtk.gdk.pixbuf_new_from_file(os.path.dirname(__file__) + os.sep + 'data' + os.sep + 'icon_hexadecimal_16.png'),
'Regexp':gtk.gdk.pixbuf_new_from_file(os.path.dirname(__file__) + os.sep + 'data' + os.sep + 'icon_regexp_16.png')
}
for option in options.keys():
store.append([options[option], option])
self.search_combo.set_active(0)
self.search_combo_align.add(self.search_combo)
self.search_combo_tb.add(self.search_combo_align)
self.main_tb.insert(self.search_combo_tb, 14)
# Separator
self.sep = gtk.SeparatorToolItem()
self.sep.set_draw(False)
self.main_tb.insert(self.sep, 15)
self.search_entry_tb = gtk.ToolItem()
self.search_entry = gtk.Entry(100)
self.search_entry.set_text('Text to search')
self.search_entry.set_icon_from_stock(1, gtk.STOCK_FIND)
self.search_entry.set_icon_tooltip_text(1, 'Search')
self.search_entry.connect("activate", self.search)
self.search_entry.connect("icon-press", self.search)
self.search_entry.connect('focus-in-event', self._clean, 'in')
self.search_entry.connect('focus-out-event', self._clean, 'out')
self.search_entry_tb.add(self.search_entry)
self.main_tb.insert(self.search_entry_tb, 16)
# Separator
self.sep = gtk.SeparatorToolItem()
self.main_tb.insert(self.sep, 17)
# Cheatsheet button
self.cheatsheet_tb = gtk.ToolButton(gtk.STOCK_JUSTIFY_FILL)
self.cheatsheet_tb.set_tooltip_text('Show assembler reference sheet')
self.cheatsheet_tb.connect("clicked", self.create_cheatsheet_dialog)
self.main_tb.insert(self.cheatsheet_tb, 18)
# Separator
self.sep = gtk.SeparatorToolItem()
self.sep.set_expand(True)
self.sep.set_draw(False)
self.main_tb.insert(self.sep, 19)
# Exit button
self.exit_tb = gtk.ToolButton(gtk.STOCK_QUIT)
self.exit_tb.set_label('Quit')
self.exit_tb.connect("clicked", self.main.quit)
self.exit_tb.set_tooltip_text('Have a nice day ;-)')
self.main_tb.insert(self.exit_tb, 20)
# Throbber
self.throbber = throbber.Throbber()
self.throbber_tb = gtk.ToolItem()
self.throbber_tb.add(self.throbber)
self.main_tb.insert(self.throbber_tb, 21)
self.toolbox.pack_start(self.main_tb, True, True)
self.show_all()
def __init__(self):
logger = logging.getLogger('INIT')
self.uimanager = gtk.UIManager()
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
gtk.window_set_default_icon_from_file(IMGDIR + "icon.png")
self.window.set_size_request(490, 420)
self.window.set_title("leo-lookup Version " + self.__version__)
self.window.connect("destroy", self.destroyWin)
self.box = gtk.VBox(False, 5)
self.menubar_acts = [('File', None, "_File"),
('Quit', gtk.STOCK_QUIT, "_Quit", None,
"Close Program", self.destroyWin),
('Extensions', None, "_Extensions"),
('ext_prefs', None, "_Preferences", None,
"Set prefereences for extensions", None),
('Help', None, "_Help"),
('aboutdlg', None, "_About", None,
"View informations about leo-lookup.", None)]
self.actgroup = gtk.ActionGroup("LEO_LOOKUP")
self.actgroup.add_actions(self.menubar_acts)
accelgroup = self.uimanager.get_accel_group()
self.window.add_accel_group(accelgroup)
self.uimanager.add_ui_from_string(self.menubardesc)
self.uimanager.insert_action_group(self.actgroup, 0)
self.menubar = self.uimanager.get_widget("/Mainmenu")
self.box.pack_start(self.menubar, False)
self.word2lookup = gtk.Entry()
self.word2lookup.set_text("Enter word to lookup here ...")
self.box.pack_start(self.word2lookup, False, False, 0)
self.box2 = gtk.HBox(False, 6)
self.fromLangLabel = gtk.Label("From ")
self.box2.pack_start(self.fromLangLabel, False, False, 0)
# Create combo box for the language to translate from
self.lstst_fromLang = gtk.ListStore(gtk.gdk.Pixbuf, str)
self.fromLang = gtk.ComboBox(self.lstst_fromLang)
cellpb = gtk.CellRendererPixbuf()
cellt = gtk.CellRendererText()
self.fromLang.pack_start(cellpb, True)
self.fromLang.pack_start(cellt, True)
self.fromLang.add_attribute(cellpb, 'pixbuf', 0)
self.fromLang.add_attribute(cellt, 'text', 1)
# add languages to combobox
for lang in self.supportedLangs:
self.lstst_fromLang.append(
[gtk.gdk.pixbuf_new_from_file(IMGDIR + lang + ".png"), lang])
self.fromLang.set_active(0)
self.box2.pack_start(self.fromLang, False, False, 0)
self.swapToFrom = gtk.Button("<>")
self.swapToFrom.connect("clicked", self.swapToFromClicked)
self.box2.pack_start(self.swapToFrom, False, False, 0)
self.toLangLabel = gtk.Label("to ")
self.box2.pack_start(self.toLangLabel, False, False, 0)
# Create combo box for the language to translate to
self.lstst_toLang = gtk.ListStore(gtk.gdk.Pixbuf, str)
self.toLang = gtk.ComboBox(self.lstst_toLang)
self.toLang.pack_start(cellpb, True)
self.toLang.pack_start(cellt, True)
self.toLang.add_attribute(cellpb, 'pixbuf', 0)
self.toLang.add_attribute(cellt, 'text', 1)
for lang in self.supportedLangs:
self.lstst_toLang.append(
[gtk.gdk.pixbuf_new_from_file(IMGDIR + lang + ".png"), lang])
self.toLang.set_active(1)
self.box2.pack_start(self.toLang, False, False, 0)
# Create indicator of successes
self.results = gtk.Label("")
self.box2.pack_end(self.results, False, False, 0)
self.box.pack_start(self.box2, False, False, 0)
self.lookup = gtk.Button("Look up!")
self.lookup.connect("clicked", self.onTransClick)
self.box.pack_start(self.lookup, False, False, 0)
self.scrollcont = gtk.ScrolledWindow()
self.scrollcont.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.meanings = gtk.ListStore(str, str)
self.listOfMeanings = gtk.TreeView(self.meanings)
self.listOfMeaningsCol = gtk.TreeViewColumn("Foreign Lang.")
self.listOfMeanings.append_column(self.listOfMeaningsCol)
cell = gtk.CellRendererText()
self.listOfMeaningsCol.pack_start(cell, True)
self.listOfMeaningsCol.add_attribute(cell, 'text', 0)
self.listOfMeaningsCol2 = gtk.TreeViewColumn("Familiar Lang.")
self.listOfMeanings.append_column(self.listOfMeaningsCol2)
cell2 = gtk.CellRendererText()
self.listOfMeaningsCol2.pack_start(cell2, True)
self.listOfMeaningsCol2.add_attribute(cell2, 'text', 1)
self.lom_treesel = self.listOfMeanings.get_selection()
self.lom_treesel.set_mode(gtk.SELECTION_MULTIPLE)
self.scrollcont.add(self.listOfMeanings)
self.box.pack_start(self.scrollcont, True, True, 0)
self.box.show_all()
self.window.add(self.box)
logger.info("window constructed, let's make it visible ...")
self.window.show_all()
logger.info("initializing plugin architecture ...")
pm = plugins.plugin_manager(self.uimanager, self.lom_treesel,
PLUGINDIR)
pm.load_plugins()
gtk.main()
