Include mastodon default config file on builds

Initial Mastodon Support

.gitlab-ci.yml

@@ -1,6 +1,6 @@
 variables:
   GIT_SUBMODULE_STRATEGY: recursive
-  PYTHON: "C:\\python37\\python.exe"
+  PYTHON: "C:\\python310\\python.exe"
   NSIS: "C:\\program files (x86)\\nsis\\makensis.exe"
 
 stages:
@@ -17,9 +17,10 @@ twblue32:
     - Set-Variable -Name "time" -Value (date -Format "%H:%m")
     - echo ${time}
     - echo "started by ${GITLAB_USER_NAME}"
-    - choco install python --version 3.7.9 -y -ForceX86
+    - choco install python --version 3.10.8 -y -ForceX86
     - '&$env:PYTHON -V'
     - '&$env:PYTHON -m pip install --upgrade pip'
+    - '&$env:PYTHON -m pip install --upgrade https://github.com/josephsl/wxpy32whl/blob/main/wxPython-4.2.0-cp310-cp310-win32.whl?raw=true'
     - '&$env:PYTHON -m pip install --upgrade -r requirements.txt'
   stage: build
   interruptible: true
@@ -30,6 +31,7 @@ twblue32:
     - cd ..\src
     - '&$env:PYTHON ..\doc\generator.py'
     - '&$env:PYTHON write_version_data.py'
+    - New-Item "appkeys.py" -ItemType File -Value "twitter_api_key='$TWITTER_API_KEY'`ntwitter_api_secret='$TWITTER_API_SECRET'"
     - '&$env:PYTHON setup.py build'
     - cd ..
     - mkdir artifacts
@@ -56,7 +58,7 @@ twblue64:
     - Set-Variable -Name "time" -Value (date -Format "%H:%m")
     - echo ${time}
     - echo "started by ${GITLAB_USER_NAME}"
-    - choco install python --version 3.7.9 -y
+    - choco install python --version 3.10.8 -y
     - '&$env:PYTHON -V'
     - '&$env:PYTHON -m pip install --upgrade pip'
     - '&$env:PYTHON -m pip install --upgrade -r requirements.txt'
@@ -69,6 +71,7 @@ twblue64:
     - cd ..\src
     - '&$env:PYTHON ..\doc\generator.py'
     - '&$env:PYTHON write_version_data.py'
+    - New-Item "appkeys.py" -ItemType File -Value "twitter_api_key='$TWITTER_API_KEY'`ntwitter_api_secret='$TWITTER_API_SECRET'"
     - '&$env:PYTHON setup.py build'
     - cd ..
     - mkdir artifacts

README.md

@@ -21,6 +21,15 @@ See [TWBlue's webpage](http://twblue.es) for more details.
 
 This document describes how to run tw blue from source and how to build a binary version which doesn't need Python and the other dependencies to run.
 
+### Generating application keys
+
+In order to communicate with Twitter, you will need to generate a set of API keys in their [developer portal](https://developer.twitter.com/en/portal/dashboard) (If you haven't signed up, [visit this site to register as a developer](https://developer.twitter.com/en/docs/twitter-api/getting-started/getting-access-to-the-twitter-api)) and create a module called appkeys.py, within the src directory, with the following content, replacing the example values with your set of API keys:
+
+```
+twitter_api_key='xxxxxxxxxx'
+twitter_api_secret='xxxxxxxxxx'
+```
+
 ### Required dependencies.
 
 Although most dependencies can be found in the windows-dependencies directory, we provide links to their official websites. If you are cloning with git, don't forget to initialize and update the submodules to get the windows-dependencies folder. You can use these two commands to perform this task from git bash:  
@@ -31,18 +40,22 @@ Although most dependencies can be found in the windows-dependencies directory, w
 
 #### Dependencies packaged in windows installers
 
-* [Python,](https://python.org) version 3.7.9  
-If you want to build both x86 and x64 binaries, you can install python x86 to C:\python38 and python x64 to C:\python38x64, for example.
+* [Python,](https://python.org) version 3.10.8  
+If you want to build both x86 and x64 binaries, you can install python x64 to C:\python310 and python x86 to C:\python310-32, for example.
 
 #### Dependencies that must be installed using pip
 
 Python installs a tool called Pip that allows to install packages in a simple way. You can find it in the python scripts directory. To install packages using Pip, you have to navigate to the scripts directory using a command prompt, for example:
 
-    `cd C:\python37x64\scripts`
+    `cd C:\python310\scripts`
 
 	You can also add the scripts folder to your path environment variable or choose the corresponding option when installing Python.  
 	Note: pip and setuptools are included in the Python installer since version 2.7.9.
 
+Note: If you are using Python for 32-bit systems, you will need to install WXPython for 32-bits before running the command for installing everything else. You can do so by running the following command:
+
+    `pip install --upgrade https://github.com/josephsl/wxpy32whl/blob/main/wxPython-4.2.0-cp310-cp310-win32.whl?raw=true`
+
 Pip is able to install packages listed in a special text file, called the requirements file. To install all remaining dependencies, perform the following command:
 
     `pip install -r requirements.txt`

contributors.txt

@@ -39,5 +39,5 @@ florian Ionașcu
 Christian Leo Mameli
 Natalia Hedlund (Наталья Хедлунд)
 Valeria (Валерия)
-Oreonan
+Corentin Bacqué-Cazenave
 Artem Plaksin (maniyax)

doc/changelog.md

@@ -2,6 +2,76 @@ TWBlue Changelog
 
 ## changes in this version
 
+Most of all changes in this release are focused on adding Mastodon support to TWBlue. The features present to handle Twitter should not have been altered in any way. We were not intended to release this version so soon, but unfortunately, Twitter started to present issues in some regions with one particular API endpoint we were using, making impossible for everyone in such regions to use the application. We will release more updates to fix any possible issue regarding Twitter API, but please take into account that this is sometimes an issue happening in Twitter's servers and while we do our best to make TWBlue work despite those problems, you might encounter glitches from time to time.
+
+* TWBlue now builds with Python 3.10.8. ([#493](https://github.com/MCV-Software/TWBlue/issues/493))
+    * This change also drops support for Windows 7.
+* The TWBlue interface has not been translated yet, as we are releasing this update to fix an important Twitter issue for some regions.
+* Twitter sessions should be able to be opened properly again in TWBlue, in regions where it didn't work since last week.
+* It is now possible to log in to instances of mastodon, hometown and similar software (Pleroma should work as well, although it has not been tested at this time). From the session manager, clicking on the “new account” button will bring up a menu from which you can select whether you want to log in to Twitter or Mastodon. For instances that have a different character limit than the one set by Mastodon, TWBlue will detect the new limit and adjust the dialogs to allow you to use it correctly.
+* Most of the TWBlue GUI has been adapted so that the buffers reflect the change of social network (in mastodon, for example, the buttons to write posts say post instead of tweet). However, the menu bar has not yet been updated. This means that most of the options still refer to Twitter, although they can be used with mastodon accounts. For example, if you select the “tweet” menu in the menu bar, and then select the “Retweet” option, TWBlue will actually do a “boost” if the buffer you are in is a Mastodon account buffer.
+* Keystrokes for the invisible interface also refer to terms used in Twitter, but can be applied to Mastodon as well.
+* There are some features, within TWBlue, that are not yet compatible with mastodon accounts. These are as follows:
+    * User autocompletion.
+    * Currently, it is not possible to update account settings for mastodon sessions. However, if you know how to edit configuration files, you can close TWBlue, change your session file with any text editor and restart the application to update what you want.
+    * The template editor is not yet available for mastodon accounts.
+    * Filters have not yet been implemented in TWBlue mastodon support.
+    * User aliases are not implemented yet.
+    * It is not possible to view a user’s profile, nor edit your own, for now. However, you can use the keystroke to open the item in the browser when focusing a user to access their profile website. This only works in buffers where users are listed.
+    * You cannot manage lists in TWBlue at the moment.
+* Most of the buffers planned for mastodon should just work. Among those currently tested are: home (main timeline for the logged-in user), Local (public posts for the instance), federated (public posts for all federating instances), mentions, direct messages, sent posts, favorites, bookmarks, followers, following, blocked users, muted users, user searches and timelines for users.
+    *  The difference between favorites and bookmarks is that the author of the post can see who has marked his posts as favorites, but bookmarks are completely private. In any buffer containing mastodon posts, except direct messages, the GUI will display an option to add the post to favorites or bookmarks.
+    * Direct messages in mastodon are posts, exactly like normal posts, but with their privacy setting set so that they can only be seen by the accounts that are mentioned. In the direct message buffer, a conversation will appear for each item in the buffer. The conversation represents a thread of messages, but TWBlue can only display the last of the messages sent. This is similar to what happens on platforms like Telegram, where you can only see the list of conversations at the beginning. To see the entire thread of direct messages present in a conversation, you can use the command to open the conversation, or go to the “tweet” menu in the menu bar, and then towards the “view conversation” option. This will create a new conversation buffer that will be located just after the direct messages buffer (for the GUI, the buffer will be located just inside the direct messages buffer in the buffer tree). When a private post appears (whose visibility only allows the mentioned accounts to see it), TWBlue will display that post in the home buffer, in mentions and also will update/create the conversation with that item. This is because Mastodon does not differentiate between a private message and a normal post. You can reply to the post in any buffer to continue the conversation. If you reply to any post, the privacy set in the original post is maintained by default, but can also be changed.
+    * The buffer showing the federated timeline has been disabled from settings. This is because on servers that federate with many instances it can load many posts in a very short time. To enable this buffer, for now, edit the TWBlue configuration while the application is closed, and add the “federated” buffer in the option called “buffer_order”. As soon as buffers can be shown or hidden, this process can be done through the GUI.
+    * There is a Streaming API that allows the elements for the start buffers, mentions, direct messages, sent posts and followers to appear in real time. This feature is implemented by default and should also just work.
+    * Timelines for users only allow to get all posts from users who are in the same instance. For users belonging to other instances, you can get the posts that have been downloaded to your instance since your instance “knows” the remote user.
+    * Timelines for followers and following can be fully retrieved only for users belonging to the same instance. Remote users may yield unclear results.
+    * You can search by users (by opening a search and selecting the “users” radio button). The search can be done by local users, such as twblue, or by remote users, such as @twblue@maaw.social.
+* In all buffers, a maximum of 40 items are retrieved per load, but more can be retrieved by using the option to load more items in the buffer.
+* In post buffers, you can do most of the actions already supported in TWBlue (boost, add/remove from favorites or bookmarks, reply, send message to user, open post URL, play audio or video, open post on web, view conversation, open action dialog for user).
+* In user buffers, you can send private message to the user, and open user actions dialog, which in turn allows you to follow/unfollow, block/unblock and mute/unmute.
+* When writing posts, it is possible to attach up to 4 images, 4 givs, or even a video, poll, or audio. It is also possible to add the “sensitive content” tag to posts, change privacy and write a content warning text. It is possible to create threads using the “add post” button.
+* When replying to a post, TWBlue will place the username of all participants in the item you reply to. The privacy options will default to those of the original post.
+
+## Changes in version 2022.8.28
+
+* the user autocompletion feature has been completely rewritten to be easier to use, particularly for people with many followers/following users:
+    * In the account settings dialog, there's a button that opens up a new dialog that allows you to "scan" your account in order to add all users from your followers/following list. This process will read your data directly from Twitter and depending in the amount of people you have in your account it might take too many API calls. Please use it with caution. You can, for example, do the process separately for your followers/following people so it will be easier to handle, in case you have a massive amount of people. If TWBlue is unable to complete the scan, you will see an error and will be prompted to try again in 15 minutes, once your API calls have refreshed.
+    * It is possible to use the user autocompletion functionality in dialogs where you can select an user, for example when adding or removing someone from a list, or displaying lists for someone.
+* Implemented a new setting, available in the account settings dialog, that allows to hide emojis in twitter usernames.
+* TWBlue should be able to sort conversations in a more logical way. This should make it easier to follow a long thread in Twitter.
+* When opening a thread, TWBlue should be able to load the right conversation if the original tweet from where the thread was loaded was a retweet.
+* TWBlue will restart the Streaming subsystem every time there are changes to followed, muted or blocked users within the application.
+* Fixed error when attempting to mention an user by using the "mention" button in any people buffer. Now tweets should be posted normally.
+* Fixed error when loading other user lists. ([#465](https://github.com/MCV-Software/TWBlue/issues/465))
+* Fixed an issue that was making TWBlue to display incorrectly some retweets of quoted tweets.
+* If TWBlue is unable to open a timeline for someone who has blocked you, this will be reported in a dialog. ([#485,](https://github.com/mcv-software/twblue/issues/485))
+* Added "find a string in the currently focused buffer" action into Windows 10 and windows 11 keymap. ([#476](https://github.com/MCV-Software/TWBlue/pull/476))
+
+## changes in version 22.2.23
+
+* We have added Experimental support for templates in the invisible interface. The GUI will remain unchanged for now:
+    * Each object (tweet, received direct message, sent direct message and people) has its own template in the settings. You can edit those templates from the account settings dialog, in the new "templates" tab.
+    * Every template is composed of the group of variables you want to display for each object. Each variable will start with a dollar sign ($) and cannot contain spaces or special characters. Templates can include arbitrary text that will not be processed. When editing the example templates, you can get an idea of the variables that are available for each object by using the template editing dialog. When you press enter on a variable from the list of available variables, it will be added to the template automatically. When you try to save a template, TWBlue will warn you if the template is incorrectly formatted or if it includes variables that do not exist in the information provided by objects. It is also possible to return to default values from the same dialog when editing a template.
+    * TWBlue can display image descriptions within Tweet templates. For that, you can use the $image_description variable in your template.
+* We have restored conversation and threads support powered by Twitter API V2 thanks to a set of improvements we have done in the application, as well as more generous limits to Tweet monthly cap by Twitter.
+* In the Windows 11 Keymap, the default shortcut to open the keystrokes editor is now CTRL+Alt+Windows+K to avoid conflicts with the new global mute microphone shortcut.
+* TWBlue show display properly HTML entities in tweet's text.
+* TWBlue should no longer load old tweets in buffers.
+* Fixed issue when uploading attachments (images, videos or gif files) while sending tweets or replies.
+* Fixed an error that was making TWBlue to ask for a restart after saving account settings, even if such restart was not required. ([#413,](https://github.com/manuelcortez/TWBlue/issues/413))
+
+## Changes in version 2021.11.12
+
+* Now it is possible to create a tweet from a trending topics buffer again.
+* TWBlue now includes a completely new set of dialogs to handle tweeting, replying and sending direct messages that takes advantage of more Twitter features.
+    * It is possible to add videos in tweets and direct messages by using the new "add" button, located in every dialog where  media can be added. Twitter suggests to add videos from 5 seconds up to 2 minutes lenght, in mp4 format (video Codec H.264 and audio codec AAC). Currently, TWBlue does not check if the uploaded video complies with Twitter media requirements. You can add only a video in a tweet or direct message. No other kind of media can be added after a video is in a tweet. If the video was unable to be uploaded successfully, the tweet or direct message won't be created.
+    * Now you can add a poll to tweets. Polls can have up to 4 different options and allow voting up to 7 days after being created. Take into account, though, that currently TWBlue does not support reading polls in tweets.
+    * TWBlue now support threads while creating a new tweet. There is a new button, called add tweet which will add the current tweet to the thread and will allow you to write another tweet in the thread. Every tweet might include media (up to 4 photos, or one GIF image or a video) or up to one poll.
+    * Some functionality was removed from tweet dialogs within TWBlue. Particularly, URL shorteners and long tweets via Twishort. You still can read long tweets posted via Twishort, though.
+
+## Changes in version 2021.11.07
+
 * TWBlue should retrieve tweets from threads and conversations in a more reliable way. Tweets in the same thread (made by the same author) will be sorted correctly, although replies to the thread (made by different people) may not be ordered in the same way they are displayed in Twitter apps. ([#417](https://github.com/manuelcortez/TWBlue/issues/417))
 * When creating a filter, TWBlue will show an error if user has not provided a name for the filter. Before, unnamed filters were a cause of config breaks in the application.
 * It is again possible to read the changelog for TWBlue from the help menu in the menu bar.

requirements.txt

@@ -1,9 +1,10 @@
 wxpython
+pytest
+coverage
 wheel
-six
+future
 configobj
 markdown
-future
 requests
 oauthlib
 requests-oauthlib
@@ -12,7 +13,6 @@ pypubsub
 geopy
 arrow
 python-dateutil
-futures
 winpaths
 PySocks
 win_inet_pton
@@ -31,6 +31,7 @@ backports.functools_lru_cache
 cx_freeze
 tweepy
 twitter-text-parser
+mastodon.py
 pyenchant
 sqlitedict
 cx-Logging
@@ -48,6 +49,7 @@ importlib-metadata
 numpy
 pillow
 charset-normalizer
+demoji
 git+https://github.com/accessibleapps/libloader
 git+https://github.com/accessibleapps/platform_utils
 git+https://github.com/accessibleapps/accessible_output2

scripts/twblue.nsi

@@ -14,7 +14,7 @@ SetCompress auto
 SetCompressor /solid lzma
 SetDatablockOptimize on
 VIAddVersionKey ProductName "TWBlue"
-VIAddVersionKey LegalCopyright "Copyright 2014-2021 Manuel Cortéz."
+VIAddVersionKey LegalCopyright "Copyright 2014-2022 MCV Software."
 VIAddVersionKey ProductVersion "0.95.0"
 VIAddVersionKey FileVersion "0.95.0"
 VIProductVersion "0.95.0"

src/Conf.defaults

@@ -14,7 +14,8 @@ retweet_mode = string(default="ask")
 persist_size = integer(default=0)
 load_cache_in_memory=boolean(default=True)
 show_screen_names = boolean(default=False)
-buffer_order = list(default=list('home','mentions', 'dm', 'sent_dm', 'sent_tweets','favorites','followers','friends','blocks','muted','events'))
+hide_emojis = boolean(default=False)
+buffer_order = list(default=list('home','mentions', 'dm', 'sent_dm', 'sent_tweets','favorites','followers','friends','blocks','muted'))
 
 [sound]
 volume = float(default=1.0)
@@ -48,6 +49,12 @@ ocr_language = string(default="")
 braille_reporting = boolean(default=True)
 speech_reporting = boolean(default=True)
 
+[templates]
+tweet = string(default="$display_name, $text $image_descriptions $date. $source")
+dm = string(default="$sender_display_name, $text $date")
+dm_sent = string(default="Dm to $recipient_display_name, $text $date")
+person = string(default="$display_name (@$screen_name). $followers followers, $following following, $tweets tweets. Joined Twitter $created_at.")
+
 [filters]
 
 [user-aliases]

src/application.py

@@ -1,16 +1,14 @@
 # -*- coding: utf-8 -*-
-import datetime
-
 name = 'TWBlue'
 short_name='twblue'
 update_url = 'https://twblue.es/updates/updates.php'
 mirror_update_url = 'https://raw.githubusercontent.com/manuelcortez/TWBlue/next-gen/updates/updates.json'
 authors = ["Manuel Cortéz", "José Manuel Delicado"]
 authorEmail = "manuel@manuelcortez.net"
-copyright = "Copyright (C) 2013-2021, Manuel cortéz."
+copyright = "Copyright (C) 2013-2022, MCV Software."
 description = name+" is an app designed to use Twitter simply and efficiently while using minimal system resources. This app provides access to most Twitter  features."
-translators = ["Manuel Cortéz (English)", "Mohammed Al Shara, Hatoun Felemban (Arabic)", "Francisco Torres (Catalan)", "Manuel cortéz (Spanish)", "Sukil Etxenike Arizaleta (Basque)", "Jani Kinnunen (finnish)", "Oreonan (Français)", "Juan Buño (Galician)", "Steffen Schultz (German)", "Zvonimir Stanečić (Croatian)", "Robert Osztolykan (Hungarian)", "Christian Leo Mameli (Italian)", "Riku (Japanese)", "Paweł Masarczyk (Polish)", "Odenilton Júnior Santos (Portuguese)", "Florian Ionașcu, Nicușor Untilă (Romanian)", "Natalia Hedlund, Valeria Kuznetsova (Russian)", "Aleksandar Đurić (Serbian)", "Burak Yüksek (Turkish)"]
-url = u"https://twblue.es"
-report_bugs_url = "https://github.com/manuelcortez/twblue/issues"
+translators = ["Manuel Cortéz (English)", "Mohammed Al Shara, Hatoun Felemban (Arabic)", "Francisco Torres (Catalan)", "Manuel cortéz (Spanish)", "Sukil Etxenike Arizaleta (Basque)", "Jani Kinnunen (finnish)", "Corentin Bacqué-Cazenave (Français)", "Juan Buño (Galician)", "Steffen Schultz (German)", "Zvonimir Stanečić (Croatian)", "Robert Osztolykan (Hungarian)", "Christian Leo Mameli (Italian)", "Riku (Japanese)", "Paweł Masarczyk (Polish)", "Odenilton Júnior Santos (Portuguese)", "Florian Ionașcu, Nicușor Untilă (Romanian)", "Natalia Hedlund, Valeria Kuznetsova (Russian)", "Aleksandar Đurić (Serbian)", "Burak Yüksek (Turkish)"]
+url = "https://twblue.es"
+report_bugs_url = "https://github.com/mcvsoftware/twblue/issues"
 supported_languages = []
 version = "11"

src/config_utils.py

@@ -4,6 +4,7 @@ from validate import Validator, ValidateError
 import os
 import string
 from logging import getLogger
+from wxUI import commonMessageDialogs
 log = getLogger("config_utils")
 
 class ConfigLoadError(Exception): pass
@@ -21,6 +22,7 @@ def load_config(config_path, configspec_path=None, copy=True, *args, **kwargs):
         return config
     else:
         log.exception("Error in config file: {0}".format(validated,))
+        commonMessageDialogs.invalid_configuration()
 
 def is_blank(arg):
     "Check if a line is blank."

src/controller/attach.py

@@ -1,40 +0,0 @@
-# -*- coding: utf-8 -*-
-from __future__ import unicode_literals
-from builtins import object
-import os
-import widgetUtils
-import logging
-from wxUI.dialogs import attach as gui
-log = logging.getLogger("controller.attach")
-
-class attach(object):
-    def __init__(self):
-        self.attachments = list()
-        self.dialog = gui.attachDialog()
-        widgetUtils.connect_event(self.dialog.photo, widgetUtils.BUTTON_PRESSED, self.upload_image)
-        widgetUtils.connect_event(self.dialog.remove, widgetUtils.BUTTON_PRESSED, self.remove_attachment)
-        self.dialog.get_response()
-        log.debug("Attachments controller started.")
-
-    def upload_image(self, *args, **kwargs):
-        image, description  = self.dialog.get_image()
-        if image != None:
-            imageInfo = {"type": "photo", "file": image, "description": description}
-            log.debug("Image data to upload: %r" % (imageInfo,))
-            self.attachments.append(imageInfo)
-            info = [_(u"Photo"), description]
-            self.dialog.attachments.insert_item(False, *info)
-            self.dialog.remove.Enable(True)
-
-    def remove_attachment(self, *args, **kwargs):
-        current_item = self.dialog.attachments.get_selected()
-        log.debug("Removing item %d" % (current_item,))
-        if current_item == -1: current_item = 0
-        self.attachments.pop(current_item)
-        self.dialog.attachments.remove_item(current_item)
-        self.check_remove_status()
-        log.debug("Removed")
-
-    def check_remove_status(self):
-        if len(self.attachments) == 0 and self.dialog.attachments.get_count() == 0:
-            self.dialog.remove.Enable(False)

src/controller/buffers/__init__.py

@@ -1,3 +1,4 @@
 # -*- coding: utf-8 -*-
 from . import base as base
-from . import twitter as twitter
+from . import twitter as twitter
+from . import mastodon as mastodon

src/controller/buffers/base/base.py

@@ -125,6 +125,9 @@ class Buffer(object):
     def share_item(self):
         pass
 
+    def can_share(self):
+        pass
+
     def destroy_status(self):
         pass
 
@@ -135,4 +138,7 @@ class Buffer(object):
         try:
             self.session.db[self.name+"_pos"]=self.buffer.list.get_selected()
         except AttributeError:
-            pass
+            pass
+
+    def view_item(self):
+        pass

src/controller/buffers/mastodon/__init__.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+from .base import BaseBuffer
+from .mentions import MentionsBuffer
+from .conversations import ConversationBuffer, ConversationListBuffer
+from .users import UserBuffer

src/controller/buffers/mastodon/base.py

@@ -0,0 +1,498 @@
+# -*- coding: utf-8 -*-
+import time
+import wx
+import widgetUtils
+import arrow
+import webbrowser
+import output
+import config
+import sound
+import languageHandler
+import logging
+from audio_services import youtube_utils
+from controller.buffers.base import base
+from controller.mastodon import messages
+from sessions.mastodon import compose, utils, templates
+from mysc.thread_utils import call_threaded
+from pubsub import pub
+from extra import ocr
+from wxUI import buffers, dialogs, commonMessageDialogs
+from wxUI.dialogs.mastodon import menus
+from wxUI.dialogs.mastodon import dialogs as mastodon_dialogs
+
+log = logging.getLogger("controller.buffers.mastodon.base")
+
+class BaseBuffer(base.Buffer):
+    def __init__(self, parent, function, name, sessionObject, account, sound=None, compose_func="compose_post", *args, **kwargs):
+        super(BaseBuffer, self).__init__(parent, function, *args, **kwargs)
+        log.debug("Initializing buffer %s, account %s" % (name, account,))
+        self.create_buffer(parent, name)
+        self.invisible = True
+        self.name = name
+        self.type = self.buffer.type
+        self.session = sessionObject
+        self.compose_function = getattr(compose, compose_func)
+        log.debug("Compose_function: %s" % (self.compose_function,))
+        self.account = account
+        self.buffer.account = account
+        self.bind_events()
+        self.sound = sound
+        if "-timeline" in self.name or "-followers" in self.name or "-following" in self.name:
+            self.finished_timeline = False
+
+    def create_buffer(self, parent, name):
+        self.buffer = buffers.mastodon.basePanel(parent, name)
+
+    def get_buffer_name(self):
+        """ Get buffer name from a set of different techniques."""
+        # firstly let's take the easier buffers.
+        basic_buffers = dict(home_timeline=_("Home"), local_timeline=_("Local"), federated_timeline=_("Federated"), mentions=_("Mentions"), bookmarks=_("Bookmarks"), direct_messages=_("Direct messages"),  sent=_("Sent"), favorites=_("Favorites"), followers=_("Followers"), following=_("Following"), blocked=_("Blocked users"), muted=_("Muted users"), notifications=_("Notifications"))
+        if self.name in list(basic_buffers.keys()):
+            return basic_buffers[self.name]
+        # Check user timelines
+        elif hasattr(self, "username"):
+            if "-timeline" in self.name:
+                return _(u"{username}'s timeline").format(username=self.username,)
+            elif "-followers" in self.name:
+                return _(u"{username}'s followers").format(username=self.username,)
+            elif "-following" in self.name:
+                return _(u"{username}'s following").format(username=self.username,)
+        log.error("Error getting name for buffer %s" % (self.name,))
+        return _(u"Unknown buffer")
+
+    def post_status(self, *args, **kwargs):
+        title = _("Post")
+        caption = _("Write your post here")
+        post = messages.post(session=self.session, title=title, caption=caption)
+        response = post.message.ShowModal()
+        if response == wx.ID_OK:
+            post_data = post.get_data()
+            call_threaded(self.session.send_post, posts=post_data, visibility=post.get_visibility(), **kwargs)
+        if hasattr(post.message, "destroy"):
+            post.message.destroy()
+
+    def get_formatted_message(self):
+        return self.compose_function(self.get_item(), self.session.db, self.session.settings["general"]["relative_times"], self.session.settings["general"]["show_screen_names"])[1]
+
+    def get_message(self):
+        post = self.get_item()
+        if post == None:
+            return
+        template = self.session.settings["templates"]["post"]
+
+        t = templates.render_post(post, template, relative_times=self.session.settings["general"]["relative_times"], offset_hours=self.session.db["utc_offset"])
+        return t
+
+    def start_stream(self, mandatory=False, play_sound=True, avoid_autoreading=False):
+        current_time = time.time()
+        if self.execution_time == 0 or current_time-self.execution_time >= 180 or mandatory==True:
+            self.execution_time = current_time
+            log.debug("Starting stream for buffer %s, account %s and type %s" % (self.name, self.account, self.type))
+            log.debug("args: %s, kwargs: %s" % (self.args, self.kwargs))
+            count = self.session.settings["general"]["max_posts_per_call"]
+            min_id = None
+            # toDo: Implement reverse timelines properly here.
+            if (self.name != "favorites" and self.name != "bookmarks") and self.name in self.session.db and len(self.session.db[self.name]) > 0:
+                min_id = self.session.db[self.name][-1].id
+            try:
+                results = getattr(self.session.api, self.function)(min_id=min_id, limit=count, *self.args, **self.kwargs)
+                results.reverse()
+            except Exception as e:
+                log.exception("Error %s" % (str(e)))
+                return
+            number_of_items = self.session.order_buffer(self.name, results)
+            log.debug("Number of items retrieved: %d" % (number_of_items,))
+            if hasattr(self, "finished_timeline") and self.finished_timeline == False:
+                if "-timeline" in self.name:
+                    self.username = self.session.db[self.name][0]["account"].username
+                self.finished_timeline = True
+            self.put_items_on_list(number_of_items)
+            if number_of_items > 0 and  self.name != "sent_posts" and self.name != "sent_direct_messages" and self.sound != None and self.session.settings["sound"]["session_mute"] == False and self.name not in self.session.settings["other_buffers"]["muted_buffers"] and play_sound == True:
+                self.session.sound.play(self.sound)
+            # Autoread settings
+            if avoid_autoreading == False and mandatory == True and number_of_items > 0 and self.name in self.session.settings["other_buffers"]["autoread_buffers"]:
+                self.auto_read(number_of_items)
+            return number_of_items
+
+    def auto_read(self, number_of_items):
+        if number_of_items == 1 and self.name in self.session.settings["other_buffers"]["autoread_buffers"] and self.name not in self.session.settings["other_buffers"]["muted_buffers"] and self.session.settings["sound"]["session_mute"] == False:
+            if self.session.settings["general"]["reverse_timelines"] == False:
+                post = self.session.db[self.name][-1]
+            else:
+                post = self.session.db[self.name][0]
+            output.speak(_("New post in {0}").format(self.get_buffer_name()))
+            output.speak(" ".join(self.compose_function(post, self.session.db, self.session.settings["general"]["relative_times"], self.session.settings["general"]["show_screen_names"])))
+        elif number_of_items > 1 and self.name in self.session.settings["other_buffers"]["autoread_buffers"] and self.name not in self.session.settings["other_buffers"]["muted_buffers"] and self.session.settings["sound"]["session_mute"] == False:
+            output.speak(_("{0} new posts in {1}.").format(number_of_items, self.get_buffer_name()))
+
+    def get_more_items(self):
+        elements = []
+        if self.session.settings["general"]["reverse_timelines"] == False:
+            max_id = self.session.db[self.name][0].id
+        else:
+            max_id = self.session.db[self.name][-1].id
+        try:
+            items = getattr(self.session.api, self.function)(max_id=max_id, limit=self.session.settings["general"]["max_posts_per_call"], *self.args, **self.kwargs)
+        except Exception as e:
+            log.exception("Error %s" % (str(e)))
+            return
+        items_db = self.session.db[self.name]
+        for i in items:
+            if utils.find_item(i, self.session.db[self.name]) == None:
+                elements.append(i)
+                if self.session.settings["general"]["reverse_timelines"] == False:
+                    items_db.insert(0, i)
+                else:
+                    items_db.append(i)
+        self.session.db[self.name] = items_db
+        selection = self.buffer.list.get_selected()
+        log.debug("Retrieved %d items from cursored search in function %s." % (len(elements), self.function))
+        if self.session.settings["general"]["reverse_timelines"] == False:
+            for i in elements:
+                post = self.compose_function(i, self.session.db, self.session.settings["general"]["relative_times"], self.session.settings["general"]["show_screen_names"])
+                self.buffer.list.insert_item(True, *post)
+        else:
+            for i in items:
+                post = self.compose_function(i, self.session.db, self.session.settings["general"]["relative_times"], self.session.settings["general"]["show_screen_names"])
+                self.buffer.list.insert_item(False, *post)
+            self.buffer.list.select_item(selection)
+        output.speak(_(u"%s items retrieved") % (str(len(elements))), True)
+
+    def remove_buffer(self, force=False):
+        if "-timeline" in self.name:
+            if force == False:
+                dlg = commonMessageDialogs.remove_buffer()
+            else:
+                dlg = widgetUtils.YES
+            if dlg == widgetUtils.YES:
+                if self.kwargs.get("id") in self.session.settings["other_buffers"]["timelines"]:
+                    self.session.settings["other_buffers"]["timelines"].remove(self.kwargs.get("id"))
+                    self.session.settings.write()
+                if self.name in self.session.db:
+                    self.session.db.pop(self.name)
+                    return True
+            elif dlg == widgetUtils.NO:
+                return False
+        else:
+            output.speak(_(u"This buffer is not a timeline; it can't be deleted."), True)
+            return False
+
+    def put_items_on_list(self, number_of_items):
+        list_to_use = self.session.db[self.name]
+        if number_of_items == 0 and self.session.settings["general"]["persist_size"] == 0: return
+        log.debug("The list contains %d items " % (self.buffer.list.get_count(),))
+        log.debug("Putting %d items on the list" % (number_of_items,))
+        if self.buffer.list.get_count() == 0:
+            for i in list_to_use:
+                post = self.compose_function(i, self.session.db, self.session.settings["general"]["relative_times"], self.session.settings["general"]["show_screen_names"])
+                self.buffer.list.insert_item(False, *post)
+            self.buffer.set_position(self.session.settings["general"]["reverse_timelines"])
+        elif self.buffer.list.get_count() > 0 and number_of_items > 0:
+            if self.session.settings["general"]["reverse_timelines"] == False:
+                items = list_to_use[len(list_to_use)-number_of_items:]
+                for i in items:
+                    post = self.compose_function(i, self.session.db, self.session.settings["general"]["relative_times"], self.session.settings["general"]["show_screen_names"])
+                    self.buffer.list.insert_item(False, *post)
+            else:
+                items = list_to_use[0:number_of_items]
+                items.reverse()
+                for i in items:
+                    post = self.compose_function(i, self.session.db, self.session.settings["general"]["relative_times"], self.session.settings["general"]["show_screen_names"])
+                    self.buffer.list.insert_item(True, *post)
+        log.debug("Now the list contains %d items " % (self.buffer.list.get_count(),))
+
+    def add_new_item(self, item):
+        post = self.compose_function(item, self.session.db, self.session.settings["general"]["relative_times"], self.session.settings["general"]["show_screen_names"])
+        if self.session.settings["general"]["reverse_timelines"] == False:
+            self.buffer.list.insert_item(False, *post)
+        else:
+            self.buffer.list.insert_item(True, *post)
+        if self.name in self.session.settings["other_buffers"]["autoread_buffers"] and self.name not in self.session.settings["other_buffers"]["muted_buffers"] and self.session.settings["sound"]["session_mute"] == False:
+            output.speak(" ".join(post[:2]), speech=self.session.settings["reporting"]["speech_reporting"], braille=self.session.settings["reporting"]["braille_reporting"])
+
+    def update_item(self, item, position):
+        post = self.compose_function(item, self.session.db, self.session.settings["general"]["relative_times"], self.session.settings["general"]["show_screen_names"])
+        self.buffer.list.list.SetItem(position, 1, post[1])
+
+    def bind_events(self):
+        log.debug("Binding events...")
+        self.buffer.set_focus_function(self.onFocus)
+        widgetUtils.connect_event(self.buffer.list.list, widgetUtils.KEYPRESS, self.get_event)
+        widgetUtils.connect_event(self.buffer, widgetUtils.BUTTON_PRESSED, self.post_status, self.buffer.post)
+        widgetUtils.connect_event(self.buffer, widgetUtils.BUTTON_PRESSED, self.share_item, self.buffer.boost)
+        widgetUtils.connect_event(self.buffer, widgetUtils.BUTTON_PRESSED, self.send_message, self.buffer.dm)
+        widgetUtils.connect_event(self.buffer, widgetUtils.BUTTON_PRESSED, self.reply, self.buffer.reply)
+        widgetUtils.connect_event(self.buffer, widgetUtils.BUTTON_PRESSED, self.toggle_favorite, self.buffer.fav)
+        widgetUtils.connect_event(self.buffer, widgetUtils.BUTTON_PRESSED, self.toggle_bookmark, self.buffer.bookmark)
+        widgetUtils.connect_event(self.buffer.list.list, wx.EVT_LIST_ITEM_RIGHT_CLICK, self.show_menu)
+        widgetUtils.connect_event(self.buffer.list.list, wx.EVT_LIST_KEY_DOWN, self.show_menu_by_key)
+
+    def show_menu(self, ev, pos=0, *args, **kwargs):
+        if self.buffer.list.get_count() == 0:
+            return
+        menu = menus.base()
+        widgetUtils.connect_event(menu, widgetUtils.MENU, self.reply, menuitem=menu.reply)
+        widgetUtils.connect_event(menu, widgetUtils.MENU, self.user_actions, menuitem=menu.userActions)
+        widgetUtils.connect_event(menu, widgetUtils.MENU, self.share_item, menuitem=menu.boost)
+        widgetUtils.connect_event(menu, widgetUtils.MENU, self.fav, menuitem=menu.fav)
+        widgetUtils.connect_event(menu, widgetUtils.MENU, self.unfav, menuitem=menu.unfav)
+        widgetUtils.connect_event(menu, widgetUtils.MENU, self.url_, menuitem=menu.openUrl)
+        widgetUtils.connect_event(menu, widgetUtils.MENU, self.audio, menuitem=menu.play)
+        widgetUtils.connect_event(menu, widgetUtils.MENU, self.view, menuitem=menu.view)
+        widgetUtils.connect_event(menu, widgetUtils.MENU, self.copy, menuitem=menu.copy)
+        widgetUtils.connect_event(menu, widgetUtils.MENU, self.destroy_status, menuitem=menu.remove)
+        if hasattr(menu, "openInBrowser"):
+            widgetUtils.connect_event(menu, widgetUtils.MENU, self.open_in_browser, menuitem=menu.openInBrowser)
+        if pos != 0:
+            self.buffer.PopupMenu(menu, pos)
+        else:
+            self.buffer.PopupMenu(menu, self.buffer.list.list.GetPosition())
+
+    def view(self, *args, **kwargs):
+        pub.sendMessage("execute-action", action="view_item")
+
+    def copy(self, *args, **kwargs):
+        pub.sendMessage("execute-action", action="copy_to_clipboard")
+
+    def user_actions(self, *args, **kwargs):
+        pub.sendMessage("execute-action", action="follow")
+
+    def fav(self, *args, **kwargs):
+        pub.sendMessage("execute-action", action="add_to_favourites")
+
+    def unfav(self, *args, **kwargs):
+        pub.sendMessage("execute-action", action="remove_from_favourites")
+
+    def delete_item_(self, *args, **kwargs):
+        pub.sendMessage("execute-action", action="delete_item")
+
+    def url_(self, *args, **kwargs):
+        self.url()
+
+    def show_menu_by_key(self, ev):
+        if self.buffer.list.get_count() == 0:
+            return
+        if ev.GetKeyCode() == wx.WXK_WINDOWS_MENU:
+            self.show_menu(widgetUtils.MENU, pos=self.buffer.list.list.GetPosition())
+
+    def get_item(self):
+        index = self.buffer.list.get_selected()
+        if index > -1 and self.session.db.get(self.name) != None:
+            return self.session.db[self.name][index]
+
+    def can_share(self):
+        post = self.get_item()
+        if post.visibility == "direct":
+            return False
+        return True
+
+    def reply(self, *args):
+        item = self.get_item()
+        visibility = item.visibility
+        if visibility == "direct":
+            title = _("Conversation with {}").format(item.account.username)
+            caption = _("Write your message here")
+        else:
+            title = _("Reply to {}").format(item.account.username)
+            caption = _("Write your reply here")
+        if item.reblog != None:
+            users = ["@{} ".format(user.acct) for user in item.reblog.mentions if user.id != self.session.db["user_id"]]
+            if item.reblog.account.acct != item.account.acct and "@{} ".format(item.reblog.account.acct) not in users:
+                users.append("@{} ".format(item.reblog.account.acct))
+        else:
+            users = ["@{} ".format(user.acct) for user in item.mentions if user.id != self.session.db["user_id"]]
+        if "@{} ".format(item.account.acct) not in users and item.account.id != self.session.db["user_id"]:
+            users.insert(0, "@{} ".format(item.account.acct))
+        users_str = "".join(users)
+        post = messages.post(session=self.session, title=title, caption=caption, text=users_str)
+        visibility_settings = dict(public=0, unlisted=1, private=2, direct=3)
+        post.message.visibility.SetSelection(visibility_settings.get(visibility))
+        # Respect content warning settings.
+        if item.sensitive:
+            post.message.sensitive.SetValue(item.sensitive)
+            post.message.spoiler.ChangeValue(item.spoiler_text)
+            post.message.on_sensitivity_changed()
+        response = post.message.ShowModal()
+        if response == wx.ID_OK:
+            post_data = post.get_data()
+            call_threaded(self.session.send_post, reply_to=item.id, posts=post_data, visibility=post.get_visibility())
+        if hasattr(post.message, "destroy"):
+            post.message.destroy()
+
+    def send_message(self, *args, **kwargs):
+        item = self.get_item()
+        title = _("Conversation with {}").format(item.account.username)
+        caption = _("Write your message here")
+        if item.reblog != None:
+            users = ["@{} ".format(user.acct) for user in item.reblog.mentions if user.id != self.session.db["user_id"]]
+            if item.reblog.account.acct != item.account.acct and "@{} ".format(item.reblog.account.acct) not in users:
+                users.append("@{} ".format(item.reblog.account.acct))
+        else:
+            users = ["@{} ".format(user.acct) for user in item.mentions if user.id != self.session.db["user_id"]]
+        if item.account.acct not in users and item.account.id != self.session.db["user_id"]:
+            users.insert(0, "@{} ".format(item.account.acct))
+        users_str = "".join(users)
+        post = messages.post(session=self.session, title=title, caption=caption, text=users_str)
+        post.message.visibility.SetSelection(3)
+        if item.sensitive:
+            post.message.sensitive.SetValue(item.sensitive)
+            post.message.spoiler.ChangeValue(item.spoiler_text)
+            post.message.on_sensitivity_changed()
+        response = post.message.ShowModal()
+        if response == wx.ID_OK:
+            post_data = post.get_data()
+            call_threaded(self.session.send_post, posts=post_data, visibility="direct", reply_to=item.id)
+        if hasattr(post.message, "destroy"):
+            post.message.destroy()
+
+    def share_item(self, *args, **kwargs):
+        if self.can_share() == False:
+            return output.speak(_("This action is not supported on conversation posts."))
+        post = self.get_item()
+        id = post.id
+        if self.session.settings["general"]["boost_mode"] == "ask":
+            answer = mastodon_dialogs.boost_question()
+            if answer == True:
+                self._direct_boost(id)
+        else:
+            self._direct_boost(id)
+
+    def _direct_boost(self, id):
+        item = self.session.api_call(call_name="status_reblog", _sound="retweet_send.ogg", id=id)
+
+    def onFocus(self, *args, **kwargs):
+        post = self.get_item()
+        if self.session.settings["general"]["relative_times"] == True:
+            original_date = arrow.get(self.session.db[self.name][self.buffer.list.get_selected()].created_at)
+            ts = original_date.humanize(locale=languageHandler.getLanguage())
+            self.buffer.list.list.SetItem(self.buffer.list.get_selected(), 2, ts)
+        if self.session.settings['sound']['indicate_audio'] and utils.is_audio_or_video(post):
+            self.session.sound.play("audio.ogg")
+        if self.session.settings['sound']['indicate_img'] and utils.is_image(post):
+            self.session.sound.play("image.ogg")
+        can_share = self.can_share()
+        pub.sendMessage("toggleShare", shareable=can_share)
+        self.buffer.boost.Enable(can_share)
+
+    def audio(self, url='', *args, **kwargs):
+        if sound.URLPlayer.player.is_playing():
+            return sound.URLPlayer.stop_audio()
+        item = self.get_item()
+        if item == None:
+            return
+        urls = utils.get_media_urls(item)
+        if len(urls) == 1:
+            url=urls[0]
+        elif len(urls) > 1:
+            urls_list = dialogs.urlList.urlList()
+            urls_list.populate_list(urls)
+            if urls_list.get_response() == widgetUtils.OK:
+                url=urls_list.get_string()
+            if hasattr(urls_list, "destroy"): urls_list.destroy()
+        if url != '':
+            #   try:
+            sound.URLPlayer.play(url, self.session.settings["sound"]["volume"])
+#   except:
+#    log.error("Exception while executing audio method.")
+
+    def url(self, url='', announce=True, *args, **kwargs):
+        if url == '':
+            post = self.get_item()
+            if post.reblog != None:
+                urls = utils.find_urls(post.reblog)
+            else:
+                urls = utils.find_urls(post)
+            if len(urls) == 1:
+                url=urls[0]
+            elif len(urls) > 1:
+                urls_list = dialogs.urlList.urlList()
+                urls_list.populate_list(urls)
+                if urls_list.get_response() == widgetUtils.OK:
+                    url=urls_list.get_string()
+                if hasattr(urls_list, "destroy"): urls_list.destroy()
+            if url != '':
+                if announce:
+                    output.speak(_(u"Opening URL..."), True)
+                webbrowser.open_new_tab(url)
+
+    def clear_list(self):
+        dlg = commonMessageDialogs.clear_list()
+        if dlg == widgetUtils.YES:
+            self.session.db[self.name] = []
+            self.buffer.list.clear()
+
+    def destroy_status(self, *args, **kwargs):
+        index = self.buffer.list.get_selected()
+        item = self.session.db[self.name][index]
+        if item.account.id != self.session.db["user_id"] or item.reblog != None:
+            output.speak(_("You can delete only your own posts."))
+            return
+        answer = mastodon_dialogs.delete_post_dialog()
+        if answer == True:
+            items = self.session.db[self.name]
+            try:
+                self.session.api.status_delete(id=item.id)
+                items.pop(index)
+                self.buffer.list.remove_item(index)
+            except Exception as e:
+                self.session.sound.play("error.ogg")
+            self.session.db[self.name] = items
+
+    def user_details(self):
+        item = self.get_item()
+        pass
+
+    def get_item_url(self):
+        post = self.get_item()
+        if post.reblog != None:
+            return post.reblog.url
+        return post.url
+
+    def open_in_browser(self, *args, **kwargs):
+        url = self.get_item_url()
+        output.speak(_("Opening item in web browser..."))
+        webbrowser.open(url)
+
+    def add_to_favorites(self):
+        item = self.get_item()
+        if item.reblog != None:
+            item = item.reblog
+        call_threaded(self.session.api_call, call_name="status_favourite", preexec_message=_("Adding to favorites..."), _sound="favourite.ogg", id=item.id)
+
+    def remove_from_favorites(self):
+        item = self.get_item()
+        if item.reblog != None:
+            item = item.reblog
+        call_threaded(self.session.api_call, call_name="status_unfavourite", preexec_message=_("Removing from favorites..."), _sound="favourite.ogg", id=item.id)
+
+    def toggle_favorite(self, *args, **kwargs):
+        item = self.get_item()
+        if item.reblog != None:
+            item = item.reblog
+        item = self.session.api.status(item.id)
+        if item.favourited == False:
+            call_threaded(self.session.api_call, call_name="status_favourite", preexec_message=_("Adding to favorites..."), _sound="favourite.ogg", id=item.id)
+        else:
+            call_threaded(self.session.api_call, call_name="status_unfavourite", preexec_message=_("Removing from favorites..."), _sound="favourite.ogg", id=item.id)
+
+    def toggle_bookmark(self, *args, **kwargs):
+        item = self.get_item()
+        if item.reblog != None:
+            item = item.reblog
+        item = self.session.api.status(item.id)
+        if item.bookmarked == False:
+            call_threaded(self.session.api_call, call_name="status_bookmark", preexec_message=_("Adding to bookmarks..."), _sound="favourite.ogg", id=item.id)
+        else:
+            call_threaded(self.session.api_call, call_name="status_unbookmark", preexec_message=_("Removing from bookmarks..."), _sound="favourite.ogg", id=item.id)
+
+    def view_item(self):
+        post = self.get_item()
+        # Update object so we can retrieve newer stats
+        post = self.session.api.status(id=post.id)
+        print(post)
+        msg = messages.viewPost(post, offset_hours=self.session.db["utc_offset"], item_url=self.get_item_url())
+
+    def ocr_image(self):
+        post = self.get_item()
+        media_list = []
+        pass

src/controller/buffers/mastodon/conversations.py

@@ -0,0 +1,241 @@
+# -*- coding: utf-8 -*-
+import time
+import logging
+import wx
+import widgetUtils
+import output
+from controller.mastodon import messages
+from controller.buffers.mastodon.base import BaseBuffer
+from mysc.thread_utils import call_threaded
+from sessions.mastodon import utils, templates
+from wxUI import buffers, commonMessageDialogs
+log = logging.getLogger("controller.buffers.mastodon.conversations")
+
+class ConversationListBuffer(BaseBuffer):
+
+    def create_buffer(self, parent, name):
+        self.buffer = buffers.mastodon.conversationListPanel(parent, name)
+
+    def get_item(self):
+        index = self.buffer.list.get_selected()
+        if index > -1 and self.session.db.get(self.name) != None and len(self.session.db[self.name]) > index:
+            return self.session.db[self.name][index]["last_status"]
+
+    def get_conversation(self):
+        index = self.buffer.list.get_selected()
+        if index > -1 and self.session.db.get(self.name) != None:
+            return self.session.db[self.name][index]
+
+    def get_formatted_message(self):
+        return self.compose_function(self.get_conversation(), self.session.db, self.session.settings["general"]["relative_times"], self.session.settings["general"]["show_screen_names"])[1]
+
+    def get_message(self):
+        conversation = self.get_conversation()
+        if conversation == None:
+            return
+        template = self.session.settings["templates"]["conversation"]
+        post_template = self.session.settings["templates"]["post"]
+        t = templates.render_conversation(conversation=conversation, template=template, post_template=post_template, relative_times=self.session.settings["general"]["relative_times"], offset_hours=self.session.db["utc_offset"])
+        return t
+
+    def start_stream(self, mandatory=False, play_sound=True, avoid_autoreading=False):
+        current_time = time.time()
+        if self.execution_time == 0 or current_time-self.execution_time >= 180 or mandatory==True:
+            self.execution_time = current_time
+            log.debug("Starting stream for buffer %s, account %s and type %s" % (self.name, self.account, self.type))
+            log.debug("args: %s, kwargs: %s" % (self.args, self.kwargs))
+            count = self.session.settings["general"]["max_posts_per_call"]
+            min_id = None
+            # toDo: Implement reverse timelines properly here.
+#            if (self.name != "favorites" and self.name != "bookmarks") and self.name in self.session.db and len(self.session.db[self.name]) > 0:
+#                min_id = self.session.db[self.name][-1].id
+            try:
+                results = getattr(self.session.api, self.function)(min_id=min_id, limit=count, *self.args, **self.kwargs)
+                results.reverse()
+            except Exception as e:
+                log.exception("Error %s" % (str(e)))
+                return
+            new_position, number_of_items = self.order_buffer(results)
+            log.debug("Number of items retrieved: %d" % (number_of_items,))
+            self.put_items_on_list(number_of_items)
+            if new_position > -1:
+                self.buffer.list.select_item(new_position)
+            if number_of_items > 0 and  self.name != "sent_posts" and self.name != "sent_direct_messages" and self.sound != None and self.session.settings["sound"]["session_mute"] == False and self.name not in self.session.settings["other_buffers"]["muted_buffers"] and play_sound == True:
+                self.session.sound.play(self.sound)
+            # Autoread settings
+            if avoid_autoreading == False and mandatory == True and number_of_items > 0 and self.name in self.session.settings["other_buffers"]["autoread_buffers"]:
+                self.auto_read(number_of_items)
+            return number_of_items
+
+    def get_more_items(self):
+        elements = []
+        if self.session.settings["general"]["reverse_timelines"] == False:
+            max_id = self.session.db[self.name][0].last_status.id
+        else:
+            max_id = self.session.db[self.name][-1].last_status.id
+        try:
+            items = getattr(self.session.api, self.function)(max_id=max_id, limit=self.session.settings["general"]["max_posts_per_call"], *self.args, **self.kwargs)
+        except Exception as e:
+            log.exception("Error %s" % (str(e)))
+            return
+        items_db = self.session.db[self.name]
+        for i in items:
+            if utils.find_item(i, self.session.db[self.name]) == None:
+                elements.append(i)
+                if self.session.settings["general"]["reverse_timelines"] == False:
+                    items_db.insert(0, i)
+                else:
+                    items_db.append(i)
+        self.session.db[self.name] = items_db
+        selection = self.buffer.list.get_selected()
+        log.debug("Retrieved %d items from cursored search in function %s." % (len(elements), self.function))
+        if self.session.settings["general"]["reverse_timelines"] == False:
+            for i in elements:
+                conversation = self.compose_function(i, self.session.db, self.session.settings["general"]["relative_times"], self.session.settings["general"]["show_screen_names"])
+                self.buffer.list.insert_item(True, *conversation)
+        else:
+            for i in items:
+                conversation = self.compose_function(i, self.session.db, self.session.settings["general"]["relative_times"], self.session.settings["general"]["show_screen_names"])
+                self.buffer.list.insert_item(False, *conversation)
+            self.buffer.list.select_item(selection)
+        output.speak(_(u"%s items retrieved") % (str(len(elements))), True)
+
+    def get_item_position(self, conversation):
+        for i in range(len(self.session.db[self.name])):
+            if self.session.db[self.name][i].id == conversation.id:
+                return i
+
+    def order_buffer(self, data):
+        num = 0
+        focus_object = None
+        if self.session.db.get(self.name) == None:
+            self.session.db[self.name] = []
+        objects = self.session.db[self.name]
+        for i in data:
+            position = self.get_item_position(i)
+            if position != None:
+                conversation = self.session.db[self.name][position]
+                if conversation.last_status.id != i.last_status.id:
+                    focus_object = i
+                    objects.pop(position)
+                    self.buffer.list.remove_item(position)
+                    if self.session.settings["general"]["reverse_timelines"] == False:
+                        objects.append(i)
+                    else:
+                        objects.insert(0, i)
+                    num = num+1
+            else:
+                if self.session.settings["general"]["reverse_timelines"] == False:
+                    objects.append(i)
+                else:
+                    objects.insert(0, i)
+                num = num+1
+        self.session.db[self.name] = objects
+        if focus_object == None:
+            return (-1, num)
+        new_position = self.get_item_position(focus_object)
+        if new_position != None:
+            return (new_position, num)
+        return (-1, num)
+
+    def bind_events(self):
+        log.debug("Binding events...")
+        self.buffer.set_focus_function(self.onFocus)
+        widgetUtils.connect_event(self.buffer.list.list, widgetUtils.KEYPRESS, self.get_event)
+        widgetUtils.connect_event(self.buffer, widgetUtils.BUTTON_PRESSED, self.post_status, self.buffer.post)
+        widgetUtils.connect_event(self.buffer, widgetUtils.BUTTON_PRESSED, self.reply, self.buffer.reply)
+        widgetUtils.connect_event(self.buffer.list.list, wx.EVT_LIST_ITEM_RIGHT_CLICK, self.show_menu)
+        widgetUtils.connect_event(self.buffer.list.list, wx.EVT_LIST_KEY_DOWN, self.show_menu_by_key)
+
+    def fav(self):
+        pass
+
+    def unfav(self):
+        pass
+
+    def can_share(self):
+        return False
+
+    def send_message(self):
+        return self.reply()
+
+    def onFocus(self, *args, **kwargs):
+        post = self.get_item()
+        if self.session.settings['sound']['indicate_audio'] and utils.is_audio_or_video(post):
+            self.session.sound.play("audio.ogg")
+        if self.session.settings['sound']['indicate_img'] and utils.is_image(post):
+            self.session.sound.play("image.ogg")
+
+    def destroy_status(self):
+        pass
+
+    def reply(self, *args):
+        item = self.get_item()
+        conversation = self.get_conversation()
+        visibility = item.visibility
+        title = _("Reply to conversation with {}").format(conversation.accounts[0].username)
+        caption = _("Write your message here")
+        users = ["@{} ".format(user.acct) for user in conversation.accounts]
+        users_str = "".join(users)
+        post = messages.post(session=self.session, title=title, caption=caption, text=users_str)
+        visibility_settings = dict(public=0, unlisted=1, private=2, direct=3)
+        post.message.visibility.SetSelection(visibility_settings.get(visibility))
+        if item.sensitive:
+            post.message.sensitive.SetValue(item.sensitive)
+            post.message.spoiler.ChangeValue(item.spoiler_text)
+            post.message.on_sensitivity_changed()
+        response = post.message.ShowModal()
+        if response == wx.ID_OK:
+            post_data = post.get_data()
+            call_threaded(self.session.send_post, reply_to=item.id, posts=post_data, visibility=visibility)
+        if hasattr(post.message, "destroy"):
+            post.message.destroy()
+
+class ConversationBuffer(BaseBuffer):
+
+    def __init__(self, post, *args, **kwargs):
+        self.post = post
+        super(ConversationBuffer, self).__init__(*args, **kwargs)
+
+    def start_stream(self, mandatory=False, play_sound=True, avoid_autoreading=False):
+        current_time = time.time()
+        if self.execution_time == 0 or current_time-self.execution_time >= 180 or mandatory==True:
+            self.execution_time = current_time
+            log.debug("Starting stream for buffer %s, account %s and type %s" % (self.name, self.account, self.type))
+            log.debug("args: %s, kwargs: %s" % (self.args, self.kwargs))
+            self.post = self.session.api.status(id=self.post.id)
+            # toDo: Implement reverse timelines properly here.
+            try:
+                results = []
+                items = getattr(self.session.api, self.function)(*self.args, **self.kwargs)
+                [results.append(item) for item in items.ancestors]
+                results.append(self.post)
+                [results.append(item) for item in items.descendants]
+            except Exception as e:
+                log.exception("Error %s" % (str(e)))
+                return
+            number_of_items = self.session.order_buffer(self.name, results)
+            log.debug("Number of items retrieved: %d" % (number_of_items,))
+            self.put_items_on_list(number_of_items)
+            if number_of_items > 0 and  self.name != "sent_posts" and self.name != "sent_direct_messages" and self.sound != None and self.session.settings["sound"]["session_mute"] == False and self.name not in self.session.settings["other_buffers"]["muted_buffers"] and play_sound == True:
+                self.session.sound.play(self.sound)
+            # Autoread settings
+            if avoid_autoreading == False and mandatory == True and number_of_items > 0 and self.name in self.session.settings["other_buffers"]["autoread_buffers"]:
+                self.auto_read(number_of_items)
+            return number_of_items
+
+
+    def get_more_items(self):
+        output.speak(_(u"This action is not supported for this buffer"), True)
+
+    def remove_buffer(self, force=False):
+        if force == False:
+            dlg = commonMessageDialogs.remove_buffer()
+        else:
+            dlg = widgetUtils.YES
+        if dlg == widgetUtils.YES:
+            if self.name in self.session.db:
+                self.session.db.pop(self.name)
+            return True
+        elif dlg == widgetUtils.NO:
+            return False

src/controller/buffers/mastodon/mentions.py

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+import time
+import logging
+from controller.buffers.mastodon.base import BaseBuffer
+from sessions.mastodon import utils
+
+log = logging.getLogger("controller.buffers.mastodon.mentions")
+
+class MentionsBuffer(BaseBuffer):
+
+    def start_stream(self, mandatory=False, play_sound=True, avoid_autoreading=False):
+        current_time = time.time()
+        if self.execution_time == 0 or current_time-self.execution_time >= 180 or mandatory==True:
+            self.execution_time = current_time
+            log.debug("Starting stream for buffer %s, account %s and type %s" % (self.name, self.account, self.type))
+            log.debug("args: %s, kwargs: %s" % (self.args, self.kwargs))
+            count = self.session.settings["general"]["max_posts_per_call"]
+            min_id = None
+            # toDo: Implement reverse timelines properly here.
+#            if self.name != "favorites" and self.name in self.session.db and len(self.session.db[self.name]) > 0:
+#                min_id = self.session.db[self.name][-1].id
+            try:
+                items = getattr(self.session.api, self.function)(min_id=min_id, limit=count, exclude_types=["follow", "favourite", "reblog", "poll", "follow_request"], *self.args, **self.kwargs)
+                items.reverse()
+                results = [item.status for item in items if item.get("status") and item.type == "mention"]
+            except Exception as e:
+                log.exception("Error %s" % (str(e)))
+                return
+            number_of_items = self.session.order_buffer(self.name, results)
+            log.debug("Number of items retrieved: %d" % (number_of_items,))
+            self.put_items_on_list(number_of_items)
+            if number_of_items > 0 and  self.name != "sent_posts" and self.name != "sent_direct_messages" and self.sound != None and self.session.settings["sound"]["session_mute"] == False and self.name not in self.session.settings["other_buffers"]["muted_buffers"] and play_sound == True:
+                self.session.sound.play(self.sound)
+            # Autoread settings
+            if avoid_autoreading == False and mandatory == True and number_of_items > 0 and self.name in self.session.settings["other_buffers"]["autoread_buffers"]:
+                self.auto_read(number_of_items)
+            return number_of_items
+
+    def get_more_items(self):
+        elements = []
+        if self.session.settings["general"]["reverse_timelines"] == False:
+            max_id = self.session.db[self.name][0].id
+        else:
+            max_id = self.session.db[self.name][-1].id
+        try:
+            items = getattr(self.session.api, self.function)(max_id=max_id, limit=self.session.settings["general"]["max_posts_per_call"], exclude_types=["follow", "favourite", "reblog", "poll", "follow_request"], *self.args, **self.kwargs)
+            items = [item.status for item in items if item.get("status") and item.type == "mention"]
+        except Exception as e:
+            log.exception("Error %s" % (str(e)))
+            return
+        items_db = self.session.db[self.name]
+        for i in items:
+            if utils.find_item(i, self.session.db[self.name]) == None:
+                elements.append(i)
+                if self.session.settings["general"]["reverse_timelines"] == False:
+                    items_db.insert(0, i)
+                else:
+                    items_db.append(i)
+        self.session.db[self.name] = items_db
+        selection = self.buffer.list.get_selected()
+        log.debug("Retrieved %d items from cursored search in function %s." % (len(elements), self.function))
+        if self.session.settings["general"]["reverse_timelines"] == False:
+            for i in elements:
+                post = self.compose_function(i, self.session.db, self.session.settings["general"]["relative_times"], self.session.settings["general"]["show_screen_names"])
+                self.buffer.list.insert_item(True, *post)
+        else:
+            for i in items:
+                post = self.compose_function(i, self.session.db, self.session.settings["general"]["relative_times"], self.session.settings["general"]["show_screen_names"])
+                self.buffer.list.insert_item(False, *post)
+            self.buffer.list.select_item(selection)
+        output.speak(_(u"%s items retrieved") % (str(len(elements))), True)

src/controller/buffers/mastodon/users.py

@@ -0,0 +1,202 @@
+# -*- coding: utf-8 -*-
+import time
+import logging
+import wx
+import widgetUtils
+import output
+from mysc.thread_utils import call_threaded
+from controller.buffers.mastodon.base import BaseBuffer
+from controller.mastodon import messages
+from sessions.mastodon import templates, utils
+from wxUI import buffers, commonMessageDialogs
+
+log = logging.getLogger("controller.buffers.mastodon.conversations")
+
+class UserBuffer(BaseBuffer):
+
+    def create_buffer(self, parent, name):
+        self.buffer = buffers.mastodon.userPanel(parent, name)
+
+    def get_message(self):
+        user = self.get_item()
+        if user == None:
+            return
+        template = self.session.settings["templates"]["person"]
+        t = templates.render_user(user=user, template=template, relative_times=self.session.settings["general"]["relative_times"], offset_hours=self.session.db["utc_offset"])
+        return t
+
+    def bind_events(self):
+        widgetUtils.connect_event(self.buffer.list.list, widgetUtils.KEYPRESS, self.get_event)
+        widgetUtils.connect_event(self.buffer, widgetUtils.BUTTON_PRESSED, self.post_status, self.buffer.post)
+        widgetUtils.connect_event(self.buffer, widgetUtils.BUTTON_PRESSED, self.send_message, self.buffer.message)
+        widgetUtils.connect_event(self.buffer, widgetUtils.BUTTON_PRESSED, self.user_actions, self.buffer.actions)
+        widgetUtils.connect_event(self.buffer.list.list, wx.EVT_LIST_ITEM_RIGHT_CLICK, self.show_menu)
+        widgetUtils.connect_event(self.buffer.list.list, wx.EVT_LIST_KEY_DOWN, self.show_menu_by_key)
+
+    def fav(self):
+        pass
+
+    def unfav(self):
+        pass
+
+    def can_share(self):
+        return False
+
+    def reply(self, *args, **kwargs):
+        return self.send_message()
+
+    def send_message(self, *args, **kwargs):
+        item = self.get_item()
+        title = _("New conversation with {}").format(item.username)
+        caption = _("Write your message here")
+        users_str = "@{} ".format(item.acct)
+        post = messages.post(session=self.session, title=title, caption=caption, text=users_str)
+        post.message.visibility.SetSelection(3)
+        response = post.message.ShowModal()
+        if response == wx.ID_OK:
+            post_data = post.get_data()
+            call_threaded(self.session.send_post, posts=post_data, visibility="direct")
+        if hasattr(post.message, "destroy"):
+            post.message.destroy()
+
+    def audio(self):
+        pass
+
+    def url(self):
+        pass
+
+    def destroy_status(self):
+        pass
+
+    def start_stream(self, mandatory=False, play_sound=True, avoid_autoreading=False):
+        current_time = time.time()
+        if self.execution_time == 0 or current_time-self.execution_time >= 180 or mandatory==True:
+            self.execution_time = current_time
+            log.debug("Starting stream for buffer %s, account %s and type %s" % (self.name, self.account, self.type))
+            log.debug("args: %s, kwargs: %s" % (self.args, self.kwargs))
+            count = self.session.settings["general"]["max_posts_per_call"]
+            # toDo: Implement reverse timelines properly here.
+            try:
+                results = getattr(self.session.api, self.function)(limit=count, *self.args, **self.kwargs)
+                if hasattr(results, "_pagination_next") and self.name not in self.session.db["pagination_info"]:
+                    self.session.db["pagination_info"][self.name] = results._pagination_next
+                results.reverse()
+            except Exception as e:
+                log.exception("Error %s" % (str(e)))
+                return
+            number_of_items = self.session.order_buffer(self.name, results)
+            log.debug("Number of items retrieved: %d" % (number_of_items,))
+            if hasattr(self, "finished_timeline") and self.finished_timeline == False:
+                if "-followers" in self.name or "-following" in self.name:
+                    self.username = self.session.api.account(id=self.kwargs.get("id")).username
+                self.finished_timeline = True
+            self.put_items_on_list(number_of_items)
+            if number_of_items > 0 and  self.name != "sent_posts" and self.name != "sent_direct_messages" and self.sound != None and self.session.settings["sound"]["session_mute"] == False and self.name not in self.session.settings["other_buffers"]["muted_buffers"] and play_sound == True:
+                self.session.sound.play(self.sound)
+            # Autoread settings
+            if avoid_autoreading == False and mandatory == True and number_of_items > 0 and self.name in self.session.settings["other_buffers"]["autoread_buffers"]:
+                self.auto_read(number_of_items)
+            return number_of_items
+
+    def get_more_items(self):
+        elements = []
+        pagination_info = self.session.db["pagination_info"].get(self.name)
+        if pagination_info == None:
+            output.speak(_("There are no more items in this buffer."))
+            return
+        try:
+            items = self.session.api.fetch_next(pagination_info)
+            if hasattr(items, "_pagination_next"):
+                self.session.db["pagination_info"][self.name] = items._pagination_next
+        except Exception as e:
+            log.exception("Error %s" % (str(e)))
+            return
+        items_db = self.session.db[self.name]
+        for i in items:
+            if utils.find_item(i, self.session.db[self.name]) == None:
+                elements.append(i)
+                if self.session.settings["general"]["reverse_timelines"] == False:
+                    items_db.insert(0, i)
+                else:
+                    items_db.append(i)
+        self.session.db[self.name] = items_db
+        selection = self.buffer.list.get_selected()
+        log.debug("Retrieved %d items from cursored search in function %s." % (len(elements), self.function))
+        if self.session.settings["general"]["reverse_timelines"] == False:
+            for i in elements:
+                post = self.compose_function(i, self.session.db, self.session.settings["general"]["relative_times"], self.session.settings["general"]["show_screen_names"])
+                self.buffer.list.insert_item(True, *post)
+        else:
+            for i in items:
+                post = self.compose_function(i, self.session.db, self.session.settings["general"]["relative_times"], self.session.settings["general"]["show_screen_names"])
+                self.buffer.list.insert_item(False, *post)
+            self.buffer.list.select_item(selection)
+        output.speak(_(u"%s items retrieved") % (str(len(elements))), True)
+
+    def get_item_url(self):
+        item = self.get_item()
+        return item.url
+
+    def user_details(self):
+        item = self.get_item()
+        pass
+
+    def add_to_favorites(self):
+        pass
+
+    def remove_from_favorites(self):
+        pass
+
+    def toggle_favorite(self):
+        pass
+
+    def view_item(self):
+        item = self.get_item()
+        print(item)
+
+    def ocr_image(self):
+        pass
+
+    def remove_buffer(self, force=False):
+        if "-followers" in self.name:
+            if force == False:
+                dlg = commonMessageDialogs.remove_buffer()
+            else:
+                dlg = widgetUtils.YES
+            if dlg == widgetUtils.YES:
+                if self.kwargs.get("id") in self.session.settings["other_buffers"]["followers_timelines"]:
+                    self.session.settings["other_buffers"]["followers_timelines"].remove(self.kwargs.get("id"))
+                    self.session.settings.write()
+                    if self.name in self.session.db:
+                        self.session.db.pop(self.name)
+                    return True
+            elif dlg == widgetUtils.NO:
+                return False
+        elif "-following" in self.name:
+            if force == False:
+                dlg = commonMessageDialogs.remove_buffer()
+            else:
+                dlg = widgetUtils.YES
+            if dlg == widgetUtils.YES:
+                if self.kwargs.get("id") in self.session.settings["other_buffers"]["following_timelines"]:
+                    self.session.settings["other_buffers"]["following_timelines"].remove(self.kwargs.get("id"))
+                    self.session.settings.write()
+                    if self.name in self.session.db:
+                        self.session.db.pop(self.name)
+                    return True
+            elif dlg == widgetUtils.NO:
+                return False
+        elif "-searchUser" in self.name:
+            if force == False:
+                dlg = commonMessageDialogs.remove_buffer()
+            else:
+                dlg = widgetUtils.YES
+            if dlg == widgetUtils.YES:
+                if self.name in self.session.db:
+                    self.session.db.pop(self.name)
+                    return True
+            elif dlg == widgetUtils.NO:
+                return False
+        else:
+            output.speak(_(u"This buffer is not a timeline; it can't be deleted."), True)
+            return False

src/controller/buffers/twitter/base.py

@@ -1,14 +1,6 @@
 # -*- coding: utf-8 -*-
 import time
-import platform
-if platform.system() == "Windows":
-    import wx
-    from wxUI import buffers, dialogs, commonMessageDialogs, menus
-    from controller import user
-elif platform.system() == "Linux":
-    from gi.repository import Gtk
-    from gtkUI import buffers, dialogs, commonMessageDialogs
-from controller import messages
+import wx
 import widgetUtils
 import arrow
 import webbrowser
@@ -19,12 +11,15 @@ import languageHandler
 import logging
 from audio_services import youtube_utils
 from controller.buffers.base import base
-from sessions.twitter import compose, utils, reduce
+from sessions.twitter import compose, utils, reduce, templates
 from mysc.thread_utils import call_threaded
 from tweepy.errors import TweepyException
 from tweepy.cursor import Cursor
 from pubsub import pub
+from extra import ocr
 from sessions.twitter.long_tweets import twishort, tweets
+from wxUI import buffers, dialogs, commonMessageDialogs, menus
+from controller.twitter import user, messages
 
 log = logging.getLogger("controller.buffers")
 
@@ -40,9 +35,9 @@ class BaseBuffer(base.Buffer):
         super(BaseBuffer, self).__init__(parent, function, *args, **kwargs)
         log.debug("Initializing buffer %s, account %s" % (name, account,))
         if bufferType != None:
-            self.buffer = getattr(buffers, bufferType)(parent, name)
+            self.buffer = getattr(buffers.twitter, bufferType)(parent, name)
         else:
-            self.buffer = buffers.basePanel(parent, name)
+            self.buffer = buffers.twitter.basePanel(parent, name)
         self.invisible = True
         self.name = name
         self.type = self.buffer.type
@@ -84,42 +79,15 @@ class BaseBuffer(base.Buffer):
         return _(u"Unknown buffer")
 
     def post_status(self, *args, **kwargs):
-        item = None
-        title = _(u"Tweet")
-        caption = _(u"Write the tweet here")
+        title = _("Tweet")
+        caption = _("Write the tweet here")
         tweet = messages.tweet(self.session, title, caption, "")
-        if tweet.message.get_response() == widgetUtils.OK:
-            if config.app["app-settings"]["remember_mention_and_longtweet"]:
-                config.app["app-settings"]["longtweet"] = tweet.message.long_tweet.GetValue()
-                config.app.write()
-            text = tweet.message.get_text()
-            if len(text) > 280 and tweet.message.get("long_tweet") == True:
-                if not hasattr(tweet, "attachments"):
-                    text = twishort.create_tweet(self.session.settings["twitter"]["user_key"], self.session.settings["twitter"]["user_secret"], text)
-                else:
-                    text = twishort.create_tweet(self.session.settings["twitter"]["user_key"], self.session.settings["twitter"]["user_secret"], text, 1)
-            if not hasattr(tweet, "attachments") or len(tweet.attachments) == 0:
-                item = self.session.api_call(call_name="update_status", status=text, _sound="tweet_send.ogg", tweet_mode="extended")
-            else:
-                call_threaded(self.post_with_media, text=text, attachments=tweet.attachments)
-            # We will no longer will reuse the sent item from here as Streaming API should give us the new and correct item.
-            # but in case we'd need it, just uncomment the following couple of lines and make sure we reduce the item correctly.
-#            if item != None:
-#                pub.sendMessage("sent-tweet", data=item, user=self.session.db["user_name"])
-        if hasattr(tweet.message, "destroy"): tweet.message.destroy()
-        self.session.settings.write()
-
-    def post_with_media(self, text, attachments):
-        media_ids = []
-        for i in attachments:
-            img = self.session.twitter.media_upload(i["file"])
-            self.session.twitter.create_media_metadata(media_id=img.media_id, alt_text=i["description"])
-            media_ids.append(img.media_id)
-        item = self.session.twitter.update_status(status=text, media_ids=media_ids)
-        # We will no longer will reuse the sent item from here as Streaming API should give us the new and correct item.
-        # but in case we'd need it, just uncomment the following couple of lines and make sure we reduce the item correctly.
-#        if item != None:
-#            pub.sendMessage("sent-tweet", data=item, user=self.session.db["user_name"])
+        response = tweet.message.ShowModal()
+        if response == wx.ID_OK:
+            tweet_data = tweet.get_tweet_data()
+            call_threaded(self.session.send_tweet, *tweet_data)
+        if hasattr(tweet.message, "destroy"):
+            tweet.message.destroy()
 
     def get_formatted_message(self):
         if self.type == "dm" or self.name == "direct_messages":
@@ -127,8 +95,10 @@ class BaseBuffer(base.Buffer):
         return self.get_message()
 
     def get_message(self):
+        template = self.session.settings["templates"]["tweet"]
         tweet = self.get_right_tweet()
-        return " ".join(self.compose_function(tweet, self.session.db, self.session.settings["general"]["relative_times"], self.session.settings["general"]["show_screen_names"], self.session))
+        t = templates.render_tweet(tweet, template, self.session, relative_times=self.session.settings["general"]["relative_times"], offset_seconds=self.session.db["utc_offset"])
+        return t
 
     def get_full_tweet(self):
         tweet = self.get_right_tweet()
@@ -167,7 +137,7 @@ class BaseBuffer(base.Buffer):
             log.debug("Starting stream for buffer %s, account %s and type %s" % (self.name, self.account, self.type))
             log.debug("args: %s, kwargs: %s" % (self.args, self.kwargs))
             if self.name != "direct_messages":
-                val = self.session.call_paged(self.function, *self.args, **self.kwargs)
+                val = self.session.call_paged(self.function, self.name, *self.args, **self.kwargs)
             else:
                 # 50 results are allowed per API call, so let's assume max value can be 50.
                 # reference: https://developer.twitter.com/en/docs/twitter-api/v1/direct-messages/sending-and-receiving/api-reference/list-events
@@ -199,9 +169,9 @@ class BaseBuffer(base.Buffer):
             self.put_items_on_list(number_of_items)
             if hasattr(self, "finished_timeline") and self.finished_timeline == False:
                 if "-timeline" in self.name:
-                    self.username = val[0].user.screen_name
+                    self.username = self.session.get_user(self.kwargs.get("user_id")).screen_name
                 elif "-favorite" in self.name:
-                    self.username = self.session.api_call("get_user", **self.kwargs).screen_name
+                    self.username = self.session.get_user(self.kwargs.get("user_id")).screen_name
                 self.finished_timeline = True
             if number_of_items > 0 and self.name != "sent_tweets" and self.name != "sent_direct_messages" and self.sound != None and self.session.settings["sound"]["session_mute"] == False and self.name not in self.session.settings["other_buffers"]["muted_buffers"] and play_sound == True:
                 self.session.sound.play(self.sound)
@@ -334,9 +304,6 @@ class BaseBuffer(base.Buffer):
             self.buffer.list.insert_item(True, *tweet)
         if self.name in self.session.settings["other_buffers"]["autoread_buffers"] and self.name not in self.session.settings["other_buffers"]["muted_buffers"] and self.session.settings["sound"]["session_mute"] == False:
             output.speak(" ".join(tweet[:2]), speech=self.session.settings["reporting"]["speech_reporting"], braille=self.session.settings["reporting"]["braille_reporting"])
-        #Improve performance on Windows
-#  if platform.system() == "Windows":
-#   call_threaded(utils.is_audio,item)
 
     def bind_events(self):
         log.debug("Binding events...")
@@ -347,7 +314,6 @@ class BaseBuffer(base.Buffer):
         widgetUtils.connect_event(self.buffer, widgetUtils.BUTTON_PRESSED, self.share_item, self.buffer.retweet)
         widgetUtils.connect_event(self.buffer, widgetUtils.BUTTON_PRESSED, self.send_message, self.buffer.dm)
         widgetUtils.connect_event(self.buffer, widgetUtils.BUTTON_PRESSED, self.reply, self.buffer.reply)
-        # Replace for the correct way in other platforms.
         widgetUtils.connect_event(self.buffer.list.list, wx.EVT_LIST_ITEM_RIGHT_CLICK, self.show_menu)
         widgetUtils.connect_event(self.buffer.list.list, wx.EVT_LIST_KEY_DOWN, self.show_menu_by_key)
 
@@ -416,13 +382,18 @@ class BaseBuffer(base.Buffer):
         tweet = self.session.db[self.name][self.buffer.list.get_selected()]
         return tweet
 
+    def can_share(self):
+        tweet = self.get_right_tweet()
+        user = self.session.get_user(tweet.user)
+        is_protected = user.protected
+        return is_protected==False
+
     @_tweets_exist
     def reply(self, *args, **kwargs):
         tweet = self.get_right_tweet()
         user = self.session.get_user(tweet.user)
         screen_name = user.screen_name
         id = tweet.id
-        twishort_enabled = hasattr(tweet, "twishort")
         users = utils.get_all_mentioned(tweet, self.session.db, field="screen_name")
         ids = utils.get_all_mentioned(tweet, self.session.db, field="id")
         # Build the window title
@@ -430,38 +401,14 @@ class BaseBuffer(base.Buffer):
             title=_("Reply to {arg0}").format(arg0=screen_name)
         else:
             title=_("Reply")
-        message = messages.reply(self.session, title, _(u"Reply to %s") % (screen_name,), "", users=users, ids=ids)
-        if message.message.get_response() == widgetUtils.OK:
+        message = messages.reply(self.session, title, _("Reply to %s") % (screen_name,), "", users=users, ids=ids)
+        if message.message.ShowModal() == widgetUtils.OK:
             if config.app["app-settings"]["remember_mention_and_longtweet"]:
-                config.app["app-settings"]["longtweet"] = message.message.long_tweet.GetValue()
                 if len(users) > 0:
-                    config.app["app-settings"]["mention_all"] = message.message.mentionAll.GetValue()
+                    config.app["app-settings"]["mention_all"] = message.message.mention_all.GetValue()
                 config.app.write()
-            params = {"_sound": "reply_send.ogg", "in_reply_to_status_id": id, "tweet_mode": "extended"}
-            text = message.message.get_text()
-            if twishort_enabled == False:
-                excluded_ids = message.get_ids()
-                params["exclude_reply_user_ids"] =excluded_ids
-                params["auto_populate_reply_metadata"] =True
-            else:
-                mentioned_people = message.get_people()
-                text = "@"+screen_name+" "+mentioned_people+u" "+text
-            if len(text) > 280 and message.message.get("long_tweet") == True:
-                if message.image == None:
-                    text = twishort.create_tweet(self.session.settings["twitter"]["user_key"], self.session.settings["twitter"]["user_secret"], text)
-                else:
-                    text = twishort.create_tweet(self.session.settings["twitter"]["user_key"], self.session.settings["twitter"]["user_secret"], text, 1)
-            params["status"] = text
-            if message.image == None:
-                params["call_name"] = "update_status"
-            else:
-                params["call_name"] = "update_status_with_media"
-                params["media"] = message.file
-            item = self.session.api_call(**params)
-            # We will no longer will reuse the sent item from here as Streaming API should give us the new and correct item.
-            # but in case we'd need it, just uncomment the following couple of lines and make sure we reduce the item correctly.
-#            if item != None:
-#                pub.sendMessage("sent-tweet", data=item, user=self.session.db["user_name"])
+            tweet_data = dict(text=message.message.text.GetValue(), attachments=message.attachments, poll_options=message.poll_options, poll_period=message.poll_period)
+            call_threaded(self.session.reply, in_reply_to_status_id=id, text=message.message.text.GetValue(), attachments=message.attachments, exclude_reply_user_ids=message.get_ids())
         if hasattr(message.message, "destroy"): message.message.destroy()
         self.session.settings.write()
 
@@ -477,25 +424,23 @@ class BaseBuffer(base.Buffer):
         else:
             screen_name = self.session.get_user(tweet.user).screen_name
             users = utils.get_all_users(tweet, self.session)
-        dm = messages.dm(self.session, _(u"Direct message to %s") % (screen_name,), _(u"New direct message"), users)
-        if dm.message.get_response() == widgetUtils.OK:
-            screen_name = dm.message.get("cb")
+        dm = messages.dm(self.session, _("Direct message to %s") % (screen_name,), _("New direct message"), users)
+        if dm.message.ShowModal() == widgetUtils.OK:
+            screen_name = dm.message.cb.GetValue()
             user = self.session.get_user_by_screen_name(screen_name)
             recipient_id =  user
-            text = dm.message.get_text()
-            val = self.session.api_call(call_name="send_direct_message", recipient_id=recipient_id, text=text)
-            if val != None:
-                sent_dms = self.session.db["sent_direct_messages"]
-                if self.session.settings["general"]["reverse_timelines"] == False:
-                    sent_dms.append(val)
-                else:
-                    sent_dms.insert(0, val)
-                self.session.db["sent_direct_messages"] = sent_dms
-                pub.sendMessage("sent-dm", data=val, user=self.session.db["user_name"])
+            text = dm.message.text.GetValue()
+            if len(dm.attachments) > 0:
+                attachment = dm.attachments[0]
+            else:
+                attachment = None
+            call_threaded(self.session.direct_message, text=text, recipient=recipient_id, attachment=attachment)
         if hasattr(dm.message, "destroy"): dm.message.destroy()
 
     @_tweets_exist
     def share_item(self, *args, **kwargs):
+        if self.can_share() == False:
+            return output.speak(_("This action is not supported on protected accounts."))
         tweet = self.get_right_tweet()
         id = tweet.id
         if self.session.settings["general"]["retweet_mode"] == "ask":
@@ -509,44 +454,24 @@ class BaseBuffer(base.Buffer):
         else:
             self._retweet_with_comment(tweet, id)
 
-    def _retweet_with_comment(self, tweet, id, comment=''):
-        # If quoting a retweet, let's quote the original tweet instead the retweet.
+    def _retweet_with_comment(self, tweet, id):
         if hasattr(tweet, "retweeted_status"):
             tweet = tweet.retweeted_status
-        if hasattr(tweet, "full_text"):
-            comments = tweet.full_text
-        else:
-            comments = tweet.text
-        retweet = messages.tweet(self.session, _(u"Quote"), _(u"Add your comment to the tweet"), u"“@%s: %s ”" % (self.session.get_user(tweet.user).screen_name, comments), max=256, messageType="retweet")
-        if comment != '':
-            retweet.message.set_text(comment)
-        if retweet.message.get_response() == widgetUtils.OK:
-            text = retweet.message.get_text()
-            text = text+" https://twitter.com/{0}/status/{1}".format(self.session.get_user(tweet.user).screen_name, id)
-            if retweet.image == None:
-                # We will no longer will reuse the sent item from here as Streaming API should give us the new and correct item.
-                # but in case we'd need it, just uncomment the following couple of lines and make sure we reduce the item correctly.
-                item = self.session.api_call(call_name="update_status", _sound="retweet_send.ogg", status=text, in_reply_to_status_id=id, tweet_mode="extended")
-#                if item != None:
-#                    new_item = self.session.twitter.get_status(id=item.id, include_ext_alt_text=True, tweet_mode="extended")
-#                    pub.sendMessage("sent-tweet", data=new_item, user=self.session.db["user_name"])
-            else:
-                call_threaded(self.session.api_call, call_name="update_status", _sound="retweet_send.ogg", status=text, media=retweet.image)
-        if hasattr(retweet.message, "destroy"): retweet.message.destroy()
+        retweet = messages.tweet(session=self.session, title=_("Quote"), caption=_("Add your comment to the tweet"), max=256, thread_mode=False)
+        if retweet.message.ShowModal() == widgetUtils.OK:
+            text = retweet.message.text.GetValue()
+            tweet_data = dict(text=text, attachments=retweet.attachments, poll_period=retweet.poll_period, poll_options=retweet.poll_options)
+            tweet_data.update(quote_tweet_id=id)
+            call_threaded(self.session.send_tweet, *[tweet_data])
+        if hasattr(retweet.message, "destroy"):
+            retweet.message.Destroy()
 
     def _direct_retweet(self, id):
         item = self.session.api_call(call_name="retweet", _sound="retweet_send.ogg", id=id)
-        # We will no longer will reuse the sent item from here as Streaming API should give us the new and correct item.
-        # but in case we'd need it, just uncomment the following couple of lines and make sure we reduce the item correctly.
-#        if item != None:
-            # Retweets are returned as non-extended tweets, so let's get the object as extended
-            # just before sending the event message. See https://github.com/manuelcortez/TWBlue/issues/253
-#            item = self.session.twitter.get_status(id=item.id, include_ext_alt_text=True, tweet_mode="extended")
-#            pub.sendMessage("sent-tweet", data=item, user=self.session.db["user_name"])
 
     def onFocus(self, *args, **kwargs):
         tweet = self.get_tweet()
-        if platform.system() == "Windows" and self.session.settings["general"]["relative_times"] == True:
+        if self.session.settings["general"]["relative_times"] == True:
             # fix this:
             original_date = arrow.get(self.session.db[self.name][self.buffer.list.get_selected()].created_at, locale="en")
             ts = original_date.humanize(locale=languageHandler.getLanguage())
@@ -557,6 +482,9 @@ class BaseBuffer(base.Buffer):
             self.session.sound.play("geo.ogg")
         if self.session.settings['sound']['indicate_img'] and utils.is_media(tweet):
             self.session.sound.play("image.ogg")
+        can_share = self.can_share()
+        pub.sendMessage("toggleShare", shareable=can_share)
+        self.buffer.retweet.Enable(can_share)
 
     def audio(self, url='', *args, **kwargs):
         if sound.URLPlayer.player.is_playing():
@@ -652,4 +580,84 @@ class BaseBuffer(base.Buffer):
     def open_in_browser(self, *args, **kwargs):
         url = self.get_item_url()
         output.speak(_(u"Opening item in web browser..."))
-        webbrowser.open(url)
+        webbrowser.open(url)
+
+    def add_to_favorites(self):
+        id = self.get_tweet().id
+        call_threaded(self.session.api_call, call_name="create_favorite", _sound="favourite.ogg", id=id)
+
+    def remove_from_favorites(self):
+        id = self.get_tweet().id
+        call_threaded(self.session.api_call, call_name="destroy_favorite", id=id)
+
+    def toggle_favorite(self):
+        id = self.get_tweet().id
+        tweet = self.session.twitter.get_status(id=id, include_ext_alt_text=True, tweet_mode="extended")
+        if tweet.favorited == False:
+            call_threaded(self.session.api_call, call_name="create_favorite", _sound="favourite.ogg", id=id)
+        else:
+            call_threaded(self.session.api_call, call_name="destroy_favorite", id=id)
+
+    def view_item(self):
+        if self.type == "dm" or self.name == "direct_messages":
+            non_tweet = self.get_formatted_message()
+            item = self.get_right_tweet()
+            original_date = arrow.get(int(item.created_timestamp))
+            date = original_date.shift(seconds=self.session.db["utc_offset"]).format(_(u"MMM D, YYYY. H:m"), locale=languageHandler.getLanguage())
+            msg = messages.viewTweet(non_tweet, [], False, date=date)
+        else:
+            tweet, tweetsList = self.get_full_tweet()
+            msg = messages.viewTweet(tweet, tweetsList, utc_offset=self.session.db["utc_offset"], item_url=self.get_item_url())
+
+    def reverse_geocode(self, geocoder):
+        try:
+            tweet = self.get_tweet()
+            if tweet.coordinates != None:
+                x = tweet.coordinates["coordinates"][0]
+                y = tweet.coordinates["coordinates"][1]
+                address = geocoder.reverse_geocode(y, x, language = languageHandler.curLang)
+                return address
+            else:
+                output.speak(_("There are no coordinates in this tweet"))
+#        except GeocoderError:
+#            output.speak(_(u"There are no results for the coordinates in this tweet"))
+        except ValueError:
+            output.speak(_(u"Error decoding coordinates. Try again later."))
+        except KeyError:
+            pass
+        except AttributeError:
+            pass
+
+    def ocr_image(self):
+        tweet = self.get_tweet()
+        media_list = []
+        if hasattr(tweet, "entities") and tweet.entities.get("media") != None:
+            [media_list.append(i) for i in tweet.entities["media"] if i not in media_list]
+        elif hasattr(tweet, "retweeted_status") and tweet.retweeted_status.get("media") != None:
+            [media_list.append(i) for i in tweet.retweeted_status.entities["media"] if i not in media_list]
+        elif hasattr(tweet, "quoted_status") and tweet.quoted_status.entities.get("media") != None:
+            [media_list.append(i) for i in tweet.quoted_status.entities["media"] if i not in media_list]
+        if len(media_list) > 1:
+            image_list = [_(u"Picture {0}").format(i,) for i in range(0, len(media_list))]
+            dialog = dialogs.urlList.urlList(title=_(u"Select the picture"))
+            if dialog.get_response() == widgetUtils.OK:
+                img = media_list[dialog.get_item()]
+            else:
+                return
+        elif len(media_list) == 1:
+            img = media_list[0]
+        else:
+            output.speak(_(u"Invalid buffer"))
+            return
+        if self.session.settings["mysc"]["ocr_language"] != "":
+            ocr_lang = self.session.settings["mysc"]["ocr_language"]
+        else:
+            ocr_lang = ocr.OCRSpace.short_langs.index(tweet.lang)
+            ocr_lang = ocr.OCRSpace.OcrLangs[ocr_lang]
+        api = ocr.OCRSpace.OCRSpaceAPI()
+        try:
+            text = api.OCR_URL(img["media_url"], lang=ocr_lang)
+        except ocr.OCRSpace.APIError as er:
+            output.speak(_(u"Unable to extract text"))
+            return
+        msg = messages.viewTweet(text["ParsedText"], [], False)

src/controller/buffers/twitter/directMessages.py

@@ -1,5 +1,4 @@
 # -*- coding: utf-8 -*-
-import platform
 import widgetUtils
 import arrow
 import webbrowser
@@ -7,12 +6,12 @@ import output
 import config
 import languageHandler
 import logging
-from controller import messages
-from sessions.twitter import compose, utils
+from sessions.twitter import compose, utils, templates
 from mysc.thread_utils import call_threaded
 from tweepy.errors import TweepyException
 from pubsub import pub
 from wxUI import commonMessageDialogs
+from controller.twitter import messages
 from . import base
 
 log = logging.getLogger("controller.buffers.twitter.dmBuffer")
@@ -70,7 +69,7 @@ class DirectMessagesBuffer(base.BaseBuffer):
         self.session.db["sent_direct_messages"] = sent_dms
         user_ids = [item.message_create["sender_id"] for item in items]
         self.session.save_users(user_ids)
-        pub.sendMessage("more-sent-dms", data=sent, account=self.session.db["user_name"])
+        pub.sendMessage("twitter.more_sent_dms", data=sent, account=self.session.db["user_name"])
         selected = self.buffer.list.get_selected()
         if self.session.settings["general"]["reverse_timelines"] == True:
             for i in received:
@@ -90,22 +89,16 @@ class DirectMessagesBuffer(base.BaseBuffer):
     def reply(self, *args, **kwargs):
         tweet = self.get_right_tweet()
         screen_name = self.session.get_user(tweet.message_create["sender_id"]).screen_name
-        message = messages.reply(self.session, _(u"Mention"), _(u"Mention to %s") % (screen_name,), "@%s " % (screen_name,), [screen_name,])
-        if message.message.get_response() == widgetUtils.OK:
-            if config.app["app-settings"]["remember_mention_and_longtweet"]:
-                config.app["app-settings"]["longtweet"] = message.message.long_tweet.GetValue()
-                config.app.write()
-            if message.image == None:
-                item = self.session.api_call(call_name="update_status", _sound="reply_send.ogg", status=message.message.get_text(), tweet_mode="extended")
-                if item != None:
-                    pub.sendMessage("sent-tweet", data=item, user=self.session.db["user_name"])
-            else:
-                call_threaded(self.session.api_call, call_name="update_status_with_media", _sound="reply_send.ogg", status=message.message.get_text(), media=message.file)
-        if hasattr(message.message, "destroy"): message.message.destroy()
+        message = messages.reply(session=self.session, title=_("Mention"), caption=_("Mention to %s") % (screen_name,), text="@%s " % (screen_name,), thread_mode=False, users=[screen_name,])
+        if message.message.ShowModal() == widgetUtils.OK:
+            tweet_data = message.get_tweet_data()
+            call_threaded(self.session.send_tweet, tweet_data)
+        if hasattr(message.message, "destroy"):
+            message.message.destroy()
 
     def onFocus(self, *args, **kwargs):
         tweet = self.get_tweet()
-        if platform.system() == "Windows" and self.session.settings["general"]["relative_times"] == True:
+        if self.session.settings["general"]["relative_times"] == True:
             # fix this:
             original_date = arrow.get(int(tweet.created_timestamp))
             ts = original_date.humanize(locale=languageHandler.getLanguage())
@@ -135,6 +128,12 @@ class DirectMessagesBuffer(base.BaseBuffer):
     def open_in_browser(self, *args, **kwargs):
         output.speak(_(u"This action is not supported in the buffer yet."))
 
+    def get_message(self):
+        template = self.session.settings["templates"]["dm"]
+        dm = self.get_right_tweet()
+        t = templates.render_dm(dm, template, self.session, relative_times=self.session.settings["general"]["relative_times"], offset_seconds=self.session.db["utc_offset"])
+        return t
+
 class SentDirectMessagesBuffer(DirectMessagesBuffer):
 
     def __init__(self, *args, **kwargs):
@@ -156,4 +155,17 @@ class SentDirectMessagesBuffer(DirectMessagesBuffer):
         else:
             for i in items:
                 tweet = self.compose_function(i, self.session.db, self.session.settings["general"]["relative_times"], self.session.settings["general"]["show_screen_names"], self.session)
-                self.buffer.list.insert_item(False, *tweet)
+                self.buffer.list.insert_item(False, *tweet)
+
+    def get_message(self):
+        template = self.session.settings["templates"]["dm_sent"]
+        dm = self.get_right_tweet()
+        t = templates.render_dm(dm, template, self.session, relative_times=self.session.settings["general"]["relative_times"], offset_seconds=self.session.db["utc_offset"])
+        return t
+
+    def view_item(self):
+        non_tweet = self.get_formatted_message()
+        item = self.get_right_tweet()
+        original_date = arrow.get(int(item.created_timestamp))
+        date = original_date.shift(seconds=self.session.db["utc_offset"]).format(_(u"MMM D, YYYY. H:m"), locale=languageHandler.getLanguage())
+        msg = messages.viewTweet(non_tweet, [], False, date=date)

src/controller/buffers/twitter/list.py

@@ -1,13 +1,8 @@
 # -*- coding: utf-8 -*-
-import platform
-if platform.system() == "Windows":
-    from wxUI import dialogs, commonMessageDialogs
-elif platform.system() == "Linux":
-    from gi.repository import Gtk
-    from gtkUI import dialogs, commonMessageDialogs
 import widgetUtils
 import logging
 from tweepy.cursor import Cursor
+from wxUI import dialogs, commonMessageDialogs
 from . import base
 
 log = logging.getLogger("controller.buffers.twitter.listBuffer")

src/controller/buffers/twitter/people.py

@@ -1,13 +1,5 @@
 # -*- coding: utf-8 -*-
 import time
-import platform
-if platform.system() == "Windows":
-    from wxUI import commonMessageDialogs, menus
-    from controller import user
-elif platform.system() == "Linux":
-    from gi.repository import Gtk
-    from gtkUI import dialogs, commonMessageDialogs
-from controller import messages
 import widgetUtils
 import webbrowser
 import output
@@ -16,7 +8,9 @@ import logging
 from mysc.thread_utils import call_threaded
 from tweepy.errors import TweepyException
 from pubsub import pub
-from sessions.twitter import compose
+from controller.twitter import user, messages
+from sessions.twitter import compose, templates
+from wxUI import commonMessageDialogs, menus
 from . import base
 
 log = logging.getLogger("controller.buffers.twitter.peopleBuffer")
@@ -84,7 +78,10 @@ class PeopleBuffer(base.BaseBuffer):
         pass
 
     def get_message(self):
-        return " ".join(self.compose_function(self.get_tweet(), self.session.db, self.session.settings["general"]["relative_times"], self.session.settings["general"]["show_screen_names"], self.session))
+        template = self.session.settings["templates"]["person"]
+        user = self.get_right_tweet()
+        t = templates.render_person(user, template, self.session, relative_times=True, offset_seconds=self.session.db["utc_offset"])
+        return t
 
     def delete_item(self): pass
 
@@ -92,18 +89,12 @@ class PeopleBuffer(base.BaseBuffer):
     def reply(self, *args, **kwargs):
         tweet = self.get_right_tweet()
         screen_name = tweet.screen_name
-        message = messages.reply(self.session, _(u"Mention"), _(u"Mention to %s") % (screen_name,), "@%s " % (screen_name,), [screen_name,])
-        if message.message.get_response() == widgetUtils.OK:
-            if config.app["app-settings"]["remember_mention_and_longtweet"]:
-                config.app["app-settings"]["longtweet"] = message.message.long_tweet.GetValue()
-                config.app.write()
-            if message.image == None:
-                item = self.session.api_call(call_name="update_status", _sound="reply_send.ogg", status=message.message.get_text(), tweet_mode="extended")
-                if item != None:
-                    pub.sendMessage("sent-tweet", data=item, user=self.session.db["user_name"])
-            else:
-                call_threaded(self.session.api_call, call_name="update_status_with_media", _sound="reply_send.ogg", status=message.message.get_text(), media=message.file)
-        if hasattr(message.message, "destroy"): message.message.destroy()
+        message = messages.tweet(session=self.session, title=_("Mention"), caption=_("Mention to %s") % (screen_name,), text="@%s " % (screen_name,), thread_mode=False)
+        if message.message.ShowModal() == widgetUtils.OK:
+            tweet_data = message.get_tweet_data()
+            call_threaded(self.session.send_tweet, *tweet_data)
+        if hasattr(message.message, "destroy"):
+            message.message.destroy()
 
     def start_stream(self, mandatory=False, play_sound=True, avoid_autoreading=False):
         # starts stream every 3 minutes.
@@ -255,4 +246,9 @@ class PeopleBuffer(base.BaseBuffer):
     def get_item_url(self, *args, **kwargs):
         tweet = self.get_tweet()
         url = "https://twitter.com/{screen_name}".format(screen_name=tweet.screen_name)
-        return url
+        return url
+
+    def view_item(self):
+        item_url = self.get_item_url()
+        non_tweet = self.get_formatted_message()
+        msg = messages.viewTweet(non_tweet, [], False, item_url=item_url)

src/controller/buffers/twitter/search.py

@@ -1,15 +1,10 @@
 # -*- coding: utf-8 -*-
 import time
-import platform
 import locale
-if platform.system() == "Windows":
-    from wxUI import  commonMessageDialogs
-elif platform.system() == "Linux":
-    from gi.repository import Gtk
-    from gtkUI import commonMessageDialogs
 import widgetUtils
 import logging
 from tweepy.errors import TweepyException
+from wxUI import  commonMessageDialogs
 from . import base, people
 
 log = logging.getLogger("controller.buffers.twitter.searchBuffer")
@@ -64,12 +59,20 @@ class SearchPeopleBuffer(people.PeopleBuffer):
             return False
 
 class ConversationBuffer(SearchBuffer):
+    last_thread_id = None
+    last_reply_id = None
+
+    def __init__(self, tweet, *args, **kwargs):
+        self.tweet = tweet
+        super(ConversationBuffer, self).__init__(*args, **kwargs)
 
     def start_stream(self, start=False, mandatory=False, play_sound=True, avoid_autoreading=False):
         current_time = time.time()
         if self.execution_time == 0 or current_time-self.execution_time >= 180 or mandatory == True:
             self.execution_time = current_time
-            results = self.get_replies_v1(self.tweet)
+            log.debug("Retrieving conversation. Last thread ID is {}, last reply ID is {}".format(self.last_thread_id, self.last_reply_id))
+            results = self.get_replies(self.tweet)
+            log.debug("Retrieved {} items before filters.".format(len(results)))
             number_of_items = self.session.order_buffer(self.name, results)
             log.debug("Number of items retrieved: %d" % (number_of_items,))
             self.put_items_on_list(number_of_items)
@@ -117,12 +120,12 @@ class ConversationBuffer(SearchBuffer):
         # find all tweets replying to the original thread only. Those tweets are sent by the same author who originally posted the first tweet.
         try:
             term = "conversation_id:{} from:{} to:{}".format(conversation_id, original_tweet.data.author_id, original_tweet.data.author_id)
-            thread_tweets = self.session.twitter_v2.search_recent_tweets(term, user_auth=True, max_results=98, tweet_fields=["in_reply_to_user_id", "author_id", "conversation_id"])
+            thread_tweets = self.session.twitter_v2.search_recent_tweets(term, user_auth=True, max_results=98, since_id=self.last_thread_id, tweet_fields=["in_reply_to_user_id", "author_id", "conversation_id"])
             if thread_tweets.data != None:
                 thread_results.extend(thread_tweets.data)
             # Search only replies to conversation_id.
             term = "conversation_id:{}".format(conversation_id, original_tweet.data.author_id)
-            reply_tweets = self.session.twitter_v2.search_recent_tweets(term, user_auth=True, max_results=50, tweet_fields=["in_reply_to_user_id", "author_id", "conversation_id"])
+            reply_tweets = self.session.twitter_v2.search_recent_tweets(term, user_auth=True, max_results=50, since_id=self.last_reply_id, tweet_fields=["in_reply_to_user_id", "author_id", "conversation_id"])
             if reply_tweets.data != None:
                 reply_results.extend(reply_tweets.data)
         except TweepyException as e:
@@ -135,6 +138,7 @@ class ConversationBuffer(SearchBuffer):
             try:
                 thread_results = self.session.twitter.lookup_statuses(ids, include_ext_alt_text=True, tweet_mode="extended")
                 thread_results.sort(key=lambda x: x.id)
+                self.last_thread_id = thread_results[-1].id
                 results.extend(thread_results)
             except TweepyException as e:
                 log.exception("There was an error attempting to retrieve tweets for Twitter API V1.1, in conversation buffer {}".format(self.name))
@@ -144,9 +148,11 @@ class ConversationBuffer(SearchBuffer):
             try:
                 reply_results = self.session.twitter.lookup_statuses(ids, include_ext_alt_text=True, tweet_mode="extended")
                 reply_results.sort(key=lambda x: x.id)
+                self.last_reply_id = reply_results[-1].id
                 results.extend(reply_results)
             except TweepyException as e:
                 log.exception("There was an error attempting to retrieve tweets for Twitter API V1.1, in conversation buffer {}".format(self.name))
+        results.sort(key=lambda x: x.id)
         return results
 
     def get_replies_v1(self, tweet):

src/controller/buffers/twitter/trends.py

@@ -1,20 +1,14 @@
 # -*- coding: utf-8 -*-
 import time
-import platform
-if platform.system() == "Windows":
-    import wx
-    from wxUI import buffers, commonMessageDialogs, menus
-    from controller import user
-elif platform.system() == "Linux":
-    from gi.repository import Gtk
-    from gtkUI import buffers, commonMessageDialogs
-from controller import messages
+import wx
 import widgetUtils
 import output
 import logging
 from mysc.thread_utils import call_threaded
 from tweepy.errors import TweepyException
 from pubsub import pub
+from wxUI import buffers, commonMessageDialogs, menus
+from controller.twitter import user, messages
 from controller.buffers import base
 
 log = logging.getLogger("controller.buffers.twitter.trends")
@@ -26,7 +20,7 @@ class TrendsBuffer(base.Buffer):
         self.session = sessionObject
         self.account = account
         self.invisible = True
-        self.buffer = buffers.trendsPanel(parent, name)
+        self.buffer = buffers.twitter.trendsPanel(parent, name)
         self.buffer.account = account
         self.type = self.buffer.type
         self.bind_events()
@@ -38,6 +32,18 @@ class TrendsBuffer(base.Buffer):
         self.get_formatted_message = self.get_message
         self.reply = self.search_topic
 
+
+    def post_status(self, *args, **kwargs):
+        title = _("Tweet")
+        caption = _("Write the tweet here")
+        tweet = messages.tweet(self.session, title, caption, "")
+        response = tweet.message.ShowModal()
+        if response == wx.ID_OK:
+            tweet_data = tweet.get_tweet_data()
+            call_threaded(self.session.send_tweet, *tweet_data)
+        if hasattr(tweet.message, "destroy"):
+            tweet.message.destroy()
+
     def start_stream(self, mandatory=False, play_sound=True, avoid_autoreading=False):
         # starts stream every 3 minutes.
         current_time = time.time()
@@ -119,21 +125,13 @@ class TrendsBuffer(base.Buffer):
 
     def tweet_about_this_trend(self, *args, **kwargs):
         if self.buffer.list.get_count() == 0: return
-        title = _(u"Tweet")
-        caption = _(u"Write the tweet here")
-        tweet = messages.tweet(self.session, title, caption, self.get_message()+ " ")
-        tweet.message.set_cursor_at_end()
-        if tweet.message.get_response() == widgetUtils.OK:
-            text = tweet.message.get_text()
-            if len(text) > 280 and tweet.message.get("long_tweet") == True:
-                if tweet.image == None:
-                    text = twishort.create_tweet(self.session.settings["twitter"]["user_key"], self.session.settings["twitter"]["user_secret"], text)
-                else:
-                    text = twishort.create_tweet(self.session.settings["twitter"]["user_key"], self.session.settings["twitter"]["user_secret"], text, 1)
-            if tweet.image == None:
-                call_threaded(self.session.api_call, call_name="update_status", status=text)
-            else:
-                call_threaded(self.session.api_call, call_name="update_status_with_media", status=text, media=tweet.image)
+        title = _("Tweet")
+        caption = _("Write the tweet here")
+        tweet = messages.tweet(session=self.session, title=title, caption=caption, text=self.get_message()+ " ")
+        tweet.message.SetInsertionPoint(len(tweet.message.GetValue()))
+        if tweet.message.ShowModal() == widgetUtils.OK:
+            tweet_data = tweet.get_tweet_data()
+            call_threaded(self.session.send_tweet, *tweet_data)
         if hasattr(tweet.message, "destroy"): tweet.message.destroy()
 
     def show_menu_by_key(self, ev):

src/controller/mastodon/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

src/controller/mastodon/handler.py

@@ -0,0 +1,179 @@
+# -*- coding: utf-8 -*-
+import wx
+import logging
+from pubsub import pub
+from wxUI.dialogs.mastodon import dialogs
+from wxUI.dialogs.mastodon import search as search_dialogs
+from wxUI.dialogs.mastodon import dialogs
+from wxUI import commonMessageDialogs
+from sessions.twitter import utils
+from . import userActions
+
+log = logging.getLogger("controller.mastodon.handler")
+
+class Handler(object):
+
+    def __init__(self):
+        super(Handler, self).__init__()
+
+    def create_buffers(self, session, createAccounts=True, controller=None):
+        session.get_user_info()
+        name = session.get_name()
+        if createAccounts == True:
+            pub.sendMessage("core.create_account", name=name, session_id=session.session_id, logged=True)
+        root_position =controller.view.search(name, name)
+        for i in session.settings['general']['buffer_order']:
+            if i == 'home':
+                pub.sendMessage("createBuffer", buffer_type="BaseBuffer", session_type=session.type, buffer_title=_("Home"), parent_tab=root_position, start=False, kwargs=dict(parent=controller.view.nb, function="timeline_home", name="home_timeline", sessionObject=session, account=name, sound="tweet_received.ogg"))
+            elif i == 'local':
+                pub.sendMessage("createBuffer", buffer_type="BaseBuffer", session_type=session.type, buffer_title=_("Local"), parent_tab=root_position, start=False, kwargs=dict(parent=controller.view.nb, function="timeline_local", name="local_timeline", sessionObject=session, account=name, sound="tweet_received.ogg"))
+            elif i == 'federated':
+                pub.sendMessage("createBuffer", buffer_type="BaseBuffer", session_type=session.type, buffer_title=_("Federated"), parent_tab=root_position, start=False, kwargs=dict(parent=controller.view.nb, function="timeline_public", name="federated_timeline", sessionObject=session, account=name, sound="tweet_received.ogg"))
+            elif i == 'mentions':
+                pub.sendMessage("createBuffer", buffer_type="MentionsBuffer", session_type=session.type, buffer_title=_("Mentions"), parent_tab=root_position, start=False, kwargs=dict(parent=controller.view.nb, function="notifications", name="mentions", sessionObject=session, account=name, sound="mention_received.ogg"))
+            elif i == 'direct_messages':
+                pub.sendMessage("createBuffer", buffer_type="ConversationListBuffer", session_type=session.type, buffer_title=_("Direct messages"), parent_tab=root_position, start=False, kwargs=dict(compose_func="compose_conversation", parent=controller.view.nb, function="conversations", name="direct_messages", sessionObject=session, account=name, sound="dm_received.ogg"))
+            elif i == 'sent':
+                pub.sendMessage("createBuffer", buffer_type="BaseBuffer", session_type=session.type, buffer_title=_("Sent"), parent_tab=root_position, start=False, kwargs=dict(parent=controller.view.nb, function="account_statuses", name="sent", sessionObject=session, account=name, sound="tweet_received.ogg", id=session.db["user_id"]))
+            elif i == 'favorites':
+                pub.sendMessage("createBuffer", buffer_type="BaseBuffer", session_type=session.type, buffer_title=_("Favorites"), parent_tab=root_position, start=False, kwargs=dict(parent=controller.view.nb, function="favourites", name="favorites", sessionObject=session, account=name, sound="favourite.ogg"))
+            elif i == 'bookmarks':
+                pub.sendMessage("createBuffer", buffer_type="BaseBuffer", session_type=session.type, buffer_title=_("Bookmarks"), parent_tab=root_position, start=False, kwargs=dict(parent=controller.view.nb, function="bookmarks", name="bookmarks", sessionObject=session, account=name, sound="favourite.ogg"))
+            elif i == 'followers':
+                pub.sendMessage("createBuffer", buffer_type="UserBuffer", session_type=session.type, buffer_title=_("Followers"), parent_tab=root_position, start=False, kwargs=dict(parent=controller.view.nb, compose_func="compose_user", function="account_followers", name="followers", sessionObject=session, account=name, sound="update_followers.ogg", id=session.db["user_id"]))
+            elif i == 'following':
+                pub.sendMessage("createBuffer", buffer_type="UserBuffer", session_type=session.type, buffer_title=_("Following"), parent_tab=root_position, start=False, kwargs=dict(parent=controller.view.nb, compose_func="compose_user", function="account_following", name="following", sessionObject=session, account=name, sound="update_followers.ogg", id=session.db["user_id"]))
+            elif i == 'muted':
+                pub.sendMessage("createBuffer", buffer_type="UserBuffer", session_type=session.type, buffer_title=_("Muted users"), parent_tab=root_position, start=False, kwargs=dict(parent=controller.view.nb, compose_func="compose_user", function="mutes", name="muted", sessionObject=session, account=name))
+            elif i == 'blocked':
+                pub.sendMessage("createBuffer", buffer_type="UserBuffer", session_type=session.type, buffer_title=_("Blocked users"), parent_tab=root_position, start=False, kwargs=dict(parent=controller.view.nb, compose_func="compose_user", function="blocks", name="blocked", sessionObject=session, account=name))
+        pub.sendMessage("createBuffer", buffer_type="EmptyBuffer", session_type="base", buffer_title=_("Timelines"), parent_tab=root_position, start=False, kwargs=dict(parent=controller.view.nb, name="timelines", account=name))
+        timelines_position =controller.view.search("timelines", name)
+        for i in session.settings["other_buffers"]["timelines"]:
+                pub.sendMessage("createBuffer", buffer_type="BaseBuffer", session_type=session.type, buffer_title=i, parent_tab=timelines_position, start=False, kwargs=dict(parent=controller.view.nb, function="account_statuses", name="%s-timeline".format(i), sessionObject=session, account=name, sound="tweet_timeline.ogg", id=i))
+        for i in session.settings["other_buffers"]["followers_timelines"]:
+            pub.sendMessage("createBuffer", buffer_type="UserBuffer", session_type=session.type, buffer_title=_("Followers for {}").format(i), parent_tab=timelines_position, start=False, kwargs=dict(parent=controller.view.nb, compose_func="compose_user", function="account_followers", name="%s-followers" % (i,), sessionObject=session, account=name, sound="new_event.ogg", id=i))
+        for i in session.settings["other_buffers"]["following_timelines"]:
+            pub.sendMessage("createBuffer", buffer_type="UserBuffer", session_type=session.type, buffer_title=_("Following for {}").format(i), parent_tab=timelines_position, start=False, kwargs=dict(parent=controller.view.nb, compose_func="compose_user", function="account_following", name="%s-following" % (i,), sessionObject=session, account=name, sound="new_event.ogg", id=i))
+#        pub.sendMessage("createBuffer", buffer_type="EmptyBuffer", session_type="base", buffer_title=_("Lists"), parent_tab=root_position, start=False, kwargs=dict(parent=controller.view.nb, name="lists", name))
+#        lists_position =controller.view.search("lists", session.db["user_name"])
+#        for i in session.settings["other_buffers"]["lists"]:
+#            pub.sendMessage("createBuffer", buffer_type="ListBuffer", session_type=session.type, buffer_title=_(u"List for {}").format(i), parent_tab=lists_position, start=False, kwargs=dict(parent=controller.view.nb, function="list_timeline", name="%s-list" % (i,), sessionObject=session, name, bufferType=None, sound="list_tweet.ogg", list_id=utils.find_list(i, session.db["lists"]), include_ext_alt_text=True, tweet_mode="extended"))
+        pub.sendMessage("createBuffer", buffer_type="EmptyBuffer", session_type="base", buffer_title=_("Searches"), parent_tab=root_position, start=False, kwargs=dict(parent=controller.view.nb, name="searches", account=name))
+#        searches_position =controller.view.search("searches", session.db["user_name"])
+#        for i in session.settings["other_buffers"]["tweet_searches"]:
+#            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, 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, name, trendsFor=i, sound="trends_updated.ogg"))
+
+    def start_buffer(self, controller, buffer):
+        if hasattr(buffer, "finished_timeline") and buffer.finished_timeline == False:
+            change_title = True
+        else:
+            change_title = False
+        try:
+            buffer.start_stream(play_sound=False)
+        except Exception as err:
+            log.exception("Error %s starting buffer %s on account %s, with args %r and kwargs %r." % (str(err), buffer.name, buffer.account, buffer.args, buffer.kwargs))
+        if change_title:
+            pub.sendMessage("buffer-title-changed", buffer=buffer)
+
+    def open_conversation(self, controller, buffer):
+        post = buffer.get_item()
+        if post.reblog != None:
+            post = post.reblog
+        conversations_position =controller.view.search("direct_messages", buffer.session.get_name())
+        pub.sendMessage("createBuffer", buffer_type="ConversationBuffer", session_type=buffer.session.type, buffer_title=_("Conversation with {0}").format(post.account.acct), parent_tab=conversations_position, start=True, kwargs=dict(parent=controller.view.nb, function="status_context", name="%s-conversation" % (post.id,), sessionObject=buffer.session, account=buffer.session.get_name(), sound="search_updated.ogg", post=post, id=post.id))
+
+    def follow(self, buffer):
+        if not hasattr(buffer, "get_item"):
+            return
+        item = buffer.get_item()
+        if buffer.type == "user":
+            users = [item.acct]
+        elif buffer.type == "baseBuffer":
+            if item.reblog != None:
+                users = [user.acct for user in item.reblog.mentions if user.id != buffer.session.db["user_id"]]
+                if item.reblog.account.acct not in users and item.account.id != buffer.session.db["user_id"]:
+                    users.insert(0, item.reblog.account.acct)
+            else:
+                users = [user.acct for user in item.mentions if user.id != buffer.session.db["user_id"]]
+            if item.account.acct not in users:
+                users.insert(0, item.account.acct)
+        u = userActions.userActions(buffer.session, users)
+
+    def search(self, controller, session, value):
+        log.debug("Creating a new search...")
+        dlg = search_dialogs.searchDialog(value)
+        if dlg.ShowModal() == wx.ID_OK and dlg.term.GetValue() != "":
+            term = dlg.term.GetValue()
+            searches_position =controller.view.search("searches", session.get_name())
+            if dlg.posts.GetValue() == True:
+                if term not in session.settings["other_buffers"]["post_searches"]:
+                    session.settings["other_buffers"]["post_searches"].append(term)
+                    session.settings.write()
+#                    pub.sendMessage("createBuffer", buffer_type="SearchBuffer", session_type=session.type, buffer_title=_("Search for {}").format(term), parent_tab=searches_position, start=True, kwargs=dict(parent=controller.view.nb, function="search_tweets", name="%s-searchterm" % (term,), sessionObject=session, account=session.get_name(), bufferType="searchPanel", sound="search_updated.ogg", q=term, include_ext_alt_text=True, tweet_mode="extended"))
+                else:
+                    log.error("A buffer for the %s search term is already created. You can't create a duplicate buffer." % (term,))
+                    return
+            elif dlg.users.GetValue() == True:
+                pub.sendMessage("createBuffer", buffer_type="UserBuffer", session_type=session.type, buffer_title=_("Search for {}").format(term), parent_tab=searches_position, start=True, kwargs=dict(parent=controller.view.nb, compose_func="compose_user", function="account_search", name="%s-searchUser" % (term,), sessionObject=session, account=session.get_name(), sound="search_updated.ogg", q=term))
+        dlg.Destroy()
+
+    # ToDo: explore how to play sound & save config differently.
+    # currently, TWBlue will play the sound and save the config for the timeline even if the buffer did not load or something else.
+    def open_timeline(self, controller, buffer):
+        if not hasattr(buffer, "get_item"):
+            return
+        item = buffer.get_item()
+        if buffer.type == "user":
+            users = [item.acct]
+        elif buffer.type == "baseBuffer":
+            if item.reblog != None:
+                users = [user.acct for user in item.reblog.mentions if user.id != buffer.session.db["user_id"]]
+                if item.reblog.account.acct not in users and item.account.id != buffer.session.db["user_id"]:
+                    users.insert(0, item.reblog.account.acct)
+            else:
+                users = [user.acct for user in item.mentions if user.id != buffer.session.db["user_id"]]
+            if item.account.acct not in users and item.account.id != buffer.session.db["user_id"]:
+                users.insert(0, item.account.acct)
+                u = userActions.UserTimeline(buffer.session, users)
+                if u.dialog.ShowModal() == wx.ID_OK:
+                    action = u.process_action()
+                    if action == None:
+                        return
+                    user = u.user
+                    if action == "posts":
+                        if user.statuses_count == 0:
+                            dialogs.no_posts()
+                            return
+                        if user.id in buffer.session.settings["other_buffers"]["timelines"]:
+                            commonMessageDialogs.timeline_exist()
+                            return
+                        timelines_position =controller.view.search("timelines", buffer.session.get_name())
+                        pub.sendMessage("createBuffer", buffer_type="BaseBuffer", session_type=buffer.session.type, buffer_title=_("Timeline for {}").format(user.username,), parent_tab=timelines_position, start=True, kwargs=dict(parent=controller.view.nb, function="account_statuses", name="%s-timeline" % (user.id,), sessionObject=buffer.session, account=buffer.session.get_name(), sound="tweet_timeline.ogg", id=user.id))
+                        buffer.session.settings["other_buffers"]["timelines"].append(user.id)
+                        buffer.session.sound.play("create_timeline.ogg")
+                    elif action == "followers":
+                        if user.followers_count == 0:
+                            dialogs.no_followers()
+                            return
+                        if user.id in buffer.session.settings["other_buffers"]["followers_timelines"]:
+                            commonMessageDialogs.timeline_exist()
+                            return
+                        timelines_position =controller.view.search("timelines", buffer.session.get_name())
+                        pub.sendMessage("createBuffer", buffer_type="UserBuffer", session_type=buffer.session.type, buffer_title=_("Followers for {}").format(user.username,), parent_tab=timelines_position, start=True, kwargs=dict(parent=controller.view.nb, compose_func="compose_user", function="account_followers", name="%s-followers" % (user.id,), sessionObject=buffer.session, account=buffer.session.get_name(), sound="new_event.ogg", id=user.id))
+                        buffer.session.settings["other_buffers"]["followers_timelines"].append(user.id)
+                        buffer.session.sound.play("create_timeline.ogg")
+                    elif action == "following":
+                        if user.following_count == 0:
+                            dialogs.no_following()
+                            return
+                        if user.id in buffer.session.settings["other_buffers"]["following_timelines"]:
+                            commonMessageDialogs.timeline_exist()
+                            return
+                        timelines_position =controller.view.search("timelines", buffer.session.get_name())
+                        pub.sendMessage("createBuffer", buffer_type="UserBuffer", session_type=buffer.session.type, buffer_title=_("Following for {}").format(user.username,), parent_tab=timelines_position, start=True, kwargs=dict(parent=controller.view.nb, compose_func="compose_user", function="account_following", name="%s-followers" % (user.id,), sessionObject=buffer.session, account=buffer.session.get_name(), sound="new_event.ogg", id=user.id))
+                        buffer.session.settings["other_buffers"]["following_timelines"].append(user.id)
+                        buffer.session.sound.play("create_timeline.ogg")
+        buffer.session.settings.write()

src/controller/mastodon/messages.py

@@ -0,0 +1,227 @@
+# -*- coding: utf-8 -*-
+import os
+import wx
+import widgetUtils
+import config
+import output
+from controller.twitter import messages
+from sessions.mastodon import templates
+from wxUI.dialogs.mastodon import postDialogs
+
+class post(messages.basicTweet):
+    def __init__(self, session, title, caption, text="", *args, **kwargs):
+        # take max character limit from session as this might be different for some instances.
+        self.max = session.char_limit
+        self.title = title
+        self.session = session
+        self.message = postDialogs.Post(caption=caption, text=text, *args, **kwargs)
+        self.message.SetTitle(title)
+        self.message.text.SetInsertionPoint(len(self.message.text.GetValue()))
+        widgetUtils.connect_event(self.message.spellcheck, widgetUtils.BUTTON_PRESSED, self.spellcheck)
+        widgetUtils.connect_event(self.message.text, widgetUtils.ENTERED_TEXT, self.text_processor)
+        widgetUtils.connect_event(self.message.translate, widgetUtils.BUTTON_PRESSED, self.translate)
+        widgetUtils.connect_event(self.message.add, widgetUtils.BUTTON_PRESSED, self.on_attach)
+        widgetUtils.connect_event(self.message.remove_attachment, widgetUtils.BUTTON_PRESSED, self.remove_attachment)
+        # ToDo: Add autocomplete feature to mastodon and uncomment this.
+        # widgetUtils.connect_event(self.message.autocomplete_users, widgetUtils.BUTTON_PRESSED, self.autocomplete_users)
+        widgetUtils.connect_event(self.message.add_post, widgetUtils.BUTTON_PRESSED, self.add_post)
+        widgetUtils.connect_event(self.message.remove_post, widgetUtils.BUTTON_PRESSED, self.remove_post)
+        self.attachments = []
+        self.thread = []
+        self.text_processor()
+
+    def add_post(self, event, update_gui=True, *args, **kwargs):
+        text = self.message.text.GetValue()
+        attachments = self.attachments[::]
+        postdata = dict(text=text, attachments=attachments, sensitive=self.message.sensitive.GetValue(), spoiler_text=None)
+        if postdata.get("sensitive") == True:
+            postdata.update(spoiler_text=self.message.spoiler.GetValue())
+        self.thread.append(postdata)
+        self.attachments = []
+        if update_gui:
+            self.message.reset_controls()
+            self.message.add_item(item=[text, len(attachments)], list_type="post")
+            self.message.text.SetFocus()
+            self.text_processor()
+
+    def get_post_data(self):
+        self.add_post(event=None, update_gui=False)
+        return self.thread
+
+    def text_processor(self, *args, **kwargs):
+        super(post, self).text_processor(*args, **kwargs)
+        if len(self.thread) > 0:
+            if hasattr(self.message, "posts"):
+                self.message.posts.Enable(True)
+                self.message.remove_post.Enable(True)
+            else:
+                self.message.posts.Enable(False)
+                self.message.remove_post.Enable(False)
+        if len(self.attachments) > 0:
+            self.message.attachments.Enable(True)
+            self.message.remove_attachment.Enable(True)
+        else:
+            self.message.attachments.Enable(False)
+            self.message.remove_attachment.Enable(False)
+        if len(self.message.text.GetValue()) > 0 or len(self.attachments) > 0:
+            self.message.add_post.Enable(True)
+        else:
+            self.message.add_post.Enable(False)
+
+    def remove_post(self, *args, **kwargs):
+        post = self.message.posts.GetFocusedItem()
+        if post > -1 and len(self.thread) > post:
+            self.thread.pop(post)
+            self.message.remove_item(list_type="post")
+            self.text_processor()
+            self.message.text.SetFocus()
+
+    def can_attach(self):
+        if len(self.attachments) == 0:
+            return True
+        elif len(self.attachments) == 1 and (self.attachments[0]["type"] == "poll" or self.attachments[0]["type"] == "video" or self.attachments[0]["type"] == "audio"):
+            return False
+        elif len(self.attachments) < 4:
+            return True
+        return False
+
+    def on_attach(self, *args, **kwargs):
+        can_attach = self.can_attach()
+        menu = self.message.attach_menu(can_attach)
+        self.message.Bind(wx.EVT_MENU, self.on_attach_image, self.message.add_image)
+        self.message.Bind(wx.EVT_MENU, self.on_attach_video, self.message.add_video)
+        self.message.Bind(wx.EVT_MENU, self.on_attach_audio, self.message.add_audio)
+        self.message.Bind(wx.EVT_MENU, self.on_attach_poll, self.message.add_poll)
+        self.message.PopupMenu(menu, self.message.add.GetPosition())
+
+    def on_attach_image(self, *args, **kwargs):
+        can_attach = self.can_attach()
+        big_media_present = False
+        for a in self.attachments:
+            if a["type"] == "video" or a["type"] == "audio" or a["type"] == "poll":
+                big_media_present = True
+                break
+        if can_attach == False or big_media_present == True:
+            return self.message.unable_to_attach_file()
+        image, description  = self.message.get_image()
+        if image != None:
+            if image.endswith("gif"):
+                image_type = "gif"
+            else:
+                image_type = "photo"
+            imageInfo = {"type": image_type, "file": image, "description": description}
+            if len(self.attachments) > 0 and image_type == "gif":
+                return self.message.unable_to_attach_file()
+            self.attachments.append(imageInfo)
+            self.message.add_item(item=[os.path.basename(imageInfo["file"]), imageInfo["type"], imageInfo["description"]])
+            self.text_processor()
+
+    def on_attach_video(self, *args, **kwargs):
+        if len(self.attachments) >= 4:
+            return self.message.unable_to_attach_file()
+        can_attach = self.can_attach()
+        big_media_present = False
+        for a in self.attachments:
+            if a["type"] == "video" or a["type"] == "audio" or a["type"] == "poll":
+                big_media_present = True
+                break
+        if can_attach == False or big_media_present == True:
+            return self.message.unable_to_attach_file()
+        video = self.message.get_video()
+        if video != None:
+            videoInfo = {"type": "video", "file": video, "description": ""}
+            self.attachments.append(videoInfo)
+            self.message.add_item(item=[os.path.basename(videoInfo["file"]), videoInfo["type"], videoInfo["description"]])
+            self.text_processor()
+
+    def on_attach_audio(self, *args, **kwargs):
+        if len(self.attachments) >= 4:
+            return self.message.unable_to_attach_file()
+        can_attach = self.can_attach()
+        big_media_present = False
+        for a in self.attachments:
+            if a["type"] == "video" or a["type"] == "audio" or a["type"] == "poll":
+                big_media_present = True
+                break
+        if can_attach == False or big_media_present == True:
+            return self.message.unable_to_attach_file()
+        audio = self.message.get_audio()
+        if audio != None:
+            audioInfo = {"type": "audio", "file": audio, "description": ""}
+            self.attachments.append(audioInfo)
+            self.message.add_item(item=[os.path.basename(audioInfo["file"]), audioInfo["type"], audioInfo["description"]])
+            self.text_processor()
+
+    def on_attach_poll(self, *args, **kwargs):
+        if len(self.attachments) > 0:
+            return self.message.unable_to_attach_poll()
+        can_attach = self.can_attach()
+        big_media_present = False
+        for a in self.attachments:
+            if a["type"] == "video" or a["type"] == "audio" or a["type"] == "poll":
+                big_media_present = True
+                break
+        if can_attach == False or big_media_present == True:
+            return self.message.unable_to_attach_file()
+        dlg = postDialogs.poll()
+        if dlg.ShowModal() == wx.ID_OK:
+            day = 86400
+            periods = [300, 1800, 3600, 21600, day, day*2, day*3, day*4, day*5, day*6, day*7]
+            period = periods[dlg.period.GetSelection()]
+            poll_options = dlg.get_options()
+            multiple = dlg.multiple.GetValue()
+            hide_totals = dlg.hide_votes.GetValue()
+            data = dict(type="poll", file="", description=_("Poll with {} options").format(len(poll_options)), options=poll_options, expires_in=period, multiple=multiple, hide_totals=hide_totals)
+            self.attachments.append(data)
+            self.message.add_item(item=[data["file"], data["type"], data["description"]])
+            self.text_processor()
+        dlg.Destroy()
+
+    def get_data(self):
+        self.add_post(event=None, update_gui=False)
+        return self.thread
+
+    def get_visibility(self):
+        visibility_settings = ["public", "unlisted", "private", "direct"]
+        return visibility_settings[self.message.visibility.GetSelection()]
+
+class viewPost(post):
+    def __init__(self, post, offset_hours=0, date="", item_url=""):
+        if post.reblog != None:
+            post = post.reblog
+        author = post.account.display_name if post.account.display_name != "" else post.account.username
+        title = _(u"Post from {}").format(author)
+        image_description = templates.process_image_descriptions(post.media_attachments)
+        text = templates.process_text(post, safe=False)
+        date = templates.process_date(post.created_at, relative_times=False, offset_hours=offset_hours)
+        privacy_settings = dict(public=_("Public"), unlisted=_("Not listed"), private=_("followers only"), direct=_("Direct"))
+        privacy = privacy_settings.get(post.visibility)
+        boost_count = str(post.reblogs_count)
+        favs_count = str(post.favourites_count)
+        # Gets the client from where this post was made.
+        source_obj = post.get("application")
+        if source_obj == None:
+            source = _("Remote instance")
+        else:
+            source = source_obj.get("name")
+        self.message = postDialogs.viewPost(text=text, boosts_count=boost_count, favs_count=favs_count, source=source, date=date, privacy=privacy)
+        self.message.SetTitle(title)
+        if image_description != "":
+            self.message.image_description.Enable(True)
+            self.message.image_description.ChangeValue(image_description)
+        widgetUtils.connect_event(self.message.spellcheck, widgetUtils.BUTTON_PRESSED, self.spellcheck)
+        if item_url != "":
+            self.message.enable_button("share")
+            widgetUtils.connect_event(self.message.share, widgetUtils.BUTTON_PRESSED, self.share)
+            self.item_url = item_url
+        widgetUtils.connect_event(self.message.translateButton, widgetUtils.BUTTON_PRESSED, self.translate)
+        self.message.ShowModal()
+
+    # We won't need text_processor in this dialog, so let's avoid it.
+    def text_processor(self):
+        pass
+
+    def share(self, *args, **kwargs):
+        if hasattr(self, "item_url"):
+            output.copy(self.item_url)
+            output.speak(_("Link copied to clipboard."))

src/controller/mastodon/userActions.py

@@ -0,0 +1,101 @@
+# -*- coding: utf-8 -*-
+import logging
+import widgetUtils
+import output
+from wxUI.dialogs.mastodon import userActions as userActionsDialog
+from wxUI.dialogs.mastodon import userTimeline as userTimelineDialog
+from pubsub import pub
+from mastodon import MastodonError, MastodonNotFoundError
+from extra.autocompletionUsers import completion
+
+log = logging.getLogger("controller.mastodon.userActions")
+
+class BasicUserSelector(object):
+    def __init__(self, session, users=[]):
+        super(BasicUserSelector, self).__init__()
+        self.session = session
+        self.create_dialog(users=users)
+
+    def create_dialog(self, users):
+        pass
+
+    def autocomplete_users(self, *args, **kwargs):
+        c = completion.autocompletionUsers(self.dialog, self.session.session_id)
+        c.show_menu("dm")
+
+    def search_user(self, user):
+        try:
+            user = self.session.api.account_lookup(user)
+            return user
+        except MastodonError:
+            log.exception("Error searching for user %s.".format(user))
+
+class userActions(BasicUserSelector):
+
+    def __init__(self, *args, **kwargs):
+        super(userActions, self).__init__(*args, **kwargs)
+        if self.dialog.get_response() == widgetUtils.OK:
+            self.process_action()
+
+    def create_dialog(self, users):
+        self.dialog = userActionsDialog.UserActionsDialog(users)
+        widgetUtils.connect_event(self.dialog.autocompletion, widgetUtils.BUTTON_PRESSED, self.autocomplete_users)
+
+    def process_action(self):
+        action = self.dialog.get_action()
+        user = self.dialog.get_user()
+        user = self.search_user(user)
+        if user == None:
+            return
+        getattr(self, action)(user)
+
+    def follow(self, user):
+        try:
+            self.session.api.account_follow(user.id)
+        except MastodonError  as err:
+            output.speak("Error %s" % (str(err)), True)
+
+    def unfollow(self, user):
+        try:
+            result = self.session.api.account_unfollow(user.id)
+        except MastodonError as err:
+            output.speak("Error %s" % (str(err)), True)
+
+    def mute(self, user):
+        try:
+            id = self.session.api.account_mute(user.id)
+        except MastodonError as err:
+            output.speak("Error %s" % (str(err)), True)
+
+    def unmute(self, user):
+        try:
+            id = self.session.api.account_unmute(user.id)
+        except MastodonError as err:
+            output.speak("Error %s" % (str(err)), True)
+
+    def block(self, user):
+        try:
+            id = self.session.api.account_block(user.id)
+        except MastodonError as err:
+            output.speak("Error %s" % (str(err)), True)
+
+    def unblock(self, user):
+        try:
+            id = self.session.api.account_unblock(user.id)
+        except MastodonError as err:
+            output.speak("Error %s" % (str(err)), True)
+
+class UserTimeline(BasicUserSelector):
+
+    def create_dialog(self, users):
+        self.dialog = userTimelineDialog.UserTimeline(users)
+        widgetUtils.connect_event(self.dialog.autocompletion, widgetUtils.BUTTON_PRESSED, self.autocomplete_users)
+
+    def process_action(self):
+        action = self.dialog.get_action()
+        user = self.dialog.get_user()
+        user = self.search_user(user)
+        if user == None:
+            return
+        self.user = user
+        return action

src/controller/messages.py

@@ -1,301 +0,0 @@
-# -*- coding: utf-8 -*-
-import re
-import platform
-import arrow
-import languageHandler
-system = platform.system()
-import widgetUtils
-import output
-import url_shortener
-import sound
-import config
-from pubsub import pub
-from twitter_text import parse_tweet
-if system == "Windows":
-    from wxUI.dialogs import message, urlList
-    from wxUI import commonMessageDialogs
-    from extra import translator, SpellChecker, autocompletionUsers
-    from extra.AudioUploader import audioUploader
-elif system == "Linux":
-    from gtkUI.dialogs import message
-from sessions.twitter import utils
-from . import attach
-
-class basicTweet(object):
-    """ This class handles the tweet main features. Other classes should derive from this class."""
-    def __init__(self, session, title, caption, text, messageType="tweet", max=280, *args, **kwargs):
-        super(basicTweet, self).__init__()
-        self.max = max
-        self.title = title
-        self.session = session
-        self.message = getattr(message, messageType)(title, caption, text, *args, **kwargs)
-        widgetUtils.connect_event(self.message.spellcheck, widgetUtils.BUTTON_PRESSED, self.spellcheck)
-        widgetUtils.connect_event(self.message.attach, widgetUtils.BUTTON_PRESSED, self.attach)
-        widgetUtils.connect_event(self.message.text, widgetUtils.ENTERED_TEXT, self.text_processor)
-        widgetUtils.connect_event(self.message.shortenButton, widgetUtils.BUTTON_PRESSED, self.shorten)
-        widgetUtils.connect_event(self.message.unshortenButton, widgetUtils.BUTTON_PRESSED, self.unshorten)
-        widgetUtils.connect_event(self.message.translateButton, widgetUtils.BUTTON_PRESSED, self.translate)
-        if hasattr(self.message, "long_tweet"):
-            widgetUtils.connect_event(self.message.long_tweet, widgetUtils.CHECKBOX, self.text_processor)
-            if config.app["app-settings"]["remember_mention_and_longtweet"]:
-                self.message.long_tweet.SetValue(config.app["app-settings"]["longtweet"])
-        self.attachments = []
-
-    def translate(self, event=None):
-        dlg = translator.gui.translateDialog()
-        if dlg.get_response() == widgetUtils.OK:
-            text_to_translate = self.message.get_text()
-            language_dict = translator.translator.available_languages()
-            for k in language_dict:
-                if language_dict[k] == dlg.dest_lang.GetStringSelection():
-                    dst = k
-            msg = translator.translator.translate(text=text_to_translate, target=dst)
-            self.message.set_text(msg)
-            self.text_processor()
-            self.message.text_focus()
-            output.speak(_(u"Translated"))
-        else:
-            return
-
-    def shorten(self, event=None):
-        urls = utils.find_urls_in_text(self.message.get_text())
-        if len(urls) == 0:
-            output.speak(_(u"There's no URL to be shortened"))
-            self.message.text_focus()
-        elif len(urls) == 1:
-            self.message.set_text(self.message.get_text().replace(urls[0], url_shortener.shorten(urls[0])))
-            output.speak(_(u"URL shortened"))
-            self.text_processor()
-            self.message.text_focus()
-        elif len(urls) > 1:
-            list_urls = urlList.urlList()
-            list_urls.populate_list(urls)
-            if list_urls.get_response() == widgetUtils.OK:
-                self.message.set_text(self.message.get_text().replace(urls[list_urls.get_item()], url_shortener.shorten(list_urls.get_string())))
-                output.speak(_(u"URL shortened"))
-                self.text_processor()
-                self.message.text_focus()
-
-    def unshorten(self, event=None):
-        urls = utils.find_urls_in_text(self.message.get_text())
-        if len(urls) == 0:
-            output.speak(_(u"There's no URL to be expanded"))
-            self.message.text_focus()
-        elif len(urls) == 1:
-            self.message.set_text(self.message.get_text().replace(urls[0], url_shortener.unshorten(urls[0])))
-            output.speak(_(u"URL expanded"))
-            self.text_processor()
-            self.message.text_focus()
-        elif len(urls) > 1:
-            list_urls = urlList.urlList()
-            list_urls.populate_list(urls)
-            if list_urls.get_response() == widgetUtils.OK:
-                self.message.set_text(self.message.get_text().replace(urls[list_urls.get_item()], url_shortener.unshorten(list_urls.get_string())))
-                output.speak(_(u"URL expanded"))
-                self.text_processor()
-                self.message.text_focus()
-
-    def text_processor(self, *args, **kwargs):
-        if len(self.message.get_text()) > 1:
-            self.message.enable_button("shortenButton")
-            self.message.enable_button("unshortenButton")
-        else:
-            self.message.disable_button("shortenButton")
-            self.message.disable_button("unshortenButton")
-        if self.message.get("long_tweet") == False and hasattr(self, "max"):
-            text = self.message.get_text()
-            results = parse_tweet(text)
-            self.message.set_title(_(u"%s - %s of %d characters") % (self.title, results.weightedLength, self.max))
-            if results.weightedLength > self.max:
-                self.session.sound.play("max_length.ogg")
-        else:
-            self.message.set_title(_(u"%s - %s characters") % (self.title, len(self.message.get_text())))
-
-    def spellcheck(self, event=None):
-        text = self.message.get_text()
-        checker = SpellChecker.spellchecker.spellChecker(text, "")
-        if hasattr(checker, "fixed_text"):
-            self.message.set_text(checker.fixed_text)
-            self.text_processor()
-            self.message.text_focus()
-
-    def attach(self, *args, **kwargs):
-        def completed_callback(dlg):
-            url = dlg.uploaderFunction.get_url()
-            pub.unsubscribe(dlg.uploaderDialog.update, "uploading")
-            dlg.uploaderDialog.destroy()
-            if "sndup.net/" in url:
-                self.message.set_text(self.message.get_text()+url+" #audio")
-                self.text_processor()
-            else:
-                commonMessageDialogs.common_error(url)
-
-            dlg.cleanup()
-        dlg = audioUploader.audioUploader(self.session.settings, completed_callback)
-        self.message.text_focus()
-
-class tweet(basicTweet):
-    def __init__(self, session, title, caption, text, max=280, messageType="tweet", *args, **kwargs):
-        super(tweet, self).__init__(session, title, caption, text, messageType, max, *args, **kwargs)
-        self.image = None
-        widgetUtils.connect_event(self.message.upload_image, widgetUtils.BUTTON_PRESSED, self.upload_image)
-        widgetUtils.connect_event(self.message.autocompletionButton, widgetUtils.BUTTON_PRESSED, self.autocomplete_users)
-        self.text_processor()
-
-    def upload_image(self, *args, **kwargs):
-        a = attach.attach()
-        if len(a.attachments) != 0:
-            self.attachments = a.attachments
-
-    def autocomplete_users(self, *args, **kwargs):
-        c = autocompletionUsers.completion.autocompletionUsers(self.message, self.session.session_id)
-        c.show_menu()
-
-class reply(tweet):
-    def __init__(self, session, title, caption, text, users=[], ids=[]):
-        super(reply, self).__init__(session, title, caption, text, messageType="reply", users=users)
-        self.ids = ids
-        self.users = users
-        if len(users) > 0:
-            widgetUtils.connect_event(self.message.mentionAll, widgetUtils.CHECKBOX, self.mention_all)
-            self.message.enable_button("mentionAll")
-            if config.app["app-settings"]["remember_mention_and_longtweet"]:
-                self.message.mentionAll.SetValue(config.app["app-settings"]["mention_all"])
-            self.mention_all()
-        self.message.set_cursor_at_end()
-        self.text_processor()
-
-    def mention_all(self, *args, **kwargs):
-        if self.message.mentionAll.GetValue() == True:
-            for i in self.message.checkboxes:
-                i.SetValue(True)
-                i.Hide()
-        else:
-            for i in self.message.checkboxes:
-                i.SetValue(False)
-                i.Show()
-
-    def get_ids(self):
-        excluded_ids  = ""
-        for i in range(0, len(self.message.checkboxes)):
-            if self.message.checkboxes[i].GetValue() == False:
-                excluded_ids = excluded_ids + "{0},".format(self.ids[i],)
-        return excluded_ids
-
-    def get_people(self):
-        people  = ""
-        for i in range(0, len(self.message.checkboxes)):
-            if self.message.checkboxes[i].GetValue() == True:
-                people = people + "{0} ".format(self.message.checkboxes[i].GetLabel(),)
-        return people
-
-class dm(basicTweet):
-    def __init__(self, session, title, caption, text):
-        super(dm, self).__init__(session, title, caption, text, messageType="dm", max=10000)
-        widgetUtils.connect_event(self.message.autocompletionButton, widgetUtils.BUTTON_PRESSED, self.autocomplete_users)
-        self.text_processor()
-        widgetUtils.connect_event(self.message.cb, widgetUtils.ENTERED_TEXT, self.user_changed)
-
-    def user_changed(self, *args, **kwargs):
-        self.title = _("Direct message to %s") % (self.message.get_user())
-        self.text_processor()
-
-    def autocomplete_users(self, *args, **kwargs):
-        c = autocompletionUsers.completion.autocompletionUsers(self.message, self.session.session_id)
-        c.show_menu("dm")
-
-class viewTweet(basicTweet):
-    def __init__(self, tweet, tweetList, is_tweet=True, utc_offset=0, date="", item_url=""):
-        """ This represents a tweet displayer. However it could be used for showing something wich is not a tweet, like a direct message or an event.
-         param tweet: A dictionary that represents a full tweet or a string for non-tweets.
-         param tweetList: If is_tweet is set to True, this could be a list of quoted tweets.
-         param is_tweet: True or false, depending wether the passed object is a tweet or not."""
-        if is_tweet == True:
-            self.title = _(u"Tweet")
-            image_description = []
-            text = ""
-            for i in range(0, len(tweetList)):
-                # tweets with message keys are longer tweets, the message value is the full messaje taken from twishort.
-                if hasattr(tweetList[i], "message")  and tweetList[i].is_quote_status == False:
-                    value = "message"
-                else:
-                    value = "full_text"
-                if hasattr(tweetList[i], "retweeted_status") and tweetList[i].is_quote_status == False:
-                    if not hasattr(tweetList[i], "message"):
-                        text = text + "rt @%s: %s\n" % (tweetList[i].retweeted_status.user.screen_name, tweetList[i].retweeted_status.full_text)
-                    else:
-                        text = text + "rt @%s: %s\n" % (tweetList[i].retweeted_status.user.screen_name, getattr(tweetList[i], value))
-                else:
-                    text = text + " @%s: %s\n" % (tweetList[i].user.screen_name, getattr(tweetList[i], value))
-                # tweets with extended_entities could include image descriptions.
-                if hasattr(tweetList[i], "extended_entities") and "media" in tweetList[i].extended_entities:
-                    for z in tweetList[i].extended_entities["media"]:
-                        if "ext_alt_text" in z and z["ext_alt_text"] != None:
-                            image_description.append(z["ext_alt_text"])
-                if hasattr(tweetList[i], "retweeted_status") and hasattr(tweetList[i].retweeted_status, "extended_entities") and "media" in tweetList[i].retweeted_status["extended_entities"]:
-                    for z in tweetList[i].retweeted_status.extended_entities["media"]:
-                        if "ext_alt_text" in z and z["ext_alt_text"] != None:
-                            image_description.append(z["ext_alt_text"])
-            # set rt and likes counters.
-            rt_count = str(tweet.retweet_count)
-            favs_count = str(tweet.favorite_count)
-            # Gets the client from where this tweet was made.
-            source = tweet.source
-            original_date = arrow.get(tweet.created_at, locale="en")
-            date = original_date.shift(seconds=utc_offset).format(_(u"MMM D, YYYY. H:m"), locale=languageHandler.getLanguage())
-            if text == "":
-                if hasattr(tweet, "message"):
-                    value = "message"
-                else:
-                    value = "full_text"
-                if hasattr(tweet, "retweeted_status"):
-                    if not hasattr(tweet, "message"):
-                        text = "rt @%s: %s" % (tweet.retweeted_status.user.screen_name, tweet.retweeted_status.full_text)
-                    else:
-                        text = "rt @%s: %s" % (tweet.retweeted_status.user.screen_name, getattr(tweet, value))
-                else:
-                    text = getattr(tweet, value)
-            text = self.clear_text(text)
-            if hasattr(tweet, "extended_entities") and "media" in tweet.extended_entities:
-                for z in tweet.extended_entities["media"]:
-                    if "ext_alt_text" in z and z["ext_alt_text"] != None:
-                        image_description.append(z["ext_alt_text"])
-            if hasattr(tweet, "retweeted_status") and hasattr(tweet.retweeted_status, "extended_entities") and "media" in tweet.retweeted_status.extended_entities:
-                for z in tweet.retweeted_status.extended_entities["media"]:
-                    if "ext_alt_text" in z and z["ext_alt_text"] != None:
-                        image_description.append(z["ext_alt_text"])
-            self.message = message.viewTweet(text, rt_count, favs_count, source, date)
-            results = parse_tweet(text)
-            self.message.set_title(results.weightedLength)
-            [self.message.set_image_description(i) for i in image_description]
-        else:
-            self.title = _(u"View item")
-            text = tweet
-            self.message = message.viewNonTweet(text, date)
-        widgetUtils.connect_event(self.message.spellcheck, widgetUtils.BUTTON_PRESSED, self.spellcheck)
-        if item_url != "":
-            self.message.enable_button("share")
-            widgetUtils.connect_event(self.message.share, widgetUtils.BUTTON_PRESSED, self.share)
-            self.item_url = item_url
-        widgetUtils.connect_event(self.message.translateButton, widgetUtils.BUTTON_PRESSED, self.translate)
-        if self.contain_urls() == True:
-            self.message.enable_button("unshortenButton")
-            widgetUtils.connect_event(self.message.unshortenButton, widgetUtils.BUTTON_PRESSED, self.unshorten)
-        self.message.get_response()
-
-    def contain_urls(self):
-        if len(utils.find_urls_in_text(self.message.get_text())) > 0:
-            return True
-        return False
-
-    def clear_text(self, text):
-        urls = utils.find_urls_in_text(text)
-        for i in urls:
-            if "https://twitter.com/" in i:
-                text = text.replace(i, "\n")
-        return text
-
-    def share(self, *args, **kwargs):
-        if hasattr(self, "item_url"):
-            output.copy(self.item_url)
-            output.speak(_("Link copied to clipboard."))

src/controller/settings.py

@@ -1,24 +1,16 @@
 # -*- coding: utf-8 -*-
 import os
-import webbrowser
-import sound_lib
+import logging
 import paths
-import widgetUtils
 import config
 import languageHandler
-import output
 import application
+from pubsub import pub
+from mysc import autostart as autostart_windows
 from wxUI.dialogs import configuration
 from wxUI import commonMessageDialogs
-from extra.autocompletionUsers import settings
-from extra.ocr import OCRSpace
-from pubsub import pub
-import logging
-import config_utils
+
 log = logging.getLogger("Settings")
-import keys
-from collections import OrderedDict
-from mysc import autostart as autostart_windows
 
 class globalSettingsController(object):
     def __init__(self):
@@ -90,10 +82,12 @@ class globalSettingsController(object):
             config.app["app-settings"]["language"] = self.codes[self.dialog.general.language.GetSelection()]
             languageHandler.setLanguage(config.app["app-settings"]["language"])
             self.needs_restart = True
+            log.debug("Triggered app restart due to interface language changes.")
         if self.kmnames[self.dialog.general.km.GetSelection()] != config.app["app-settings"]["load_keymap"]:
             config.app["app-settings"]["load_keymap"] =self.kmnames[self.dialog.general.km.GetSelection()]
             kmFile = open(os.path.join(paths.config_path(), "keymap.keymap"), "w")
             kmFile.close()
+            log.debug("Triggered app restart due to a keymap change.")
             self.needs_restart = True
         if config.app["app-settings"]["autostart"] != self.dialog.get_value("general", "autostart") and paths.mode == "installed":
             config.app["app-settings"]["autostart"] = self.dialog.get_value("general", "autostart")
@@ -104,9 +98,11 @@ class globalSettingsController(object):
         if config.app["app-settings"]["no_streaming"] != self.dialog.get_value("general", "no_streaming"):
             config.app["app-settings"]["no_streaming"] = self.dialog.get_value("general", "no_streaming")
             self.needs_restart = True
+            log.debug("Triggered app restart due to change in streaming availability.")
         if config.app["app-settings"]["update_period"] != self.dialog.get_value("general", "update_period"):
             config.app["app-settings"]["update_period"] = self.dialog.get_value("general", "update_period")
             self.needs_restart = True
+            log.debug("Triggered app restart due to changes in update period.")
         config.app["app-settings"]["voice_enabled"] = self.dialog.get_value("general", "disable_sapi5")
         config.app["app-settings"]["hide_gui"] = self.dialog.get_value("general", "hide_gui")
         config.app["app-settings"]["ask_at_exit"] = self.dialog.get_value("general", "ask_at_exit")
@@ -118,196 +114,10 @@ class globalSettingsController(object):
         if config.app["proxy"]["type"]!=self.dialog.get_value("proxy", "type") or config.app["proxy"]["server"] != self.dialog.get_value("proxy", "server") or config.app["proxy"]["port"] != self.dialog.get_value("proxy", "port") or config.app["proxy"]["user"] != self.dialog.get_value("proxy", "user") or config.app["proxy"]["password"] != self.dialog.get_value("proxy", "password"):
             if self.is_started == True:
                 self.needs_restart = True
+                log.debug("Triggered app restart due to change in proxy settings.")
             config.app["proxy"]["type"] = self.dialog.proxy.type.Selection
             config.app["proxy"]["server"] = self.dialog.get_value("proxy", "server")
             config.app["proxy"]["port"] = self.dialog.get_value("proxy", "port")
             config.app["proxy"]["user"] = self.dialog.get_value("proxy", "user")
             config.app["proxy"]["password"] = self.dialog.get_value("proxy", "password")
         config.app.write()
-
-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.au, widgetUtils.BUTTON_PRESSED, self.manage_autocomplete)
-        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", "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"])
-        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", 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 save_configuration(self):
-        if self.config["general"]["relative_times"] != self.dialog.get_value("general", "relative_time"):
-            self.needs_restart = True
-            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"]["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
-        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
-            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
-            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["other_buffers"]["show_followers"] != self.dialog.get_value("buffers", "followers"):
-#   self.config["other_buffers"]["show_followers"] = self.dialog.get_value("buffers", "followers")
-#   pub.sendMessage("create-new-buffer", buffer="followers", account=self.user, create=self.config["other_buffers"]["show_followers"])
-#  if self.config["other_buffers"]["show_friends"] != self.dialog.get_value("buffers", "friends"):
-#   self.config["other_buffers"]["show_friends"] = self.dialog.get_value("buffers", "friends")
-#   pub.sendMessage("create-new-buffer", buffer="friends", account=self.user, create=self.config["other_buffers"]["show_friends"])
-#  if self.config["other_buffers"]["show_favourites"] != self.dialog.get_value("buffers", "favs"):
-#   self.config["other_buffers"]["show_favourites"] = self.dialog.get_value("buffers", "favs")
-#   pub.sendMessage("create-new-buffer", buffer="favourites", account=self.user, create=self.config["other_buffers"]["show_favourites"])
-#  if self.config["other_buffers"]["show_blocks"] != self.dialog.get_value("buffers", "blocks"):
-#   self.config["other_buffers"]["show_blocks"] = self.dialog.get_value("buffers", "blocks")
-#   pub.sendMessage("create-new-buffer", buffer="blocked", account=self.user, create=self.config["other_buffers"]["show_blocks"])
-#  if self.config["other_buffers"]["show_muted_users"] != self.dialog.get_value("buffers", "mutes"):
-#   self.config["other_buffers"]["show_muted_users"] = self.dialog.get_value("buffers", "mutes")
-#   pub.sendMessage("create-new-buffer", buffer="muted", account=self.user, create=self.config["other_buffers"]["show_muted_users"])
-#  if self.config["other_buffers"]["show_events"] != self.dialog.get_value("buffers", "events"):
-#   self.config["other_buffers"]["show_events"] = self.dialog.get_value("buffers", "events")
-#   pub.sendMessage("create-new-buffer", buffer="events", account=self.user, create=self.config["other_buffers"]["show_events"])
-        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 manage_autocomplete(self, *args, **kwargs):
-        configuration = settings.autocompletionSettings(self.buffer.session.settings, self.buffer, self.window)
-
-    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()

src/controller/twitter/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

src/controller/twitter/handler.py

@@ -0,0 +1,340 @@
+# -*- coding: utf-8 -*-
+import logging
+import widgetUtils
+import output
+from pubsub import pub
+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, trendingTopics, user
+
+log = logging.getLogger("controller.twitter.handler")
+
+class Handler(object):
+
+    def __init__(self):
+        super(Handler, self).__init__()
+
+    def create_buffers(self, session, createAccounts=True, controller=None):
+        session.get_user_info()
+        name = session.get_name()
+        if createAccounts == True:
+            pub.sendMessage("core.create_account", name=name, session_id=session.session_id, logged=True)
+        root_position =controller.view.search(name, name)
+        for i in session.settings['general']['buffer_order']:
+            if i == 'home':
+                pub.sendMessage("createBuffer", buffer_type="BaseBuffer", session_type=session.type, buffer_title=_("Home"), parent_tab=root_position, start=False, kwargs=dict(parent=controller.view.nb, function="home_timeline", name="home_timeline", sessionObject=session, account=session.get_name(), sound="tweet_received.ogg", include_ext_alt_text=True, tweet_mode="extended"))
+            elif i == 'mentions':
+                pub.sendMessage("createBuffer", buffer_type="BaseBuffer", session_type=session.type, buffer_title=_("Mentions"), parent_tab=root_position, start=False, kwargs=dict(parent=controller.view.nb, function="mentions_timeline", name="mentions", sessionObject=session, account=session.get_name(), sound="mention_received.ogg", include_ext_alt_text=True, tweet_mode="extended"))
+            elif i == 'dm':
+                pub.sendMessage("createBuffer", buffer_type="DirectMessagesBuffer", session_type=session.type, buffer_title=_("Direct messages"), parent_tab=root_position, start=False, kwargs=dict(parent=controller.view.nb, function="get_direct_messages", name="direct_messages", sessionObject=session, account=session.get_name(), bufferType="dmPanel", compose_func="compose_direct_message", sound="dm_received.ogg"))
+            elif i == 'sent_dm':
+                pub.sendMessage("createBuffer", buffer_type="SentDirectMessagesBuffer", session_type=session.type, buffer_title=_("Sent direct messages"), parent_tab=root_position, start=False, kwargs=dict(parent=controller.view.nb, function=None, name="sent_direct_messages", sessionObject=session, account=session.get_name(), bufferType="dmPanel", compose_func="compose_direct_message"))
+            elif i == 'sent_tweets':
+                pub.sendMessage("createBuffer", buffer_type="BaseBuffer", session_type=session.type, buffer_title=_("Sent tweets"), parent_tab=root_position, start=False, kwargs=dict(parent=controller.view.nb, function="user_timeline", name="sent_tweets", sessionObject=session, account=session.get_name(), screen_name=session.db["user_name"], include_ext_alt_text=True, tweet_mode="extended"))
+            elif i == 'favorites':
+                pub.sendMessage("createBuffer", buffer_type="BaseBuffer", session_type=session.type, buffer_title=_("Likes"), parent_tab=root_position, start=False, kwargs=dict(parent=controller.view.nb, function="get_favorites", name="favourites", sessionObject=session, account=session.get_name(), sound="favourite.ogg", include_ext_alt_text=True, tweet_mode="extended"))
+            elif i == 'followers':
+                pub.sendMessage("createBuffer", buffer_type="PeopleBuffer", session_type=session.type, buffer_title=_("Followers"), parent_tab=root_position, start=False, kwargs=dict(parent=controller.view.nb, function="get_followers", name="followers", sessionObject=session, account=session.get_name(), sound="update_followers.ogg", screen_name=session.db["user_name"]))
+            elif i == 'friends':
+                pub.sendMessage("createBuffer", buffer_type="PeopleBuffer", session_type=session.type, buffer_title=_("Following"), parent_tab=root_position, start=False, kwargs=dict(parent=controller.view.nb, function="get_friends", name="friends", sessionObject=session, account=session.get_name(), screen_name=session.db["user_name"]))
+            elif i == 'blocks':
+                pub.sendMessage("createBuffer", buffer_type="PeopleBuffer", session_type=session.type, buffer_title=_("Blocked users"), parent_tab=root_position, start=False, kwargs=dict(parent=controller.view.nb, function="get_blocks", name="blocked", sessionObject=session, account=session.get_name()))
+            elif i == 'muted':
+                pub.sendMessage("createBuffer", buffer_type="PeopleBuffer", session_type=session.type, buffer_title=_("Muted users"), parent_tab=root_position, start=False, kwargs=dict(parent=controller.view.nb, function="get_mutes", name="muted", sessionObject=session, account=session.get_name()))
+        pub.sendMessage("createBuffer", buffer_type="EmptyBuffer", session_type="base", buffer_title=_("Timelines"), parent_tab=root_position, start=False, kwargs=dict(parent=controller.view.nb, name="timelines", account=name))
+        timelines_position =controller.view.search("timelines", name)
+        for i in session.settings["other_buffers"]["timelines"]:
+            pub.sendMessage("createBuffer", buffer_type="BaseBuffer", session_type=session.type, buffer_title=_(u"Timeline for {}").format(i,), parent_tab=timelines_position, start=False, kwargs=dict(parent=controller.view.nb, function="user_timeline", name="%s-timeline" % (i,), sessionObject=session, account=session.get_name(), sound="tweet_timeline.ogg", bufferType=None, user_id=i, include_ext_alt_text=True, tweet_mode="extended"))
+        pub.sendMessage("createBuffer", buffer_type="EmptyBuffer", session_type="base", buffer_title=_("Likes timelines"), parent_tab=root_position, start=False, kwargs=dict(parent=controller.view.nb, name="favs_timelines", account=name))
+        favs_timelines_position =controller.view.search("favs_timelines", name)
+        for i in session.settings["other_buffers"]["favourites_timelines"]:
+            pub.sendMessage("createBuffer", buffer_type="BaseBuffer", session_type=session.type, buffer_title=_("Likes for {}").format(i,), parent_tab=favs_timelines_position, start=False, kwargs=dict(parent=controller.view.nb, function="get_favorites", name="%s-favorite" % (i,), sessionObject=session, account=name, bufferType=None, sound="favourites_timeline_updated.ogg", user_id=i, include_ext_alt_text=True, tweet_mode="extended"))
+        pub.sendMessage("createBuffer", buffer_type="EmptyBuffer", session_type="base", buffer_title=_("Followers timelines"), parent_tab=root_position, start=False, kwargs=dict(parent=controller.view.nb, name="followers_timelines", account=session.get_name()))
+        followers_timelines_position =controller.view.search("followers_timelines", name)
+        for i in session.settings["other_buffers"]["followers_timelines"]:
+            pub.sendMessage("createBuffer", buffer_type="PeopleBuffer", session_type=session.type, buffer_title=_("Followers for {}").format(i,), parent_tab=followers_timelines_position, start=False, kwargs=dict(parent=controller.view.nb, function="get_followers", name="%s-followers" % (i,), sessionObject=session, account=session.get_name(), sound="new_event.ogg", user_id=i))
+        pub.sendMessage("createBuffer", buffer_type="EmptyBuffer", session_type="base", buffer_title=_("Following timelines"), parent_tab=root_position, start=False, kwargs=dict(parent=controller.view.nb, name="friends_timelines", account=name))
+        friends_timelines_position =controller.view.search("friends_timelines", name)
+        for i in session.settings["other_buffers"]["friends_timelines"]:
+            pub.sendMessage("createBuffer", buffer_type="PeopleBuffer", session_type=session.type, buffer_title=_(u"Friends for {}").format(i,), parent_tab=friends_timelines_position, start=False, kwargs=dict(parent=controller.view.nb, function="get_friends", name="%s-friends" % (i,), sessionObject=session, account=session.get_name(), sound="new_event.ogg", user_id=i))
+        pub.sendMessage("createBuffer", buffer_type="EmptyBuffer", session_type="base", buffer_title=_("Lists"), parent_tab=root_position, start=False, kwargs=dict(parent=controller.view.nb, name="lists", account=name))
+        lists_position =controller.view.search("lists", name)
+        for i in session.settings["other_buffers"]["lists"]:
+            pub.sendMessage("createBuffer", buffer_type="ListBuffer", session_type=session.type, buffer_title=_(u"List for {}").format(i), parent_tab=lists_position, start=False, kwargs=dict(parent=controller.view.nb, function="list_timeline", name="%s-list" % (i,), sessionObject=session, account=session.get_name(), bufferType=None, sound="list_tweet.ogg", list_id=utils.find_list(i, session.db["lists"]), include_ext_alt_text=True, tweet_mode="extended"))
+        pub.sendMessage("createBuffer", buffer_type="EmptyBuffer", session_type="base", buffer_title=_("Searches"), parent_tab=root_position, start=False, kwargs=dict(parent=controller.view.nb, name="searches", account=name))
+        searches_position =controller.view.search("searches", name)
+        for i in session.settings["other_buffers"]["tweet_searches"]:
+            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.get_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.get_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.get_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.get_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, lists_buffer_position):
+        return lists.listsController(session=session, lists_buffer_position=lists_buffer_position)
+
+    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")
+
+    # ToDo: explore how to play sound & save config differently.
+    # currently, TWBlue will play the sound and save the config for the timeline even if the buffer did not load or something else.
+    def open_timeline(self, controller, buffer, default="tweets"):
+        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.userSelection.selectUserDialog(users=users, default=default)
+        if dlg.get_response() == widgetUtils.OK:
+            usr = utils.if_user_exists(buffer.session.twitter, dlg.get_user())
+            if usr != None:
+                if usr == dlg.get_user():
+                    commonMessageDialogs.suspended_user()
+                    return
+                if usr.protected == True:
+                    if usr.following == False:
+                        commonMessageDialogs.no_following()
+                        return
+                tl_type = dlg.get_action()
+                if tl_type  == "tweets":
+                    if usr.statuses_count == 0:
+                        commonMessageDialogs.no_tweets()
+                        return
+                    if usr.id_str in buffer.session.settings["other_buffers"]["timelines"]:
+                        commonMessageDialogs.timeline_exist()
+                        return
+                    timelines_position =controller.view.search("timelines", buffer.session.get_name())
+                    pub.sendMessage("createBuffer", buffer_type="BaseBuffer", session_type=buffer.session.type, buffer_title=_("Timeline for {}").format(usr.screen_name,), parent_tab=timelines_position, start=True, kwargs=dict(parent=controller.view.nb, function="user_timeline", name="%s-timeline" % (usr.id_str,), sessionObject=buffer.session, account=buffer.session.get_name(), sound="tweet_timeline.ogg", bufferType=None, user_id=usr.id_str, include_ext_alt_text=True, tweet_mode="extended"))
+                    buffer.session.settings["other_buffers"]["timelines"].append(usr.id_str)
+                    buffer.session.sound.play("create_timeline.ogg")
+                elif tl_type == "favourites":
+                    if usr.favourites_count == 0:
+                        commonMessageDialogs.no_favs()
+                        return
+                    if usr.id_str in buffer.session.settings["other_buffers"]["favourites_timelines"]:
+                        commonMessageDialogs.timeline_exist()
+                        return
+                    favs_timelines_position =controller.view.search("favs_timelines", buffer.session.get_name())
+                    pub.sendMessage("createBuffer", buffer_type="BaseBuffer", session_type=buffer.session.type, buffer_title=_("Likes for {}").format(usr.screen_name,), parent_tab=favs_timelines_position, start=True, kwargs=dict(parent=controller.view.nb, function="get_favorites", name="%s-favorite" % (usr.id_str,), sessionObject=buffer.session, account=buffer.session.get_name(), bufferType=None, sound="favourites_timeline_updated.ogg", user_id=usr.id_str, include_ext_alt_text=True, tweet_mode="extended"))
+                    buffer.session.settings["other_buffers"]["favourites_timelines"].append(usr.id_str)
+                    buffer.session.sound.play("create_timeline.ogg")
+                elif tl_type == "followers":
+                    if usr.followers_count == 0:
+                        commonMessageDialogs.no_followers()
+                        return
+                    if usr.id_str in buffer.session.settings["other_buffers"]["followers_timelines"]:
+                        commonMessageDialogs.timeline_exist()
+                        return
+                    followers_timelines_position =controller.view.search("followers_timelines", buffer.session.get_name())
+                    pub.sendMessage("createBuffer", buffer_type="PeopleBuffer", session_type=buffer.session.type, buffer_title=_("Followers for {}").format(usr.screen_name,), parent_tab=followers_timelines_position, start=True, kwargs=dict(parent=controller.view.nb, function="get_followers", name="%s-followers" % (usr.id_str,), sessionObject=buffer.session, account=buffer.session.get_name(), sound="new_event.ogg", user_id=usr.id_str))
+                    buffer.session.settings["other_buffers"]["followers_timelines"].append(usr.id_str)
+                    buffer.session.sound.play("create_timeline.ogg")
+                elif tl_type == "friends":
+                    if usr.friends_count == 0:
+                        commonMessageDialogs.no_friends()
+                        return
+                    if usr.id_str in buffer.session.settings["other_buffers"]["friends_timelines"]:
+                        commonMessageDialogs.timeline_exist()
+                        return
+                    friends_timelines_position =controller.view.search("friends_timelines", buffer.session.get_name())
+                    pub.sendMessage("createBuffer", buffer_type="PeopleBuffer", session_type=buffer.session.type, buffer_title=_("Friends for {}").format(usr.screen_name,), parent_tab=friends_timelines_position, start=True, kwargs=dict(parent=controller.view.nb, function="get_friends", name="%s-friends" % (usr.id_str,), sessionObject=buffer.session, account=buffer.session.get_name(), sound="new_event.ogg", user_id=usr.id_str))
+                    buffer.session.settings["other_buffers"]["friends_timelines"].append(usr.id_str)
+                    buffer.session.sound.play("create_timeline.ogg")
+            else:
+                commonMessageDialogs.user_not_exist()
+        buffer.session.settings.write()
+
+    def open_conversation(self, controller, buffer):
+        tweet = buffer.get_right_tweet()
+        if hasattr(tweet, "retweeted_status") and tweet.retweeted_status != None:
+            tweet = tweet.retweeted_status
+        user = buffer.session.get_user(tweet.user).screen_name
+        searches_position =controller.view.search("searches", buffer.session.get_name())
+        pub.sendMessage("createBuffer", buffer_type="ConversationBuffer", session_type=buffer.session.type, buffer_title=_(u"Conversation with {0}").format(user), parent_tab=searches_position, start=True, kwargs=dict(tweet=tweet, parent=controller.view.nb, function="search_tweets", name="%s-searchterm" % (tweet.id,), sessionObject=buffer.session, account=buffer.session.get_name(), bufferType="searchPanel", sound="search_updated.ogg", since_id=tweet.id, q="@{0}".format(user)))
+
+    def get_trending_topics(self, controller, session):
+        trends = trendingTopics.trendingTopicsController(session)
+        if trends.dialog.get_response() == widgetUtils.OK:
+            woeid = trends.get_woeid()
+            if woeid in session.settings["other_buffers"]["trending_topic_buffers"]:
+                return
+            root_position =controller.view.search(session.get_name(), session.get_name())
+            pub.sendMessage("createBuffer", buffer_type="TrendsBuffer", session_type=session.type, buffer_title=_("Trending topics for %s") % (trends.get_string()), parent_tab=root_position, start=True, kwargs=dict(parent=controller.view.nb, name="%s_tt" % (woeid,), sessionObject=session, account=session.get_name(), trendsFor=woeid, sound="trends_updated.ogg"))
+            session.settings["other_buffers"]["trending_topic_buffers"].append(str(woeid))
+            session.settings.write()
+
+    def start_buffer(self, controller, buffer):
+        if hasattr(buffer, "finished_timeline") and buffer.finished_timeline == False:
+            change_title = True
+        else:
+            change_title = False
+        try:
+            if "mentions" in buffer.name or "direct_messages" in buffer.name:
+                buffer.start_stream()
+            else:
+                buffer.start_stream(play_sound=False)
+        except TweepyException as err:
+            log.exception("Error %s starting buffer %s on account %s, with args %r and kwargs %r." % (str(err), buffer.name, buffer.account, buffer.args, buffer.kwargs))
+            # Determine if this error was caused by a block applied to the current user (IE permission errors).
+            if type(err) == Forbidden:
+                buff = controller.view.search(buffer.name, buffer.account)
+                buffer.remove_buffer(force=True)
+                commonMessageDialogs.blocked_timeline()
+                if controller.get_current_buffer() == buffer:
+                    controller.right()
+                controller.view.delete_buffer(buff)
+                controller.buffers.remove(buffer)
+                del buffer
+        if change_title:
+            pub.sendMessage("buffer-title-changed", buffer=buffer)
+
+    def update_profile(self, session):
+        r = user.profileController(session)
+
+    def search(self, controller, session, value):
+        log.debug("Creating a new search...")
+        dlg = dialogs.search.searchDialog(value)
+        if dlg.get_response() == widgetUtils.OK and dlg.get("term") != "":
+            term = dlg.get("term")
+            searches_position =controller.view.search("searches", session.get_name())
+            if dlg.get("tweets") == True:
+                if term not in session.settings["other_buffers"]["tweet_searches"]:
+                    session.settings["other_buffers"]["tweet_searches"].append(term)
+                    session.settings.write()
+                    args = {"lang": dlg.get_language(), "result_type": dlg.get_result_type()}
+                    pub.sendMessage("createBuffer", buffer_type="SearchBuffer", session_type=session.type, buffer_title=_("Search for {}").format(term), parent_tab=searches_position, start=True, kwargs=dict(parent=controller.view.nb, function="search_tweets", name="%s-searchterm" % (term,), sessionObject=session, account=session.get_name(), bufferType="searchPanel", sound="search_updated.ogg", q=term, include_ext_alt_text=True, tweet_mode="extended"))
+                else:
+                    log.error("A buffer for the %s search term is already created. You can't create a duplicate buffer." % (term,))
+                    return
+            elif dlg.get("users") == True:
+                pub.sendMessage("createBuffer", buffer_type="SearchPeopleBuffer", session_type=session.type, buffer_title=_("Search for {}").format(term), parent_tab=searches_position, start=True, kwargs=dict(parent=controller.view.nb, function="search_users", name="%s-searchUser" % (term,), sessionObject=session, account=session.get_name(), bufferType=None, sound="search_updated.ogg", q=term))
+        dlg.Destroy()

src/controller/twitter/lists.py

@@ -10,9 +10,10 @@ from pubsub import pub
 log = logging.getLogger("controller.listsController")
 
 class listsController(object):
-    def __init__(self, session, user=None):
+    def __init__(self, session, user=None, lists_buffer_position=0):
         super(listsController, self).__init__()
         self.session = session
+        self.lists_buffer_position = lists_buffer_position
         if user == None:
             self.dialog = lists.listViewer()
             self.dialog.populate_list(self.get_all_lists())
@@ -32,7 +33,7 @@ class listsController(object):
         return [compose.compose_list(item) for item in self.session.db["lists"]]
 
     def get_user_lists(self, user):
-        self.lists = self.session.twitter.lists_all(reverse=True, screen_name=user)
+        self.lists = self.session.twitter.get_lists(reverse=True, screen_name=user)
         return [compose.compose_list(item) for item in self.lists]
 
     def create_list(self, *args, **kwargs):
@@ -90,7 +91,9 @@ class listsController(object):
     def open_list_as_buffer(self, *args, **kwargs):
         if self.dialog.lista.get_count() == 0: return
         list = self.session.db["lists"][self.dialog.get_item()]
-        pub.sendMessage("create-new-buffer", buffer="list", account=self.session.db["user_name"], create=list.name)
+        pub.sendMessage("createBuffer", buffer_type="ListBuffer", session_type=self.session.type, buffer_title=_("List for {}").format(list.name), parent_tab=self.lists_buffer_position, start=True, kwargs=dict(function="list_timeline", name="%s-list" % (list.name,), sessionObject=self.session, account=self.session.get_name(), bufferType=None, sound="list_tweet.ogg", list_id=list.id, include_ext_alt_text=True, tweet_mode="extended"))
+        self.session.settings["other_buffers"]["lists"].append(list.name)
+        self.session.settings.write()
 
     def subscribe(self, *args, **kwargs):
         if self.dialog.lista.get_count() == 0: return

src/controller/twitter/messages.py

@@ -0,0 +1,382 @@
+# -*- coding: utf-8 -*-
+import os
+import arrow
+import languageHandler
+import wx
+import widgetUtils
+import output
+import sound
+import config
+from pubsub import pub
+from twitter_text.parse_tweet import parse_tweet
+from wxUI.dialogs import twitterDialogs, urlList
+from wxUI import commonMessageDialogs
+from extra import translator, SpellChecker
+from extra.AudioUploader import audioUploader
+from extra.autocompletionUsers import completion
+from sessions.twitter import utils
+
+class basicTweet(object):
+    """ This class handles the tweet main features. Other classes should derive from this class."""
+    def __init__(self, session, title, caption, text="", messageType="tweet", max=280, *args, **kwargs):
+        super(basicTweet, self).__init__()
+        self.max = max
+        self.title = title
+        self.session = session
+        self.message = getattr(twitterDialogs, messageType)(title=title, caption=caption, message=text, max_length=max, *args, **kwargs)
+        self.message.text.SetValue(text)
+        self.message.text.SetInsertionPoint(len(self.message.text.GetValue()))
+        widgetUtils.connect_event(self.message.spellcheck, widgetUtils.BUTTON_PRESSED, self.spellcheck)
+        widgetUtils.connect_event(self.message.add_audio, widgetUtils.BUTTON_PRESSED, self.attach)
+        widgetUtils.connect_event(self.message.text, widgetUtils.ENTERED_TEXT, self.text_processor)
+        widgetUtils.connect_event(self.message.translate, widgetUtils.BUTTON_PRESSED, self.translate)
+        if hasattr(self.message, "add"):
+            widgetUtils.connect_event(self.message.add, widgetUtils.BUTTON_PRESSED, self.on_attach)
+        self.attachments = []
+
+    def translate(self, event=None):
+        dlg = translator.gui.translateDialog()
+        if dlg.get_response() == widgetUtils.OK:
+            text_to_translate = self.message.text.GetValue()
+            language_dict = translator.translator.available_languages()
+            for k in language_dict:
+                if language_dict[k] == dlg.dest_lang.GetStringSelection():
+                    dst = k
+            msg = translator.translator.translate(text=text_to_translate, target=dst)
+            self.message.text.ChangeValue(msg)
+            self.message.text.SetInsertionPoint(len(self.message.text.GetValue()))
+            self.text_processor()
+            self.message.text.SetFocus()
+            output.speak(_(u"Translated"))
+        else:
+            return
+
+    def text_processor(self, *args, **kwargs):
+        text = self.message.text.GetValue()
+        results = parse_tweet(text)
+        self.message.SetTitle(_("%s - %s of %d characters") % (self.title, results.weightedLength, self.max))
+        if results.weightedLength > self.max:
+            self.session.sound.play("max_length.ogg")
+
+    def spellcheck(self, event=None):
+        text = self.message.text.GetValue()
+        checker = SpellChecker.spellchecker.spellChecker(text, "")
+        if hasattr(checker, "fixed_text"):
+            self.message.text.ChangeValue(checker.fixed_text)
+            self.text_processor()
+            self.message.text.SetFocus()
+
+    def attach(self, *args, **kwargs):
+        def completed_callback(dlg):
+            url = dlg.uploaderFunction.get_url()
+            pub.unsubscribe(dlg.uploaderDialog.update, "uploading")
+            dlg.uploaderDialog.destroy()
+            if "sndup.net/" in url:
+                self.message.text.ChangeValue(self.message.text.GetValue()+url+" #audio")
+                self.text_processor()
+            else:
+                commonMessageDialogs.common_error(url)
+            dlg.cleanup()
+        dlg = audioUploader.audioUploader(self.session.settings, completed_callback)
+        self.message.text.SetFocus()
+
+    def can_attach(self):
+        if len(self.attachments) == 0:
+            return True
+        elif len(self.attachments) == 1 and (self.attachments[0]["type"] == "video" or self.attachments[0]["type"] == "gif"):
+            return False
+        elif len(self.attachments) < 4:
+            return True
+        return False
+
+    def on_attach(self, *args, **kwargs):
+        can_attach = self.can_attach()
+        menu = self.message.attach_menu(can_attach)
+        self.message.Bind(wx.EVT_MENU, self.on_attach_image, self.message.add_image)
+        self.message.Bind(wx.EVT_MENU, self.on_attach_video, self.message.add_video)
+        if hasattr(self.message, "add_poll"):
+            self.message.Bind(wx.EVT_MENU, self.on_attach_poll, self.message.add_poll)
+        self.message.PopupMenu(menu, self.message.add.GetPosition())
+
+    def on_attach_image(self, *args, **kwargs):
+        can_attach = self.can_attach()
+        video_or_gif_present = False
+        for a in self.attachments:
+            if a["type"] == "video" or a["type"] == "gif":
+                video_or_gif = True
+                break
+        if can_attach == False or video_or_gif_present == True:
+            return self.message.unable_to_attach_file()
+        image, description  = self.message.get_image()
+        if image != None:
+            if image.endswith("gif"):
+                image_type = "gif"
+            else:
+                image_type = "photo"
+            imageInfo = {"type": image_type, "file": image, "description": description}
+            if len(self.attachments) > 0 and image_type == "gif":
+                return self.message.unable_to_attach_file()
+            self.attachments.append(imageInfo)
+            self.message.add_item(item=[os.path.basename(imageInfo["file"]), imageInfo["type"], imageInfo["description"]])
+            self.text_processor()
+
+    def on_attach_video(self, *args, **kwargs):
+        if len(self.attachments) > 0:
+            return self.message.unable_to_attach_file()
+        video = self.message.get_video()
+        if video != None:
+            videoInfo = {"type": "video", "file": video, "description": ""}
+            if len(self.attachments) > 0:
+                return self.message.unable_to_attach_file()
+            self.attachments.append(videoInfo)
+            self.message.add_item(item=[os.path.basename(videoInfo["file"]), videoInfo["type"], videoInfo["description"]])
+            self.text_processor()
+
+    def on_attach_poll(self, *args, **kwargs):
+        dlg = twitterDialogs.poll()
+        if dlg.ShowModal() == wx.ID_OK:
+            self.poll_options = dlg.get_options()
+            self.poll_period = 60*24*dlg.period.GetValue()
+        dlg.Destroy()
+
+    def remove_attachment(self, *args, **kwargs):
+        attachment = self.message.attachments.GetFocusedItem()
+        if attachment > -1 and len(self.attachments) > attachment:
+            self.attachments.pop(attachment)
+            self.message.remove_item(list_type="attachment")
+            self.text_processor()
+            self.message.text.SetFocus()
+
+class tweet(basicTweet):
+    def __init__(self, session, title, caption, text="", max=280, messageType="tweet", *args, **kwargs):
+        self.thread = []
+        self.poll_options = None
+        self.poll_period = None
+        super(tweet, self).__init__(session, title, caption, text, messageType, max, *args, **kwargs)
+        widgetUtils.connect_event(self.message.autocomplete_users, widgetUtils.BUTTON_PRESSED, self.autocomplete_users)
+        if hasattr(self.message, "add_tweet"):
+            widgetUtils.connect_event(self.message.add_tweet, widgetUtils.BUTTON_PRESSED, self.add_tweet)
+            widgetUtils.connect_event(self.message.remove_tweet, widgetUtils.BUTTON_PRESSED, self.remove_tweet)
+        widgetUtils.connect_event(self.message.remove_attachment, widgetUtils.BUTTON_PRESSED, self.remove_attachment)
+        self.text_processor()
+
+    def autocomplete_users(self, *args, **kwargs):
+        c = completion.autocompletionUsers(self.message, self.session.session_id)
+        c.show_menu()
+
+    def add_tweet(self, event, update_gui=True, *args, **kwargs):
+        text = self.message.text.GetValue()
+        attachments = self.attachments[::]
+        tweetdata = dict(text=text, attachments=attachments, poll_options=self.poll_options, poll_period=self.poll_period)
+        self.thread.append(tweetdata)
+        self.attachments = []
+        self.poll_options = None
+        self.poll_period = None
+        if update_gui:
+            self.message.reset_controls()
+            self.message.add_item(item=[text, len(attachments)], list_type="tweet")
+            self.message.text.SetFocus()
+            self.text_processor()
+
+    def get_tweet_data(self):
+        self.add_tweet(event=None, update_gui=False)
+        return self.thread
+
+    def text_processor(self, *args, **kwargs):
+        super(tweet, self).text_processor(*args, **kwargs)
+        if len(self.thread) > 0:
+            if hasattr(self.message, "tweets"):
+                self.message.tweets.Enable(True)
+                self.message.remove_tweet.Enable(True)
+            else:
+                self.message.tweets.Enable(False)
+                self.message.remove_tweet.Enable(False)
+        if len(self.attachments) > 0:
+            self.message.attachments.Enable(True)
+            self.message.remove_attachment.Enable(True)
+        else:
+            self.message.attachments.Enable(False)
+            self.message.remove_attachment.Enable(False)
+        if hasattr(self.message, "add_tweet"):
+            if len(self.message.text.GetValue()) > 0 or len(self.attachments) > 0:
+                self.message.add_tweet.Enable(True)
+            else:
+                self.message.add_tweet.Enable(False)
+
+    def remove_tweet(self, *args, **kwargs):
+        tweet = self.message.tweets.GetFocusedItem()
+        if tweet > -1 and len(self.thread) > tweet:
+            self.thread.pop(tweet)
+            self.message.remove_item(list_type="tweet")
+            self.text_processor()
+            self.message.text.SetFocus()
+
+
+class reply(tweet):
+    def __init__(self, session, title, caption, text, users=[], ids=[]):
+        super(reply, self).__init__(session, title, caption, text, messageType="reply", users=users)
+        self.ids = ids
+        self.users = users
+        if len(users) > 0:
+            widgetUtils.connect_event(self.message.mention_all, widgetUtils.CHECKBOX, self.mention_all)
+            self.message.mention_all.Enable(True)
+            if config.app["app-settings"]["remember_mention_and_longtweet"]:
+                self.message.mention_all.SetValue(config.app["app-settings"]["mention_all"])
+            self.mention_all()
+        self.message.text.SetInsertionPoint(len(self.message.text.GetValue()))
+        self.text_processor()
+
+    def text_processor(self, *args, **kwargs):
+        super(tweet, self).text_processor(*args, **kwargs)
+        if len(self.attachments) > 0:
+            self.message.attachments.Enable(True)
+            self.message.remove_attachment.Enable(True)
+        else:
+            self.message.attachments.Enable(False)
+            self.message.remove_attachment.Enable(False)
+
+    def mention_all(self, *args, **kwargs):
+        if self.message.mention_all.GetValue() == True:
+            for i in self.message.checkboxes:
+                i.SetValue(True)
+                i.Hide()
+        else:
+            for i in self.message.checkboxes:
+                i.SetValue(False)
+                i.Show()
+
+    def get_ids(self):
+        excluded_ids  = []
+        for i in range(0, len(self.message.checkboxes)):
+            if self.message.checkboxes[i].GetValue() == False:
+                excluded_ids.append(self.ids[i])
+        return excluded_ids
+
+    def get_people(self):
+        people  = ""
+        for i in range(0, len(self.message.checkboxes)):
+            if self.message.checkboxes[i].GetValue() == True:
+                people = people + "{0} ".format(self.message.checkboxes[i].GetLabel(),)
+        return people
+
+class dm(basicTweet):
+    def __init__(self, session, title, caption, users):
+        super(dm, self).__init__(session, title, caption, messageType="dm", max=10000, users=users)
+        widgetUtils.connect_event(self.message.autocomplete_users, widgetUtils.BUTTON_PRESSED, self.autocomplete_users)
+        self.text_processor()
+        widgetUtils.connect_event(self.message.cb, widgetUtils.ENTERED_TEXT, self.user_changed)
+
+    def user_changed(self, *args, **kwargs):
+        self.title = _("Direct message to %s") % (self.message.cb.GetValue())
+        self.text_processor()
+
+    def autocomplete_users(self, *args, **kwargs):
+        c = completion.autocompletionUsers(self.message, self.session.session_id)
+        c.show_menu("dm")
+
+    def text_processor(self, *args, **kwargs):
+        super(dm, self).text_processor(*args, **kwargs)
+        if len(self.attachments) > 0:
+            self.message.attachments.Enable(True)
+            self.message.remove_attachment.Enable(True)
+        else:
+            self.message.attachments.Enable(False)
+            self.message.remove_attachment.Enable(False)
+
+    def can_attach(self):
+        if len(self.attachments) == 0:
+            return True
+        return False
+
+class viewTweet(basicTweet):
+    def __init__(self, tweet, tweetList, is_tweet=True, utc_offset=0, date="", item_url=""):
+        """ This represents a tweet displayer. However it could be used for showing something wich is not a tweet, like a direct message or an event.
+         param tweet: A dictionary that represents a full tweet or a string for non-tweets.
+         param tweetList: If is_tweet is set to True, this could be a list of quoted tweets.
+         param is_tweet: True or false, depending wether the passed object is a tweet or not."""
+        if is_tweet == True:
+            self.title = _(u"Tweet")
+            image_description = []
+            text = ""
+            for i in range(0, len(tweetList)):
+                # tweets with message keys are longer tweets, the message value is the full messaje taken from twishort.
+                if hasattr(tweetList[i], "message")  and tweetList[i].is_quote_status == False:
+                    value = "message"
+                else:
+                    value = "full_text"
+                if hasattr(tweetList[i], "retweeted_status") and tweetList[i].is_quote_status == False:
+                    if not hasattr(tweetList[i], "message"):
+                        text = text + "rt @%s: %s\n" % (tweetList[i].retweeted_status.user.screen_name, tweetList[i].retweeted_status.full_text)
+                    else:
+                        text = text + "rt @%s: %s\n" % (tweetList[i].retweeted_status.user.screen_name, getattr(tweetList[i], value))
+                else:
+                    text = text + " @%s: %s\n" % (tweetList[i].user.screen_name, getattr(tweetList[i], value))
+                # tweets with extended_entities could include image descriptions.
+                if hasattr(tweetList[i], "extended_entities") and "media" in tweetList[i].extended_entities:
+                    for z in tweetList[i].extended_entities["media"]:
+                        if "ext_alt_text" in z and z["ext_alt_text"] != None:
+                            image_description.append(z["ext_alt_text"])
+                if hasattr(tweetList[i], "retweeted_status") and hasattr(tweetList[i].retweeted_status, "extended_entities") and "media" in tweetList[i].retweeted_status["extended_entities"]:
+                    for z in tweetList[i].retweeted_status.extended_entities["media"]:
+                        if "ext_alt_text" in z and z["ext_alt_text"] != None:
+                            image_description.append(z["ext_alt_text"])
+            # set rt and likes counters.
+            rt_count = str(tweet.retweet_count)
+            favs_count = str(tweet.favorite_count)
+            # Gets the client from where this tweet was made.
+            source = tweet.source
+            original_date = arrow.get(tweet.created_at, locale="en")
+            date = original_date.shift(seconds=utc_offset).format(_(u"MMM D, YYYY. H:m"), locale=languageHandler.getLanguage())
+            if text == "":
+                if hasattr(tweet, "message"):
+                    value = "message"
+                else:
+                    value = "full_text"
+                if hasattr(tweet, "retweeted_status"):
+                    if not hasattr(tweet, "message"):
+                        text = "rt @%s: %s" % (tweet.retweeted_status.user.screen_name, tweet.retweeted_status.full_text)
+                    else:
+                        text = "rt @%s: %s" % (tweet.retweeted_status.user.screen_name, getattr(tweet, value))
+                else:
+                    text = getattr(tweet, value)
+            text = self.clear_text(text)
+            if hasattr(tweet, "extended_entities") and "media" in tweet.extended_entities:
+                for z in tweet.extended_entities["media"]:
+                    if "ext_alt_text" in z and z["ext_alt_text"] != None:
+                        image_description.append(z["ext_alt_text"])
+            if hasattr(tweet, "retweeted_status") and hasattr(tweet.retweeted_status, "extended_entities") and "media" in tweet.retweeted_status.extended_entities:
+                for z in tweet.retweeted_status.extended_entities["media"]:
+                    if "ext_alt_text" in z and z["ext_alt_text"] != None:
+                        image_description.append(z["ext_alt_text"])
+            self.message = twitterDialogs.viewTweet(text, rt_count, favs_count, source, date)
+            results = parse_tweet(text)
+            self.message.set_title(results.weightedLength)
+            [self.message.set_image_description(i) for i in image_description]
+        else:
+            self.title = _(u"View item")
+            text = tweet
+            self.message = twitterDialogs.viewNonTweet(text, date)
+        widgetUtils.connect_event(self.message.spellcheck, widgetUtils.BUTTON_PRESSED, self.spellcheck)
+        if item_url != "":
+            self.message.enable_button("share")
+            widgetUtils.connect_event(self.message.share, widgetUtils.BUTTON_PRESSED, self.share)
+            self.item_url = item_url
+        widgetUtils.connect_event(self.message.translateButton, widgetUtils.BUTTON_PRESSED, self.translate)
+        self.message.ShowModal()
+
+    # We won't need text_processor in this dialog, so let's avoid it.
+    def text_processor(self):
+        pass
+
+    def clear_text(self, text):
+        text = utils.StripChars(text)
+        urls = utils.find_urls_in_text(text)
+        for i in urls:
+            if "https://twitter.com/" in i:
+                text = text.replace(i, "\n")
+        return text
+
+    def share(self, *args, **kwargs):
+        if hasattr(self, "item_url"):
+            output.copy(self.item_url)
+            output.speak(_("Link copied to clipboard."))

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()

src/controller/twitter/templateEditor.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+import re
+import wx
+from typing import List
+from sessions.twitter.templates import tweet_variables, dm_variables, person_variables
+from wxUI.dialogs.twitterDialogs import templateDialogs
+
+class EditTemplate(object):
+    def __init__(self, template: str, type: str) -> None:
+        super(EditTemplate, self).__init__()
+        self.default_template = template
+        if type == "tweet":
+            self.variables = tweet_variables
+        elif type == "dm":
+            self.variables = dm_variables
+        else:
+            self.variables = person_variables
+        self.template: str = template
+
+    def validate_template(self, template: str) -> bool:
+        used_variables: List[str] = re.findall("\$\w+", template)
+        validated: bool = True
+        for var in used_variables:
+            if var[1:] not in self.variables:
+                validated = False
+        return validated
+
+    def run_dialog(self) -> str:
+        dialog = templateDialogs.EditTemplateDialog(template=self.template, variables=self.variables, default_template=self.default_template)
+        response = dialog.ShowModal()
+        if response == wx.ID_SAVE:
+            validated: bool = self.validate_template(dialog.template.GetValue())
+            if validated == False:
+                templateDialogs.invalid_template()
+                self.template = dialog.template.GetValue()
+                return self.run_dialog()
+            else:
+                return dialog.template.GetValue()
+        else:
+            return ""

src/controller/twitter/user.py

@@ -107,7 +107,7 @@ class profileController(object):
         string = string+ _(u"Protected: %s\n") % (protected)
         if hasattr(self, "friendship_status"):
             relation = False
-            friendship = "Relationship: "
+            friendship = _(u"Relationship: ")
             if self.friendship_status[0].following:
                 friendship += _(u"You follow {0}. ").format(self.data.name,)
                 relation = True

src/controller/twitter/userActions.py

@@ -4,7 +4,7 @@ import output
 from wxUI.dialogs import userActions
 from pubsub import pub
 from tweepy.errors  import TweepyException
-from extra import autocompletionUsers
+from extra.autocompletionUsers import completion
 
 class userActionsController(object):
     def __init__(self, buffer, users=[], default="follow"):
@@ -17,7 +17,7 @@ class userActionsController(object):
             self.process_action()
 
     def autocomplete_users(self, *args, **kwargs):
-        c = autocompletionUsers.completion.autocompletionUsers(self.dialog, self.session.session_id)
+        c = completion.autocompletionUsers(self.dialog, self.session.session_id)
         c.show_menu("dm")
 
     def process_action(self):
@@ -29,36 +29,42 @@ class userActionsController(object):
     def follow(self, user):
         try:
             self.session.twitter.create_friendship(screen_name=user )
+            pub.sendMessage("twitter.restart_streaming", session=self.session.session_id)
         except TweepyException  as err:
             output.speak("Error %s" % (str(err)), True)
 
     def unfollow(self, user):
         try:
             id = self.session.twitter.destroy_friendship(screen_name=user )
+            pub.sendMessage("twitter.restart_streaming", session=self.session.session_id)
         except TweepyException as err:
             output.speak("Error %s" % (str(err)), True)
 
     def mute(self, user):
         try:
             id = self.session.twitter.create_mute(screen_name=user )
+            pub.sendMessage("twitter.restart_streaming", session=self.session.session_id)
         except TweepyException as err:
             output.speak("Error %s" % (str(err)), True)
 
     def unmute(self, user):
         try:
             id = self.session.twitter.destroy_mute(screen_name=user )
+            pub.sendMessage("twitter.restart_streaming", session=self.session.session_id)
         except TweepyException as err:
             output.speak("Error %s" % (str(err)), True)
 
     def report(self, user):
         try:
             id = self.session.twitter.report_spam(screen_name=user )
+            pub.sendMessage("twitter.restart_streaming", session=self.session.session_id)
         except TweepyException as err:
             output.speak("Error %s" % (str(err)), True)
 
     def block(self, user):
         try:
             id = self.session.twitter.create_block(screen_name=user )
+            pub.sendMessage("twitter.restart_streaming", session=self.session.session_id)
         except TweepyException as err:
             output.speak("Error %s" % (str(err)), True)
 

src/controller/userAlias.py

@@ -2,7 +2,6 @@
 import widgetUtils
 from pubsub import pub
 from wxUI.dialogs import userAliasDialogs
-from extra import autocompletionUsers
 
 class userAliasController(object):
     def __init__(self, settings):

src/controller/userSelector.py

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+""" Small utility dessigned to select users from the currently focused item or the autocomplete database. """
+import wx
+import widgetUtils
+from wxUI.dialogs import utils
+from extra.autocompletionUsers import completion
+
+class userSelector(object):
+
+    def __init__(self, users, session_id, title=_("Select user")):
+        """ Creates a dialog that chooses an user selector, from where users who have the autocomplete database already filled can also use that feature.
+
+        :param users: lists of users extracted from the currently focused item.
+        :type users: list
+        :param session_id: ID of the session to instantiate autocomplete database.
+        :type session_id: str
+        :param title: Title of the user selector dialog.
+        :type title: str
+        """
+        self.session_id = session_id
+        self.dlg = utils.selectUserDialog(users=users, title=title)
+        widgetUtils.connect_event(self.dlg.autocompletion, widgetUtils.BUTTON_PRESSED, self.on_autocomplete_users)
+
+    def on_autocomplete_users(self, *args, **kwargs):
+        """ performs user autocompletion, if configured properly. """
+        c = completion.autocompletionUsers(self.dlg, self.session_id)
+        c.show_menu("dm")
+
+    def get_user(self):
+        """ Actually shows the dialog and returns an user if the dialog was accepted, None otherwise.
+
+        :rtype: str or None
+        """
+        if self.dlg.ShowModal() == wx.ID_OK:
+            user = self.dlg.get_user()
+        else:
+            user = None
+        self.dlg.Destroy()
+        return user

src/extra/SoundsTutorial/__init__.py

@@ -1,3 +1 @@
-from __future__ import absolute_import
-from __future__ import unicode_literals
 from .soundsTutorial import soundsTutorial

src/extra/SoundsTutorial/gtk_ui.py

@@ -1,26 +0,0 @@
-# -*- coding: utf-8 -*-
-from __future__ import unicode_literals
-from gi.repository import Gtk
-import widgetUtils
-
-class soundsTutorialDialog(Gtk.Dialog):
-    def __init__(self, actions):
-        super(soundsTutorialDialog, self).__init__("Sounds tutorial", None, 0, (Gtk.STOCK_CANCEL, widgetUtils.CANCEL))
-        box = self.get_content_area()
-        label = Gtk.Label("Press enter for listen the sound")
-        self.list = widgetUtils.list("Action")
-        self.populate_actions(actions)
-        lBox = Gtk.Box(spacing=6)
-        lBox.add(label)
-        lBox.add(self.list.list)
-        box.add(lBox)
-        self.play = Gtk.Button("Play")
-        box.add(self.play)
-        self.show_all()
-
-    def populate_actions(self, actions):
-        for i in actions:
-            self.list.insert_item(i)
-
-    def get_selected(self):
-        return self.list.get_selected()

src/extra/SoundsTutorial/reverse_sort.py

@@ -1,4 +1,3 @@
-from __future__ import unicode_literals
 #Reverse sort, by Bill Dengler <codeofdusk@gmail.com> for use in TWBlue http://twblue.es
 def invert_tuples(t):
     "Invert a list of tuples, so that the 0th element becomes the -1th, and the -1th becomes the 0th."

src/extra/SoundsTutorial/soundsTutorial.py

@@ -1,7 +1,4 @@
 # -*- coding: utf-8 -*-
-from __future__ import absolute_import
-from __future__ import unicode_literals
-from builtins import object
 import platform
 import widgetUtils
 import os
@@ -9,10 +6,7 @@ import paths
 import logging
 log = logging.getLogger("extra.SoundsTutorial.soundsTutorial")
 from . import soundsTutorial_constants
-if platform.system() == "Windows":
-    from . import wx_ui as UI
-elif platform.system() == "Linux":
-    from . import gtk_ui as UI
+from . import wx_ui as UI
 
 class soundsTutorial(object):
     def __init__(self, sessionObject):

src/extra/SoundsTutorial/soundsTutorial_constants.py

@@ -1,7 +1,4 @@
 #-*- coding: utf-8 -*-
-from __future__ import absolute_import
-from __future__ import unicode_literals
-#-*- coding: utf-8 -*-
 from . import reverse_sort
 import application
 actions = reverse_sort.reverse_sort([  ("audio", _(u"Audio tweet.")),

src/extra/SoundsTutorial/wx_ui.py

@@ -1,5 +1,4 @@
 # -*- coding: utf-8 -*-
-from __future__ import unicode_literals
 import wx
 import widgetUtils
 

src/extra/SpellChecker/spellchecker.py

@@ -1,8 +1,4 @@
 # -*- coding: utf-8 -*-
-from __future__ import absolute_import
-from __future__ import unicode_literals
-from builtins import next
-from builtins import object
 import os
 import logging
 from . import wx_ui

src/extra/SpellChecker/twitterFilter.py

@@ -1,5 +1,4 @@
 # -*- coding: utf-8 -*-
-from __future__ import unicode_literals
 import re
 from enchant.tokenize import Filter
 

src/extra/SpellChecker/wx_ui.py

@@ -16,7 +16,6 @@
 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 ############################################################
-from __future__ import unicode_literals
 import wx
 import application
 

src/extra/autocompletionUsers/__init__.py

@@ -1,5 +1,2 @@
 # -*- coding: utf-8 -*-
-from __future__ import absolute_import
-from __future__ import unicode_literals
-# -*- coding: utf-8 -*-
-from . import completion, settings
+""" Autocompletion users for TWBlue. This package contains all needed code to support this feature, including automatic addition of users, management and code to show the autocompletion menu when an user is composing a tweet. """

src/extra/autocompletionUsers/completion.py

@@ -1,18 +1,37 @@
 # -*- coding: utf-8 -*-
+""" Module to display the user autocompletion menu in tweet or direct message dialogs. """
 import output
 from . import storage
 from . import wx_menu
 
 class autocompletionUsers(object):
     def __init__(self, window, session_id):
+        """ Class constructor. Displays a menu with users matching the specified pattern for autocompletion.
+
+        :param window: A wx control where the menu should be displayed. Normally this is going to be the wx.TextCtrl indicating the tweet's text or direct message recipient.
+        :type window: wx.Dialog
+        :param session_id: Session ID which calls this class. We will load the users database from this session.
+        :type session_id: str.
+        """
         super(autocompletionUsers, self).__init__()
         self.window = window
         self.db = storage.storage(session_id)
 
     def show_menu(self, mode="tweet"):
-        position = self.window.get_position()
+        """ displays a menu with possible users matching the specified pattern.
+
+        this menu can be displayed in tweet dialogs or in any other dialog where an username is expected. For tweet dialogs, the string should start with an at symbol (@), otherwise it won't match the pattern.
+
+        Of course, users must be already loaded in database before attempting this.
+
+        If no users are found, an error message will be spoken.
+
+        :param mode: this controls how the dialog will behave. Possible values are 'tweet' and 'dm'. In tweet mode, the matching pattern will be @user (@ is required), while in 'dm' mode the matching pattern will be anything written in the text control.
+        :type mode: str
+        """
         if mode == "tweet":
-            text = self.window.get_text()
+            position = self.window.text.GetInsertionPoint()
+            text = self.window.text.GetValue()
             text = text[:position]
             try:
                 pattern = text.split()[-1]
@@ -24,14 +43,14 @@ class autocompletionUsers(object):
                 users = self.db.get_users(pattern[1:])
                 if len(users) > 0:
                     menu.append_options(users)
-                    self.window.popup_menu(menu)
+                    self.window.PopupMenu(menu, self.window.text.GetPosition())
                     menu.destroy()
                 else:
                     output.speak(_(u"There are no results in your users database"))
             else:
                 output.speak(_(u"Autocompletion only works for users."))
         elif mode == "dm":
-            text = self.window.get_user()
+            text = self.window.cb.GetValue()
             try:
                 pattern = text.split()[-1]
             except IndexError:
@@ -41,7 +60,7 @@ class autocompletionUsers(object):
             users = self.db.get_users(pattern)
             if len(users) > 0:
                 menu.append_options(users)
-                self.window.popup_menu(menu)
+                self.window.PopupMenu(menu, self.window.cb.GetPosition())
                 menu.destroy()
             else:
                 output.speak(_(u"There are no results in your users database"))

src/extra/autocompletionUsers/manage.py

@@ -1,15 +1,27 @@
 # -*- coding: utf-8 -*-
+""" Management of users in the local database for autocompletion. """
+import time
 import widgetUtils
+from tweepy.cursor import Cursor
 from tweepy.errors import TweepyException
-from . import storage, wx_manage
 from wxUI import commonMessageDialogs
+from . import storage, wx_manage
 
 class autocompletionManage(object):
     def __init__(self, session):
+        """ class constructor. Manages everything related to user autocompletion.
+
+        :param session: Sessiom where the autocompletion management has been requested.
+        :type session: sessions.base.Session.
+        """
         super(autocompletionManage, self).__init__()
         self.session = session
-        self.dialog = wx_manage.autocompletionManageDialog()
+        # Instantiate database so we can perform modifications on it.
         self.database = storage.storage(self.session.session_id)
+
+    def show_settings(self):
+        """ display user management  dialog and connect events associated to it. """
+        self.dialog = wx_manage.autocompletionManageDialog()
         self.users = self.database.get_all_users()
         self.dialog.put_users(self.users)
         widgetUtils.connect_event(self.dialog.add, widgetUtils.BUTTON_PRESSED, self.add_user)
@@ -17,6 +29,7 @@ class autocompletionManage(object):
         self.dialog.get_response()
 
     def update_list(self):
+        """ update users list in management dialog. This function is normallhy used after we modify the database in any way, so we can reload all users in the autocompletion user management list. """
         item = self.dialog.users.get_selected()
         self.dialog.users.clear()
         self.users = self.database.get_all_users()
@@ -24,9 +37,12 @@ class autocompletionManage(object):
         self.dialog.users.select_item(item)
 
     def add_user(self, *args, **kwargs):
+        """ Add a new Twitter username to the autocompletion database. """
         usr = self.dialog.get_user()
         if usr == False:
             return
+        # check if user exists.
+        # ToDo: in case we want to adapt this for other networks we'd need to refactor this check.
         try:
             data = self.session.twitter.get_user(screen_name=usr)
         except TweepyException as e:
@@ -36,7 +52,8 @@ class autocompletionManage(object):
         self.database.set_user(data.screen_name, data.name, 0)
         self.update_list()
 
-    def remove_user(self, ev):
+    def remove_user(self, *args, **kwargs):
+        """ Remove focused user from the autocompletion database. """
         if commonMessageDialogs.delete_user_from_db() == widgetUtils.YES:
             item = self.dialog.users.get_selected()
             user = self.users[item]

src/extra/autocompletionUsers/scan.py

@@ -0,0 +1,110 @@
+# -*- coding: utf-8 -*-
+""" Scanning code for autocompletion feature on TWBlue. This module can retrieve user objects from the selected Twitter account automatically. """
+import time
+import wx
+import widgetUtils
+import output
+from tweepy.cursor import Cursor
+from tweepy.errors import TweepyException
+from pubsub import pub
+from . import wx_scan
+from . import manage
+from . import storage
+
+class autocompletionScan(object):
+    def __init__(self, config, buffer, window):
+        """ Class constructor. This class will take care of scanning the selected Twitter account to populate the database with users automatically upon request.
+
+        :param config: Config for the session that will be scanned in search for users.
+        :type config: dict
+        :param buffer: home buffer for the focused session.
+        :type buffer: controller.buffers.twitter.base.baseBuffer
+        :param window: Main Window of TWBlue.
+        :type window:wx.Frame
+        """
+        super(autocompletionScan, self).__init__()
+        self.config = config
+        self.buffer = buffer
+        self.window = window
+
+    def show_dialog(self):
+        self.dialog = wx_scan.autocompletionScanDialog()
+        self.dialog.set("friends", self.config["mysc"]["save_friends_in_autocompletion_db"])
+        self.dialog.set("followers", self.config["mysc"]["save_followers_in_autocompletion_db"])
+        if self.dialog.get_response() == widgetUtils.OK:
+            confirmation = wx_scan.confirm()
+            return confirmation
+
+    def prepare_progress_dialog(self):
+        self.progress_dialog = wx_scan.autocompletionScanProgressDialog()
+        # connect method to update progress dialog
+        pub.subscribe(self.on_update_progress, "on-update-progress")
+        self.progress_dialog.Show()
+
+    def on_update_progress(self, percent):
+        if percent > 100:
+            percent = 100
+        wx.CallAfter(self.progress_dialog.update, percent)
+
+    def scan(self):
+        """ Attempts to add all users selected by current user to the autocomplete database. """
+        ids = []
+        self.config["mysc"]["save_friends_in_autocompletion_db"] = self.dialog.get("friends")
+        self.config["mysc"]["save_followers_in_autocompletion_db"] = self.dialog.get("followers")
+        output.speak(_("Updating database... You can close this window now. A message will tell you when the process finishes."))
+        database = storage.storage(self.buffer.session.session_id)
+        percent = 0
+        # Retrieve ids of all following users
+        if self.dialog.get("friends") == True:
+            for i in Cursor(self.buffer.session.twitter.get_friend_ids, count=5000).items():
+                if str(i) not in ids:
+                    ids.append(str(i))
+        # same step, but for followers.
+        if self.dialog.get("followers") == True:
+            try:
+                for i in Cursor(self.buffer.session.twitter.get_follower_ids, count=5000).items():
+                    if str(i) not in ids:
+                        ids.append(str(i))
+            except TweepyException:
+                wx.CallAfter(wx_scan.show_error)
+                return self.done()
+        # As next step requires batches of 100s users, let's split our user Ids so we won't break the param rules.
+        split_users = [ids[i:i + 100] for i in range(0, len(ids), 100)]
+        # store returned users in this list.
+        users = []
+        for z in split_users:
+            if len(z) == 0:
+                continue
+            try:
+                results = self.buffer.session.twitter.lookup_users(user_id=z)
+            except TweepyException:
+                wx.CallAfter(wx_scan.show_error)
+                return self.done()
+            users.extend(results)
+            time.sleep(1)
+            percent = percent + (100/len(split_users))
+            pub.sendMessage("on-update-progress", percent=percent)
+        for user in users:
+            database.set_user(user.screen_name, user.name, 1)
+        wx.CallAfter(wx_scan.show_success, len(users))
+        self.done()
+
+    def done(self):
+        wx.CallAfter(self.progress_dialog.Destroy)
+        wx.CallAfter(self.dialog.Destroy)
+        pub.unsubscribe(self.on_update_progress, "on-update-progress")
+
+def execute_at_startup(window, buffer, config):
+    database = storage.storage(buffer.session.session_id)
+    if config["mysc"]["save_followers_in_autocompletion_db"] == True and config["other_buffers"]["show_followers"] == True:
+        buffer = window.search_buffer("followers", config["twitter"]["user_name"])
+        for i in buffer.session.db[buffer.name]:
+            database.set_user(i.screen_name, i.name, 1)
+    else:
+        database.remove_by_buffer(1)
+    if config["mysc"]["save_friends_in_autocompletion_db"] == True and config["other_buffers"]["show_friends"] == True:
+        buffer = window.search_buffer("friends", config["twitter"]["user_name"])
+        for i in buffer.session.db[buffer.name]:
+            database.set_user(i.screen_name, i.name, 2)
+    else:
+        database.remove_by_buffer(2)  

src/extra/autocompletionUsers/settings.py

@@ -1,59 +0,0 @@
-# -*- coding: utf-8 -*-
-import widgetUtils
-import output
-from . import wx_settings
-from . import manage
-from . import storage
-from mysc.thread_utils import call_threaded
-
-class autocompletionSettings(object):
-    def __init__(self, config, buffer, window):
-        super(autocompletionSettings, self).__init__()
-        self.config = config
-        self.buffer = buffer
-        self.window = window
-        self.dialog = wx_settings.autocompletionSettingsDialog()
-        self.dialog.set("friends_buffer", self.config["mysc"]["save_friends_in_autocompletion_db"])
-        self.dialog.set("followers_buffer", self.config["mysc"]["save_followers_in_autocompletion_db"])
-        widgetUtils.connect_event(self.dialog.viewList, widgetUtils.BUTTON_PRESSED, self.view_list)
-        if self.dialog.get_response() == widgetUtils.OK:
-            call_threaded(self.add_users_to_database)
-
-    def add_users_to_database(self):
-        self.config["mysc"]["save_friends_in_autocompletion_db"] = self.dialog.get("friends_buffer")
-        self.config["mysc"]["save_followers_in_autocompletion_db"] = self.dialog.get("followers_buffer")
-        output.speak(_(u"Updating database... You can close this window now. A message will tell you when the process finishes."))
-        database = storage.storage(self.buffer.session.session_id)
-        if self.dialog.get("followers_buffer") == True:
-            buffer = self.window.search_buffer("followers", self.config["twitter"]["user_name"])
-            for i in buffer.session.db[buffer.name]:
-                database.set_user(i.screen_name, i.name, 1)
-        else:
-            database.remove_by_buffer(1)
-        if self.dialog.get("friends_buffer") == True:
-            buffer = self.window.search_buffer("friends", self.config["twitter"]["user_name"])
-            for i in buffer.session.db[buffer.name]:
-                database.set_user(i.screen_name, i.name, 2)
-        else:
-            database.remove_by_buffer(2)
-        wx_settings.show_success_dialog()
-        self.dialog.destroy()
-
-    def view_list(self, ev):
-        q = manage.autocompletionManage(self.buffer.session)
-
-
-def execute_at_startup(window, buffer, config):
-    database = storage.storage(buffer.session.session_id)
-    if config["mysc"]["save_followers_in_autocompletion_db"] == True and config["other_buffers"]["show_followers"] == True:
-        buffer = window.search_buffer("followers", config["twitter"]["user_name"])
-        for i in buffer.session.db[buffer.name]:
-            database.set_user(i.screen_name, i.name, 1)
-    else:
-        database.remove_by_buffer(1)
-    if config["mysc"]["save_friends_in_autocompletion_db"] == True and config["other_buffers"]["show_friends"] == True:
-        buffer = window.search_buffer("friends", config["twitter"]["user_name"])
-        for i in buffer.session.db[buffer.name]:
-            database.set_user(i.screen_name, i.name, 2)
-    else:
-        database.remove_by_buffer(2)  

src/extra/autocompletionUsers/wx_menu.py

@@ -11,7 +11,7 @@ class menu(wx.Menu):
     def append_options(self, options):
         for i in options:
             item = wx.MenuItem(self, wx.ID_ANY, "%s (@%s)" % (i[1], i[0]))
-            self.AppendItem(item)
+            self.Append(item)
             self.Bind(wx.EVT_MENU, lambda evt, temp=i[0]: self.select_text(evt, temp), item)
 
     def select_text(self, ev, text):

src/extra/autocompletionUsers/wx_scan.py

@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+import wx
+import widgetUtils
+import application
+
+class autocompletionScanDialog(widgetUtils.BaseDialog):
+    def __init__(self):
+        super(autocompletionScanDialog, self).__init__(parent=None, id=-1, title=_(u"Autocomplete users' settings"))
+        panel = wx.Panel(self)
+        sizer = wx.BoxSizer(wx.VERTICAL)
+        self.followers = wx.CheckBox(panel, -1, _("Add followers to database"))
+        self.friends = wx.CheckBox(panel, -1, _("Add  friends to database"))
+        sizer.Add(self.followers, 0, wx.ALL, 5)
+        sizer.Add(self.friends, 0, wx.ALL, 5)
+        ok = wx.Button(panel, wx.ID_OK)
+        cancel = wx.Button(panel, wx.ID_CANCEL)
+        sizerBtn = wx.BoxSizer(wx.HORIZONTAL)
+        sizerBtn.Add(ok, 0, wx.ALL, 5)
+        sizer.Add(cancel, 0, wx.ALL, 5)
+        sizer.Add(sizerBtn, 0, wx.ALL, 5)
+        panel.SetSizer(sizer)
+        self.SetClientSize(sizer.CalcMin())
+
+class autocompletionScanProgressDialog(widgetUtils.BaseDialog):
+    def __init__(self, *args, **kwargs):
+        super(autocompletionScanProgressDialog, self).__init__(parent=None, id=wx.ID_ANY, title=_("Updating autocompletion database"), *args, **kwargs)
+        panel = wx.Panel(self)
+        sizer = wx.BoxSizer(wx.VERTICAL)
+        self.progress_bar = wx.Gauge(parent=panel)
+        sizer.Add(self.progress_bar)
+        panel.SetSizerAndFit(sizer)
+
+    def update(self, percent):
+        self.progress_bar.SetValue(percent)
+
+def confirm():
+    with wx.MessageDialog(None, _("This process will retrieve the users you selected from Twitter, and add them to the user autocomplete database. Please note that if there are many users or you have tried to perform this action less than 15 minutes ago, TWBlue may reach a limit in Twitter API calls when trying to load the users into the database. If this happens, we will show you an error, in which case you will have to try this process again in a few minutes. If this process ends with no error, you will be redirected back to the account settings dialog. Do you want to continue?"), _("Attention"), style=wx.ICON_QUESTION|wx.YES_NO) as result:
+        if result.ShowModal() == wx.ID_YES:
+            return True
+        return False
+
+def show_success(users):
+    with wx.MessageDialog(None, _("TWBlue has imported {} users successfully.").format(users), _("Done")) as dlg:
+        dlg.ShowModal()
+
+def show_error():
+    with wx.MessageDialog(None, _("Error adding users from Twitter. Please try again in about 15 minutes."), _("Error"), style=wx.ICON_ERROR) as dlg:
+        dlg.ShowModal()

src/extra/autocompletionUsers/wx_settings.py

@@ -1,27 +0,0 @@
-# -*- coding: utf-8 -*-
-import wx
-import widgetUtils
-import application
-
-class autocompletionSettingsDialog(widgetUtils.BaseDialog):
-    def __init__(self):
-        super(autocompletionSettingsDialog, self).__init__(parent=None, id=-1, title=_(u"Autocomplete users' settings"))
-        panel = wx.Panel(self)
-        sizer = wx.BoxSizer(wx.VERTICAL)
-        self.followers_buffer = wx.CheckBox(panel, -1, _(u"Add users from followers buffer"))
-        self.friends_buffer = wx.CheckBox(panel, -1, _(u"Add users from friends buffer"))
-        sizer.Add(self.followers_buffer, 0, wx.ALL, 5)
-        sizer.Add(self.friends_buffer, 0, wx.ALL, 5)
-        self.viewList = wx.Button(panel, -1, _(u"Manage database..."))
-        sizer.Add(self.viewList, 0, wx.ALL, 5)
-        ok = wx.Button(panel, wx.ID_OK)
-        cancel = wx.Button(panel, wx.ID_CANCEL)
-        sizerBtn = wx.BoxSizer(wx.HORIZONTAL)
-        sizerBtn.Add(ok, 0, wx.ALL, 5)
-        sizer.Add(cancel, 0, wx.ALL, 5)
-        sizer.Add(sizerBtn, 0, wx.ALL, 5)
-        panel.SetSizer(sizer)
-        self.SetClientSize(sizer.CalcMin())
-
-def show_success_dialog():
-    wx.MessageDialog(None, _(u"{0}'s database of users has been updated.").format(application.name,), _(u"Done"), wx.OK).ShowModal()

src/extra/translator/__init__.py

@@ -2,7 +2,4 @@
 from __future__ import absolute_import
 from __future__ import unicode_literals
 from . import translator
-import platform
-if platform.system() == "Windows":
-    from . import wx_ui as gui
-
+from . import wx_ui as gui

src/issueReporter/constants.py

@@ -1,22 +0,0 @@
-# -*- coding: utf-8 -*-
-############################################################
-#    Copyright (c) 2013, 2014 Manuel Eduardo Cortéz Vallejo <manuel@manuelcortez.net>
-#       
-#    This program is free software: you can redistribute it and/or modify
-#    it under the terms of the GNU General Public License as published by
-#    the Free Software Foundation, either version 2 of the License, or
-#    (at your option) any later version.
-#
-#    This program is distributed in the hope that it will be useful,
-#    but WITHOUT ANY WARRANTY; without even the implied warranty of
-#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#    GNU General Public License for more details.
-#
-#    You should have received a copy of the GNU General Public License
-#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-############################################################
-from __future__ import unicode_literals
-categories = ["General"]
-reproducibilities = ["always", "sometimes", "random", "have not tried", "unable to duplicate"]
-severities = ["block", "crash", "major", "minor", "tweak", "text", "trivial", "feature"]

src/issueReporter/issueReporter.py

@@ -1,66 +0,0 @@
-# -*- coding: utf-8 -*-
-############################################################
-#    Copyright (c) 2013, 2014 Manuel Eduardo Cortéz Vallejo <manuel@manuelcortez.net>
-#       
-#    This program is free software: you can redistribute it and/or modify
-#    it under the terms of the GNU General Public License as published by
-#    the Free Software Foundation, either version 2 of the License, or
-#    (at your option) any later version.
-#
-#    This program is distributed in the hope that it will be useful,
-#    but WITHOUT ANY WARRANTY; without even the implied warranty of
-#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#    GNU General Public License for more details.
-#
-#    You should have received a copy of the GNU General Public License
-#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-############################################################
-from __future__ import unicode_literals
-from builtins import object
-import keys
-import wx
-import wx_ui
-import widgetUtils
-import application
-from suds.client import Client
-import constants
-
-class reportBug(object):
-    def __init__(self, user_name):
-        self.user_name = user_name
-        self.categories = [_(u"General")]
-        self.reproducibilities = [_(u"always"), _(u"sometimes"), _(u"random"), _(u"have not tried"), _(u"unable to duplicate")]
-        self.severities = [_(u"block"), _(u"crash"), _(u"major"), _(u"minor"), _(u"tweak"), _(u"text"), _(u"trivial"), _(u"feature")]
-        self.dialog = wx_ui.reportBugDialog(self.categories, self.reproducibilities, self.severities)
-        widgetUtils.connect_event(self.dialog.ok, widgetUtils.BUTTON_PRESSED, self.send)
-        self.dialog.get_response()
-
-    def send(self, *args, **kwargs):
-        if self.dialog.get("summary") == "" or self.dialog.get("description") == "":
-            self.dialog.no_filled()
-            return
-        if self.dialog.get("agree") == False:
-            self.dialog.no_checkbox()
-            return
-        try:
-            client = Client(application.report_bugs_url)
-            issue = client.factory.create('IssueData')
-            issue.project.name = application.name
-            issue.project.id = 0
-            issue.summary = self.dialog.get("summary"),
-            issue.description = "Reported by @%s on version %s (snapshot = %s)\n\n" % (self.user_name, application.version, application.snapshot) + self.dialog.get("description")
-            # to do: Create getters for category, severity and reproducibility in wx_UI.
-            issue.category = constants.categories[self.dialog.category.GetSelection()]
-            issue.reproducibility.name = constants.reproducibilities[self.dialog.reproducibility.GetSelection()]
-            issue.severity.name = constants.severities[self.dialog.severity.GetSelection()]
-            issue.priority.name = "normal"
-            issue.view_state.name = "public"
-            issue.resolution.name = "open"
-            issue.projection.name = "none"
-            issue.eta.name = "eta"
-            issue.status.name = "new"
-            id = client.service.mc_issue_add(keys.keyring.get("bts_user"), keys.keyring.get("bts_password"), issue)
-            self.dialog.success(id)
-        except:
-            self.dialog.error()

src/issueReporter/wx_ui.py

@@ -1,95 +0,0 @@
-# -*- coding: utf-8 -*-
-############################################################
-#    Copyright (c) 2013, 2014 Manuel Eduardo Cortéz Vallejo <manuel@manuelcortez.net>
-#       
-#    This program is free software: you can redistribute it and/or modify
-#    it under the terms of the GNU General Public License as published by
-#    the Free Software Foundation, either version 2 of the License, or
-#    (at your option) any later version.
-#
-#    This program is distributed in the hope that it will be useful,
-#    but WITHOUT ANY WARRANTY; without even the implied warranty of
-#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#    GNU General Public License for more details.
-#
-#    You should have received a copy of the GNU General Public License
-#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-############################################################
-from __future__ import unicode_literals
-import wx
-import widgetUtils
-import application
-class reportBugDialog(widgetUtils.BaseDialog):
-    def __init__(self, categories, reproducibilities, severities):
-        super(reportBugDialog, self).__init__(parent=None, id=wx.NewId())
-        self.SetTitle(_(u"Report an error"))
-        panel = wx.Panel(self)
-        sizer = wx.BoxSizer(wx.VERTICAL)
-        categoryLabel = wx.StaticText(panel, -1, _(u"Select a category"), size=wx.DefaultSize)
-        self.category = wx.ComboBox(panel, -1, choices=categories, style=wx.CB_READONLY)
-        self.category.SetSelection(0)
-        categoryB = wx.BoxSizer(wx.HORIZONTAL)
-        categoryB.Add(categoryLabel, 0, wx.ALL, 5)
-        categoryB.Add(self.category, 0, wx.ALL, 5)
-        self.category.SetFocus()
-        sizer.Add(categoryB, 0, wx.ALL, 5)
-        summaryLabel = wx.StaticText(panel, -1, _(u"Briefly describe what happened. You will be able to thoroughly explain it later"), size=wx.DefaultSize)
-        self.summary = wx.TextCtrl(panel, -1)
-        dc = wx.WindowDC(self.summary)
-        dc.SetFont(self.summary.GetFont())
-        self.summary.SetSize(dc.GetTextExtent("a"*80))
-        summaryB = wx.BoxSizer(wx.HORIZONTAL)
-        summaryB.Add(summaryLabel, 0, wx.ALL, 5)
-        summaryB.Add(self.summary, 0, wx.ALL, 5)
-        sizer.Add(summaryB, 0, wx.ALL, 5)
-        descriptionLabel = wx.StaticText(panel, -1, _(u"Here, you can describe the bug in detail"), size=wx.DefaultSize)
-        self.description = wx.TextCtrl(panel, -1, style=wx.TE_MULTILINE)
-        dc = wx.WindowDC(self.description)
-        dc.SetFont(self.description.GetFont())
-        (x, y, z) = dc.GetMultiLineTextExtent("0"*2000)
-        self.description.SetSize((x, y))
-        descBox = wx.BoxSizer(wx.HORIZONTAL)
-        descBox.Add(descriptionLabel, 0, wx.ALL, 5)
-        descBox.Add(self.description, 0, wx.ALL, 5)
-        sizer.Add(descBox, 0, wx.ALL, 5)
-        reproducibilityLabel = wx.StaticText(panel, -1, _(u"how often does this bug happen?"), size=wx.DefaultSize)
-        self.reproducibility = wx.ComboBox(panel, -1, choices=reproducibilities, style=wx.CB_READONLY)
-        self.reproducibility.SetSelection(3)
-        reprB = wx.BoxSizer(wx.HORIZONTAL)
-        reprB.Add(reproducibilityLabel, 0, wx.ALL, 5)
-        reprB.Add(self.reproducibility, 0, wx.ALL, 5)
-        sizer.Add(reprB, 0, wx.ALL, 5)
-        severityLabel = wx.StaticText(panel, -1, _(u"Select the importance that you think this bug has"))
-        self.severity = wx.ComboBox(panel, -1, choices=severities, style=wx.CB_READONLY)
-        self.severity.SetSelection(3)
-        severityB = wx.BoxSizer(wx.HORIZONTAL)
-        severityB.Add(severityLabel, 0, wx.ALL, 5)
-        severityB.Add(self.severity, 0, wx.ALL, 5)
-        sizer.Add(severityB, 0, wx.ALL, 5)
-        self.agree = wx.CheckBox(panel, -1, _(u"I know that the {0} bug system will get my Twitter username to contact me and fix the bug quickly").format(application.name,))
-        self.agree.SetValue(False)
-        sizer.Add(self.agree, 0, wx.ALL, 5)
-        self.ok = wx.Button(panel, wx.ID_OK, _(u"Send report"))
-        self.ok.SetDefault()
-        cancel = wx.Button(panel, wx.ID_CANCEL, _(u"Cancel"))
-        btnBox = wx.BoxSizer(wx.HORIZONTAL)
-        btnBox.Add(self.ok, 0, wx.ALL, 5)
-        btnBox.Add(cancel, 0, wx.ALL, 5)
-        sizer.Add(btnBox, 0, wx.ALL, 5)
-        panel.SetSizer(sizer)
-        self.SetClientSize(sizer.CalcMin())
-
-    def no_filled(self):
-        wx.MessageDialog(self, _(u"You must fill out both fields"), _(u"Error"), wx.OK|wx.ICON_ERROR).ShowModal()
-
-    def no_checkbox(self):
-        wx.MessageDialog(self, _(u"You need to mark the checkbox to provide us your twitter username to contact you if it is necessary."), _(u"Error"), wx.ICON_ERROR).ShowModal()
-
-    def success(self, id):
-        wx.MessageDialog(self, _(u"Thanks for reporting this bug! In future versions, you may be able to find it in the changes list. You've reported the bug number %i") % (id), _(u"reported"), wx.OK).ShowModal()
-        self.EndModal(wx.ID_OK)
-
-    def error(self):
-        wx.MessageDialog(self, _(u"Something unexpected occurred while trying to report the bug. Please, try again later"), _(u"Error while reporting"), wx.ICON_ERROR|wx.OK).ShowModal()
-        self.EndModal(wx.ID_CANCEL)

src/keyboard_handler/linux.py

@@ -21,7 +21,7 @@ def parse(s):
             lst.remove(item)
 #end if
     if len(lst) > 1: #more than one key, parse error
-        raise ValueError, 'unknown modifier %s' % lst[0]
+        raise ValueError('unknown modifier %s' % lst[0])
     return (m, lst[0].lower())
 class AtspiThread(threading.Thread):
     def run(self):

src/keymaps/Windows 10.keymap

@@ -55,4 +55,5 @@ accountConfiguration = string(default="control+win+shift+o")
 update_buffer = string(default="control+alt+shift+u")
 ocr_image = string(default="win+alt+o")
 open_in_browser = string(default="alt+control+win+return")
-add_alias=string(default="")
+add_alias=string(default="")
+find = string(default="control+win+{")

src/keymaps/Windows11.keymap

@@ -42,7 +42,7 @@ toggle_buffer_mute = string(default="alt+win+shift+m")
 toggle_session_mute = string(default="control+alt+win+m")
 toggle_autoread = string(default="alt+win+e")
 search = string(default="alt+win+-")
-edit_keystrokes = string(default="alt+win+k")
+edit_keystrokes = string(default="control+alt+win+k")
 view_user_lists = string(default="alt+win+l")
 get_more_items = string(default="alt+win+pageup")
 reverse_geocode = string(default="control+win+g")
@@ -55,4 +55,5 @@ accountConfiguration = string(default="control+win+shift+o")
 update_buffer = string(default="control+alt+shift+u")
 ocr_image = string(default="win+alt+o")
 open_in_browser = string(default="alt+control+win+return")
-add_alias=string(default="")
+add_alias=string(default="")
+find = string(default="control+win+{")

src/keystrokeEditor/wx_ui.py

@@ -6,27 +6,26 @@ from wxUI.dialogs import baseDialog
 class keystrokeEditorDialog(baseDialog.BaseWXDialog):
     def __init__(self):
         super(keystrokeEditorDialog, self).__init__(parent=None, id=-1, title=_(u"Keystroke editor"))
-        panel = wx.Panel(self)
         self.actions = []
         sizer = wx.BoxSizer(wx.VERTICAL)
-        keysText = wx.StaticText(panel, -1, _(u"Select a keystroke to edit"))
+        keysText = wx.StaticText(self, -1, _(u"Select a keystroke to edit"))
         self.keys = widgets.list(self, _(u"Action"), _(u"Keystroke"), style=wx.LC_REPORT|wx.LC_SINGLE_SEL, size=(400, 450))
         self.keys.list.SetFocus()
         firstSizer = wx.BoxSizer(wx.HORIZONTAL)
         firstSizer.Add(keysText, 0, wx.ALL, 5)
         firstSizer.Add(self.keys.list, 0, wx.ALL, 5)
-        self.edit = wx.Button(panel, -1, _(u"Edit"))
+        self.edit = wx.Button(self, -1, _(u"Edit"))
         self.edit.SetDefault()
-        self.undefine = wx.Button(panel, -1, _("Undefine keystroke"))
-        self.execute = wx.Button(panel, -1, _(u"Execute action"))
-        close = wx.Button(panel, wx.ID_CANCEL, _(u"Close"))
+        self.undefine = wx.Button(self, -1, _("Undefine keystroke"))
+        self.execute = wx.Button(self, -1, _(u"Execute action"))
+        close = wx.Button(self, wx.ID_CANCEL, _(u"Close"))
         secondSizer = wx.BoxSizer(wx.HORIZONTAL)
         secondSizer.Add(self.edit, 0, wx.ALL, 5)
         secondSizer.Add(self.execute, 0, wx.ALL, 5)
         secondSizer.Add(close, 0, wx.ALL, 5)
         sizer.Add(firstSizer, 0, wx.ALL, 5)
         sizer.Add(secondSizer, 0, wx.ALL, 5)
-        panel.SetSizer(sizer)
+        self.SetSizer(sizer)
         self.SetClientSize(sizer.CalcMin())
 
     def put_keystrokes(self, actions, keystrokes):