def OnStatus(self, event): status_dict = statuscombo.status_dict for status in status_dict: if status_dict[status] == event.GetId(): import hooks hooks.notify('digsby.statistics.ui.select_status') profile.set_status(status)
def on_state_change(self, src, attr, old, new): assert attr in ('state', None) hooks.notify('account.state', src, new) # Update "connected_accounts" list conn = [a for a in self.accounts + [self.profile] if a.connected] if self.connected_accounts != conn: self.connected_accounts[:] = conn if new != StateMixin.Statuses.OFFLINE: if src in self.cancellers: self.cancellers.pop(src).cancel() x = self.reconnect_timers.pop(src,None) if x is not None: x.stop() if new == StateMixin.Statuses.OFFLINE: self._on_account_offline(src) self._check_all_offline() if new == StateMixin.Statuses.ONLINE: src.error_count = 0 # for IM accounts signing on, set their profile. if src in self.accounts: self.profile.set_formatted_profile(src.connection)
def OnOk(self,event): self.Show(False) import hooks; hooks.notify('digsby.statistics.contact_added') proto = self.protocombo.Value.id name = self.namefield.Value group = self.groupcombo.Value if isinstance(self.groupcombo.Value,basestring) else self.groupcombo.Value.GetContentAsString() alias = self.aliasfield.Value accounts = self.accountchecks.theset import hub from common import profile meta = False x = None for account in accounts: with traceguard: account.connection.add_new_buddy(name, group, proto, alias) x = (name, account.connection.service) if x in profile.blist.metacontacts.buddies_to_metas: meta = True if meta: id = list(profile.blist.metacontacts.buddies_to_metas[x])[0].id m = profile.blist.metacontacts[id] alias = m.alias group = list(m.groups)[0][-1] hub.get_instance().user_message( "That buddy is already part of metacontact \"" + alias + "\" in group \"" + group + "\"") self.Close()
def OnComposeEmail(self, to='', subject='', body='', cc='', bcc='', callback = None): import hooks; hooks.notify('digsby.statistics.email.compose') for name in ('to','subject', 'body', 'cc', 'bcc'): assert isinstance(vars()[name], basestring), (name, type(vars()[name]), vars()[name]) if self.mailclient and try_this(lambda: self.mailclient.startswith('file:'), False): os.startfile(self.mailclient[5:]) elif self.mailclient == 'sysdefault': kw = {} for name in ('subject', 'body', 'cc', 'bcc'): if vars()[name]: kw[name] = vars()[name] query = UrlQuery('mailto:' + quote(to), **kw) log.info('OnComposeEmail is launching query: %s' % query) try: os.startfile(query) except WindowsError: # WindowsError: [Error 1155] No application is associated with the specified file for this operation: 'mailto:' mailclient_error() raise elif self.mailclient == '__urls__': url = self.custom_compose_url if url is not None: launch_browser(url) else: url = self.compose(to, subject, body, cc, bcc) if url: launch_browser(url) callback.success()
def download_success(self, success_files): log.info("Downloaded files. %d files downloaded", len(success_files)) updater = self.updater if updater is None: self.cancel() return self.write_file_changes(updater.temp_dir, updater.update_files, updater.delete_files) hooks.notify('digsby.updater.update_complete') if not common.pref("digsby.updater.install_prompt", type = bool, default = False): log.debug("Update install prompt disabled. Scheduling install") self.schedule_install() else: res = [] def after_popup(): if (not res) or res[0] is None: log.debug("Popup was not shown. Scheduling install") self.schedule_install() @wx.CallAfter def do_popup(): res.append(gui.toast.popup( icon = gui.skin.get('serviceicons.digsby'), header = _("Update Ready"), minor = _("A new version of Digsby is ready to install. Restart Digsby to apply the update."), sticky = True, buttons = [(_("Restart Now"), self.do_install), (_("Restart Later"), self.schedule_install)], onclose = self._install_popup_closed, # popupid = 'digsby.update', )) wx.CallAfter(after_popup)
def markAsRead(self, email_message): ''' Mark the email object as read. ''' import hooks hooks.notify('digsby.statistics.email.mark_as_read') self._remove_email(email_message)
def handle_response(self, stanza): try: c = CounterQuery(stanza.get_query()) except ValueError: return with self.lock: for action in c: #usually one element, but whatever. if action.type is None: continue self.cached[action.type] = action.result import hooks #has protected notify actions = [] for action in c: #usually one element, but whatever. if action.type is None: continue actions.append(dict( type = action.type, initial = action.initial, value = action.value, result = action.result, ) ) for action in actions: hooks.notify('digsby.stats_counter', **action) hooks.notify('digsby.stats_counter.batch', actions)
def got_file(self, file, resp, backup_exception = None): dest_path = self.local_path_for_file(file) if not dest_path.parent.isdir(): dest_path.parent.makedirs() with open(dest_path, 'wb') as f: data = resp.read(32768) while data: f.write(data) data = resp.read(32768) resp.close() if file.match_local(dest_path): log.debug("successful download: %r", file.path) self.downloaded_files.append(file) hooks.notify("digsby.updater.file_download_complete", file) else: try: dest_path.remove() except Exception, e: log.debug("Error deleting bad file: %r", e) if backup_exception is None: self.try_backup(file, Exception("Bad data from primary server")) return # Don't queue next file yet. else: log.error("Error downloading %r. Bad data from backup server; primary server error was: %r", file.path, backup_exception) self.errored_files.append(file) hooks.notify("digsby.updater.file_download_error", file)
def append_comments(self, webview, id, post_id): hooks.notify('digsby.linkedin.comment_added', {}) t = LinkedInIB(self) context = {} context['item'] = self.connection.get_post_by_id(post_id) comments_html = t.get_html( None, set_dirty=False, file='comments_list.tenjin', dir=t.get_context()['app'].get_res_dir('base'), context=context) comment_link_html = t.get_html( None, set_dirty=False, file='comment_link.tenjin', dir=t.get_context()['app'].get_res_dir('base'), context=context) log.debug("comments_html = %r; comment_link_html = %r", comments_html, comment_link_html) self.Dsuccess(webview, id, comments_html=comments_html, comment_link_html=comment_link_html)
def set_blob(self, elem_name, data, force=False, callback=None): ''' Decide to send a blob to the server, or not. Run caching routine before doing so. response goes to self.set_blob_success ''' try: hooks.notify('digsby.identity.save_data', elem_name, data) except Exception: callback.error() else: callback.success() finally: return blob = name_to_obj[elem_name](data=data) stored = self.blobhashes.get(elem_name, sentinel) if stored is not sentinel: stored1 = stored[1] else: stored1 = sentinel if stored1 == self.calc_blob_hash(blob) and not force: log.info('set_blob %s: no change', elem_name) return callback.success() #cache here sending_stamp = blob.tstamp try: int(sending_stamp) except Exception, e: if stored is not sentinel: blob.tstamp = stored[0] else: blob.tstamp = 0
def CheckBoxClicked(self, item, checkbox): uinfo = self.UserNotifications topic = self.TopicForIndex(item) reaction = self.checkBoxReactions[checkbox] if not None in uinfo: uinfo[None] = {} reactions = uinfo[None].setdefault(topic, []) # # remove # foundOne = False for rdict in list(reactions): if rdict['reaction'] == reaction: foundOne = True log.info('removing %r', rdict) reactions.remove(rdict) # # add # if not foundOne: # adding one newEntry = self.ReactionEntry(topic, reaction) log.info('adding %r', newEntry) reactions.append(newEntry) import hooks hooks.notify('digsby.notifications.changed') self.RefreshLine(item)
def do_acct_math(*a, **k): has_accts = set(a.protocol for a in self.profile.all_accounts) if (has_accts & set(accttypes)): #user has accounts we're targeting log.critical('sending message obj to hook') hooks.notify('digsby.server.announcement', messageobj) else: log.critical('filtering conditional message for no accounts in common')
def on_close(self): if getattr(self, "_closed", False): log.warning("FIXME: imwin_ctrl.on_close was called more than once!!!") return self._closed = True del self.capsbar.buddy_callback del self.capsbar import hooks hooks.notify("digsby.overlay_icon_updated", self) from plugin_manager import plugin_hub plugin_hub.act("digsby.im.conversation.close.async", self.convo) self.unlink_observers() if self.convo is not None: self.unwatch_conversation(self.convo) try: self.convo.explicit_exit() except Exception: print_exc()
def check_for_updates(self, rpc, webview, id): if self._update_check_rpc_id is not None: return self.Derror(self.webview, id, message="checking") self._update_check_rpc_id = id log.info("Requesting update check from about dialog") hooks.notify('digsby.updater.check')
def OnOk(self, event): self.Show(False) import hooks hooks.notify('digsby.statistics.contact_added') proto = self.protocombo.Value.id name = self.namefield.Value group = self.groupcombo.Value if isinstance( self.groupcombo.Value, basestring) else self.groupcombo.Value.GetContentAsString() alias = self.aliasfield.Value accounts = self.accountchecks.theset import hub from common import profile meta = False x = None for account in accounts: with traceguard: account.connection.add_new_buddy(name, group, proto, alias) x = (name, account.connection.service) if x in profile.blist.metacontacts.buddies_to_metas: meta = True if meta: id = list(profile.blist.metacontacts.buddies_to_metas[x])[0].id m = profile.blist.metacontacts[id] alias = m.alias group = list(m.groups)[0][-1] hub.get_instance().user_message( "That buddy is already part of metacontact \"" + alias + "\" in group \"" + group + "\"") self.Close()
def session_started_notify(self, s): ''' whatever needs to be done after most setup and before the callback/state change happens. usually that will be plugins doing their own setup. allows notify to be overridden in subclass ''' hooks.notify('digsby.jabber.session_started', self, s)
def download_error(self, error_files, success_files): log.error("Update incomplete. %d successful files, %d errored files", len(success_files), len(error_files)) for f in error_files: log.error("\t%r", f.path) self.cancel() hooks.notify('digsby.updater.update_failed') auto_download = common.pref("digsby.updater.auto_download", type=bool, default=True) if not auto_download: popup = gui.toast.popup( icon=gui.skin.get('serviceicons.digsby'), header=_("Update Failed"), minor= _("Digsby was unable to complete the download. This update will be attempted again later." ), sticky=True, buttons=[(_("Manual Update"), lambda: wx.LaunchDefaultBrowser( "http://install.digsby.com")), (_("Close"), lambda: popup.cancel())], # popupid = 'digsby.update', )
def notify_click(self): ppe = self.content['net_ppe'] if ppe is not None: cents = int(ppe*100) hooks.notify('digsby.statistics.feed_ads.citygrid.click_cents', cents) hooks.notify('digsby.statistics.feed_ads.citygrid.click')
def set_blob(self, elem_name, data, force = False, callback = None): ''' Decide to send a blob to the server, or not. Run caching routine before doing so. response goes to self.set_blob_success ''' try: hooks.notify('digsby.identity.save_data', elem_name, data) except Exception: callback.error() else: callback.success() finally: return blob = name_to_obj[elem_name](data=data) stored = self.blobhashes.get(elem_name, sentinel) if stored is not sentinel: stored1 = stored[1] else: stored1 = sentinel if stored1 == self.calc_blob_hash(blob) and not force: log.info('set_blob %s: no change', elem_name) return callback.success() #cache here sending_stamp = blob.tstamp try: int(sending_stamp) except Exception, e: if stored is not sentinel: blob.tstamp = stored[0] else: blob.tstamp = 0
def _incoming_blob_notifications(self, newdata): def fix_underscore(d): for key in d.keys()[:]: if key and '_' in key: d[key.replace('_', '.')] = d.pop(key) if not hasattr(self, 'notifications'): self.notifications = ObservableDict() else: fix_underscore(self.notifications) fix_underscore(newdata) self.notifications.update(newdata) import common.notifications # for any notification keys that exist in YAML, but not in the users # blob, add them with the values in the YAML 'default' key ni = common.notifications.get_notification_info() base = self.notifications[None] for k in ni: if k in base: continue try: defaults = ni[k].get('default', {}) base[k] = [dict(reaction=v) for v in defaults.get('reaction', ())] except Exception: traceback.print_exc() continue import hooks hooks.notify('digsby.notifications.changed')
def on_state_change(self, src, attr, old, new): assert attr in ('state', None) hooks.notify('account.state', src, new) # Update "connected_accounts" list conn = [a for a in self.accounts + [self.profile] if a.connected] if self.connected_accounts != conn: self.connected_accounts[:] = conn if new != StateMixin.Statuses.OFFLINE: if src in self.cancellers: self.cancellers.pop(src).cancel() x = self.reconnect_timers.pop(src, None) if x is not None: x.stop() if new == StateMixin.Statuses.OFFLINE: self._on_account_offline(src) self._check_all_offline() if new == StateMixin.Statuses.ONLINE: src.error_count = 0 # for IM accounts signing on, set their profile. if src in self.accounts: self.profile.set_formatted_profile(src.connection)
def on_close(self): if getattr(self, '_closed', False): log.warning( 'FIXME: imwin_ctrl.on_close was called more than once!!!') return self._closed = True del self.capsbar.buddy_callback del self.capsbar import hooks hooks.notify('digsby.overlay_icon_updated', self) from plugin_manager import plugin_hub plugin_hub.act('digsby.im.conversation.close.async', self.convo) self.unlink_observers() if self.convo is not None: self.unwatch_conversation(self.convo) try: self.convo.explicit_exit() except Exception: print_exc()
def on_send_message_sms(self): 'Invoked when enter is pressed in the message input box during SMS mode.' # Early exit if there is no message to send. if not self.input_area.Value: return to, frm = self.SMSControl.ToSMS, self.SMSControl.FromAccount if to is None: MessageBox(_('Please add an SMS number first.'), _('Send SMS Message')) elif frm is None: MessageBox( _('You are not signed in to any accounts which can send SMS messages.' ), _('Send SMS Message')) else: message = self.input_area.Value def on_success(): self.show_message( Message(buddy=frm.self_buddy, message=message[:SMS_MAX_LENGTH], conversation=self.convo, type='outgoing')) self.ClearAndFocus() def on_error(errstr=None): if errstr is not None: more = '\n' + _( 'The error message received was:') + '\n\t%s' % errstr else: more = '' MessageBox( _('There was an error in sending your SMS message.') + more, _('Send SMS Message Error'), style=wx.ICON_ERROR) # Check the length--even though we limit the number of characters in SMS mode, the input box # may already have had too many characters. if len(message) > SMS_MAX_LENGTH: sms_line1 = _( 'Only the first {max_length:d} characters of your message can be sent over SMS:' ).format(max_length=SMS_MAX_LENGTH) sms_line2 = _('Do you want to send this message now?') if wx.NO == wx.MessageBox(u'%s\n\n"%s"\n\n%s' % (sms_line1, message, sms_line2), _('Send SMS - Character Limit'), style=wx.YES_NO): return import hooks hooks.notify('digsby.statistics.sms.sent') frm.send_sms(to, message[:SMS_MAX_LENGTH], success=on_success, error=on_error)
def set_profile_status(msg): ''' The combo calls this method by default when setting a new status. This can be changed in the constructor. ''' import hooks; hooks.notify('digsby.statistics.ui.select_status') return profile.set_status(msg)
def onsave(diag): status = diag.StatusMessageFromInfo() if diag.SaveForLater: # only save if the checkbox is checked profile.add_status_message(status) import hooks; hooks.notify('digsby.statistics.ui.select_status') profile.set_status(status)
def notify_click(self): ppe = self.content['net_ppe'] if ppe is not None: cents = int(ppe * 100) hooks.notify('digsby.statistics.feed_ads.citygrid.click_cents', cents) hooks.notify('digsby.statistics.feed_ads.citygrid.click')
def add_account(self, protocol_name): with self.create_account_dialog(protocol_name) as diag: unusedres = diag.ShowModal() if diag.ReturnCode == wx.ID_SAVE: info = diag.info() common.profile.add_email_account(**info) import hooks hooks.notify('digsby.email.new_account', parent = self.Top, **info)
def _update_afters(self): with self.lock: old_afters = self.afters self.afters = dict((self.ids[i - 1], id) for i, id in enumerate(self.ids) if isfinishedad(id)) if old_afters != self.afters: hooks.notify('social.feed.mark_dirty', self.context)
def later(): try: p.ShowModal() except Exception: print_exc() else: hooks.notify('proxy.info_changed', util.GetProxyInfo()) finally: p.Destroy()
def set_profile_status(msg): ''' The combo calls this method by default when setting a new status. This can be changed in the constructor. ''' import hooks hooks.notify('digsby.statistics.ui.select_status') return profile.set_status(msg)
def do_acct_math(*a, **k): has_accts = set(a.protocol for a in self.profile.all_accounts) if (has_accts & set(accttypes)): #user has accounts we're targeting log.critical('sending message obj to hook') hooks.notify('digsby.server.announcement', messageobj) else: log.critical( 'filtering conditional message for no accounts in common')
def resort(self, mock = False): assert on_thread('sorter').now rootgroups = [display_copy(g) for g in self.rootgroups if isinstance(g, GroupTypes)] self.personalities = self.track_personalities(rootgroups) metacontacts = self.safe_metacontacts(rootgroups) # Always collect metacontacts, but exit early here if sorting is paused. if self.sorting_paused:# or not profile.prefs_loaded: return metrics.event('Buddylist Sort') self._setup_blist_sorter() # invalidate all sorter knowledge of contacts. # results in more CPU usage, but until we put metacontact combining into the sorter # this might be necessary. self.new_sorter.removeAllContacts() newroots = rootgroups[:] + [metacontacts] for i, root in enumerate(newroots): root.name = "Root" + str(i) root._root = True root = DGroup('none', [], [], newroots) if mock: self.mock_root = make_mocklist(root) self.new_sorter.set_root(root) view = get_view_from_sorter(self.new_sorter) if getattr(self, '_search_by', ''): if len(view) > 0: contacts_group = view[0] # don't allow renaming, etc of the search "Contacts" group contacts_group._disallow_actions = True num_contacts = len(contacts_group) else: num_contacts = -1 self._search_results = self._search_results[1], num_contacts else: if pref('buddylist.hide_offline_dependant', False, bool): hide_offline_groups = not pref('buddylist.show_offline') and pref('buddylist.hide_offline_groups') else: hide_offline_groups = pref('buddylist.hide_offline_groups') if hide_offline_groups: view[:] = filter((lambda g: not offline_nonempty_group_re.match(g.display_string)), view) for g in view: remove_duplicate_contacts(g) self.add_search_entries(view) hooks.notify('buddylist.sorted', view) return view
def OnClickInboxURL(self, e = None): import hooks; hooks.notify('digsby.statistics.email.inbox_opened') if self.mailclient: url = self.start_client_email() if url is None: return else: url = self.inbox_url launch_browser(self.inbox_url)
def finished(self): cb, self.callback = self.callback, None if self.errored_files: hooks.notify("digsby.updater.update_download_error", self.errored_files, self.downloaded_files) if cb is not None: cb.error(self.errored_files, self.downloaded_files) else: hooks.notify("digsby.updater.update_download_complete", self.downloaded_files) if cb is not None: cb.success(self.downloaded_files)
def SetStatusMessage(self, message, editable = True, edit_toggle = True, **k): new_status = StatusMessage(title = None, status = self.status.status, message = message, editable = editable, edit_toggle = edit_toggle) import hooks hooks.notify('digsby.statistics.ui.select_status') self.set_status(new_status)
def add_account(self, protocol_name): with self.create_account_dialog(protocol_name) as diag: unusedres = diag.ShowModal() if diag.ReturnCode == wx.ID_SAVE: info = diag.info() common.profile.add_email_account(**info) import hooks hooks.notify('digsby.email.new_account', parent=self.Top, **info)
def on_send_message_sms(self): "Invoked when enter is pressed in the message input box during SMS mode." # Early exit if there is no message to send. if not self.input_area.Value: return to, frm = self.SMSControl.ToSMS, self.SMSControl.FromAccount if to is None: MessageBox(_("Please add an SMS number first."), _("Send SMS Message")) elif frm is None: MessageBox(_("You are not signed in to any accounts which can send SMS messages."), _("Send SMS Message")) else: message = self.input_area.Value def on_success(): self.show_message( Message( buddy=frm.self_buddy, message=message[:SMS_MAX_LENGTH], conversation=self.convo, type="outgoing" ) ) self.ClearAndFocus() def on_error(errstr=None): if errstr is not None: more = "\n" + _("The error message received was:") + "\n\t%s" % errstr else: more = "" MessageBox( _("There was an error in sending your SMS message.") + more, _("Send SMS Message Error"), style=wx.ICON_ERROR, ) # Check the length--even though we limit the number of characters in SMS mode, the input box # may already have had too many characters. if len(message) > SMS_MAX_LENGTH: sms_line1 = _("Only the first {max_length:d} characters of your message can be sent over SMS:").format( max_length=SMS_MAX_LENGTH ) sms_line2 = _("Do you want to send this message now?") if wx.NO == wx.MessageBox( u'%s\n\n"%s"\n\n%s' % (sms_line1, message, sms_line2), _("Send SMS - Character Limit"), style=wx.YES_NO, ): return import hooks hooks.notify("digsby.statistics.sms.sent") frm.send_sms(to, message[:SMS_MAX_LENGTH], success=on_success, error=on_error)
def handle_comment_remove_resp(self, resp, comment_id, callback): if resp: for post_id, comments in self.last_stream['comments'].items(): for i, comment in enumerate(comments): if comment['id'] == comment_id: c = comments.pop(i) post = self.last_stream['post_ids'][post_id] post['comments']['count'] -= 1 callback.success(post_id) hooks.notify('digsby.facebook.comment_removed', c) return
def OnClickInboxURL(self, e=None): import hooks hooks.notify('digsby.statistics.email.inbox_opened') if self.mailclient: url = self.start_client_email() if url is None: return else: url = self.inbox_url launch_browser(self.inbox_url)
def success(*a): log.info('Email send success') # store history profile.blist.add_tofrom('email', to, frm) epanel.Clear() epanel.SetStatusMessage(_('Message Sent')) epanel.send_button.Enable(True) epanel.openin.Enable(True) import hooks hooks.notify('digsby.statistics.email.sent_from_imwindow')
def MakeOrShow(cls,group='', service = '', name = '', account = None): if not hasattr(cls,'current_instance'): cls.current_instance = None if cls.current_instance: cls.current_instance.Show(True) cls.current_instance.Raise() else: cls.current_instance = AddContactDialog(None, group, service, name, account) cls.current_instance.Show(True) import hooks; hooks.notify('digsby.statistics.ui.dialogs.add_contact.shown')
def ViewLogForFile(logpath, do_aliases=True): ''' Update the log viewer with the file specified ''' with viewer.Frozen(): viewer.SetPageSource(logpath.text('utf-8', 'replace'), logpath.url()) viewer.RunScript('window.scroll(0, 0);') if do_aliases: substitue_aliases() import hooks hooks.notify('digsby.statistics.logviewer.log_viewed')
def success(*a): log.info("Email send success") # store history profile.blist.add_tofrom("email", to, frm) epanel.Clear() epanel.SetStatusMessage(_("Message Sent")) epanel.send_button.Enable(True) epanel.openin.Enable(True) import hooks hooks.notify("digsby.statistics.email.sent_from_imwindow")
def OnClickEmail(self, email): import hooks; hooks.notify('digsby.statistics.email.email_opened') if self.mailclient: self.start_client_email(email) else: url = self.urlForEmail(email) launch_browser(url) # For accounts where we are guaranteed to actually read the email # on click (i.e., ones that use webclients and have autologin on), # decrement the email count. if self.opening_email_marks_as_read: self._remove_email(email)
def handle_comment_resp(self, response, post_id, comment, callback): comment_id = response post = self.last_stream['post_ids'][post_id] post['comments']['count'] += 1 import time comment_dict = S({'fromid': post['viewer_id'], 'id': comment_id, 'post_id': post_id, 'text': comment, 'time': time.time()}) self.last_stream['comments'].setdefault(post_id, []).append(comment_dict) callback.success(post_id, comment_dict) hooks.notify('digsby.facebook.comment_added', comment_dict)
def show(tabname='accounts'): ''' Displays the Preferences dialog with the specified tab active. For tab names, see "prefstrings.py" ''' if not isinstance(tabname, str): raise TypeError('prefsdialog.show takes a tab name') import hooks; hooks.notify('digsby.statistics.prefs.prefs_opened') tabindex = [c[0] for c in tabnames].index(tabname) return show_prefs_window(None, tabindex)
def OnClickEmail(self, email): import hooks hooks.notify('digsby.statistics.email.email_opened') if self.mailclient: self.start_client_email(email) else: url = self.urlForEmail(email) launch_browser(url) # For accounts where we are guaranteed to actually read the email # on click (i.e., ones that use webclients and have autologin on), # decrement the email count. if self.opening_email_marks_as_read: self._remove_email(email)
def save_local_info(self): 'Writes our local account data to disk.' hooks.notify('digsby.identity.save_data', 'accounts', self.all_accounts) return if not SAVE_ACCOUNTS: return try: digsby.digsbylocal.save_local_info( self.profile.username, self.profile.password, self.all_accounts, self.order) log.info('serialized local accounts') except Exception: log.error('failed to serialize local accounts') traceback.print_exc()
def MakeOrShow(cls, group='', service='', name='', account=None): if not hasattr(cls, 'current_instance'): cls.current_instance = None if cls.current_instance: cls.current_instance.Show(True) cls.current_instance.Raise() else: cls.current_instance = AddContactDialog(None, group, service, name, account) cls.current_instance.Show(True) import hooks hooks.notify('digsby.statistics.ui.dialogs.add_contact.shown')