def get_files(self, file_descriptors):
        """download given list of file

        file_descriptor is a list: [ [split path], size ]"""
        if self.peer.server.current_state == self.peer.server.new_state:
            SecurityAlert(self.peer.peer_id,
                          "Can't get files: peer's server not known yet")
        else:
            # display downlaod dialog if necessary
            if get_prefs("display_dl") \
                   and "wx" in sys.modules:
                print "xxx using wx"
                from solipsis.util.uiproxy import UIProxy
                from solipsis.services.profile.gui.DownloadDialog \
                     import DownloadDialog
                self.download_dlg = UIProxy(DownloadDialog(
                    get_prefs("display_dl"), None, -1))
                self.download_dlg.init()
                self.download_dlg.Show()
            # launch first download
            self.files = file_descriptors
            if self.files:
                split_path, size = self.files.pop()
                self.update_file(split_path[-1], size)
                self._connect(MESSAGE_FILES,
                                     format_data_file(split_path, size))
                # create deferred to be called when all files downloaded
                deferred = defer.Deferred()
                self.files_deferred = deferred
                return self.files_deferred
            else:
                display_warning(_("Empty List"),
                                _("No file selected to download"))

 def __set_properties(self):
     # begin wxGlade: MatchFrame.__set_properties
     self.SetTitle(_("Matches"))
     self.SetSize((460, 600))
     # end wxGlade
     width = get_prefs("match_width")
     height = get_prefs("match_height")
     self.SetSize((width, height))

 def on_close(self, evt=None):
     """hide  application"""
     # save size
     new_size = self.GetSize()
     get_prefs().set("match_width", new_size.GetWidth())
     get_prefs().set("match_height", new_size.GetHeight())
     # do not destroy window
     self.Hide()

 def on_set_repo(self, evt):
     """set download directory according to value"""
     path = self.repo_value.GetValue()
     while path and not os.path.isdir(path):
         path = os.path.dirname(path)
     get_prefs().set("download_repo", path.encode(ENCODING))
     self.repo_value.SetValue(path)
     self.repo_button.SetToolTipString(path)
     self.SetTitle()

 def SetTitle(self, title=None):
     if not title:
         if self.peer_desc:
             title = self.peer_desc.pseudo + "'s files"
         else:
             title = unicode("your files going into " + get_prefs().get("download_repo"), ENCODING)
     wx.Dialog.SetTitle(self, title)

 def get_message(self):
     """format message to send to client according to file to be
     uploaded"""
     if self.message == MESSAGE_PROFILE:
         self.file = tempfile.NamedTemporaryFile()
         message = ASK_UPLOAD_PROFILE
     elif self.message == MESSAGE_BLOG:
         self.file = StringIO()
         message = ASK_UPLOAD_BLOG
     elif self.message == MESSAGE_SHARED:
         self.file = StringIO()
         message = ASK_UPLOAD_SHARED
     elif self.message == MESSAGE_FILES:
         # TODO: check place where to download and non overwriting
         down_path = os.path.abspath(os.path.join(
             get_prefs().get("download_repo"),
             self.split_path[-1]))
         self.file = open(down_path, "w+b")
         self.manager.download_dlg.update_file(self.split_path, self.size)
         message = "%s %s"% (ASK_UPLOAD_FILES,
                             UNIVERSAL_SEP.join(self.split_path))
     else:
         print "%s not valid"% self.message
         message = MESSAGE_ERROR
     return message

 def save(self, directory=None, doc_extension=PROFILE_EXT):
     """save both document & blog"""
     if directory is None:
         directory = get_prefs("profile_dir")
     file_path = os.path.join(directory, self.node_id)
     self.document.save(file_path + doc_extension)
     self.blog.save(file_path + BLOG_EXT)

 def connectionMade(self):
     """after ip is checked, begin connection"""
     PeerProtocol.connectionMade(self)
     # check action to be made
     if self.factory.download.startswith(ASK_DOWNLOAD_FILES):
         if self.factory.files:
             self.setRawMode()
             # TODO: check place where to download and non overwriting
             # create file
             file_path, size = self.factory.files.pop()
             self.factory.manager.update_file(file_path[-1], size)
             down_path = os.path.abspath(os.path.join(
                 get_prefs("download_repo"),
                 file_path[-1]))
             print "loading into", down_path
             self.file = open(down_path, "w+b")
             self.sendLine("%s %s"% (self.factory.download,
                                     UNIVERSAL_SEP.join(file_path)))
         else:
             self.factory.manager._on_all_files()
     elif self.factory.download.startswith(ASK_DOWNLOAD_BLOG)\
              or self.factory.download.startswith(ASK_DOWNLOAD_SHARED):
         self.setRawMode()
         self.file = StringIO()
         self.sendLine(self.factory.download)
     elif self.factory.download.startswith(ASK_DOWNLOAD_PROFILE):
         self.setRawMode()
         self.file = tempfile.NamedTemporaryFile()
         self.sendLine(self.factory.download)
     elif self.factory.download.startswith(ASK_UPLOAD):
         self.file = None
         self.setLineMode()
         self.sendLine(self.factory.download)
     else:
         print "unexpected command %s"% self.factory.download

 def on_about(self, event): # wxGlade: FilterFrame.<event_handler>
     """display about"""
     # not modal because would freeze the wx thread while twisted
     # one goes on and initialize profile
     about_dlg = AboutDialog(get_prefs("disclaimer"), self, -1)
     about_dlg.Show()
     event.Skip()

def create_filter_facade(pseudo, directory=None):
    """implements pattern singleton on FilterFacade"""
    if directory is None:
        directory = get_prefs("profile_dir")
    if isinstance(pseudo, str):
        pseudo = unicode(pseudo, ENCODING)
    FilterFacade.filter_facade = FilterFacade(pseudo, directory)
    return FilterFacade.filter_facade

 def SetTitle(self, title=None):
     if not title:
         if self.peer_desc:
             title = self.peer_desc.document.get_pseudo() + "'s files"
         else:
             title = force_unicode("your files going into " + \
                             get_prefs("download_repo"))
     wx.Dialog.SetTitle(self, title)

 def __init__(self, pseudo, directory=None):
     assert isinstance(pseudo, unicode), "pseudo must be a unicode"
     if directory is None:
         directory = get_prefs("profile_dir")
     AbstractPersonalData.__init__(self)
     AbstractSharingData.__init__(self)
     AbstractContactsData.__init__(self)
     SaverMixin.__init__(self, pseudo, directory)

 def __init__(self, pseudo, directory=None):
     assert isinstance(pseudo, unicode), "pseudo must be a unicode"
     if directory is None:
         directory = get_prefs("profile_dir")
     self._desc = None
     self.pseudo = pseudo
     self._activated = True
     self.views = {}

    def __set_properties(self):
        # begin wxGlade: FilterFrame.__set_properties
        self.SetTitle(_("Profile Filters"))
        self.SetSize((709, 632))
        self.statusbar.SetStatusWidths([-1])
        # statusbar fields
        statusbar_fields = [_("status")]
        for i in range(len(statusbar_fields)):
            self.statusbar.SetStatusText(statusbar_fields[i], i)
        # end wxGlade

        # properties not generated by wxglade
        width = get_prefs("filter_width")
        height = get_prefs("filter_height")
        self.SetSize((width, height))
        self.do_modified(False)
        self.activate_item.Check()

 def on_browse_repo(self, evt):
     """select download directory in DirDialog"""
     # pop up to choose repository
     dlg = wx.DirDialog(
         self,
         message=_("Choose location to download files into"),
         defaultPath=unicode(get_prefs().get("download_repo"), ENCODING),
         style=wx.DD_DEFAULT_STYLE | wx.DD_NEW_DIR_BUTTON,
     )
     if dlg.ShowModal() == wx.ID_OK:
         # path chosen
         path = dlg.GetPath()
         get_prefs().set("download_repo", path.encode(ENCODING))
         self.repo_value.SetValue(path)
         self.repo_button.SetToolTipString(path)
         self.SetTitle()
     dlg.Destroy()

 def __init__(self, pseudo, directory=None):
     assert isinstance(pseudo, unicode), "pseudo must be a unicode"
     if directory is None:
         directory = get_prefs("profile_dir")
     CachePersonalMixin.__init__(self)
     CacheSharingMixin.__init__(self)
     CacheContactMixin.__init__(self)
     SaverMixin.__init__(self, pseudo, directory)

def create_facade(pseudo, directory=None):
    """implements pattern singleton on Facade. User may specify
    document end/or view to initialize facade with at creation"""
    if directory is None:
        directory = get_prefs("profile_dir")
    if isinstance(pseudo, str):
        pseudo = unicode(pseudo, ENCODING)
    Facade.s_facade = Facade(pseudo, directory)
    return Facade.s_facade

 def __set_properties(self):
     # begin wxGlade: FilterFrame.__set_properties
     self.SetTitle(_("Profile Filters"))
     self.SetSize((460, 600))
     self.statusbar.SetStatusWidths([-1])
     # statusbar fields
     statusbar_fields = [_("status")]
     for i in range(len(statusbar_fields)):
         self.statusbar.SetStatusText(statusbar_fields[i], i)
     # end wxGlade
     width = get_prefs("filter_width")
     height = get_prefs("filter_height")
     self.SetSize((width, height))
     self.do_modified(False)
     self.activate_item.Check()
     # should be passed through constructor but wxglade does not allow it
     self.personal_filter_tab.do_modified = self.do_modified
     self.file_filter_tab.do_modified = self.do_modified

 def __init__(self, pseudo, directory=None):
     assert isinstance(pseudo, unicode), "pseudo must be a unicode"
     if directory is None:
         directory = get_prefs("profile_dir")
     self.pseudo = pseudo 
     self._dir = directory
     self.blogs = []
     # tag class to be enable retro-compatibility
     self.version = VERSION

 def get_files(self, peer_id, file_descriptors):
     """request downwload of given files"""
     if self.editor_frame and get_prefs().get("display_dl"):
         self.editor_frame.download_dlg.init()
         self.editor_frame.download_dlg.Show()
     deferred = self.network.get_files(peer_id, file_descriptors,
                                       self._on_all_files)
     deferred and deferred.addCallback(
         lambda file_name: sys.stdout.write("%s downloaded\n"% file_name))