def __init__(self,node,parent = None, title = "Internode Usage Alert", text = None, hidden = False):
NodeDialog.__init__(self,node,parent)
if not parent:
self.set_title(title)
self.parent.set_position(gtk.WIN_POS_CENTER)
glade = gtk.glade.XML(UI_FILE, "alert_vbox")
controls = glade.get_widget("alert_vbox")
self.label = glade.get_widget("message")
btnOK = glade.get_widget("btnOK")
btnOK.connect("clicked",self.close)
btnBuy = glade.get_widget("btnBuyData")
self.handler = btnBuy.connect("clicked",self.buy_data)
self.glade = glade
self.controls = controls
self.show_usage_data = True
if text:
self.set_text(text)
self.parent.add(controls)
if not hidden:
self.parent.show_all()
def testIP(subnet):
dev = glade.get_widget("interface").get_active_text()
time = int(glade.get_widget("time").get_active_text())
for ipEnding in random.sample(range(5, 254), time + 1):
ip = ".".join((subnet, str(ipEnding)))
setStatus(info=ip)
if os.system("ifconfig %s %s up" % (dev, ip)) is not 0:
gtk.threads_enter()
errMessage = "You don't have permission to change the IP of device %s.\n" % dev + \
"Please run this application as super user. I will now exit..."
msgBox = gtk.MessageDialog(type=gtk.MESSAGE_ERROR,
buttons=gtk.BUTTONS_CLOSE,
message_format=errMessage)
msgBox.show()
msgBox.run()
msgBox.destroy()
gtk.main_quit()
gtk.threads_leave()
return True
for routerEnding in [1, 2]:
if "doStopScan" in globals():
return True
ip = ".".join((subnet, str(routerEnding)))
if os.system("arping -qfw %d -I %s %s >/dev/null" %
(time, dev, ip)) is 0:
addLog("\nThe subnet %s seems to have a router at %s" %
(subnet, ip))
return True
return False
def __init__(self, parent=None):
glade = gtk.glade.XML(common.terp_path('openerp.glade'), 'win_extension', gettext.textdomain())
self.win = glade.get_widget('win_extension')
self.win.set_icon(common.OPENERP_ICON)
model = gtk.ListStore( str, str, str )
self.treeview = glade.get_widget('treeview_extension')
self.treeview.set_model(model)
for index, text in enumerate(['Extension', 'Application', 'Print Processor']):
renderer = gtk.CellRendererText()
renderer.set_property( 'editable', True )
renderer.connect( 'edited', self._on_cell_renderer_edited )
column = gtk.TreeViewColumn( text, renderer, text=index )
column.set_resizable( True )
self.treeview.append_column( column )
dict = {
'on_button5_clicked' : self._sig_add,
'on_button6_clicked' : self._sig_remove,
}
for signal in dict:
glade.signal_connect( signal, dict[signal] )
self.load_from_file()
def on_selection_changed(treeview):
cursor_position = treeview.get_cursor()[0]
if not cursor_position:
return
task = Conversation.task_list[(cursor_position[0])]
'''restore parametrs if cursor changes'''
a = gui.bloc
gui.bloc = True
folder, dic = Conversation.task_parametrs[task]
widget = [
'quality', 'album', 'date', 'genre', 'composer'
, 'bin_file', 'filename', 'performer']
map(lambda x:glade.get_widget(x).set_text(dic[x]), widget)
var = [
'bitratebtn', 'VBR',
'same_folder','qualitybtn']
map(lambda x:glade.get_widget(x).set_active(dic[x]), var)
glade.get_widget('level').set_active(dic['level_n'])
glade.get_widget('codec').set_active(dic['codec_n'])
glade.get_widget('bitrate').set_value(float(dic['bitrate']))
glade.get_widget('savefolder').set_text(dic['folder'])
gui.bloc = a
if len(cursor_position) > 1:
gui.renderer.set_property('editable', not get('cue2tracks'))
else:
gui.renderer.set_property('editable', False)
if treeview.get_cursor()[1] is not treeview.get_column(3):
if treeview.row_expanded(cursor_position):
treeview.collapse_row(cursor_position)
else:
treeview.expand_to_path(cursor_position)
def __init__(self,node,parent = None, title = "Internode Usage Alert", markup = None, hidden = False):
#we don't pass 'hidden' off to the parent's constructor, we'll do that later -
# (we might want to change things between creation and showing)
NodeDialog_UsageAlert.__init__(self,node,parent, title, None, False)
#NodeDialog.__init__(self,node,parent)
if False:
if not parent:
self.set_title(title)
self.parent.set_position(gtk.WIN_POS_CENTER)
glade = gtk.glade.XML(UI_FILE, "alert_vbox")
controls = glade.get_widget("alert_vbox")
self.label = glade.get_widget("message")
btnOK = self.get_widget("btnOK")
btnOK.connect("clicked",self.close)
btnOK.set_label("Meh")
btnBuy = self.get_widget("btnBuyData")
btnBuy.set_label("Download Now...")
btnBuy.disconnect(self.handler)
btnBuy.connect("clicked",self.download)
#self.glade = glade
#self.controls = controls
#self.show_usage_data = True
if markup:
self.set_markup(markup)
#self.parent.add(controls)
if not hidden:
self.show()
def __init_gui_dialog(self):
file = os.path.join(self.config.read('base', '/usr/share/daluang'), "browser/res/external.glade")
glade = gtk.glade.XML(file)
self.dialog_external = glade.get_widget('dialog')
self.dialog_external_url = glade.get_widget('lbl_url')
self.dialog_external.connect("close", self.__on_dialog_external_closed)
def show_move_storage_dialog(self, status):
log.debug("show_move_storage_dialog")
glade = gtk.glade.XML(pkg_resources.resource_filename(
"deluge.ui.gtkui", "glade/move_storage_dialog.glade"
))
# Keep it referenced:
# https://bugzilla.gnome.org/show_bug.cgi?id=546802
self.move_storage_dialog = glade.get_widget("move_storage_dialog")
self.move_storage_dialog.set_transient_for(self.window.window)
self.move_storage_dialog_entry = glade.get_widget("entry_destination")
self.move_storage_dialog_entry.set_text(status["save_path"])
def on_dialog_response_event(widget, response_id):
def on_core_result(result):
# Delete references
del self.move_storage_dialog
del self.move_storage_dialog_entry
if response_id == gtk.RESPONSE_OK:
log.debug("Moving torrents to %s",
self.move_storage_dialog_entry.get_text())
path = self.move_storage_dialog_entry.get_text()
client.core.move_storage(
component.get("TorrentView").get_selected_torrents(), path
).addCallback(on_core_result)
self.move_storage_dialog.hide()
self.move_storage_dialog.connect("response", on_dialog_response_event)
self.move_storage_dialog.show()
def show_move_storage_dialog(self, status):
log.debug("show_move_storage_dialog")
glade = gtk.glade.XML(
deluge.common.resource_filename(
"deluge.ui.gtkui",
os.path.join("glade", "move_storage_dialog.glade")))
# Keep it referenced:
# https://bugzilla.gnome.org/show_bug.cgi?id=546802
self.move_storage_dialog = glade.get_widget("move_storage_dialog")
self.move_storage_dialog.set_transient_for(self.window.window)
self.move_storage_dialog_entry = glade.get_widget("entry_destination")
self.move_storage_dialog_entry.set_text(status["save_path"])
def on_dialog_response_event(widget, response_id):
def on_core_result(result):
# Delete references
del self.move_storage_dialog
del self.move_storage_dialog_entry
if response_id == gtk.RESPONSE_OK:
log.debug("Moving torrents to %s",
self.move_storage_dialog_entry.get_text())
path = self.move_storage_dialog_entry.get_text()
client.core.move_storage(
component.get("TorrentView").get_selected_torrents(),
path).addCallback(on_core_result)
self.move_storage_dialog.hide()
self.move_storage_dialog.connect("response", on_dialog_response_event)
self.move_storage_dialog.show()
def __init__(self,node):
log("Showing Preferences Dialog")
#The prefs dialog never has a parent
NodeDialog.__init__(self,node,None)
self.gconf_client = gconf.client_get_default()
# Load and show the preferences dialog box
glade = gtk.glade.XML(UI_FILE, "preferences")
preferences = glade.get_widget("preferences")
# Set the input text to the current username/password values
usertext = glade.get_widget("username")
usertext.set_text(self.nodeutil.username)
passtext = glade.get_widget("password")
passtext.set_text(self.nodeutil.password)
# Set the used/remaining radio buttons
used = glade.get_widget("show_used")
used.set_active(self.nodeutil.show_used)
result = preferences.run()
if result == gtk.RESPONSE_OK:
# Update username and password
self.nodeutil.username = usertext.get_text()
self.nodeutil.password = passtext.get_text()
self.nodeutil.show_used = used.get_active()
self.write_prefs()
#self.update()
preferences.destroy()
def show_prefs(self, widget, data):
"""
Displays the Preferences dialog
"""
# Load and show the preferences dialog box
glade = gtk.glade.XML(self.ui_dir + "/adam-applet.glade", "preferences")
preferences = glade.get_widget("preferences")
# Set the input text to the current username/password values
passtext = glade.get_widget("password")
passtext.set_text(self.adamutil.password)
# Set the used/remaining radio buttons
used = glade.get_widget("show_used")
used.set_active(self.adamutil.show_used)
result = preferences.run()
if result == gtk.RESPONSE_OK:
# Update username and password
self.adamutil.username = usertext.get_text()
self.adamutil.password = passtext.get_text()
self.adamutil.show_used = used.get_active()
self.write_prefs()
# updating here causes a delay after pressing OK
#self.update()
preferences.destroy()
def show_prefs(self, widget, data):
"""
Displays the Preferences dialog
"""
# Load and show the preferences dialog box
glade = gtk.glade.XML(self.ui_dir + "/adam-applet.glade",
"preferences")
preferences = glade.get_widget("preferences")
# Set the input text to the current username/password values
passtext = glade.get_widget("password")
passtext.set_text(self.adamutil.password)
# Set the used/remaining radio buttons
used = glade.get_widget("show_used")
used.set_active(self.adamutil.show_used)
result = preferences.run()
if result == gtk.RESPONSE_OK:
# Update username and password
self.adamutil.username = usertext.get_text()
self.adamutil.password = passtext.get_text()
self.adamutil.show_used = used.get_active()
self.write_prefs()
# updating here causes a delay after pressing OK
#self.update()
preferences.destroy()
def __init__(self, torrent_ids):
if type(torrent_ids) != list and type(torrent_ids) != tuple:
raise TypeError("requires a list of torrent_ids")
if not torrent_ids:
raise ValueError("requires a list of torrent_ids")
self.__torrent_ids = torrent_ids
glade = gtk.glade.XML(
pkg_resources.resource_filename(
"deluge.ui.gtkui", "glade/remove_torrent_dialog.glade"))
self.__dialog = glade.get_widget("remove_torrent_dialog")
self.__dialog.set_transient_for(component.get("MainWindow").window)
self.__dialog.set_title("")
if len(self.__torrent_ids) > 1:
# We need to pluralize the dialog
label_title = glade.get_widget("label_title")
button_ok = glade.get_widget("button_ok_label")
button_data = glade.get_widget("button_data_label")
def pluralize_torrents(text):
plural_torrent = _("Torrents")
return text.replace("torrent", plural_torrent.lower()).replace(
"Torrent", plural_torrent)
label_title.set_markup(pluralize_torrents(label_title.get_label()))
button_ok.set_label(pluralize_torrents(button_ok.get_label()))
button_data.set_label(pluralize_torrents(button_data.get_label()))
def get_command(name='wav.wav'):
dec_command = {
'ape':'%s "%s" "%s/wav.wav" -d' % (get('mac'), bin_file, tmpdir),
'flac':'%s -d -f -o "%s/%s" "%s"' % (get('flac'), tmpdir, name, bin_file),
'wv':'%s -o "%s/wav.wav" "%s"' % (get('wvunpack'), tmpdir, bin_file),
'wav':'cp "%s" "%s/wav.wav"' % (bin_file, tmpdir)
}
gtk.gdk.threads_enter()
glade.get_widget('stop_button').set_sensitive(True)
glade.get_widget('start').set_sensitive(False)
glade.get_widget('test').set_sensitive(False)
gtk.gdk.threads_leave()
codec = bin_file.split('.')[-1]
if codec in dec_command:
'''codec supported?'''
command = dec_command[codec]
else:
gtk.gdk.threads_enter()
message = _('Format <b>%s</b>\ndon\'t supported '
) %codec
show_dialog(message)
glade.get_widget('stop_button').set_sensitive(False)
glade.get_widget('start').set_sensitive(True)
gtk.gdk.threads_leave()
return
if codec == 'wv' and not codec_path('wvunpack'):
return
if codec == 'ape'and not codec_path('mac'):
return
if codec == 'flac'and not codec_path('flac'):
return
return command
def __init__(self, parent=None):
glade = gtk.glade.XML(common.terp_path('openerp.glade'), 'win_extension', gettext.textdomain())
self.win = glade.get_widget('win_extension')
self.win.set_transient_for(parent)
self.win.set_icon(common.OPENERP_ICON)
model = gtk.ListStore( str, str, str )
self.treeview = glade.get_widget('treeview_extension')
self.treeview.set_model(model)
for index, text in enumerate([_('Extension'), _('Application'), _('Print Processor')]):
renderer = gtk.CellRendererText()
renderer.set_property( 'editable', True )
renderer.connect( 'edited', self._on_cell_renderer_edited )
column = gtk.TreeViewColumn( text, renderer, text=index )
column.set_resizable( True )
self.treeview.append_column( column )
dict = {
'on_button5_clicked' : self._sig_add,
'on_button6_clicked' : self._sig_remove,
}
for signal in dict:
glade.signal_connect( signal, dict[signal] )
self.load_from_file()
def __init__(self, folder, task_list = None):
threading.Thread.__init__(self)
self.folder = folder
self.task_list = task_list
self.job_up = glade.get_widget('job_up')
self.job_down = glade.get_widget('job_down')
Conversation.value = None
def __init__(self):
APP_NAME= 'color-grab-py'
glade = gtk.glade.XML('gui/color-selection-window.glade', None, APP_NAME)
glade.signal_autoconnect(self)
self.main_window = glade.get_widget("main_window")
self.about_dialog = glade.get_widget("about_dialog")
def __init__(self, torrent_ids):
if type(torrent_ids) != list and type(torrent_ids) != tuple:
raise TypeError("requires a list of torrent_ids")
if not torrent_ids:
raise ValueError("requires a list of torrent_ids")
self.__torrent_ids = torrent_ids
glade = gtk.glade.XML(deluge.common.resource_filename(
"deluge.ui.gtkui", os.path.join("glade", "remove_torrent_dialog.glade"))
)
self.__dialog = glade.get_widget("remove_torrent_dialog")
self.__dialog.set_transient_for(component.get("MainWindow").window)
self.__dialog.set_title("")
if len(self.__torrent_ids) > 1:
# We need to pluralize the dialog
label_title = glade.get_widget("label_title")
button_ok = glade.get_widget("button_ok_label")
button_data = glade.get_widget("button_data_label")
def pluralize_torrents(text):
plural_torrent = _("Torrents")
return text.replace("torrent", plural_torrent.lower()).replace("Torrent", plural_torrent)
label_title.set_markup(pluralize_torrents(label_title.get_label()))
button_ok.set_label(pluralize_torrents(button_ok.get_label()))
button_data.set_label(pluralize_torrents(button_data.get_label()))
def show_other_dialog(header, type_str, image_stockid=None, image_filename=None, default=0):
"""
Shows a dialog with `header` as the header text and `type_str`
as the type text. The type of spinbutton (int or float) is determined by
`default` type.
:param header: str, the header label text
:param type_str: str, the type label text, what comes after the spinbutton
:param image_stockid: gtkStockId, the stock id of the image in the header
:param image_filename: str, filename of icon in pixmaps folder
:param default: the default value in the spinbutton
:returns: None, int or float from spinbutton depending on `default`.
None is returned if the user clicks on Cancel.
:rtype: None, int or float
:raises TypeError: if `default` is not of type int or float
"""
if type(default) != int and type(default) != float:
raise TypeError("default value needs to be an int or float")
glade = gtk.glade.XML(deluge.common.resource_filename(
"deluge.ui.gtkui", os.path.join("glade", "dgtkpopups.glade"))
)
dialog = glade.get_widget("other_dialog")
dialog.set_transient_for(component.get("MainWindow").window)
dialog.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
dialog.set_title("")
glade.get_widget("label_header").set_markup("<b>" + header + "</b>")
glade.get_widget("label_type").set_text(type_str)
if image_stockid:
glade.get_widget("image").set_from_stock(image_stockid, gtk.ICON_SIZE_LARGE_TOOLBAR)
if image_filename:
# Hack for Windows since it doesn't support svg
if os.path.splitext(image_filename)[1] == ".svg" and (deluge.common.windows_check() or deluge.common.osx_check()):
image_filename = os.path.splitext(image_filename)[0] + "16.png"
pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(
deluge.common.get_pixmap(image_filename), 32, 32)
glade.get_widget("image").set_from_pixbuf(pixbuf)
spinbutton = glade.get_widget("spinbutton")
if type(default) == float:
spinbutton.set_digits(1)
# Set default value and select text
spinbutton.set_value(default)
spinbutton.select_region(0, -1)
value = None
response = dialog.run()
if response == gtk.RESPONSE_OK:
if type(default) == int:
value = spinbutton.get_value_as_int()
else:
value = spinbutton.get_value()
dialog.destroy()
return value
def startScan(widget):
for widget in ("btnStart", "interface"):
glade.get_widget(widget).set_sensitive(False)
glade.get_widget("btnStop").set_sensitive(True)
global scannerThread
scannerThread = threading.Thread(target=testIPs)
scannerThread.setDaemon(True)
scannerThread.start()
def file_not_found():
gtk.gdk.threads_enter()
message = (_('File \n<b>%s</b>\nnot found'
) %bin_file)
show_dialog(message)
if len(Conversation.task_list) > 0:
glade.get_widget('start').set_sensitive(True)
gtk.gdk.threads_leave()
def addLog(text):
gtk.threads_enter()
if text is None:
glade.get_widget("log").get_buffer().set_text("")
else:
glade.get_widget("log").get_buffer().insert(
glade.get_widget("log").get_buffer().get_end_iter(), "%s\n" % text)
gtk.threads_leave()
def __init__(self):
component.Component.__init__(self, "TorrentDetails", interval=2)
self.window = component.get("MainWindow")
glade = self.window.main_glade
self.notebook = glade.get_widget("torrent_info")
# This is the menu item we'll attach the tabs checklist menu to
self.menu_tabs = glade.get_widget("menu_tabs")
self.notebook.connect("switch-page", self._on_switch_page)
# Tabs holds references to the Tab objects by their name
self.tabs = {}
# Add the default tabs
from status_tab import StatusTab
from details_tab import DetailsTab
from files_tab import FilesTab
from peers_tab import PeersTab
from options_tab import OptionsTab
default_tabs = {
"Status": StatusTab,
"Details": DetailsTab,
"Files": FilesTab,
"Peers": PeersTab,
"Options": OptionsTab
}
# tab_name, visible
default_order = [("Status", True), ("Details", True), ("Files", True),
("Peers", True), ("Options", True)]
# Get the state from saved file
state = self.load_state()
if state:
for item in state:
if not isinstance(item, tuple):
log.debug("Old tabs.state, using default..")
state = None
break
# The state is a list of tab_names in the order they should appear
if state == None:
# Set the default order
state = default_order
# We need to rename the tab in the state for backwards compat
self.state = [(tab_name.replace("Statistics", "Status"), visible)
for tab_name, visible in state]
for tab in default_tabs.itervalues():
self.add_tab(tab(), generate_menu=False)
# Generate the checklist menu
self.generate_menu()
def show_other_dialog(header, type_str, image_stockid=None, image_filename=None, default=0):
"""
Shows a dialog with `header` as the header text and `type_str`
as the type text. The type of spinbutton (int or float) is determined by
`default` type.
:param header: str, the header label text
:param type_str: str, the type label text, what comes after the spinbutton
:param image_stockid: gtkStockId, the stock id of the image in the header
:param image_filename: str, filename of icon in pixmaps folder
:param default: the default value in the spinbutton
:returns: None, int or float from spinbutton depending on `default`.
None is returned if the user clicks on Cancel.
:rtype: None, int or float
:raises TypeError: if `default` is not of type int or float
"""
if type(default) != int and type(default) != float:
raise TypeError("default value needs to be an int or float")
glade = gtk.glade.XML(
pkg_resources.resource_filename("deluge.ui.gtkui",
"glade/dgtkpopups.glade"))
dialog = glade.get_widget("other_dialog")
dialog.set_transient_for(component.get("MainWindow").window)
dialog.set_title("")
glade.get_widget("label_header").set_markup("<b>" + header + "</b>")
glade.get_widget("label_type").set_text(type_str)
if image_stockid:
glade.get_widget("image").set_from_stock(image_stockid, gtk.ICON_SIZE_LARGE_TOOLBAR)
if image_filename:
# Hack for Windows since it doesn't support svg
if os.path.splitext(image_filename)[1] == ".svg" and (deluge.common.windows_check() or deluge.common.osx_check()):
image_filename = os.path.splitext(image_filename)[0] + "16.png"
pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(
deluge.common.get_pixmap(image_filename), 32, 32)
glade.get_widget("image").set_from_pixbuf(pixbuf)
spinbutton = glade.get_widget("spinbutton")
if type(default) == float:
spinbutton.set_digits(1)
# Set default value and select text
spinbutton.set_value(default)
spinbutton.select_region(0, -1)
value = None
response = dialog.run()
if response == gtk.RESPONSE_OK:
if type(default) == int:
value = spinbutton.get_value_as_int()
else:
value = spinbutton.get_value()
dialog.destroy()
return value
def stopScan(widget):
global scannerThread, doStopScan
doStopScan = True
if threading.currentThread() is not scannerThread:
scannerThread.join()
del doStopScan
for widget in ("btnStart", "interface"):
glade.get_widget(widget).set_sensitive(True)
glade.get_widget("btnStop").set_sensitive(False)
def menu_bar(self):
log.debug("menu_bar")
window = self.gtkui.mainwindow
glade = window.main_glade
menubar = glade.get_widget("menubar")
group = gtk.accel_groups_from_object(window.window)[0]
# NOTE: accel maps doesn't work with glade file format
# because of libglade not setting MenuItem accel groups
# That's why we remove / set accelerators by hand... (dirty)
# Clean solution: migrate glades files to gtkbuilder format
file_menu = glade.get_widget("menu_file").get_submenu()
file_items = file_menu.get_children()
self.accel_meta(file_items[0], group, "o")
self.accel_meta(file_items[1], group, "n")
quit_all_item = file_items[3]
self.accel_swap(
quit_all_item,
group,
"q",
gtk.gdk.SHIFT_MASK | gtk.gdk.CONTROL_MASK,
"q",
gtk.gdk.SHIFT_MASK | gtk.gdk.META_MASK,
)
for item in range(2, len(file_items)): # remove quits
file_menu.remove(file_items[item])
menu_widget = glade.get_widget("menu_edit")
edit_menu = menu_widget.get_submenu()
edit_items = edit_menu.get_children()
pref_item = edit_items[0]
self.accel_swap(pref_item, group, "p", gtk.gdk.CONTROL_MASK, ",", gtk.gdk.META_MASK)
edit_menu.remove(pref_item)
conn_item = edit_items[1]
self.accel_meta(conn_item, group, "m")
edit_menu.remove(conn_item)
menubar.remove(menu_widget)
help_menu = glade.get_widget("menu_help").get_submenu()
help_items = help_menu.get_children()
about_item = help_items[4]
help_menu.remove(about_item)
help_menu.remove(help_items[3]) # separator
menubar.hide()
self.osxapp.set_menu_bar(menubar)
# populate app menu
self.osxapp.insert_app_menu_item(about_item, 0)
self.osxapp.insert_app_menu_item(gtk.SeparatorMenuItem(), 1)
self.osxapp.insert_app_menu_item(pref_item, 2)
self.osxapp.insert_app_menu_item(conn_item, 3)
if quit_all_item.get_visible():
self.osxapp.insert_app_menu_item(gtk.SeparatorMenuItem(), 4)
self.osxapp.insert_app_menu_item(quit_all_item, 5)
def codecs_list(glade):
if get('cue2tracks'):
codecs = ['ogg', 'mp3', 'flac', 'wav', 'flake', 'ape', 'wv', 'ofr', 'shn']
else:
codecs = ['ogg', 'mp3', 'flac', 'wav', 'ape', 'wv']
list = glade.get_widget('codec').get_model()
list.clear()
map(lambda x:list.append([x]), codecs)
st = get('codec')
glade.get_widget('codec').set_active(st)
def del_task(self, widget):
selection = self.treeview.get_selection()
model, iter = selection.get_selected()
cursor_position = self.treeview.get_cursor()[0]
if len(cursor_position) > 1:
return
if len(model) == 1:
glade.get_widget('del_task').set_sensitive(False)
cursor_position = self.treeview.get_cursor()[0][0]
if Conversation.cursor[0] > cursor_position - 1:
Conversation.cursor = Conversation.cursor[0]-1,
if cursor_position +1 == len(model) and cursor_position != 0:
self.treeview.set_cursor(cursor_position -1)
if cursor_position +1 < len(model):
self.treeview.set_cursor(cursor_position + 1)
if iter:
model.remove(iter)
task_list_renew(model)
if len(model) == 1:
glade.get_widget('job_up').set_sensitive(False)
glade.get_widget('job_down').set_sensitive(False)
if len(Conversation.task_list) == 0:
glade.get_widget('start').set_sensitive(False)
if len(threading.enumerate()) > 1:
progressbar2=glade.get_widget('progressbar2')
progressbar2.set_text(
'%s in queue:%s' %(Conversation.job_name
, len(Conversation.task_list)))
def menubar_osx(gtkui, osxapp):
window = gtkui.mainwindow
glade = window.main_glade
menubar = glade.get_widget("menubar")
group = gtk.accel_groups_from_object(window.window)[0]
config = ConfigManager("gtkui.conf")
# NOTE: accel maps doesn't work with glade file format
# because of libglade not setting MenuItem accel groups
# That's why we remove / set accelerators by hand... (dirty)
# Clean solution: migrate glades files to gtkbuilder format
file_menu = glade.get_widget("menu_file").get_submenu()
file_items = file_menu.get_children()
accel_meta(file_items[0], group, 'o')
accel_meta(file_items[1], group, 'n')
quit_all_item = file_items[3]
accel_swap(quit_all_item, group, 'q',
gtk.gdk.SHIFT_MASK | gtk.gdk.CONTROL_MASK, 'q',
gtk.gdk.SHIFT_MASK | gtk.gdk.META_MASK)
for item in range(2, len(file_items)): # remove quits
file_menu.remove(file_items[item])
menu_widget = glade.get_widget("menu_edit")
edit_menu = menu_widget.get_submenu()
edit_items = edit_menu.get_children()
pref_item = edit_items[0]
accel_swap(pref_item, group, 'p', gtk.gdk.CONTROL_MASK, ',',
gtk.gdk.META_MASK)
edit_menu.remove(pref_item)
conn_item = edit_items[1]
accel_meta(conn_item, group, 'm')
edit_menu.remove(conn_item)
menubar.remove(menu_widget)
help_menu = glade.get_widget("menu_help").get_submenu()
help_items = help_menu.get_children()
about_item = help_items[4]
help_menu.remove(about_item)
help_menu.remove(help_items[3]) # separator
menubar.hide()
osxapp.set_menu_bar(menubar)
# populate app menu
osxapp.insert_app_menu_item(about_item, 0)
osxapp.insert_app_menu_item(gtk.SeparatorMenuItem(), 1)
osxapp.insert_app_menu_item(pref_item, 2)
if not config["classic_mode"]:
osxapp.insert_app_menu_item(conn_item, 3)
if quit_all_item.get_visible():
osxapp.insert_app_menu_item(gtk.SeparatorMenuItem(), 4)
osxapp.insert_app_menu_item(quit_all_item, 5)
def __init__(self, glade):
GObject.__init__(self)
PropertyObject.__init__(self)
self._code_label = glade.get_widget('code_label')
self._class_label = glade.get_widget('class_label')
self._description_label = glade.get_widget('description_label')
self._additional_textview = glade.get_widget('additional_textview')
self._additional_buffer = gtk.TextBuffer()
self._additional_textview.set_buffer(self._additional_buffer)
def setSeat(self, seat):
glade = self.table.glade
self.seat = seat
self.name = glade.get_widget("name_seat%d" % seat)
self.name.set_label(self.player.name)
self.name.show()
self.money = glade.get_widget("money_seat%d" % seat)
self.money.show()
self.bet = glade.get_widget("bet_seat%d" % seat)
self.bet.hide()
self.cards = map(lambda x: glade.get_widget("card%d_seat%d" % ( x, seat )), xrange(1,8))
def codec_path(codec):
path = get(codec)
if not os.path.isfile(path):
gtk.gdk.threads_enter()
message = _('Codec\n <b>%s</b>\nmissing') %path
show_dialog(message)
glade.get_widget('stop_button').set_sensitive(False)
if len(Conversation.task_list) > 0:
glade.get_widget('start').set_sensitive(True)
gtk.gdk.threads_leave()
else:
return True
def __init__(self, node, parent = None):
NodeDialog.__init__(self,node,parent)
#self.nodeutil = node
# Load and show the graph dialog box
#if parent:
glade = glade = gtk.glade.XML(UI_FILE, "graph_vbox")
#controls = glade.get_widget("details_vbox")
# parent.add(glade.get_widget("graph_vbox"))
#else:
# glade = gtk.glade.XML(UI_FILE, "graph")
self.glade = glade
back_button = glade.get_widget("graph_back_button")
forward_button = glade.get_widget("graph_forward_button")
self.date_label = glade.get_widget("date_label")
self.usage_label = glade.get_widget("usage_label")
self.days_spinner = glade.get_widget("graph_days")
self.btnShowAll = glade.get_widget("btnShowAll")
self.btnThisMonth = glade.get_widget("btnThisMonth")
self.btn30d = glade.get_widget("btn30d")
align = glade.get_widget("alignment1")
vbox = glade.get_widget("graph_vbox")
self.vbox = vbox
self.controls = vbox
self.graph = Graph()
align.add(self.graph)
#request more than 2px height for the chart area:
self.graph.set_size_request(0,200)
# Connect the signals
self.graph.connect("motion-notify-event", self.select)
self.graph.connect("leave-notify-event", self.clear_selection)
back_button.connect("clicked", self.move_back)
forward_button.connect("clicked", self.move_forward)
self.days_spinner.connect("value_changed", self.change_days)
self.btnShowAll.connect("clicked",self.show_all_data)
self.btnThisMonth.connect("clicked",self.show_this_month)
self.btn30d.connect("clicked",self.show_30_days)
#self.graph.show_all()
self.parent.add(vbox)
self.set_title('Chart')
self.parent.show_all()
# The number of days to display
self.days = 30
# Where to start in the usage data
self.start = 0
self.days_spinner.set_value(self.days)
self.fill_data()
def __init__(self, glade):
GObject.__init__(self)
PropertyObject.__init__(self)
self._code_label = glade.get_widget('code_label')
self._class_label = glade.get_widget('class_label')
self._description_label = glade.get_widget('description_label')
self._additional_textview = glade.get_widget('additional_textview')
self._additional_buffer = gtk.TextBuffer()
self._additional_textview.set_buffer(self._additional_buffer)
self._dtc_entry = glade.get_widget('dtc_entry')
def menubar_osx(gtkui, osxapp):
window = gtkui.mainwindow
glade = window.main_glade
menubar = glade.get_widget("menubar")
group = gtk.accel_groups_from_object(window.window)[0]
config = ConfigManager("gtkui.conf")
# NOTE: accel maps doesn't work with glade file format
# because of libglade not setting MenuItem accel groups
# That's why we remove / set accelerators by hand... (dirty)
# Clean solution: migrate glades files to gtkbuilder format
file_menu = glade.get_widget("menu_file").get_submenu()
file_items = file_menu.get_children()
accel_meta(file_items[0], group, 'o')
accel_meta(file_items[1], group, 'n')
quit_all_item = file_items[3]
accel_swap(quit_all_item, group, 'q', gtk.gdk.SHIFT_MASK | gtk.gdk.CONTROL_MASK,
'q', gtk.gdk.SHIFT_MASK | gtk.gdk.META_MASK)
for item in range(2, len(file_items)): # remove quits
file_menu.remove(file_items[item])
menu_widget = glade.get_widget("menu_edit")
edit_menu = menu_widget.get_submenu()
edit_items = edit_menu.get_children()
pref_item = edit_items[0]
accel_swap(pref_item, group, 'p', gtk.gdk.CONTROL_MASK, ',', gtk.gdk.META_MASK)
edit_menu.remove(pref_item)
conn_item = edit_items[1]
accel_meta(conn_item, group, 'm')
edit_menu.remove(conn_item)
menubar.remove(menu_widget)
help_menu = glade.get_widget("menu_help").get_submenu()
help_items = help_menu.get_children()
about_item = help_items[4]
help_menu.remove(about_item)
help_menu.remove(help_items[3]) # separator
menubar.hide()
osxapp.set_menu_bar(menubar)
# populate app menu
osxapp.insert_app_menu_item(about_item, 0)
osxapp.insert_app_menu_item(gtk.SeparatorMenuItem(), 1)
osxapp.insert_app_menu_item(pref_item, 2)
if not config["classic_mode"]:
osxapp.insert_app_menu_item(conn_item, 3)
if quit_all_item.get_visible():
osxapp.insert_app_menu_item(gtk.SeparatorMenuItem(), 4)
osxapp.insert_app_menu_item(quit_all_item, 5)
def clear_root_iter(glade):
treeview = glade.get_widget('job queue')
model = treeview.get_model()
iter_root = model.get_iter_root()
if iter_root is None:
return
gtk.gdk.threads_enter()
model.remove(iter_root)
if len(model) ==0:
glade.get_widget('del_task').set_sensitive(False)
else:
treeview.set_cursor(0)
gtk.gdk.threads_leave()
def endApplication(self,widget):
popen2.Popen4('killall -q cue2tracks')
if len(threading.enumerate()) > 1:
self.stop(None)
clean_tmp(get('tmpdir'))
widget = [
'same_folder', 'codec', 'level', 'bitratebtn', 'qualitybtn', 'VBR']
map(lambda x:set(x,glade.get_widget(x).get_active()), widget)
set('savepath',glade.get_widget('savefolder').get_text())
set('quality',glade.get_widget('quality').get_text())
set('bitrait',glade.get_widget('bitrate').get_value())
write()
gtk.main_quit()
def __init__(self,node,parent = None, tabs_visible = True):
NodeDialog.__init__(self,node,parent)
if not parent:
self.set_title("Internode Usage")
#get controls from glade & add them to the parent...
glade = gtk.glade.XML(UI_FILE, "details_vbox")
controls = glade.get_widget("details_vbox")
notebook = glade.get_widget("notebook")
notebook.set_show_tabs(tabs_visible)
glade.get_widget("btnCopyIP").connect("clicked",self.on_copy_ip_click)
glade.get_widget("version").set_markup("<i>v%0.1f</i>" % VERSION)
glade.get_widget("lnkVersionCheck").set_uri('http://antisol.org/nodeutil/version-check.php?v=%s' % VERSION)
self.glade = glade
self.controls = controls
self.notebook = notebook
self.parent.add(controls)
#load icon:
ic = self.get_widget("icon")
ic.set_from_pixbuf(NodeIcons.logo)
#add a chart to the notebook...
graph_window = NodeDialog_Chart(self.nodeutil,self.notebook)
self.graph = graph_window
self.graph_populated = False
def __init__(self, glade):
self.gconf = gconf.client_get_default()
self.gconf.add_dir(self.root, gconf.CLIENT_PRELOAD_ONELEVEL)
self.dialog = glade.get_widget("prefsdialog")
self.into_selected_folder = glade.get_widget("into_selected_folder")
self.target_folder_chooser = glade.get_widget("target_folder_chooser")
self.example = glade.get_widget("example_filename")
self.set_widget_initial_values(glade)
self.sensitive_widgets = {}
for name in self.sensitive_names:
self.sensitive_widgets[name] = glade.get_widget(name)
assert self.sensitive_widgets[name] != None
self.set_sensitive()
def __init__(self):
component.Component.__init__(self, "SideBar")
self.window = component.get("MainWindow")
glade = self.window.main_glade
self.notebook = glade.get_widget("sidebar_notebook")
self.hpaned = glade.get_widget("hpaned")
self.config = ConfigManager("gtkui.conf")
#self.hpaned_position = self.hpaned.get_position()
# Tabs holds references to the Tab widgets by their name
self.tabs = {}
# Hide if necessary
self.visible(self.config["show_sidebar"])
def __init__(self, glade):
self.widget = glade.get_widget("window")
self.filelist = FileList(self, glade)
self.filelist_selection = self.filelist.widget.get_selection()
self.filelist_selection.connect("changed", self.selection_changed)
self.existsdialog = glade.get_widget("existsdialog")
self.existsdialog.message = glade.get_widget("exists_message")
self.existslabel = glade.get_widget("existslabel")
self.progressbar = glade.get_widget("progressbar")
self.status = glade.get_widget("statustext")
self.about = glade.get_widget("about")
self.prefs = PreferencesDialog(glade)
self.addchooser = gtk.FileChooserDialog(_("Add files..."),
self.widget,
gtk.FILE_CHOOSER_ACTION_OPEN,
(gtk.STOCK_CANCEL,
gtk.RESPONSE_CANCEL,
gtk.STOCK_OPEN,
gtk.RESPONSE_OK))
self.addchooser.set_select_multiple(True)
self.connect(glade, [self.prefs])
self.about.set_property("name", NAME)
self.about.set_property("version", VERSION)
self.converter = ConverterQueue(self)
self.sensitive_widgets = {}
for name in self.sensitive_names:
self.sensitive_widgets[name] = glade.get_widget(name)
self.set_sensitive()
def __init__(self):
component.Component.__init__(self, "SideBar")
self.window = component.get("MainWindow")
glade = self.window.main_glade
self.notebook = glade.get_widget("sidebar_notebook")
self.hpaned = glade.get_widget("hpaned")
self.config = ConfigManager("gtkui.conf")
#self.hpaned_position = self.hpaned.get_position()
# Tabs holds references to the Tab widgets by their name
self.tabs = {}
# Hide if necessary
self.visible(self.config["show_sidebar"])
def __init__(self, glade, doc=None):
self.widget = glade.get_widget('window')
self.about = glade.get_widget('about')
self.about.set_property('name', NAME)
self.about.set_property('version', VERSION)
self.libraryList = LibraryList(glade)
if doc:
try:
self.libraryList.loadFromFile(doc)
except InvalidLibraryException, e:
print "Invalid library: %s" % e.filename
def run(self):
while Conversation.task_list:
task = Conversation.task_list.pop(0)
if len(Conversation.task_list) == 1:
self.job_up.set_sensitive(False)
self.job_down.set_sensitive(False)
start(Conversation.task_parametrs[task])
if Conversation.value == (_('Interrupted')):
print Conversation.value
break
Conversation.task_number = 0
gtk.gdk.threads_enter()
glade.get_widget('progressbar2').set_text (' ')
glade.get_widget('stop_button').set_sensitive(False)
gtk.gdk.threads_leave()
def __init__(self):
Tab.__init__(self)
# Get the labels we need to update.
# widgetname, modifier function, status keys
glade = component.get("MainWindow").main_glade
self._name = "Details"
self._child_widget = glade.get_widget("details_tab")
self._tab_label = glade.get_widget("details_tab_label")
self.label_widgets = [
(glade.get_widget("summary_name"), None, ("name", )),
(glade.get_widget("summary_total_size"), fsize, ("total_size", )),
(glade.get_widget("summary_num_files"), str, ("num_files", )),
(glade.get_widget("summary_tracker"), None, ("tracker", )),
(glade.get_widget("summary_torrent_path"), None, ("save_path", )),
(glade.get_widget("summary_message"), str, ("message", )),
(glade.get_widget("summary_hash"), str, ("hash", )),
(glade.get_widget("summary_comments"), str, ("comment", ))
]
def __init_filechooser_dialogs(self, glade):
self.__open_file_dialog = glade.get_widget("openFileDialog")
self.__save_as_dialog = glade.get_widget("saveAsDialog")
self.__export_midi_dialog = glade.get_widget("exportMidiDialog")
# set file filters for Open and Save as dialogs
filter1 = gtk.FileFilter()
filter1.set_name("MMA files")
filter1.add_pattern("*.mma")
filter2 = gtk.FileFilter()
filter2.set_name("All files")
filter2.add_pattern("*")
filter3 = gtk.FileFilter()
filter3.set_name("MIDI files")
filter3.add_pattern("*.mid")
self.__open_file_dialog.add_filter(filter1)
self.__open_file_dialog.add_filter(filter2)
self.__save_as_dialog.add_filter(filter1)
self.__save_as_dialog.add_filter(filter2)
self.__export_midi_dialog.add_filter(filter2)
self.__export_midi_dialog.add_filter(filter3)
def __init__(self):
glade = gtk.glade.XML("png-browser.glade")
glade.signal_autoconnect(self)
self.window = glade.get_widget("window")
self.pane = glade.get_widget("pane")
self.statusbar = glade.get_widget("statusbar")
self.status_context_chunk = self.statusbar.get_context_id("Chunk Details")
self.chunkview = glade.get_widget("chunkview")
self.chunkview.append_column(gtk.TreeViewColumn("Chunk", gtk.CellRendererText(), text=0))
self.store = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_PYOBJECT)
self.chunkview.set_model(self.store)
self.chunkview.get_selection().connect('changed', self.chunkview_selection_cb)
self.current_iter = None
self.current_view = None
png = Png.open(file(sys.argv[1], "rb"))
for c in png.chunks:
i = self.store.append()
self.store.set(i, 0, c.type, 1, c)
self.show_chunk_page(None)
self.window.show_all()
def settings_ok(self, widget, chk_autorun, spn_core, ent_swan, ent_fvcom):
global autorun, cores_use
autorun = chk_autorun.get_active()
cores_use = spn_core.get_value_as_int()
if cores < cores_use:
glade = gtk.glade.XML('wsf.glade')
warning = glade.get_widget('dia_msg_core')
warning.set_markup('Your system has only ' + str(cores) +
' cores,\n'
'which is less than demanded.\nSet to default!')
warning.run()
warning.destroy()
cores_use = cores
def setStatus(percent=None, info=None):
gtk.threads_enter()
if percent is not None:
glade.get_widget("progress").set_fraction(percent)
glade.get_widget("progress").set_text("%.2f%%" % (percent * 100))
if info is not None:
glade.get_widget("information").set_text(info)
gtk.threads_leave()
def facebook_authorize(self, account):
from gwibber.microblog.support import facelib
glade = gtk.glade.XML(resources.get_ui_asset("preferences.glade"))
dialog = glade.get_widget("facebook_config")
dialog.show_all()
def on_validate_click(w):
fb = facelib.Facebook(
microblog.facebook.APP_KEY, microblog.facebook.SECRET_KEY,
glade.get_widget("entry_auth_token").get_text().strip())
data = fb.auth.getSession()
if data and "session_key" in data:
account["secret_key"] = str(data["secret"])
account["session_key"] = str(data["session_key"])
m = gtk.MessageDialog(None, 0, gtk.MESSAGE_INFO,
gtk.BUTTONS_OK,
_("Keys obtained successfully."))
else:
m = gtk.MessageDialog(None, 0,
gtk.MESSAGE_ERROR, gtk.BUTTONS_OK,
_("Failed to obtain key."))
m.run()
m.destroy()
glade.get_widget("button_request").connect(
"clicked", lambda *a: gintegration.
load_url("http://www.facebook.com/code_gen.php?v=1.0&api_key=%s" %
microblog.facebook.APP_KEY))
glade.get_widget("button_authorize").connect(
"clicked", lambda *a: gintegration.load_url(
"http://www.facebook.com/authorize.php?api_key=%s&v=1.0&ext_perm=status_update"
% microblog.facebook.APP_KEY))
glade.get_widget("button_apply_auth").connect("clicked",
on_validate_click)
glade.get_widget("button_close_facebook_auth").connect(
"clicked", lambda w: dialog.destroy())
def on_preferences(self, mi):
glade = gtk.glade.XML(resources.get_ui_asset("preferences.glade"))
dialog = glade.get_widget("pref_dialog")
dialog.show_all()
for widget in [
"show_notifications", "refresh_interval", "minimize_to_tray",
"hide_taskbar_entry", "shorten_urls", "reply_append_colon"
]:
self.preferences.bind(glade.get_widget("pref_%s" % widget), widget)
self.preferences.bind(glade.get_widget("show_tray_icon"),
"show_tray_icon")
theme_selector = gtk.combo_box_new_text()
for theme_name in sorted(resources.get_themes()):
theme_selector.append_text(theme_name)
glade.get_widget("containerThemeSelector").pack_start(
theme_selector, True, True)
# reset theme to default if no longer available
if self.preferences['theme'] not in resources.get_themes():
config.GCONF.set_string(
"%s/%s" % (config.GCONF_PREFERENCES_DIR, "theme"),
config.gconf.VALUE_STRING, 'default')
self.preferences.bind(theme_selector, "theme")
theme_selector.show_all()
# add combo box with url shorter services
urlshorter_selector = gtk.combo_box_new_text()
for us in sorted(urlshorter.PROTOCOLS.keys()):
urlshorter_name = urlshorter.PROTOCOLS[us].PROTOCOL_INFO["name"]
urlshorter_selector.append_text(urlshorter_name)
glade.get_widget("containerURLShorterSelector").pack_start(
urlshorter_selector, True, True)
self.preferences.bind(urlshorter_selector, "urlshorter")
urlshorter_selector.show_all()
glade.get_widget("button_close").connect("clicked",
lambda *a: dialog.destroy())
def __init_recent_menu(self, glade):
# code here comes from http://lescannoniers.blogspot.com/2008/11/pygtk-recent-file-chooser.html
# add a recent files menu item
manager = gtk.recent_manager_get_default()
# define a RecentChooserMenu object
recent_menu_chooser = gtk.RecentChooserMenu(manager)
# define a file filter, otherwise all file types will show up
file_filter = gtk.RecentFilter()
file_filter.add_pattern("*.mma")
# add the file_filter to the RecentChooserMenu object
recent_menu_chooser.add_filter(file_filter)
recent_menu_chooser.set_sort_type(gtk.RECENT_SORT_MRU)
recent_menu_chooser.set_limit(10)
recent_menu_chooser.set_show_tips(True)
recent_menu_chooser.set_show_numbers(True)
recent_menu_chooser.set_local_only(True)
# add a signal to open the selected file
recent_menu_chooser.connect("item-activated", self.open_recent_file)
# attach the RecentChooserMenu to the main menu item
menuitem6 = glade.get_widget("menuitem6")
menuitem6.set_submenu(recent_menu_chooser)
# attach the RecentChooserMenu to the Open tool button
toolbutton8 = glade.get_widget("toolbutton8")
toolbutton8.set_menu(recent_menu_chooser)
def on_but_settings_clicked(self, widget):
glade = gtk.glade.XML('wsf.glade')
about = glade.get_widget('dia_settings')
chk_autorun = glade.get_widget('chk_autorun')
spn_core = glade.get_widget('spn_core')
ent_wrf = glade.get_widget('ent_wrf')
ent_swan = glade.get_widget('ent_swan')
ent_fvcom = glade.get_widget('ent_fvcom')
cancel = glade.get_widget('but_set_cancel')
ok = glade.get_widget('but_set_ok')
chk_autorun.set_active(autorun)
spn_core.set_value(cores)
ent_wrf.set_text(cmd[WRF][BASE_DIR])
ent_fvcom.set_text(cmd[FVCOM][BASE_DIR])
ent_swan.set_text(cmd[SWAN][BASE_DIR])
ent_fvcom.set_text(cmd[FVCOM][BASE_DIR])
ok.connect('clicked', self.settings_ok, chk_autorun, spn_core,
ent_swan, ent_fvcom)
about.run()
about.destroy()
def on_full_b_clicked(self,data):
if not self.isfull:
glade = gtk.glade.XML(gladefile,"video_window")
self.vidwindow = glade.get_widget("video_window")
self.vidwindow.show()
self.remoteframe.reparent(self.vidwindow)
self.vidwindow.fullscreen()
self.isfull=True
self.mainui.floatwindow.show()
self.mainui.floatwindow.present()
self.mainui.glade_float.signal_connect("on_full_b_clicked",self.on_full_b_clicked)
else:
hbox3 = self.mainui.glade.get_widget("hbox3")
self.remoteframe.reparent(hbox3)
self.vidwindow.unfullscreen()
self.vidwindow.destroy()
del self.vidwindow
self.mainui.floatwindow.hide()
self.isfull=False
def on_validate_click(w):
fb = facelib.Facebook(
microblog.facebook.APP_KEY, microblog.facebook.SECRET_KEY,
glade.get_widget("entry_auth_token").get_text().strip())
data = fb.auth.getSession()
if data and "session_key" in data:
account["secret_key"] = str(data["secret"])
account["session_key"] = str(data["session_key"])
m = gtk.MessageDialog(None, 0, gtk.MESSAGE_INFO,
gtk.BUTTONS_OK,
_("Keys obtained successfully."))
else:
m = gtk.MessageDialog(None, 0,
gtk.MESSAGE_ERROR, gtk.BUTTONS_OK,
_("Failed to obtain key."))
m.run()
m.destroy()
def __init__(self, glade):
self.widget = glade.get_widget("treeview")
args = [gobject.TYPE_STRING] * len(self.column_names)
args.append(gobject.TYPE_OBJECT)
args.append(gobject.TYPE_PYOBJECT)
self.model = apply(gtk.ListStore, args)
self.sortModel = gtk.TreeModelSort(self.model)
self.sortModel.set_sort_column_id(0, gtk.SORT_ASCENDING)
self.widget.set_model(self.sortModel)
renderer = gtk.CellRendererText()
for name in self.column_names:
column = gtk.TreeViewColumn(name,
renderer,
text=self.column_names.index(name))
column.set_sort_column_id(self.column_names.index(name))
column.set_resizable(True)
column.set_sizing(gtk.TREE_VIEW_COLUMN_GROW_ONLY)
self.widget.append_column(column)
self.add_popup()
def __init__(self):
Tab.__init__(self)
glade = component.get("MainWindow").get_glade()
self._name = "Files"
self._child_widget = glade.get_widget("files_tab")
self._tab_label = glade.get_widget("files_tab_label")
self.listview = glade.get_widget("files_listview")
# filename, size, progress string, progress value, priority, file index, icon id
self.treestore = gtk.TreeStore(str, gobject.TYPE_UINT64, str, float,
int, int, str)
# We need to store the row that's being edited to prevent updating it until
# it's been done editing
self._editing_index = None
# Filename column
self.filename_column_name = _("Filename")
column = gtk.TreeViewColumn(self.filename_column_name)
render = gtk.CellRendererPixbuf()
column.pack_start(render, False)
column.add_attribute(render, "stock-id", 6)
render = gtk.CellRendererText()
render.set_property("editable", True)
render.connect("edited", self._on_filename_edited)
render.connect("editing-started", self._on_filename_editing_start)
render.connect("editing-canceled", self._on_filename_editing_canceled)
column.pack_start(render, True)
column.add_attribute(render, "text", 0)
column.set_sort_column_id(0)
column.set_clickable(True)
column.set_resizable(True)
column.set_expand(False)
column.set_min_width(200)
column.set_reorderable(True)
self.listview.append_column(column)
# Size column
column = gtk.TreeViewColumn(_("Size"))
render = gtk.CellRendererText()
column.pack_start(render, False)
column.set_cell_data_func(render,
deluge.ui.gtkui.listview.cell_data_size, 1)
column.set_sort_column_id(1)
column.set_clickable(True)
column.set_resizable(True)
column.set_expand(False)
column.set_min_width(50)
column.set_reorderable(True)
self.listview.append_column(column)
# Progress column
column = gtk.TreeViewColumn(_("Progress"))
render = gtk.CellRendererProgress()
column.pack_start(render)
column.set_cell_data_func(render, cell_progress, (2, 3))
column.set_sort_column_id(3)
column.set_clickable(True)
column.set_resizable(True)
column.set_expand(False)
column.set_min_width(100)
column.set_reorderable(True)
self.listview.append_column(column)
# Priority column
column = gtk.TreeViewColumn(_("Priority"))
render = gtk.CellRendererPixbuf()
column.pack_start(render, False)
column.set_cell_data_func(render, cell_priority_icon, 4)
render = gtk.CellRendererText()
column.pack_start(render, False)
column.set_cell_data_func(render, cell_priority, 4)
column.set_sort_column_id(4)
column.set_clickable(True)
column.set_resizable(True)
column.set_expand(False)
column.set_min_width(100)
# Bugfix: Last column needs max_width set to stop scrollbar appearing
column.set_max_width(200)
column.set_reorderable(True)
self.listview.append_column(column)
self.listview.set_model(self.treestore)
self.listview.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
self.file_menu = glade.get_widget("menu_file_tab")
self.file_menu_priority_items = [
glade.get_widget("menuitem_donotdownload"),
glade.get_widget("menuitem_normal"),
glade.get_widget("menuitem_high"),
glade.get_widget("menuitem_highest"),
glade.get_widget("menuitem_priority_sep")
]
self.localhost_widgets = [
glade.get_widget("menuitem_open_file"),
glade.get_widget("menuitem3")
]
self.listview.connect("row-activated", self._on_row_activated)
self.listview.connect("key-press-event", self._on_key_press_event)
self.listview.connect("button-press-event",
self._on_button_press_event)
self.listview.enable_model_drag_source(
gtk.gdk.BUTTON1_MASK, [('text/plain', 0, 0)],
gtk.gdk.ACTION_DEFAULT | gtk.gdk.ACTION_MOVE)
self.listview.enable_model_drag_dest([('text/plain', 0, 0)],
gtk.gdk.ACTION_DEFAULT)
self.listview.connect("drag_data_get", self._on_drag_data_get_data)
self.listview.connect("drag_data_received",
self._on_drag_data_received_data)
glade.signal_autoconnect({
"on_menuitem_open_file_activate":
self._on_menuitem_open_file_activate,
"on_menuitem_donotdownload_activate":
self._on_menuitem_donotdownload_activate,
"on_menuitem_normal_activate":
self._on_menuitem_normal_activate,
"on_menuitem_high_activate":
self._on_menuitem_high_activate,
"on_menuitem_highest_activate":
self._on_menuitem_highest_activate,
"on_menuitem_expand_all_activate":
self._on_menuitem_expand_all_activate
})
# Connect to various events from the daemon
client.register_event_handler("TorrentFileRenamedEvent",
self._on_torrentfilerenamed_event)
client.register_event_handler("TorrentFolderRenamedEvent",
self._on_torrentfolderrenamed_event)
client.register_event_handler("TorrentRemovedEvent",
self._on_torrentremoved_event)
# Attempt to load state
self.load_state()
# torrent_id: (filepath, size)
self.files_list = {}
self.torrent_id = None
def __init__(self):
Tab.__init__(self)
# Get the labels we need to update.
# widgetname, modifier function, status keys
glade = component.get("MainWindow").main_glade
self._name = "Status"
self._child_widget = glade.get_widget("status_tab")
self._tab_label = glade.get_widget("status_tab_label")
self.label_widgets = [
(glade.get_widget("summary_pieces"), fpeer_size_second,
("num_pieces", "piece_length")),
(glade.get_widget("summary_availability"), fratio,
("distributed_copies", )),
(glade.get_widget("summary_total_downloaded"), fpeer_sized,
("all_time_download", "total_payload_download")),
(glade.get_widget("summary_total_uploaded"), fpeer_sized,
("total_uploaded", "total_payload_upload")),
(glade.get_widget("summary_download_speed"), fspeed,
("download_payload_rate", "max_download_speed")),
(glade.get_widget("summary_upload_speed"), fspeed,
("upload_payload_rate", "max_upload_speed")),
(glade.get_widget("summary_seeders"), deluge.common.fpeer,
("num_seeds", "total_seeds")),
(glade.get_widget("summary_peers"), deluge.common.fpeer,
("num_peers", "total_peers")),
(glade.get_widget("summary_eta"), deluge.common.ftime, ("eta", )),
(glade.get_widget("summary_share_ratio"), fratio, ("ratio", )),
(glade.get_widget("summary_tracker_status"), ftranslate,
("tracker_status", )),
(glade.get_widget("summary_next_announce"), deluge.common.ftime,
("next_announce", )),
(glade.get_widget("summary_active_time"), deluge.common.ftime,
("active_time", )),
(glade.get_widget("summary_seed_time"), deluge.common.ftime,
("seeding_time", )),
(glade.get_widget("summary_seed_rank"), str, ("seed_rank", )),
(glade.get_widget("summary_auto_managed"), str,
("is_auto_managed", )),
(glade.get_widget("progressbar"), fpcnt, ("progress", )),
(glade.get_widget("summary_date_added"), deluge.common.fdate,
("time_added", ))
]
if self.widgets.has_key(name):
return self.widgets[name]
return self.glade.get_widget(name)
def relative_file(self, file):
return self.glade.relative_file(file)
def signal_autoconnect(self, instance):
for name, widget in self.widgets.iteritems():
method = getattr(instance, "on_%s_clicked" % name, None)
if method: widget.connect("clicked", method)
if __name__ == '__main__':
glade = GameWindowGlade(gtk.glade.XML('data/interface/table/mockup.glade'))
event_box = glade.get_widget('game_window')
window = gtk.Window()
window.add(event_box)
gtk.rc_parse('data/interface/table/gtkrc')
for seat_index in xrange(0, 10):
for card_index in xrange(1, 8):
glade.get_widget("card%d_seat%d" %
(card_index, seat_index)).set_from_file(
'data/interface/table/card_back.png')
window.show_all()
gtk.main()
# Interpreted by emacs
# Local Variables:
# compile-command: "/usr/bin/python gamewindow.py"
# End:
