Moved filters, list features, user actions, user aliases and account config to twitter handler

src/controller/mainController.py

@@ -343,7 +343,6 @@ class Controller(object):
             self.view.add_buffer(account.buffer , name=session.db["user_name"])
         root_position =self.view.search(session.db["user_name"], session.db["user_name"])
 
-
     def set_buffer_positions(self, session):
         "Sets positions for buffers if values exist in the database."
         for i in self.buffers:
@@ -423,20 +422,19 @@ class Controller(object):
         output.speak(_(u"{0} not found.").format(string,), True)
 
     def filter(self, *args, **kwargs):
-        page = self.get_current_buffer()
+        buffer = self.get_current_buffer()
-        if not hasattr(page.buffer, "list"):
+        if not hasattr(buffer.buffer, "list"):
             output.speak(_(u"No session is currently in focus. Focus a session with the next or previous session shortcut."), True)
             return
-        # Let's prevent filtering of some buffers (people buffers, direct messages, events and sent items).
+        handler = self.get_handler(type=buffer.session.type)
-        # ToDo: Remove events from here after August 16.
+        if handler != None and hasattr(handler, "filter"):
-        if (page.name == "direct_messages" or page.name == "sent_tweets" or page.name == "events") or page.type == "people":
+            return handler.filter(buffer=buffer)
-            output.speak(_(u"Filters cannot be applied on this buffer"))
-            return
-        new_filter = filters.filter(page)
 
     def manage_filters(self, *args, **kwargs):
-        page = self.get_best_buffer()
+        buffer = self.get_best_buffer()
-        manage_filters = filters.filterManager(page.session)
+        handler = self.get_handler(type=buffer.session.type)
+        if handler != None and hasattr(handler, "manage_filters"):
+            return handler.manage_filters(session=buffer.session)
 
     def seekLeft(self, *args, **kwargs):
         try:
@@ -474,80 +472,28 @@ class Controller(object):
         SoundsTutorial.soundsTutorial(buffer.session)
 
     def view_user_lists(self, *args, **kwargs):
-        buff = self.get_best_buffer()
+        buffer = self.get_best_buffer()
-        if not hasattr(buff, "get_right_tweet"): return
+        handler = self.get_handler(type=buffer.session.type)
-        tweet = buff.get_right_tweet()
+        if handler != None and hasattr(handler, "view_user_lists"):
-        if buff.type == "people":
+            return handler.view_user_lists(buffer=buffer)
-            users = [tweet.screen_name]
-        elif buff.type == "dm":
-            users = [buff.session.get_user(tweet.message_create["sender_id"]).screen_name]
-        else:
-            users = utils.get_all_users(tweet, buff.session)
-        selector = userSelector.userSelector(users=users, session_id=buff.session.session_id)
-        user = selector.get_user()
-        if user == None:
-            return
-        l = lists.listsController(buff.session, user=user)
 
     def add_to_list(self, *args, **kwargs):
-        buff = self.get_best_buffer()
+        buffer = self.get_best_buffer()
-        if not hasattr(buff, "get_right_tweet"): return
+        handler = self.get_handler(type=buffer.session.type)
-        tweet = buff.get_right_tweet()
+        if handler != None and hasattr(handler, "add_to_list"):
-        if buff.type == "people":
+            return handler.add_to_list(controller=self, buffer=buffer)
-            users = [tweet.screen_name]
-        elif buff.type == "dm":
-            users = [buff.session.get_user(tweet.message_create["sender_id"]).screen_name]
-        else:
-            users = utils.get_all_users(tweet, buff.session)
-        selector = userSelector.userSelector(users=users, session_id=buff.session.session_id)
-        user = selector.get_user()
-        if user == None:
-            return
-        dlg = dialogs.lists.addUserListDialog()
-        dlg.populate_list([compose.compose_list(item) for item in buff.session.db["lists"]])
-        if dlg.get_response() == widgetUtils.OK:
-            try:
-                list = buff.session.twitter.add_list_member(list_id=buff.session.db["lists"][dlg.get_item()].id, screen_name=user)
-                older_list = utils.find_item(buff.session.db["lists"][dlg.get_item()].id, buff.session.db["lists"])
-                listBuffer = self.search_buffer("%s-list" % (buff.session.db["lists"][dlg.get_item()].name.lower()), buff.session.db["user_name"])
-                if listBuffer != None: listBuffer.get_user_ids()
-                buff.session.db["lists"].pop(older_list)
-                buff.session.db["lists"].append(list)
-            except TweepyException as e:
-                log.exception("error %s" % (str(e)))
-                output.speak("error %s" % (str(e)))
 
     def remove_from_list(self, *args, **kwargs):
-        buff = self.get_best_buffer()
+        buffer = self.get_best_buffer()
-        if not hasattr(buff, "get_right_tweet"): return
+        handler = self.get_handler(type=buffer.session.type)
-        tweet = buff.get_right_tweet()
+        if handler != None and hasattr(handler, "remove_from_list"):
-        if buff.type == "people":
+            return handler.remove_from_list(controller=self, buffer=buffer)
-            users = [tweet.screen_name]
-        elif buff.type == "dm":
-            users = [buff.session.get_user(tweet.message_create["sender_id"]).screen_name]
-        else:
-            users = utils.get_all_users(tweet, buff.session)
-        selector = userSelector.userSelector(users=users, session_id=buff.session.session_id)
-        user = selector.get_user()
-        if user == None:
-            return
-        dlg = dialogs.lists.removeUserListDialog()
-        dlg.populate_list([compose.compose_list(item) for item in buff.session.db["lists"]])
-        if dlg.get_response() == widgetUtils.OK:
-            try:
-                list = buff.session.twitter.remove_list_member(list_id=buff.session.db["lists"][dlg.get_item()].id, screen_name=user)
-                older_list = utils.find_item(buff.session.db["lists"][dlg.get_item()].id, buff.session.db["lists"])
-                listBuffer = self.search_buffer("%s-list" % (buff.session.db["lists"][dlg.get_item()].name.lower()), buff.session.db["user_name"])
-                if listBuffer != None: listBuffer.get_user_ids()
-                buff.session.db["lists"].pop(older_list)
-                buff.session.db["lists"].append(list)
-            except TweepyException as e:
-                output.speak("error %s" % (str(e)))
-                log.exception("error %s" % (str(e)))
 
     def list_manager(self, *args, **kwargs):
-        s = self.get_best_buffer().session
+        buffer = self.get_best_buffer()
-        l = lists.listsController(s)
+        handler = self.get_handler(type=buffer.session.type)
+        if handler != None and hasattr(handler, "list_manager"):
+            return handler.list_manager(session=buffer.session)
 
     def configuration(self, *args, **kwargs):
         """ Opens the global settings dialogue."""
@@ -560,16 +506,11 @@ class Controller(object):
 
     def accountConfiguration(self, *args, **kwargs):
         """ Opens the account settings dialogue for the current account."""
-        buff = self.get_best_buffer()
+        buffer = self.get_best_buffer()
-        manager.manager.set_current_session(buff.session.session_id)
+        handler = self.get_handler(type=buffer.session.type)
-        d = settings.accountSettingsController(buff, self)
+        if handler != None and hasattr(handler, "account_settings"):
-        if d.response == widgetUtils.OK:
+            manager.manager.set_current_session(buffer.session.session_id)
-            d.save_configuration()
+            return handler.account_settings(buffer=buffer, controller=self)
-            if d.needs_restart == True:
-                commonMessageDialogs.needs_restart()
-                buff.session.settings.write()
-                buff.session.save_persistent_data()
-                restart.restart_program()
 
     def check_for_updates(self, *args, **kwargs):
         update = updater.do_update()
@@ -615,113 +556,20 @@ class Controller(object):
         widgetUtils.exit_application()
 
     def follow(self, *args, **kwargs):
-        buff = self.get_current_buffer()
+        buffer = self.get_current_buffer()
-        if not hasattr(buff, "get_right_tweet"): return
+        handler = self.get_handler(type=buffer.session.type)
-        tweet = buff.get_right_tweet()
+        if handler != None and hasattr(handler, "follow"):
-        if buff.type == "people":
+            return handler.follow(buffer=buffer)
-            users = [tweet.screen_name]
-        elif buff.type == "dm":
-            users = [buff.session.get_user(tweet.message_create["sender_id"]).screen_name]
-        else:
-            users = utils.get_all_users(tweet, buff.session)
-        u = userActions.userActionsController(buff, users)
-
-    def unfollow(self, *args, **kwargs):
-        buff = self.get_current_buffer()
-        if not hasattr(buff, "get_right_tweet"): return
-        tweet = buff.get_right_tweet()
-        if buff.type == "people":
-            users = [tweet.screen_name]
-        elif buff.type == "dm":
-            users = [buff.session.get_user(tweet.message_create["sender_id"]).screen_name]
-        else:
-            users = utils.get_all_users(tweet, buff.session)
-        u = userActions.userActionsController(buff, users, "unfollow")
-
-    def mute(self, *args, **kwargs):
-        buff = self.get_current_buffer()
-        if not hasattr(buff, "get_right_tweet"): return
-        tweet = buff.get_right_tweet()
-        if buff.type == "people":
-            users = [tweet.screen_name]
-        elif buff.type == "dm":
-            users = [buff.session.get_user(tweet.message_create["sender_id"]).screen_name]
-        else:
-            users = utils.get_all_users(tweet, buff.session)
-        u = userActions.userActionsController(buff, users, "mute")
-
-    def unmute(self, *args, **kwargs):
-        buff = self.get_current_buffer()
-        if not hasattr(buff, "get_right_tweet"): return
-        tweet = buff.get_right_tweet()
-        if buff.type == "people":
-            users = [tweet.screen_name]
-        elif buff.type == "dm":
-            users = [buff.session.get_user(tweet.message_create["sender_id"]).screen_name]
-        else:
-            users = utils.get_all_users(tweet, buff.session)
-        u = userActions.userActionsController(buff, users, "unmute")
-
-    def block(self, *args, **kwargs):
-        buff = self.get_current_buffer()
-        if not hasattr(buff, "get_right_tweet"): return
-        tweet = buff.get_right_tweet()
-        if buff.type == "people":
-            users = [tweet.screen_name]
-        elif buff.type == "dm":
-            users = [buff.session.get_user(tweet.message_create["sender_id"]).screen_name]
-        else:
-            users = utils.get_all_users(tweet, buff.session)
-        u = userActions.userActionsController(buff, users, "block")
-
-    def unblock(self, *args, **kwargs):
-        buff = self.get_current_buffer()
-        if not hasattr(buff, "get_right_tweet"): return
-        tweet = buff.get_right_tweet()
-        if buff.type == "people":
-            users = [tweet.screen_name]
-        elif buff.type == "dm":
-            users = [buff.session.get_user(tweet.message_create["sender_id"]).screen_name]
-        else:
-            users = utils.get_all_users(tweet, buff.session)
-        u = userActions.userActionsController(buff, users, "unblock")
-
-    def report(self, *args, **kwargs):
-        buff = self.get_current_buffer()
-        if not hasattr(buff, "get_right_tweet"): return
-        tweet = buff.get_right_tweet()
-        if buff.type == "people":
-            users = [tweet.screen_name]
-        elif buff.type == "dm":
-            users = [buff.session.get_user(tweet.message_create["sender_id"]).screen_name]
-        else:
-            users = utils.get_all_users(tweet, buff.session)
-        u = userActions.userActionsController(buff, users, "report")
 
     def add_alias(self, *args, **kwargs):
-        buff = self.get_best_buffer()
+        buffer = self.get_best_buffer()
-        if not hasattr(buff, "get_right_tweet"): return
+        handler = self.get_handler(type=buffer.session.type)
-        tweet = buff.get_right_tweet()
+        if handler != None and hasattr(handler, "add_alias"):
-        if buff.type == "people":
+            return handler.add_alias(buffer=buffer)
-            users = [tweet.screen_name]
-        elif buff.type == "dm":
-            users = [buff.session.get_user(tweet.message_create["sender_id"]).screen_name]
-        else:
-            users = utils.get_all_users(tweet, buff.session)
-        dlg = dialogs.userAliasDialogs.addAliasDialog(_("Add an user alias"), users)
-        if dlg.get_response() == widgetUtils.OK:
-            user, alias = dlg.get_user()
-            if user == "" or alias == "":
-                return
-            user_id = buff.session.get_user_by_screen_name(user)
-            buff.session.settings["user-aliases"][str(user_id)] = alias
-            buff.session.settings.write()
-            output.speak(_("Alias has been set correctly for {}.").format(user))
-            pub.sendMessage("alias-added")
 
     def manage_aliases(self, *args, **kwargs):
-        buff = self.get_best_buffer()
+        buffer = self.get_best_buffer()
-        alias_controller = userAliasController.userAliasController(buff.session.settings)
+        alias_controller = userAlias.userAliasController(buffer.session.settings)
 
     def post_tweet(self, event=None):
         buffer = self.get_best_buffer()

src/controller/twitter/handler.py

@@ -1,6 +1,16 @@
 # -*- coding: utf-8 -*-
+import logging
+import widgetUtils
+import output
 from pubsub import pub
-from sessions.twitter import utils
+from tweepy.errors import TweepyException, Forbidden
+from mysc import restart
+from sessions.twitter import utils, compose
+from controller import userSelector
+from wxUI import dialogs, commonMessageDialogs
+from . import filters, lists, settings, userActions
+
+log = logging.getLogger("controller.twitter.handler")
 
 class Handler(object):
 
@@ -59,3 +69,133 @@ class Handler(object):
             pub.sendMessage("createBuffer", buffer_type="SearchBuffer", session_type=session.type, buffer_title=_(u"Search for {}").format(i), parent_tab=searches_position, start=False, kwargs=dict(parent=controller.view.nb, function="search_tweets", name="%s-searchterm" % (i,), sessionObject=session, account=session.db["user_name"], bufferType="searchPanel", sound="search_updated.ogg", q=i, include_ext_alt_text=True, tweet_mode="extended"))
         for i in session.settings["other_buffers"]["trending_topic_buffers"]:
             pub.sendMessage("createBuffer", buffer_type="TrendsBuffer", session_type=session.type, buffer_title=_("Trending topics for %s") % (i), parent_tab=root_position, start=False, kwargs=dict(parent=controller.view.nb, name="%s_tt" % (i,), sessionObject=session, account=session.db["user_name"], trendsFor=i, sound="trends_updated.ogg"))
+
+    def filter(self, buffer):
+        # Let's prevent filtering of some buffers (people buffers, direct messages, events and sent items).
+        if (buffer.name == "direct_messages" or buffer.name == "sent_tweets") or buffer.type == "people":
+            output.speak(_("Filters cannot be applied on this buffer"))
+            return
+        new_filter = filters.filter(buffer)
+
+    def manage_filters(self, session):
+        manage_filters = filters.filterManager(session)
+
+    def view_user_lists(self, buffer):
+        if not hasattr(buffer, "get_right_tweet"):
+            return
+        tweet = buffer.get_right_tweet()
+        if buffer.type == "people":
+            users = [tweet.screen_name]
+        elif buffer.type == "dm":
+            users = [buffer.session.get_user(tweet.message_create["sender_id"]).screen_name]
+        else:
+            users = utils.get_all_users(tweet, buffer.session)
+        selector = userSelector.userSelector(users=users, session_id=buffer.session.session_id)
+        user = selector.get_user()
+        if user == None:
+            return
+        l = lists.listsController(buffer.session, user=user)
+
+    def add_to_list(self, controller, buffer):
+        if not hasattr(buffer, "get_right_tweet"):
+            return
+        tweet = buffer.get_right_tweet()
+        if buffer.type == "people":
+            users = [tweet.screen_name]
+        elif buffer.type == "dm":
+            users = [buffer.session.get_user(tweet.message_create["sender_id"]).screen_name]
+        else:
+            users = utils.get_all_users(tweet, buffer.session)
+        selector = userSelector.userSelector(users=users, session_id=buffer.session.session_id)
+        user = selector.get_user()
+        if user == None:
+            return
+        dlg = dialogs.lists.addUserListDialog()
+        dlg.populate_list([compose.compose_list(item) for item in buffer.session.db["lists"]])
+        if dlg.get_response() == widgetUtils.OK:
+            try:
+                list = buffer.session.twitter.add_list_member(list_id=buffer.session.db["lists"][dlg.get_item()].id, screen_name=user)
+                older_list = utils.find_item(buffer.session.db["lists"][dlg.get_item()].id, buffer.session.db["lists"])
+                listBuffer = controller.search_buffer("%s-list" % (buffer.session.db["lists"][dlg.get_item()].name.lower()), buff.session.db["user_name"])
+                if listBuffer != None:
+                    listBuffer.get_user_ids()
+                buffer.session.db["lists"].pop(older_list)
+                buffer.session.db["lists"].append(list)
+            except TweepyException as e:
+                log.exception("error %s" % (str(e)))
+                output.speak("error %s" % (str(e)))
+
+    def remove_from_list(self, controller, buffer):
+        if not hasattr(buffer, "get_right_tweet"):
+            return
+        tweet = buffer.get_right_tweet()
+        if buffer.type == "people":
+            users = [tweet.screen_name]
+        elif buffer.type == "dm":
+            users = [buffer.session.get_user(tweet.message_create["sender_id"]).screen_name]
+        else:
+            users = utils.get_all_users(tweet, buffer.session)
+        selector = userSelector.userSelector(users=users, session_id=buffer.session.session_id)
+        user = selector.get_user()
+        if user == None:
+            return
+        dlg = dialogs.lists.removeUserListDialog()
+        dlg.populate_list([compose.compose_list(item) for item in buffer.session.db["lists"]])
+        if dlg.get_response() == widgetUtils.OK:
+            try:
+                list = buffer.session.twitter.remove_list_member(list_id=buffer.session.db["lists"][dlg.get_item()].id, screen_name=user)
+                older_list = utils.find_item(buffer.session.db["lists"][dlg.get_item()].id, buffer.session.db["lists"])
+                listBuffer = controller.search_buffer("%s-list" % (buffer.session.db["lists"][dlg.get_item()].name.lower()), buffer.session.db["user_name"])
+                if listBuffer != None:
+                    listBuffer.get_user_ids()
+                buffer.session.db["lists"].pop(older_list)
+                buffer.session.db["lists"].append(list)
+            except TweepyException as e:
+                output.speak("error %s" % (str(e)))
+                log.exception("error %s" % (str(e)))
+
+    def list_manager(self, session):
+        return lists.listsController(session=session)
+
+    def account_settings(self, buffer, controller):
+        d = settings.accountSettingsController(buffer, controller)
+        if d.response == widgetUtils.OK:
+            d.save_configuration()
+            if d.needs_restart == True:
+                commonMessageDialogs.needs_restart()
+                buffer.session.settings.write()
+                buffer.session.save_persistent_data()
+                restart.restart_program()
+
+    def follow(self, buffer):
+        if not hasattr(buffer, "get_right_tweet"):
+            return
+        tweet = buffer.get_right_tweet()
+        if buffer.type == "people":
+            users = [tweet.screen_name]
+        elif buffer.type == "dm":
+            users = [buffer.session.get_user(tweet.message_create["sender_id"]).screen_name]
+        else:
+            users = utils.get_all_users(tweet, buffer.session)
+        u = userActions.userActionsController(buffer, users)
+
+    def add_alias(self, buffer):
+        if not hasattr(buffer, "get_right_tweet"):
+            return
+        tweet = buffer.get_right_tweet()
+        if buffer.type == "people":
+            users = [tweet.screen_name]
+        elif buffer.type == "dm":
+            users = [buffer.session.get_user(tweet.message_create["sender_id"]).screen_name]
+        else:
+            users = utils.get_all_users(tweet, buffer.session)
+        dlg = dialogs.userAliasDialogs.addAliasDialog(_("Add an user alias"), users)
+        if dlg.get_response() == widgetUtils.OK:
+            user, alias = dlg.get_user()
+            if user == "" or alias == "":
+                return
+            user_id = buffer.session.get_user_by_screen_name(user)
+            buffer.session.settings["user-aliases"][str(user_id)] = alias
+            buffer.session.settings.write()
+            output.speak(_("Alias has been set correctly for {}.").format(user))
+            pub.sendMessage("alias-added")

src/controller/twitter/settings.py

@@ -0,0 +1,247 @@
+# -*- coding: utf-8 -*-
+import os
+import threading
+import logging
+import sound_lib
+import paths
+import widgetUtils
+import output
+from collections import OrderedDict
+from wxUI import commonMessageDialogs
+from extra.autocompletionUsers import scan, manage
+from extra.ocr import OCRSpace
+from controller.settings import globalSettingsController
+from . templateEditor import EditTemplate
+
+log = logging.getLogger("Settings")
+
+class accountSettingsController(globalSettingsController):
+    def __init__(self, buffer, window):
+        self.user = buffer.session.db["user_name"]
+        self.buffer = buffer
+        self.window = window
+        self.config = buffer.session.settings
+        super(accountSettingsController, self).__init__()
+
+    def create_config(self):
+        self.dialog.create_general_account()
+        widgetUtils.connect_event(self.dialog.general.userAutocompletionScan, widgetUtils.BUTTON_PRESSED, self.on_autocompletion_scan)
+        widgetUtils.connect_event(self.dialog.general.userAutocompletionManage, widgetUtils.BUTTON_PRESSED, self.on_autocompletion_manage)
+        self.dialog.set_value("general", "relative_time", self.config["general"]["relative_times"])
+        self.dialog.set_value("general", "show_screen_names", self.config["general"]["show_screen_names"])
+        self.dialog.set_value("general", "hide_emojis", self.config["general"]["hide_emojis"])
+        self.dialog.set_value("general", "itemsPerApiCall", self.config["general"]["max_tweets_per_call"])
+        self.dialog.set_value("general", "reverse_timelines", self.config["general"]["reverse_timelines"])
+        rt = self.config["general"]["retweet_mode"]
+        if rt == "ask":
+            self.dialog.set_value("general", "retweet_mode", _(u"Ask"))
+        elif rt == "direct":
+            self.dialog.set_value("general", "retweet_mode", _(u"Retweet without comments"))
+        else:
+            self.dialog.set_value("general", "retweet_mode", _(u"Retweet with comments"))
+        self.dialog.set_value("general", "persist_size", str(self.config["general"]["persist_size"]))
+        self.dialog.set_value("general", "load_cache_in_memory", self.config["general"]["load_cache_in_memory"])
+        self.dialog.create_reporting()
+        self.dialog.set_value("reporting", "speech_reporting", self.config["reporting"]["speech_reporting"])
+        self.dialog.set_value("reporting", "braille_reporting", self.config["reporting"]["braille_reporting"])
+        tweet_template = self.config["templates"]["tweet"]
+        dm_template = self.config["templates"]["dm"]
+        sent_dm_template = self.config["templates"]["dm_sent"]
+        person_template = self.config["templates"]["person"]
+        self.dialog.create_templates(tweet_template=tweet_template, dm_template=dm_template, sent_dm_template=sent_dm_template, person_template=person_template)
+        widgetUtils.connect_event(self.dialog.templates.tweet, widgetUtils.BUTTON_PRESSED, self.edit_tweet_template)
+        widgetUtils.connect_event(self.dialog.templates.dm, widgetUtils.BUTTON_PRESSED, self.edit_dm_template)
+        widgetUtils.connect_event(self.dialog.templates.sent_dm, widgetUtils.BUTTON_PRESSED, self.edit_sent_dm_template)
+        widgetUtils.connect_event(self.dialog.templates.person, widgetUtils.BUTTON_PRESSED, self.edit_person_template)
+        self.dialog.create_other_buffers()
+        buffer_values = self.get_buffers_list()
+        self.dialog.buffers.insert_buffers(buffer_values)
+        self.dialog.buffers.connect_hook_func(self.toggle_buffer_active)
+        widgetUtils.connect_event(self.dialog.buffers.toggle_state, widgetUtils.BUTTON_PRESSED, self.toggle_state)
+        widgetUtils.connect_event(self.dialog.buffers.up, widgetUtils.BUTTON_PRESSED, self.dialog.buffers.move_up)
+        widgetUtils.connect_event(self.dialog.buffers.down, widgetUtils.BUTTON_PRESSED, self.dialog.buffers.move_down)
+
+        self.dialog.create_ignored_clients(self.config["twitter"]["ignored_clients"])
+        widgetUtils.connect_event(self.dialog.ignored_clients.add, widgetUtils.BUTTON_PRESSED, self.add_ignored_client)
+        widgetUtils.connect_event(self.dialog.ignored_clients.remove, widgetUtils.BUTTON_PRESSED, self.remove_ignored_client)
+        self.input_devices = sound_lib.input.Input.get_device_names()
+        self.output_devices = sound_lib.output.Output.get_device_names()
+        self.soundpacks = []
+        [self.soundpacks.append(i) for i in os.listdir(paths.sound_path()) if os.path.isdir(os.path.join(paths.sound_path(), i)) == True ]
+        self.dialog.create_sound(self.input_devices, self.output_devices, self.soundpacks)
+        self.dialog.set_value("sound", "volumeCtrl", int(self.config["sound"]["volume"]*100))
+        self.dialog.set_value("sound", "input", self.config["sound"]["input_device"])
+        self.dialog.set_value("sound", "output", self.config["sound"]["output_device"])
+        self.dialog.set_value("sound", "session_mute", self.config["sound"]["session_mute"])
+        self.dialog.set_value("sound", "soundpack", self.config["sound"]["current_soundpack"])
+        self.dialog.set_value("sound", "indicate_audio", self.config["sound"]["indicate_audio"])
+        self.dialog.set_value("sound", "indicate_geo", self.config["sound"]["indicate_geo"])
+        self.dialog.set_value("sound", "indicate_img", self.config["sound"]["indicate_img"])
+        self.dialog.create_extras(OCRSpace.translatable_langs)
+        self.dialog.set_value("extras", "sndup_apiKey", self.config["sound"]["sndup_api_key"])
+        language_index = OCRSpace.OcrLangs.index(self.config["mysc"]["ocr_language"])
+        self.dialog.extras.ocr_lang.SetSelection(language_index)
+        self.dialog.realize()
+        self.dialog.set_title(_(u"Account settings for %s") % (self.user,))
+        self.response = self.dialog.get_response()
+
+    def edit_tweet_template(self, *args, **kwargs):
+        template = self.config["templates"]["tweet"]
+        control = EditTemplate(template=template, type="tweet")
+        result = control.run_dialog()
+        if result != "": # Template has been saved.
+            self.config["templates"]["tweet"] = result
+            self.config.write()
+            self.dialog.templates.tweet.SetLabel(_("Edit template for tweets. Current template: {}").format(result))
+
+    def edit_dm_template(self, *args, **kwargs):
+        template = self.config["templates"]["dm"]
+        control = EditTemplate(template=template, type="dm")
+        result = control.run_dialog()
+        if result != "": # Template has been saved.
+            self.config["templates"]["dm"] = result
+            self.config.write()
+            self.dialog.templates.dm.SetLabel(_("Edit template for direct messages. Current template: {}").format(result))
+
+    def edit_sent_dm_template(self, *args, **kwargs):
+        template = self.config["templates"]["dm_sent"]
+        control = EditTemplate(template=template, type="dm")
+        result = control.run_dialog()
+        if result != "": # Template has been saved.
+            self.config["templates"]["dm_sent"] = result
+            self.config.write()
+            self.dialog.templates.sent_dm.SetLabel(_("Edit template for sent direct messages. Current template: {}").format(result))
+
+    def edit_person_template(self, *args, **kwargs):
+        template = self.config["templates"]["person"]
+        control = EditTemplate(template=template, type="person")
+        result = control.run_dialog()
+        if result != "": # Template has been saved.
+            self.config["templates"]["person"] = result
+            self.config.write()
+            self.dialog.templates.person.SetLabel(_("Edit template for persons. Current template: {}").format(result))
+
+    def save_configuration(self):
+        if self.config["general"]["relative_times"] != self.dialog.get_value("general", "relative_time"):
+            self.needs_restart = True
+            log.debug("Triggered app restart due to change in relative times.")
+            self.config["general"]["relative_times"] = self.dialog.get_value("general", "relative_time")
+        self.config["general"]["show_screen_names"] = self.dialog.get_value("general", "show_screen_names")
+        self.config["general"]["hide_emojis"] = self.dialog.get_value("general", "hide_emojis")
+        self.config["general"]["max_tweets_per_call"] = self.dialog.get_value("general", "itemsPerApiCall")
+        if self.config["general"]["load_cache_in_memory"] != self.dialog.get_value("general", "load_cache_in_memory"):
+            self.config["general"]["load_cache_in_memory"] = self.dialog.get_value("general", "load_cache_in_memory")
+            self.needs_restart = True
+            log.debug("Triggered app restart due to change in database strategy management.")
+        if self.config["general"]["persist_size"] != self.dialog.get_value("general", "persist_size"):
+            if self.dialog.get_value("general", "persist_size") == '':
+                self.config["general"]["persist_size"] =-1
+            else:
+                try:
+                    self.config["general"]["persist_size"] = int(self.dialog.get_value("general", "persist_size"))
+                except ValueError:
+                    output.speak("Invalid cache size, setting to default.",True)
+                    self.config["general"]["persist_size"] =1764
+
+        if self.config["general"]["reverse_timelines"] != self.dialog.get_value("general", "reverse_timelines"):
+            self.needs_restart = True
+            log.debug("Triggered app restart due to change in timeline order.")
+            self.config["general"]["reverse_timelines"] = self.dialog.get_value("general", "reverse_timelines")
+        rt = self.dialog.get_value("general", "retweet_mode")
+        if rt == _(u"Ask"):
+            self.config["general"]["retweet_mode"] = "ask"
+        elif rt == _(u"Retweet without comments"):
+            self.config["general"]["retweet_mode"] = "direct"
+        else:
+            self.config["general"]["retweet_mode"] = "comment"
+        buffers_list = self.dialog.buffers.get_list()
+        if buffers_list != self.config["general"]["buffer_order"]:
+            self.needs_restart = True
+            log.debug("Triggered app restart due to change in buffer ordering.")
+            self.config["general"]["buffer_order"] = buffers_list
+        self.config["reporting"]["speech_reporting"] = self.dialog.get_value("reporting", "speech_reporting")
+        self.config["reporting"]["braille_reporting"] = self.dialog.get_value("reporting", "braille_reporting")
+        self.config["mysc"]["ocr_language"] = OCRSpace.OcrLangs[self.dialog.extras.ocr_lang.GetSelection()]
+        if self.config["sound"]["input_device"] != self.dialog.sound.get("input"):
+            self.config["sound"]["input_device"] = self.dialog.sound.get("input")
+            try:
+                self.buffer.session.sound.input.set_device(self.buffer.session.sound.input.find_device_by_name(self.config["sound"]["input_device"]))
+            except:
+                self.config["sound"]["input_device"] = "default"
+        if self.config["sound"]["output_device"] != self.dialog.sound.get("output"):
+            self.config["sound"]["output_device"] = self.dialog.sound.get("output")
+            try:
+                self.buffer.session.sound.output.set_device(self.buffer.session.sound.output.find_device_by_name(self.config["sound"]["output_device"]))
+            except:
+                self.config["sound"]["output_device"] = "default"
+        self.config["sound"]["volume"] = self.dialog.get_value("sound", "volumeCtrl")/100.0
+        self.config["sound"]["session_mute"] = self.dialog.get_value("sound", "session_mute")
+        self.config["sound"]["current_soundpack"] = self.dialog.sound.get("soundpack")
+        self.config["sound"]["indicate_audio"] = self.dialog.get_value("sound", "indicate_audio")
+        self.config["sound"]["indicate_geo"] = self.dialog.get_value("sound", "indicate_geo")
+        self.config["sound"]["indicate_img"] = self.dialog.get_value("sound", "indicate_img")
+        self.config["sound"]["sndup_api_key"] = self.dialog.get_value("extras", "sndup_apiKey")
+        self.buffer.session.sound.config = self.config["sound"]
+        self.buffer.session.sound.check_soundpack()
+        self.config.write()
+
+    def toggle_state(self,*args,**kwargs):
+        return self.dialog.buffers.change_selected_item()
+
+    def on_autocompletion_scan(self, *args, **kwargs):
+        configuration = scan.autocompletionScan(self.buffer.session.settings, self.buffer, self.window)
+        to_scan = configuration.show_dialog()
+        if to_scan == True:
+            configuration.prepare_progress_dialog()
+            t = threading.Thread(target=configuration.scan)
+            t.start()
+
+
+
+    def on_autocompletion_manage(self, *args, **kwargs):
+        configuration = manage.autocompletionManage(self.buffer.session)
+        configuration.show_settings()
+
+    def add_ignored_client(self, *args, **kwargs):
+        client = commonMessageDialogs.get_ignored_client()
+        if client == None: return
+        if client not in self.config["twitter"]["ignored_clients"]:
+            self.config["twitter"]["ignored_clients"].append(client)
+            self.dialog.ignored_clients.append(client)
+
+    def remove_ignored_client(self, *args, **kwargs):
+        if self.dialog.ignored_clients.get_clients() == 0: return
+        id = self.dialog.ignored_clients.get_client_id()
+        self.config["twitter"]["ignored_clients"].pop(id)
+        self.dialog.ignored_clients.remove_(id)
+
+    def get_buffers_list(self):
+        all_buffers=OrderedDict()
+        all_buffers['home']=_(u"Home")
+        all_buffers['mentions']=_(u"Mentions")
+        all_buffers['dm']=_(u"Direct Messages")
+        all_buffers['sent_dm']=_(u"Sent direct messages")
+        all_buffers['sent_tweets']=_(u"Sent tweets")
+        all_buffers['favorites']=_(u"Likes")
+        all_buffers['followers']=_(u"Followers")
+        all_buffers['friends']=_(u"Friends")
+        all_buffers['blocks']=_(u"Blocked users")
+        all_buffers['muted']=_(u"Muted users")
+        list_buffers = []
+        hidden_buffers=[]
+        all_buffers_keys = list(all_buffers.keys())
+        # Check buffers shown first.
+        for i in self.config["general"]["buffer_order"]:
+            if i in all_buffers_keys:
+                list_buffers.append((i, all_buffers[i], True))
+            # This second pass will retrieve all hidden buffers.
+        for i in all_buffers_keys:
+            if i not in self.config["general"]["buffer_order"]:
+                hidden_buffers.append((i, all_buffers[i], False))
+        list_buffers.extend(hidden_buffers)
+        return list_buffers
+
+    def toggle_buffer_active(self, ev):
+        change = self.dialog.buffers.get_event(ev)
+        if change == True:
+            self.dialog.buffers.change_selected_item()