def __init__(self):
component.Component.__init__(self,
'QueuedTorrents',
depend=['StatusBar', 'AddTorrentDialog'])
self.queue = []
self.status_item = None
self.config = ConfigManager('gtkui.conf')
self.builder = Builder()
self.builder.add_from_file(
deluge.common.resource_filename(
'deluge.ui.gtkui', os.path.join('glade', 'queuedtorrents.ui')))
self.builder.get_object('chk_autoadd').set_active(
self.config['autoadd_queued'])
self.dialog = self.builder.get_object('queued_torrents_dialog')
self.dialog.set_icon(get_logo(32))
self.builder.connect_signals(self)
self.treeview = self.builder.get_object('treeview')
self.treeview.append_column(
TreeViewColumn(_('Torrent'), CellRendererText(), text=0))
self.liststore = ListStore(str, str)
self.treeview.set_model(self.liststore)
self.treeview.set_tooltip_column(1)
def __init__(self, bus):
VBox.__init__(self)
self.bus = bus
logger.debug('Running...')
self.label = Label('Looking for Presence Service...')
self.errors = ListStore(str)
errors_tree = TreeView(model=self.errors)
errors_tree.insert_column_with_attributes(0,
'Log',
CellRendererText(),
text=0)
scroller = ScrolledWindow()
scroller.add(errors_tree)
self.paned = VPaned()
self.paned.pack1(scroller)
self.pack_start(self.label, False, False)
self.pack_end(self.paned)
bus.watch_name_owner(PS_NAME, self.on_name_owner_change)
self.ps_watcher = Label('-')
self.paned.pack2(self.ps_watcher)
self.show_all()
def create_prop_store(self, extra_props=[]):
assert (self.component is not None)
from gtk import ListStore
store = ListStore(object, str, object)
# use private properties so we connect to the actual object stores and not the inherited ones
for atom in self.component._layer_atoms:
store.append([atom, "pn", lambda o: o.name])
for atom in self.component._interlayer_atoms:
store.append([atom, "pn", lambda o: o.name])
for prop in extra_props:
store.append(prop)
return store
def __init__(self, model, view):
"""Constructor
"""
# ListStore for: id, from-state, from-key, to-state, to-key, is_external,
# name-color, to-state-color, data-flow-object, state-object, is_editable, data-flow-model
list_store = ListStore(int, str, str, str, str, bool, str, str,
gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT, bool, gobject.TYPE_PYOBJECT)
self.view_dict = {'data_flows_internal': True, 'data_flows_external': True}
self.tree_dict_combos = {'internal': {},
'external': {}}
self.data_flow_dict = {'internal': {},
'external': {}}
self.debug_log = False
super(StateDataFlowsListController, self).__init__(model, view, view.get_top_widget(), list_store, logger)
def __init__(self, dir=None):
HBox.__init__(self, False, 2)
buttonImage = Image()
buttonImage.set_from_stock(STOCK_REFRESH, ICON_SIZE_MENU)
self.combo = ComboBox()
self.refreshButton = Button()
self.refreshButton.set_image(buttonImage)
self.refreshButton.connect('clicked', self.refreshButton_clicked, None)
self.model = ListStore(str)
self.combo.set_model(self.model)
self.dir = dir
self.pack_start(self.combo, False, False, 0)
self.pack_start(self.refreshButton, False, False, 0)
if self.dir != None and exists(self.dir):
self.refresh()
def __init__(self):
Window.__init__(self)
self.model = ListStore(str, str)
self.aboutWindow = None
self.helper = Helper(None)
self.set_title('Gnome Custom Shortcuts')
self.set_icon_from_file(join(data_path, 'icon.svg'))
self.set_border_width(5)
self.set_size_request(400, 400)
list = TreeView()
list.append_column(TreeViewColumn(''))
list.append_column(TreeViewColumn('Command'))
list.append_column(TreeViewColumn('Shortcut'))
closeButton = Button(None, STOCK_CLOSE)
aboutButton = Button(None, STOCK_ABOUT)
buttonsBox = HButtonBox()
buttonsBox.pack_start(aboutButton, False, False, 0)
buttonsBox.pack_start(Label(''), True, True, 0)
buttonsBox.pack_start(closeButton, False, False, 0)
box = VBox(False, 5)
box.pack_start(list, True, True, 0)
box.pack_start(buttonsBox, False, False, 0)
self.connect('destroy', main_quit, None)
closeButton.connect('clicked', main_quit, None)
aboutButton.connect('clicked', self.show_about, None)
self.add(box)
self.show_all()
def __init__(self, objectives, new):
Expander.__init__(self)
self.connect("enter-notify-event", self.onEnterNotifyEvent)
self.connect("leave-notify-event", self.onLeaveNotifyEvent)
vBox = VBox()
self.add(vBox)
# Data model
self.model = ListStore(str, float)
# Title bar
hBox = HBox()
self.set_property("label-widget", hBox)
self.title = Label()
hBox.pack_start(self.title)
# Alternatives
treeView = TreeView(self.model)
# treeView.set_headers_visible(False)
vBox.pack_start(treeView)
listStore_objectives = ListStore(str)
for name in objectives:
listStore_objectives.append((name, ))
def combo_changed(_, path, text, model):
model[path][0] = text
cellRenderer = CellRendererCombo()
cellRenderer.connect("edited", combo_changed, self.model)
cellRenderer.set_property("text-column", 0)
cellRenderer.set_property("editable", True)
cellRenderer.set_property("has-entry", True)
cellRenderer.set_property("model", listStore_objectives)
treeViewColumn = TreeViewColumn("Alternative", cellRenderer, text=0)
# treeViewColumn = TreeViewColumn(None,cellRenderer,text=0)
treeView.append_column(treeViewColumn)
def spin_changed(_, path, value, model):
model[path][1] = float(value.replace(",", "."))
cellRenderer = CellRendererSpin()
cellRenderer.connect("edited", spin_changed, self.model)
cellRenderer.set_property("adjustment",
Adjustment(1, 0, 100, 1, 10, 0))
cellRenderer.set_property("editable", True)
cellRenderer.set_property("digits", 2)
treeViewColumn = TreeViewColumn(None, cellRenderer, text=1)
treeView.append_column(treeViewColumn)
# Add/remove alternative button box
# hButtonBox = HButtonBox()
# vBox.pack_start(hButtonBox, False)
# Add alternative
button = Button("gtk-add")
button.connect("clicked", self.on_btnAdd_Alternative_clicked)
button.set_use_stock(True)
# hButtonBox.pack_start(button)
vBox.pack_start(button, False)
# # Remove alternative
# button = Button("gtk-remove")
# button.connect("clicked",self.on_btnDel_Alternative_clicked)
# button.set_use_stock(True)
# hButtonBox.pack_start(button)
# Expand the requeriment and add an alternative if it's new
if new:
self.set_expanded(True)
self.model.append((None, 1.0))
# Show requeriment
self.show_all()
# Delete requeriment button (default is hidden)
self.imgRemove = Image()
self.imgRemove.connect("button-press-event", self.onDelRequeriment)
self.imgRemove.set_from_stock("gtk-cancel", ICON_SIZE_MENU)
hBox.pack_start(self.imgRemove)
def __init__(self, ip=None):
self.ip = ip
self.gtk_list_store = ListStore(str, str)
def __init__(self, bus, unique_name, log):
VBox.__init__(self)
self.bus = bus
self.unique_name = unique_name
self.proxy = bus.get_object(unique_name, PS_PATH)
self.iface = dbus.Interface(self.proxy, PS_IFACE)
self.log = log
self.activities = None
self.iface.connect_to_signal('ActivityAppeared',
self._on_activity_appeared)
self.iface.connect_to_signal('ActivityDisappeared',
self._on_activity_disappeared)
self.iface.GetActivities(reply_handler=self._on_get_activities_success,
error_handler=self._on_get_activities_failure)
self.buddies = None
self.iface.connect_to_signal('BuddyAppeared', self._on_buddy_appeared)
self.iface.connect_to_signal('BuddyDisappeared',
self._on_buddy_disappeared)
self.iface.GetBuddies(reply_handler=self._on_get_buddies_success,
error_handler=self._on_get_buddies_failure)
# keep this in sync with the ACT_COL_ constants
self.activities_list_store = ListStore(
str, # object path
int, # weight (bold if new)
bool, # strikethrough (dead)
str, # ID
str, # color
str, # type
str, # name
str, # conn
str, # channels
str, # buddies
)
self.pack_start(Label('Activities:'), False, False)
self.activities_list = TreeView(self.activities_list_store)
c = self.activities_list.insert_column_with_attributes(
0,
'Object path',
CellRendererText(),
text=ACT_COL_PATH,
weight=ACT_COL_WEIGHT,
strikethrough=ACT_COL_STRIKE)
c.set_resizable(True)
c.set_sort_column_id(ACT_COL_PATH)
c = self.activities_list.insert_column_with_attributes(
1,
'ID',
CellRendererText(),
text=ACT_COL_ID,
weight=ACT_COL_WEIGHT,
strikethrough=ACT_COL_STRIKE)
c.set_resizable(True)
c.set_sort_column_id(ACT_COL_ID)
c = self.activities_list.insert_column_with_attributes(
2,
'Color',
CellRendererText(),
text=ACT_COL_COLOR,
weight=ACT_COL_WEIGHT,
strikethrough=ACT_COL_STRIKE)
c.set_resizable(True)
c.set_sort_column_id(ACT_COL_COLOR)
c = self.activities_list.insert_column_with_attributes(
3,
'Type',
CellRendererText(),
text=ACT_COL_TYPE,
weight=ACT_COL_WEIGHT,
strikethrough=ACT_COL_STRIKE)
c.set_resizable(True)
c.set_sort_column_id(ACT_COL_TYPE)
c = self.activities_list.insert_column_with_attributes(
4,
'Name',
CellRendererText(),
text=ACT_COL_NAME,
weight=ACT_COL_WEIGHT,
strikethrough=ACT_COL_STRIKE)
c.set_resizable(True)
c.set_sort_column_id(ACT_COL_NAME)
c = self.activities_list.insert_column_with_attributes(
5,
'Connection',
CellRendererText(),
text=ACT_COL_CONN,
weight=ACT_COL_WEIGHT,
strikethrough=ACT_COL_STRIKE)
c.set_resizable(True)
c.set_sort_column_id(ACT_COL_CONN)
c = self.activities_list.insert_column_with_attributes(
6,
'Channels',
CellRendererText(),
text=ACT_COL_CHANNELS,
weight=ACT_COL_WEIGHT,
strikethrough=ACT_COL_STRIKE)
c.set_resizable(True)
c = self.activities_list.insert_column_with_attributes(
7,
'Buddies',
CellRendererText(),
text=ACT_COL_BUDDIES,
weight=ACT_COL_WEIGHT,
strikethrough=ACT_COL_STRIKE)
c.set_resizable(True)
scroller = ScrolledWindow()
scroller.add(self.activities_list)
self.pack_start(scroller)
# keep this in sync with the BUDDY_COL_ constants
self.buddies_list_store = ListStore(str, int, bool, str, bool, str,
str, str, str, str, str)
self.pack_start(Label('Buddies:'), False, False)
self.buddies_list = TreeView(self.buddies_list_store)
c = self.buddies_list.insert_column_with_attributes(
0,
'Object path',
CellRendererText(),
text=BUDDY_COL_PATH,
weight=BUDDY_COL_WEIGHT,
strikethrough=BUDDY_COL_STRIKE)
c.set_resizable(True)
c.set_sort_column_id(BUDDY_COL_PATH)
c = self.buddies_list.insert_column_with_attributes(
1,
'Pubkey',
CellRendererText(),
text=BUDDY_COL_KEY_ID,
weight=BUDDY_COL_WEIGHT,
strikethrough=BUDDY_COL_STRIKE)
c.set_resizable(True)
c.set_sort_column_id(BUDDY_COL_KEY_ID)
c = self.buddies_list.insert_column_with_attributes(
2,
'Nick',
CellRendererText(),
text=BUDDY_COL_NICK,
weight=BUDDY_COL_WEIGHT,
strikethrough=BUDDY_COL_STRIKE)
c.set_resizable(True)
c.set_sort_column_id(BUDDY_COL_NICK)
c = self.buddies_list.insert_column_with_attributes(
3, 'Owner', CellRendererToggle(), active=BUDDY_COL_OWNER)
c = self.buddies_list.insert_column_with_attributes(
4,
'Color',
CellRendererText(),
text=BUDDY_COL_COLOR,
weight=BUDDY_COL_WEIGHT,
strikethrough=BUDDY_COL_STRIKE)
c.set_resizable(True)
c.set_sort_column_id(BUDDY_COL_OWNER)
c = self.buddies_list.insert_column_with_attributes(
5,
'IPv4',
CellRendererText(),
text=BUDDY_COL_IP4,
weight=BUDDY_COL_WEIGHT,
strikethrough=BUDDY_COL_STRIKE)
c.set_resizable(True)
c.set_sort_column_id(BUDDY_COL_IP4)
c = self.buddies_list.insert_column_with_attributes(
6,
'CurAct',
CellRendererText(),
text=BUDDY_COL_CUR_ACT,
weight=BUDDY_COL_WEIGHT,
strikethrough=BUDDY_COL_STRIKE)
c.set_resizable(True)
c.set_sort_column_id(BUDDY_COL_CUR_ACT)
c = self.buddies_list.insert_column_with_attributes(
7,
'Activities',
CellRendererText(),
text=BUDDY_COL_ACTIVITIES,
weight=BUDDY_COL_WEIGHT,
strikethrough=BUDDY_COL_STRIKE)
c.set_resizable(True)
c.set_sort_column_id(BUDDY_COL_ACTIVITIES)
c = self.buddies_list.insert_column_with_attributes(
8,
'Handles',
CellRendererText(),
text=BUDDY_COL_HANDLES,
weight=BUDDY_COL_WEIGHT,
strikethrough=BUDDY_COL_STRIKE)
c.set_resizable(True)
c.set_sort_column_id(BUDDY_COL_HANDLES)
scroller = ScrolledWindow()
scroller.add(self.buddies_list)
self.pack_start(scroller)
self.iface.connect_to_signal('ActivityInvitation',
self._on_activity_invitation)
self.iface.connect_to_signal('PrivateInvitation',
self._on_private_invitation)
def __create_model(self): from gtk import ListStore from gobject import TYPE_OBJECT model = ListStore(str, TYPE_OBJECT, bool) return model
def __create_model(self): from gtk import ListStore from gobject import TYPE_BOOLEAN model = ListStore(TYPE_BOOLEAN, str, str) return model
def update_data_flows(model, data_flow_dict, tree_dict_combos):
""" Updates data flow dictionary and combo dictionary of the widget according handed model.
:param model: model for which the data_flow_dict and tree_dict_combos should be updated
:param data_flow_dict: dictionary that holds all internal and external data-flows and those respective row labels
:param tree_dict_combos: dictionary that holds all internal and external data-flow-adaptation-combos
:return:
"""
data_flow_dict['internal'] = {}
data_flow_dict['external'] = {}
tree_dict_combos['internal'] = {}
tree_dict_combos['external'] = {}
# free input ports and scopes are real to_keys and real states
[free_to_port_internal, from_ports_internal] = find_free_keys(model)
[free_to_port_external, from_ports_external] = find_free_keys(model.parent)
def take_from_dict(from_dict, key):
if key in from_dict:
return from_dict[key]
else:
logger.warning("Key '%s' is not in %s" % (key, from_dict))
pass
# from_state, to_key, to_state, to_key, external
if isinstance(model, ContainerStateModel):
for data_flow in model.state.data_flows.values(): # model.data_flow_list_store:
# TREE STORE LABEL
# check if from Self_state
if data_flow.from_state == model.state.state_id:
from_state = model.state
from_state_label = 'self.' + model.state.name + '.' + data_flow.from_state
else:
if take_from_dict(model.state.states, data_flow.from_state):
from_state = take_from_dict(model.state.states, data_flow.from_state)
from_state_label = from_state.name + '.' + data_flow.from_state
else:
# print data_flow.from_state, data_flow.from_key, data_flow.to_state, data_flow.to_key
logger.warning("DO break in ctrl/data_flow.py -1")
break
# check if to Self_state
if data_flow.to_state == model.state.state_id:
to_state = model.state
to_state_label = 'self.' + model.state.name + '.' + data_flow.to_state
else:
if take_from_dict(model.state.states, data_flow.to_state):
to_state = take_from_dict(model.state.states, data_flow.to_state)
to_state_label = to_state.name + '.' + data_flow.to_state
else:
# print data_flow.from_state, data_flow.from_key, data_flow.to_state, data_flow.to_key
logger.warning("DO break in ctrl/data_flow.py 0")
break
from_key_port = from_state.get_data_port_by_id(data_flow.from_key)
from_key_label = ''
if from_key_port is not None:
from_key_label = PORT_TYPE_TAG.get(type(from_key_port), 'None') + '.' + \
from_key_port.data_type.__name__ + '.' + \
from_key_port.name
to_key_port = to_state.get_data_port_by_id(data_flow.to_key)
# to_key_label = ''
if to_key_port is not None:
to_key_label = PORT_TYPE_TAG.get(type(to_key_port), 'None') + '.' + \
(to_key_port.data_type.__name__ or 'None') + '.' + \
to_key_port.name
data_flow_dict['internal'][data_flow.data_flow_id] = {'from_state': from_state_label,
'from_key': from_key_label,
'to_state': to_state_label,
'to_key': to_key_label}
# ALL INTERNAL COMBOS
from_states_store = ListStore(str)
to_states_store = ListStore(str)
if isinstance(model, ContainerStateModel):
if model.state.state_id in free_to_port_internal or model.state.state_id == data_flow.to_state:
to_states_store.append(['self.' + model.state.name + '.' + model.state.state_id])
if model.state.state_id in from_ports_internal or model.state.state_id == data_flow.from_state:
from_states_store.append(['self.' + model.state.name + '.' + model.state.state_id])
for state_model in model.states.itervalues():
if state_model.state.state_id in free_to_port_internal or \
state_model.state.state_id == data_flow.to_state:
to_states_store.append([state_model.state.name + '.' + state_model.state.state_id])
if state_model.state.state_id in from_ports_internal or \
state_model.state.state_id == data_flow.from_state:
from_states_store.append([state_model.state.name + '.' + state_model.state.state_id])
from_keys_store = ListStore(str)
if model.state.state_id == data_flow.from_state:
# print "input_ports", model.state.input_data_ports
# print type(model)
if isinstance(model, ContainerStateModel):
# print "scoped_variables", model.state.scoped_variables
combined_ports = {}
combined_ports.update(model.state.scoped_variables)
combined_ports.update(model.state.input_data_ports)
get_key_combos(combined_ports, from_keys_store, data_flow.from_key)
else:
get_key_combos(model.state.input_data_ports, from_keys_store, data_flow.from_key)
else:
# print "output_ports", model.states[data_flow.from_state].state.output_data_ports
get_key_combos(model.state.states[data_flow.from_state].output_data_ports,
from_keys_store, data_flow.from_key)
to_keys_store = ListStore(str)
if model.state.state_id == data_flow.to_state:
# print "output_ports", model.state.output_data_ports
# print type(model)
if isinstance(model, ContainerStateModel):
# print "scoped_variables", model.state.scoped_variables
combined_ports = {}
combined_ports.update(model.state.scoped_variables)
combined_ports.update(model.state.output_data_ports)
get_key_combos(combined_ports, to_keys_store, data_flow.to_key)
else:
get_key_combos(model.state.output_data_ports, to_keys_store, data_flow.to_key)
else:
# print "input_ports", model.states[data_flow.to_state].state.input_data_ports
get_key_combos(model.state.states[data_flow.to_state].input_data_ports
, to_keys_store, data_flow.to_key)
tree_dict_combos['internal'][data_flow.data_flow_id] = {'from_state': from_states_store,
'from_key': from_keys_store,
'to_state': to_states_store,
'to_key': to_keys_store}
# print "internal", data_flow_dict['internal'][data_flow.data_flow_id]
if not model.state.is_root_state:
for data_flow in model.parent.state.data_flows.values(): # model.parent.data_flow_list_store:
# TREE STORE LABEL
# check if from Self_state
if model.state.state_id == data_flow.from_state:
from_state = model.state
from_state_label = 'self.' + model.state.name + '.' + data_flow.from_state
else:
if model.parent.state.state_id == data_flow.from_state:
from_state = model.parent.state
from_state_label = 'parent.' + model.parent.state.name + '.' + data_flow.from_state
else:
if take_from_dict(model.parent.state.states, data_flow.from_state):
from_state = take_from_dict(model.parent.state.states, data_flow.from_state)
from_state_label = from_state.name + '.' + data_flow.from_state
else:
# print "#", data_flow.from_state, data_flow.from_key, data_flow.to_state, data_flow.to_key
logger.warning("DO break in ctrl/data_flow.py 1")
break
# check if to Self_state
if model.state.state_id == data_flow.to_state:
to_state = model.state
to_state_label = 'self.' + model.state.name + '.' + data_flow.to_state
else:
if model.parent.state.state_id == data_flow.to_state:
to_state = model.parent.state
to_state_label = 'parent.' + model.parent.state.name + '.' + data_flow.to_state
else:
if take_from_dict(model.parent.state.states, data_flow.to_state):
to_state = take_from_dict(model.parent.state.states, data_flow.to_state)
to_state_label = to_state.name + '.' + data_flow.to_state
else:
# print "##", data_flow.from_state, data_flow.from_key, data_flow.to_state, data_flow.to_key
logger.warning("DO break in ctrl/data_flow.py 2")
break
if model.state.state_id in [data_flow.from_state, data_flow.to_state]:
from_key_port = from_state.get_data_port_by_id(data_flow.from_key)
if from_key_port is None:
continue
from_key_label = PORT_TYPE_TAG.get(type(from_key_port), 'None') + '.' + \
from_key_port.data_type.__name__ + '.' + \
from_key_port.name
to_key_port = to_state.get_data_port_by_id(data_flow.to_key)
if to_key_port is None:
continue
to_key_label = PORT_TYPE_TAG.get(type(to_key_port), 'None') + '.' + \
to_key_port.data_type.__name__ + '.' + \
to_key_port.name
data_flow_dict['external'][data_flow.data_flow_id] = {'from_state': from_state_label,
'from_key': from_key_label,
'to_state': to_state_label,
'to_key': to_key_label}
# ALL EXTERNAL COMBOS
if model.state.state_id in [data_flow.from_state, data_flow.to_state]:
# only self-state
from_states_store = ListStore(str)
for state_id in from_ports_external.keys():
if model.parent.state.state_id == state_id:
state_model = model.parent
else:
state_model = model.parent.states[state_id]
if state_model.state.state_id == model.state.state_id:
from_states_store.append(['self.' + state_model.state.name + '.' + state_model.state.state_id])
else:
from_states_store.append([state_model.state.name + '.' + state_model.state.state_id])
# from_states_store.append(['self.' + model.state.name + '.' + model.state.state_id])
# only outports of self
from_keys_store = ListStore(str)
if model.parent.state.state_id == data_flow.from_state:
# print "output_ports", model.parent.states[data_flow.from_state].state.output_data_ports
combined_ports = {}
combined_ports.update(model.parent.state.input_data_ports)
combined_ports.update(model.parent.state.scoped_variables)
get_key_combos(combined_ports, from_keys_store, data_flow.to_key)
elif data_flow.from_state in [state_m.state.state_id for state_m in model.parent.states.values()]:
get_key_combos(model.parent.state.states[data_flow.from_state].output_data_ports,
from_keys_store, data_flow.to_key)
else:
logger.error(
"---------------- FAILURE %s ------------- external from_state PARENT or STATES" % model.state.state_id)
# all states and parent-state
to_states_store = ListStore(str)
for state_id in free_to_port_external.keys():
if model.parent.state.state_id == state_id:
state_model = model.parent
else:
state_model = model.parent.states[state_id]
if state_model.state.state_id == model.state.state_id:
to_states_store.append(['self.' + state_model.state.name + '.' + state_model.state.state_id])
else:
to_states_store.append([state_model.state.name + '.' + state_model.state.state_id])
# all keys of actual to-state
to_keys_store = ListStore(str)
if get_state_model(model.parent, data_flow.to_state):
to_state_model = get_state_model(model.parent, data_flow.to_state)
from_state_model = get_state_model(model.parent, data_flow.to_state)
act_from_key_port = from_state_model.state.get_data_port_by_id(data_flow.from_key)
act_to_key_port = to_state_model.state.get_data_port_by_id(data_flow.to_key)
# first actual port
to_keys_store.append([PORT_TYPE_TAG.get(type(act_to_key_port), 'None') + '.#' +
str(act_to_key_port.data_port_id) + '.' +
act_to_key_port.data_type.__name__ + '.' +
act_to_key_port.name])
# second all other possible ones
if to_state_model.state is model.state.parent:
possible_port_ids = to_state_model.state.output_data_ports.keys() + to_state_model.state.scoped_variables.keys()
else:
possible_port_ids = to_state_model.state.input_data_ports.keys()
for port_id in possible_port_ids:
port = to_state_model.state.get_data_port_by_id(port_id)
# to_state = get_state_model(model.parent, data_flow.to_state).state
if not (PORT_TYPE_TAG.get(type(act_from_key_port), 'None') == 'SV' and port.data_port_id == data_flow.from_key)\
and port is not act_to_key_port:
to_keys_store.append([PORT_TYPE_TAG.get(type(port), 'None') + '.#' +
str(port.data_port_id) + '.' +
port.data_type.__name__ + '.' +
port.name])
tree_dict_combos['external'][data_flow.data_flow_id] = {'from_state': from_states_store,
'from_key': from_keys_store,
'to_state': to_states_store,
'to_key': to_keys_store}
# print "external", data_flow_dict['external'][data_flow.data_flow_id]
# print "ALL SCANNED: ", data_flow_dict['internal'].keys(), data_flow_dict['external'].keys(), \
# tree_dict_combos['internal'].keys(), tree_dict_combos['external'].keys()
return free_to_port_internal, free_to_port_external, from_ports_internal, from_ports_external
def _get_new_list_store():
return ListStore(str, str, str, int, bool, str, gobject.TYPE_PYOBJECT)
def __init__(self):
super(PeersTab, self).__init__('Peers', 'peers_tab', 'peers_tab_label')
self.peer_menu = self.main_builder.get_object('menu_peer_tab')
component.get('MainWindow').connect_signals(self)
self.listview = self.main_builder.get_object('peers_listview')
self.listview.props.has_tooltip = True
self.listview.connect('button-press-event',
self._on_button_press_event)
self.listview.connect('query-tooltip', self._on_query_tooltip)
# flag, ip, client, downspd, upspd, country code, int_ip, seed/peer icon, progress
self.liststore = ListStore(Pixbuf, str, str, int, int, str, float,
Pixbuf, float)
self.cached_flag_pixbufs = {}
self.seed_pixbuf = icon_seeding
self.peer_pixbuf = icon_downloading
# key is ip address, item is row iter
self.peers = {}
# Country column
column = TreeViewColumn()
render = CellRendererPixbuf()
column.pack_start(render, False)
column.add_attribute(render, 'pixbuf', 0)
column.set_sort_column_id(5)
column.set_clickable(True)
column.set_resizable(True)
column.set_expand(False)
column.set_min_width(20)
column.set_reorderable(True)
self.listview.append_column(column)
# Address column
column = TreeViewColumn(_('Address'))
render = CellRendererPixbuf()
column.pack_start(render, False)
column.add_attribute(render, 'pixbuf', 7)
render = CellRendererText()
column.pack_start(render, False)
column.add_attribute(render, 'text', 1)
column.set_sort_column_id(6)
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)
# Client column
column = TreeViewColumn(_('Client'))
render = CellRendererText()
column.pack_start(render, False)
column.add_attribute(render, 'text', 2)
column.set_sort_column_id(2)
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)
# Progress column
column = TreeViewColumn(_('Progress'))
render = CellRendererProgress()
column.pack_start(render, True)
column.set_cell_data_func(render, cell_data_peer_progress, 8)
column.set_sort_column_id(8)
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)
# Down Speed column
column = TreeViewColumn(_('Down Speed'))
render = CellRendererText()
column.pack_start(render, False)
column.set_cell_data_func(render, cell_data_speed_down, 3)
column.set_sort_column_id(3)
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)
# Up Speed column
column = TreeViewColumn(_('Up Speed'))
render = CellRendererText()
column.pack_start(render, False)
column.set_cell_data_func(render, cell_data_speed_up, 4)
column.set_sort_column_id(4)
column.set_clickable(True)
column.set_resizable(True)
column.set_expand(False)
column.set_min_width(50)
# Bugfix: Last column needs max_width set to stop scrollbar appearing
column.set_max_width(150)
column.set_reorderable(True)
self.listview.append_column(column)
self.listview.set_model(self.liststore)
self.load_state()
self.torrent_id = None
def __create_model(self): from gtk import ListStore from gobject import TYPE_STRING model = ListStore(TYPE_STRING, TYPE_STRING) return model
def __create_model(self):
from gtk import ListStore
model = ListStore(str)
return model
def create_model(self):
return ListStore(int, str)
