def on_select_filter(self, event): # wxGlade: FilterFrame.<event_handler>
filter_names = get_selected_labels(self.filter_list)
if filter_names:
selected_filter = get_filter_facade().get_filter(filter_names[0])
if isinstance(selected_filter, PeerFilter):
# update edit panel
self.set_profile_view()
self.edit_profile_panel.update(selected_filter)
self.view_profile_panel.update(filter_names[0])
elif isinstance(selected_filter, FileFilter):
# update edit panel
self.set_file_view()
self.edit_file_panel.update(selected_filter)
self.view_file_panel.update(filter_names[0])
else:
print "unrecognised filter", selected_filter.__class__.__name__
# get ids to display in notebook
peer_ids = []
for filter_name in filter_names:
try:
for result_id, mathes in get_filter_facade().get_results(filter_name).items():
if result_id not in peer_ids and len(mathes) > 0:
peer_ids.append(result_id)
except KeyError:
pass
# update notebook
for peer_id in peer_ids:
self.set_tab(peer_id)
for peer_id in self.tabs:
if not peer_id in peer_ids:
self.hide_tab(peer_id)
event.Skip()
def Disable(self):
"""It is called when the user chooses to disable the service."""
# ask for saving (ca not simply call Close() on editor frame
# method because of multithreading and the frame is destroyed
# before the user actually answer to the popup
if self.editor_frame and self.editor_frame.modified:
import wx
self.editor_frame.do_modified(False)
dlg = wx.MessageDialog(
self.editor_frame,
'Your profile has been modified. Do you want to save it?',
'Saving Profile',
wx.YES_NO | wx.ICON_INFORMATION)
if dlg.ShowModal() == wx.ID_YES:
get_facade()._desc.save()
if self.filter_frame and self.filter_frame.modified:
import wx
self.filter_frame.do_modified(False)
dlg = wx.MessageDialog(
self.filter_frame,
'Your filters have been modified. Do you want to save them?',
'Saving Filters',
wx.YES_NO | wx.ICON_INFORMATION)
if dlg.ShowModal() == wx.ID_YES:
get_filter_facade().save()
self.activate(False)
def on_apply(self, event): # wxGlade: EditFilePanel.<event_handler>
props = {'name': self.file_name_value.GetValue(),
'size': self.size_value.GetValue()}
# set filter
get_filter_facade().update_file_filter(
self.file_name_value.GetValue(),
**props)
self.frame.do_modified(True)
event.Skip()
def on_import(self, event):
"""match current filter with given profile"""
dlg = wx.FileDialog(
self, message="Match profile ...",
defaultDir=get_prefs("profile_dir"),
defaultFile="",
wildcard="Solipsis file (*.prf)|*.prf",
style=wx.OPEN)
if dlg.ShowModal() == wx.ID_OK:
path = dlg.GetPath()[:-4]
loader = FileDocument()
loader.load(path + PROFILE_EXT)
get_facade().fill_data(loader.get_pseudo(), loader)
get_filter_facade().match(PeerDescriptor(loader.get_pseudo(),
document = loader))
event.Skip()
def cb_update(self, filter_name):
# get line
try:
item_id = get_item_id_by_label(self.filter_list, filter_name)
except KeyError:
item_id = self.filter_list.InsertStringItem(sys.maxint, filter_name)
# get data
filter_ = get_filter_facade().get_filter(filter_name)
try:
counter = 0
all_counter = 0
for matches in get_filter_facade().get_results(filter_name).values():
if matches:
counter += 1
all_counter += len(matches)
except KeyError:
pass
# update data
self.filter_list.SetStringItem(
item_id, 1,
str(counter)+"/"+str(all_counter))
self.filter_list.SetStringItem(
item_id, 2,
isinstance(filter_, FileFilter) and "file" or "peer")
def on_apply(self, event): # wxGlade: EditProfilePanel.<event_handler>
if self.all_label.IsShown():
# simple mode
filter_name = self.all_value.GetValue()
props = {"title": self.all_value.GetValue(),
"firstname": self.all_value.GetValue(),
"lastname": self.all_value.GetValue(),
"pseudo": self.all_value.GetValue(),
"email": self.all_value.GetValue()}
filter_or = True
# customs
customs = {}
else:
# advanced mode
filter_name = self.firstname_value.GetValue()
props = {"title": self.title_value.GetValue(),
"firstname": self.firstname_value.GetValue(),
"lastname": self.lastname_value.GetValue(),
"pseudo": self.pseudo_value.GetValue(),
"email": self.email_value.GetValue()}
filter_or = not self.logic_checkbox.IsChecked()
# customs
customs = {}
custom_item_ids = get_all_item_ids(self.customs_list)
for item_id in custom_item_ids:
key = self.customs_list.GetItem(item_id, 0).GetText()
value = self.customs_list.GetItem(item_id, 1).GetText()
customs[key] = value
# set filter
get_filter_facade().update_profile_filter(
filter_name,
filter_or,
customs,
**props)
self.frame.do_modified(True)
event.Skip()
def update(self, filter_name):
self.reset()
try:
results = get_filter_facade().get_results(filter_name)
for peer_id, matches in results.items():
# add peer if matches
if matches:
if not peer_id in self.items:
child = self.matching_list.AppendItem(self.root, peer_id)
self.matching_list.SetItemImage(child, self.fldridx, which = wx.TreeItemIcon_Normal)
self.matching_list.SetItemImage(child, self.fldropenidx, which = wx.TreeItemIcon_Expanded)
self.items[peer_id] = child
else:
child = self.items[peer_id]
# add matches
for matche in matches:
match_item = self.matching_list.AppendItem(
child, matche.get_name())
self.matching_list.SetItemImage(match_item, self.fileidx, which = wx.TreeItemIcon_Normal)
self.matching_list.SetItemText(match_item, matche.match, 1)
self.matching_list.Expand(self.root)
except KeyError:
print "no match for", filter_name
def on_delete(self, event): # wxGlade: FilterFrame.<event_handler>
filter_names = get_selected_labels(self.filter_list)
get_filter_facade().delete_filters(filter_names)
self.do_modified(True)
def on_refresh_filter(self, event):
filter_names = get_selected_labels(self.filter_list)
for peer in get_facade().get_peers().values():
get_filter_facade().match(peer, filter_names)
self.on_select_filter(event)
event.Skip()
def on_save(self, event): # wxGlade: FilterFrame.<event_handler>
"""save .prf"""
self.do_modified(False)
get_filter_facade().save()
event.Skip()
def on_activate(self, event): # wxGlade: FilterFrame.<event_handler>
"""activate service"""
print self.activate_item.IsChecked() and "Activating..." \
or "Disactivated"
get_filter_facade()._activated = self.activate_item.IsChecked()
event.Skip()
def on_change_facade(self):
"""called when user changes identity (facade chanegd)"""
get_filter_facade()._activated = self.activate_item.IsChecked()
def _on_hello(self, donwload_msg):
"""callback when autoloading of profile successful"""
document = read_document(donwload_msg.file)
get_facade().set_data(self.peer.peer_id, document, flag_update=False)
get_filter_facade().fill_data(self.peer.peer_id, document)
