some broken dialogs fixed

.gitignore

@@ -15,9 +15,12 @@ toxygen/libs
 toxygen/build
 toxygen/dist
 *.spec
-dist/
+dist
 toxygen/avatars
 toxygen/__pycache__
 /*.egg-info
 /*.egg
+html
+Toxygen.egg-info
+*.tox
 

.travis.yml

@@ -1,14 +1,24 @@
 language: python
 python:
-  - "3.4"
+  - "3.5"
+  - "3.6"
 before_install:
+  - sudo apt-get update
   - sudo apt-get install -y checkinstall build-essential
   - sudo apt-get install portaudio19-dev
+  - sudo apt-get install libconfig-dev libvpx-dev check -qq
+  - sudo apt-get install -y python3-pyqt5
 install:
-  - pip install PySide --no-index --find-links https://parkin.github.io/python-wheelhouse/;
-  - python ~/virtualenv/python${TRAVIS_PYTHON_VERSION}/bin/pyside_postinstall.py -install
   - pip install pyaudio
 before_script:
+# OPUS
+  - wget http://downloads.xiph.org/releases/opus/opus-1.0.3.tar.gz
+  - tar xzf opus-1.0.3.tar.gz
+  - cd opus-1.0.3
+  - ./configure
+  - make -j3
+  - sudo make install
+  - cd ..
 # Libsodium
   - git clone git://github.com/jedisct1/libsodium.git
   - cd libsodium
@@ -28,4 +38,6 @@ before_script:
   - echo '/usr/local/lib/' | sudo tee -a /etc/ld.so.conf.d/locallib.conf
   - sudo ldconfig
   - cd ..
-script: py.test tests/travis.py
+script:
+  - py.test tests/travis.py
+  - py.test tests/tests.py

README.md

@@ -1,25 +1,24 @@
 # Toxygen
 
-Toxygen is cross-platform [Tox](https://tox.chat/) client written in pure Python3
+Toxygen is powerful cross-platform [Tox](https://tox.chat/) client written in pure Python3.
 
-[![Release](https://img.shields.io/github/release/xveduk/toxygen.svg?style=flat)](https://github.com/toxygen-project/toxygen/releases/latest)
+[![Release](https://img.shields.io/github/release/toxygen-project/toxygen.svg?style=flat)](https://github.com/toxygen-project/toxygen/releases/latest)
-[![Stars](https://img.shields.io/github/stars/xveduk/toxygen.svg?style=flat)](https://github.com/toxygen-project/toxygen/stargazers)
+[![Stars](https://img.shields.io/github/stars/toxygen-project/toxygen.svg?style=flat)](https://github.com/toxygen-project/toxygen/stargazers)
-[![Open issues](https://img.shields.io/github/issues/xveduk/toxygen.svg?style=flat)](https://github.com/toxygen-project/toxygen/issues)
+[![Open issues](https://img.shields.io/github/issues/toxygen-project/toxygen.svg?style=flat)](https://github.com/toxygen-project/toxygen/issues)
 [![License](https://img.shields.io/badge/license-GPLv3-blue.svg?style=flat)](https://raw.githubusercontent.com/toxygen-project/toxygen/master/LICENSE.md)
+[![Build Status](https://travis-ci.org/toxygen-project/toxygen.svg?branch=master)](https://travis-ci.org/toxygen-project/toxygen)
 
-### [Install](/docs/install.md) - [Contribute](/docs/contributing.md) - [Plugins](/docs/plugins.md) - [Compile](/docs/compile.md) - [Contact](/docs/contact.md)
+### [Install](/docs/install.md) - [Contribute](/docs/contributing.md) - [Plugins](/docs/plugins.md) - [Compile](/docs/compile.md) - [Contact](/docs/contact.md) - [Updater](https://github.com/toxygen-project/toxygen_updater)
 
 ### Supported OS:
 
-- Windows
+![Linux, Windows and OS X](/docs/os.png)
-- Linux
-- OS X
 
-### Features
+### Features:
 
 - [x] 1v1 messages
 - [x] File transfers
-- [x] Audio
+- [x] Audio calls
 - [x] Plugins support
 - [x] Chat history
 - [x] Emoticons
@@ -43,7 +42,7 @@ Toxygen is cross-platform [Tox](https://tox.chat/) client written in pure Python
 - [x] Changing nospam
 - [x] File resuming
 - [x] Read receipts
-- [ ] Video
+- [ ] Video calls
 - [ ] Desktop sharing
 - [ ] Group chats
 
@@ -61,3 +60,7 @@ Toxygen is cross-platform [Tox](https://tox.chat/) client written in pure Python
 
 ### Docs
 [Check /docs/ for more info](/docs/)
+
+Also visit [pythonhosted.org/Toxygen/](http://pythonhosted.org/Toxygen/)
+
+[Wiki](https://wiki.tox.chat/clients/toxygen)

docs/compile.md

@@ -5,6 +5,7 @@ You can compile Toxygen using [PyInstaller](http://www.pyinstaller.org/)
 Install PyInstaller: 
 ``pip3 install pyinstaller``
 
+Compile Toxygen:
 ``pyinstaller --windowed --icon images/icon.ico main.py``
 
 Don't forget to copy /images/, /sounds/, /translations/, /styles/, /smileys/, /stickers/, /plugins/ (and /libs/libtox.dll, /libs/libsodium.a on Windows) to /dist/main/

docs/contributing.md

@@ -4,15 +4,15 @@ Help us find all bugs in Toxygen! Please provide following info:
 
 - OS
 - Toxygen version
-- Toxygen executable info - .py or precompiled binary
+- Toxygen executable info - .py or precompiled binary, how was it installed in system
 - Steps to reproduce the bug
 
-Want to see new feature in Toxygen? [Ask for it!](https://github.com/xveduk/toxygen/issues)
+Want to see new feature in Toxygen? [Ask for it!](https://github.com/toxygen-project/toxygen/issues)
 
 #Pull requests
 
-Developer? Feel free to open pull request. Our dev team is small so we glad to get help. 
+Developer? Feel free to open pull request. Our dev team is small so we glad to get help.
-Don't know what to do? Improve UI, fix [issues](https://github.com/xveduk/toxygen/issues) or implement features from our TODO list.
+Don't know what to do? Improve UI, fix [issues](https://github.com/toxygen-project/toxygen/issues) or implement features from our TODO list.
 You can find our TODO's in code, issues list and [here](/README.md). Also you can implement [plugins](/docs/plugins.md) for Toxygen.
 
 #Translations

docs/install.md

@@ -1,7 +1,7 @@
 # How to install Toxygen
 
 ## Use precompiled binary:
-[Check our releases page](https://github.com/xveduk/toxygen/releases)
+[Check our releases page](https://github.com/toxygen-project/toxygen/releases)
 
 ## Using pip3
 
@@ -27,12 +27,14 @@ Run app using ``toxygen`` command.
 2. Install PortAudio:
 ``brew install portaudio``
 3. Install toxygen: 
-``pip3 install toxygen``
+``pip3.4 install toxygen``
 4. Run toxygen using ``toxygen`` command.
 
 ## Packages
 
-Coming soon.
+Arch Linux: [AUR](https://aur.archlinux.org/packages/toxygen-git/)
+
+Debian/Ubuntu: [tox.chat](https://tox.chat/download.html#gnulinux)
 
 ## From source code (recommended for developers)
 

docs/plugin_api.md

@@ -1,4 +1,4 @@
-#Plugins API
+# Plugins API
 
 In Toxygen plugin is single python (supported Python 3.0 - 3.4) module (.py file) and directory with data associated with it. 
 Every module must contain one class derived from PluginSuperClass defined in [plugin_super_class.py](/src/plugins/plugin_super_class.py). Instance of this class will be created by PluginLoader class (defined in [plugin_support.py](/src/plugin_support.py) ). This class can enable/disable plugins and send data to it. 
@@ -18,7 +18,7 @@ All plugin's data should be stored in following structure:
 ```
 
 Plugin MUST override:
--  __init__ with params: tox (Tox instance), profile (Profile instance), settings (Settings instance), encrypt_save (ToxEncryptSave instance). Call super().__init__ with params plugin_full_name, plugin_short_name, tox, profile, settings, encrypt_save.
+-  __init__ with params: tox (Tox instance), profile (Profile instance), settings (Settings instance), encrypt_save (ToxES instance). Call super().__init__ with params plugin_full_name, plugin_short_name, tox, profile, settings, encrypt_save.
 
 Plugin can override following methods:
 - get_description - this method should return plugin description. 
@@ -51,7 +51,7 @@ Exceptions:
 
 Plugin's methods MUST NOT raise exceptions.
 
-#Examples
+# Examples
 
-You can find examples in [official repo](https://github.com/ingvar1995/toxygen_plugins)
+You can find examples in [official repo](https://github.com/toxygen-project/toxygen_plugins)
 

docs/plugins.md

@@ -1,22 +1,22 @@
-#Plugins
+# Plugins
 
 Toxygen is the first [Tox](https://tox.chat/) client with plugins support. Plugin is Python 3.4 module (.py file) and directory with plugin's data which provide some additional functionality. 
 
-#How to write plugin
+# How to write plugin
 
 Check [Plugin API](/docs/plugin_api.md) for more info
 
-#How to install plugin
+# How to install plugin
 
 Toxygen comes without preinstalled plugins.
 
-1. Put plugin and directory with its data into /src/plugins/ or import it via GUI (In menu: Plugins -> Import plugin)
+1. Put plugin and directory with its data into /src/plugins/ or import it via GUI (In menu: Plugins => Import plugin)
-2. Restart Toxygen
+2. Restart Toxygen or choose Plugins => Reload plugins in menu.
 
-##Note: /src/plugins/ should contain plugin_super_class.py and __init__.py
+## Note: /src/plugins/ should contain plugin_super_class.py and __init__.py
 
-#Plugins list
+# Plugins list
 
 WARNING: It is unsecure to install plugin not from this list!
 
-[Main repo](https://github.com/ingvar1995/toxygen_plugins)
+[Main repo](https://github.com/toxygen-project/toxygen_plugins)

docs/smileys_and_stickers.md

@@ -10,4 +10,4 @@ Animated smileys (.gif) are supported too.
 
 Sticker is inline image. If you want to create your own smiley pack, create directory in src/stickers/ and place your stickers there.
 
-Users can import plugins and stickers packs using menu: Settings -> Interface
+Users can import smileys and stickers using menu: Settings -> Interface

setup.py

@@ -11,7 +11,7 @@ version = program_version + '.0'
 MODULES = []
 
 if system() in ('Windows', 'Darwin'):
-    MODULES = ['PyAudio', 'PySide']
+    MODULES = ['PyAudio', 'PyQt5']
 else:
     try:
         import pyaudio
@@ -48,7 +48,7 @@ setup(name='Toxygen',
       version=version,
       description='Toxygen - Tox client',
       long_description='Toxygen is powerful Tox client written in Python3',
-      url='https://github.com/xveduk/toxygen/',
+      url='https://github.com/toxygen-project/toxygen/',
       keywords='toxygen tox messenger',
       author='Ingvar',
       maintainer='Ingvar',
@@ -58,9 +58,8 @@ setup(name='Toxygen',
       include_package_data=True,
       classifiers=[
           'Programming Language :: Python :: 3 :: Only',
-          'Programming Language :: Python :: 3.2',
+          'Programming Language :: Python :: 3.5',
-          'Programming Language :: Python :: 3.3',
+          'Programming Language :: Python :: 3.6',
-          'Programming Language :: Python :: 3.4',
       ],
       entry_points={
           'console_scripts': ['toxygen=toxygen.main:main'],

tests/tests.py

@@ -1,31 +1,15 @@
-from toxygen.bootstrap import node_generator
 from toxygen.profile import *
-from toxygen.settings import ProfileHelper
 from toxygen.tox_dns import tox_dns
-import toxygen.toxencryptsave as encr
+from toxygen.history import History
-
+from toxygen.smileys import SmileyLoader
-
+from toxygen.messages import *
-class TestProfile:
+import toxygen.toxes as encr
-
+import toxygen.util as util
-    def test_search(self):
+import time
-        arr = ProfileHelper.find_profiles()
-        assert len(arr) >= 2
-
-    def test_open(self):
-        data = ProfileHelper(Settings.get_default_path(), 'alice').open_profile()
-        assert data
 
 
 class TestTox:
 
-    def test_loading(self):
-        data = ProfileHelper(Settings.get_default_path(), 'alice').open_profile()
-        settings = Settings.get_default_settings()
-        tox = tox_factory(data, settings)
-        for data in node_generator():
-            tox.bootstrap(*data)
-        del tox
-
     def test_creation(self):
         name = b'Toxygen User'
         status_message = b'Toxing on Toxygen'
@@ -38,33 +22,156 @@ class TestTox:
         assert tox.self_get_name() == str(name, 'utf-8')
         assert tox.self_get_status_message() == str(status_message, 'utf-8')
 
-    def test_friend_list(self):
+
-        data = ProfileHelper(Settings.get_default_path(), 'bob').open_profile()
+class TestProfileHelper:
-        settings = Settings.get_default_settings()
+
-        tox = tox_factory(data, settings)
+    def test_creation(self):
-        s = tox.self_get_friend_list()
+        file_name, path = 'test.tox', os.path.dirname(os.path.realpath(__file__)) + '/'
-        size = tox.self_get_friend_list_size()
+        data = b'test'
-        assert size <= 2
+        with open(path + file_name, 'wb') as fl:
-        assert len(s) <= 2
+            fl.write(data)
-        del tox
+        ph = ProfileHelper(path, file_name[:4])
+        assert ProfileHelper.get_path() == path
+        assert ph.open_profile() == data
+        assert os.path.exists(path + 'avatars/')
 
 
 class TestDNS:
 
     def test_dns(self):
+        Settings._instance = Settings.get_default_settings()
         bot_id = '56A1ADE4B65B86BCD51CC73E2CD4E542179F47959FE3E0E21B4B0ACDADE51855D34D34D37CB5'
         tox_id = tox_dns('groupbot@toxme.io')
         assert tox_id == bot_id
 
+    def test_dns2(self):
+        Settings._instance = Settings.get_default_settings()
+        bot_id = '76518406F6A9F2217E8DC487CC783C25CC16A15EB36FF32E335A235342C48A39218F515C39A6'
+        tox_id = tox_dns('echobot@toxme.io')
+        assert tox_id == bot_id
+
 
 class TestEncryption:
 
     def test_encr_decr(self):
-        with open(settings.Settings.get_default_path() + '/alice.tox', 'rb') as fl:
+        tox = tox_factory()
-            data = fl.read()
+        data = tox.get_savedata()
-        lib = encr.ToxEncryptSave()
+        lib = encr.ToxES()
-        lib.set_password('easypassword')
+        for password in ('easypassword', 'njvnFjfn7vaGGV6', 'toxygen'):
-        copy_data = data[:]
+            lib.set_password(password)
-        data = lib.pass_encrypt(data)
+            copy_data = data[:]
-        data = lib.pass_decrypt(data)
+            new_data = lib.pass_encrypt(data)
-        assert copy_data == data
+            assert lib.is_data_encrypted(new_data)
+            new_data = lib.pass_decrypt(new_data)
+            assert copy_data == new_data
+
+
+class TestSmileys:
+
+    def test_loading(self):
+        settings = {'smiley_pack': 'default', 'smileys': True}
+        sm = SmileyLoader(settings)
+        assert sm.get_smileys_path() is not None
+        l = sm.get_packs_list()
+        assert len(l) == 4
+
+
+def create_singletons():
+    folder = util.curr_directory() + '/abc'
+    Settings._instance = Settings.get_default_settings()
+    if not os.path.exists(folder):
+        os.makedirs(folder)
+    ProfileHelper(folder, 'test')
+
+
+def create_friend(name, status_message, number, tox_id):
+    friend = Friend(None, number, name, status_message, None, tox_id)
+    return friend
+
+
+def create_random_friend():
+    name, status_message, number = 'Friend', 'I am friend!', 0
+    tox_id = '76518406F6A9F2217E8DC487CC783C25CC16A15EB36FF32E335A235342C48A39218F515C39A6'
+    friend = create_friend(name, status_message, number, tox_id)
+    return friend
+
+
+class TestFriend:
+
+    def test_friend_creation(self):
+        create_singletons()
+        name, status_message, number = 'Friend', 'I am friend!', 0
+        tox_id = '76518406F6A9F2217E8DC487CC783C25CC16A15EB36FF32E335A235342C48A39218F515C39A6'
+        friend = create_friend(name, status_message, number, tox_id)
+        assert friend.name == name
+        assert friend.tox_id == tox_id
+        assert friend.status_message == status_message
+        assert friend.number == number
+
+    def test_friend_corr(self):
+        create_singletons()
+        friend = create_random_friend()
+        t = time.time()
+        friend.append_message(InfoMessage('Info message', t))
+        friend.append_message(TextMessage('Hello! It is test!', MESSAGE_OWNER['ME'], t + 0.001, 0))
+        friend.append_message(TextMessage('Hello!', MESSAGE_OWNER['FRIEND'], t + 0.002, 0))
+        assert friend.get_last_message_text() == 'Hello! It is test!'
+        assert len(friend.get_corr()) == 3
+        assert len(friend.get_corr_for_saving()) == 2
+        friend.append_message(TextMessage('Not sent', MESSAGE_OWNER['NOT_SENT'], t + 0.002, 0))
+        arr = friend.get_unsent_messages_for_saving()
+        assert len(arr) == 1
+        assert arr[0][0] == 'Not sent'
+        tm = TransferMessage(MESSAGE_OWNER['FRIEND'],
+                             time.time(),
+                             TOX_FILE_TRANSFER_STATE['RUNNING'],
+                             100, 'file_name', friend.number, 0)
+        friend.append_message(tm)
+        friend.clear_corr()
+        assert len(friend.get_corr()) == 1
+        assert len(friend.get_corr_for_saving()) == 0
+        friend.append_message(TextMessage('Hello! It is test!', MESSAGE_OWNER['ME'], t, 0))
+        assert len(friend.get_corr()) == 2
+        assert len(friend.get_corr_for_saving()) == 1
+
+    def test_history_search(self):
+        create_singletons()
+        friend = create_random_friend()
+        message = 'Hello! It is test!'
+        friend.append_message(TextMessage(message, MESSAGE_OWNER['ME'], time.time(), 0))
+        last_message = friend.get_last_message_text()
+        assert last_message == message
+        result = friend.search_string('e[m|s]')
+        assert result is not None
+        result = friend.search_string('tox')
+        assert result is None
+
+
+class TestHistory:
+
+    def test_history(self):
+        create_singletons()
+        db_name = 'my_name'
+        name, status_message, number = 'Friend', 'I am friend!', 0
+        tox_id = '76518406F6A9F2217E8DC487CC783C25CC16A15EB36FF32E335A235342C48A39218F515C39A6'
+        friend = create_friend(name, status_message, number, tox_id)
+        history = History(db_name)
+        history.add_friend_to_db(friend.tox_id)
+        assert history.friend_exists_in_db(friend.tox_id)
+        text_message = 'Test!'
+        t = time.time()
+        friend.append_message(TextMessage(text_message, MESSAGE_OWNER['ME'], t, 0))
+        messages = friend.get_corr_for_saving()
+        history.save_messages_to_db(friend.tox_id, messages)
+        getter = history.messages_getter(friend.tox_id)
+        messages = getter.get_all()
+        assert len(messages) == 1
+        assert messages[0][0] == text_message
+        assert messages[0][1] == MESSAGE_OWNER['ME']
+        assert messages[0][-1] == 0
+        history.delete_message(friend.tox_id, t)
+        getter = history.messages_getter(friend.tox_id)
+        messages = getter.get_all()
+        assert len(messages) == 0
+        history.delete_friend_from_db(friend.tox_id)
+        assert not history.friend_exists_in_db(friend.tox_id)

tests/travis.py

@@ -1,4 +1,4 @@
 class TestToxygen:
 
     def test_main(self):
-        import toxygen.main
+        import toxygen.main  # check for syntax errors

toxygen/avwidgets.py

@@ -1,7 +1,4 @@
-try:
+from PyQt5 import QtCore, QtGui, QtWidgets
-    from PySide import QtCore, QtGui
-except ImportError:
-    from PyQt4 import QtCore, QtGui
 import widgets
 import profile
 import util
@@ -17,7 +14,7 @@ class IncomingCallWidget(widgets.CenteredWidget):
         super(IncomingCallWidget, self).__init__()
         self.setWindowFlags(QtCore.Qt.CustomizeWindowHint | QtCore.Qt.WindowTitleHint | QtCore.Qt.WindowStaysOnTopHint)
         self.resize(QtCore.QSize(500, 270))
-        self.avatar_label = QtGui.QLabel(self)
+        self.avatar_label = QtWidgets.QLabel(self)
         self.avatar_label.setGeometry(QtCore.QRect(10, 20, 64, 64))
         self.avatar_label.setScaledContents(False)
         self.name = widgets.DataLabel(self)
@@ -30,11 +27,11 @@ class IncomingCallWidget(widgets.CenteredWidget):
         self.call_type = widgets.DataLabel(self)
         self.call_type.setGeometry(QtCore.QRect(90, 55, 300, 25))
         self.call_type.setFont(font)
-        self.accept_audio = QtGui.QPushButton(self)
+        self.accept_audio = QtWidgets.QPushButton(self)
         self.accept_audio.setGeometry(QtCore.QRect(20, 100, 150, 150))
-        self.accept_video = QtGui.QPushButton(self)
+        self.accept_video = QtWidgets.QPushButton(self)
         self.accept_video.setGeometry(QtCore.QRect(170, 100, 150, 150))
-        self.decline = QtGui.QPushButton(self)
+        self.decline = QtWidgets.QPushButton(self)
         self.decline.setGeometry(QtCore.QRect(320, 100, 150, 150))
         pixmap = QtGui.QPixmap(util.curr_directory() + '/images/accept_audio.png')
         icon = QtGui.QIcon(pixmap)
@@ -63,6 +60,7 @@ class IncomingCallWidget(widgets.CenteredWidget):
 
             def __init__(self):
                 QtCore.QThread.__init__(self)
+                self.a = None
 
             def run(self):
                 class AudioFile:
@@ -115,15 +113,14 @@ class AudioMessageRecorder(widgets.CenteredWidget):
 
     def __init__(self, friend_number, name):
         super(AudioMessageRecorder, self).__init__()
-        self.label = QtGui.QLabel(self)
+        self.label = QtWidgets.QLabel(self)
         self.label.setGeometry(QtCore.QRect(10, 20, 250, 20))
-        text = QtGui.QApplication.translate("MenuWindow", "Send audio message to friend {}", None, QtGui.QApplication.UnicodeUTF8)
+        text = QtWidgets.QApplication.translate("MenuWindow", "Send audio message to friend {}")
         self.label.setText(text.format(name))
-        self.record = QtGui.QPushButton(self)
+        self.record = QtWidgets.QPushButton(self)
         self.record.setGeometry(QtCore.QRect(20, 100, 150, 150))
 
-        self.record.setText(QtGui.QApplication.translate("MenuWindow", "Start recording", None,
+        self.record.setText(QtWidgets.QApplication.translate("MenuWindow", "Start recording"))
-                                                         QtGui.QApplication.UnicodeUTF8))
         self.record.clicked.connect(self.start_or_stop_recording)
         self.recording = False
         self.friend_num = friend_number
@@ -131,8 +128,7 @@ class AudioMessageRecorder(widgets.CenteredWidget):
     def start_or_stop_recording(self):
         if not self.recording:
             self.recording = True
-            self.record.setText(QtGui.QApplication.translate("MenuWindow", "Stop recording", None,
+            self.record.setText(QtWidgets.QApplication.translate("MenuWindow", "Stop recording"))
-                                                             QtGui.QApplication.UnicodeUTF8))
         else:
             self.close()
 

toxygen/basecontact.py

@@ -0,0 +1,118 @@
+from settings import *
+from PyQt5 import QtCore, QtGui
+from toxcore_enums_and_consts import TOX_PUBLIC_KEY_SIZE
+
+
+class BaseContact:
+    """
+    Class encapsulating TOX contact
+    Properties: name (alias of contact or name), status_message, status (connection status)
+    widget - widget for update, tox id (or public key)
+    Base class for all contacts.
+    """
+
+    def __init__(self, name, status_message, widget, tox_id):
+        """
+        :param name: name, example: 'Toxygen user'
+        :param status_message: status message, example: 'Toxing on Toxygen'
+        :param widget: ContactItem instance
+        :param tox_id: tox id of contact
+        """
+        self._name, self._status_message = name, status_message
+        self._status, self._widget = None, widget
+        self._tox_id = tox_id
+        self.init_widget()
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Name - current name or alias of user
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def get_name(self):
+        return self._name
+
+    def set_name(self, value):
+        self._name = str(value, 'utf-8')
+        self._widget.name.setText(self._name)
+        self._widget.name.repaint()
+
+    name = property(get_name, set_name)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Status message
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def get_status_message(self):
+        return self._status_message
+
+    def set_status_message(self, value):
+        self._status_message = str(value, 'utf-8')
+        self._widget.status_message.setText(self._status_message)
+        self._widget.status_message.repaint()
+
+    status_message = property(get_status_message, set_status_message)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Status
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def get_status(self):
+        return self._status
+
+    def set_status(self, value):
+        self._status = value
+        self._widget.connection_status.update(value)
+
+    status = property(get_status, set_status)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # TOX ID. WARNING: for friend it will return public key, for profile - full address
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def get_tox_id(self):
+        return self._tox_id
+
+    tox_id = property(get_tox_id)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Avatars
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def load_avatar(self):
+        """
+        Tries to load avatar of contact or uses default avatar
+        """
+        prefix = ProfileHelper.get_path() + 'avatars/'
+        avatar_path = prefix + '{}.png'.format(self._tox_id[:TOX_PUBLIC_KEY_SIZE * 2])
+        if not os.path.isfile(avatar_path) or not os.path.getsize(avatar_path):  # load default image
+            avatar_path = curr_directory() + '/images/avatar.png'
+        width = self._widget.avatar_label.width()
+        pixmap = QtGui.QPixmap(avatar_path)
+        self._widget.avatar_label.setPixmap(pixmap.scaled(width, width, QtCore.Qt.KeepAspectRatio,
+                                                          QtCore.Qt.SmoothTransformation))
+        self._widget.avatar_label.repaint()
+
+    def reset_avatar(self):
+        avatar_path = (ProfileHelper.get_path() + 'avatars/{}.png').format(self._tox_id[:TOX_PUBLIC_KEY_SIZE * 2])
+        if os.path.isfile(avatar_path):
+            os.remove(avatar_path)
+            self.load_avatar()
+
+    def set_avatar(self, avatar):
+        avatar_path = (ProfileHelper.get_path() + 'avatars/{}.png').format(self._tox_id[:TOX_PUBLIC_KEY_SIZE * 2])
+        with open(avatar_path, 'wb') as f:
+            f.write(avatar)
+        self.load_avatar()
+
+    def get_pixmap(self):
+        return self._widget.avatar_label.pixmap()
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Widgets
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def init_widget(self):
+        if self._widget is not None:
+            self._widget.name.setText(self._name)
+            self._widget.status_message.setText(self._status_message)
+            self._widget.connection_status.update(self._status)
+            self.load_avatar()

toxygen/bootstrap.py

@@ -2,6 +2,7 @@ import random
 
 
 class Node:
+
     def __init__(self, ip, port, tox_key, rand):
         self._ip, self._port, self._tox_key, self.rand = ip, port, tox_key, rand
 

toxygen/callbacks.py

@@ -1,7 +1,4 @@
-try:
+from PyQt5 import QtCore, QtGui, QtWidgets
-    from PySide import QtCore
-except ImportError:
-    from PyQt4 import QtCore
 from notifications import *
 from settings import Settings
 from profile import Profile
@@ -225,7 +222,7 @@ def tox_file_recv(window, tray):
             if not window.isActiveWindow():
                 friend = profile.get_friend_by_number(friend_number)
                 if settings['notifications'] and profile.status != TOX_USER_STATUS['BUSY'] and not settings.locked:
-                    file_from = QtGui.QApplication.translate("Callback", "File from", None, QtGui.QApplication.UnicodeUTF8)
+                    file_from = QtWidgets.QApplication.translate("Callback", "File from")
                     invoke_in_main_thread(tray_notification, file_from + ' ' + friend.name, file_name, tray, window)
                 if settings['sound_notifications'] and profile.status != TOX_USER_STATUS['BUSY']:
                     sound_notification(SOUND_NOTIFICATION['FILE_TRANSFER'])
@@ -274,16 +271,18 @@ def lossless_packet(tox, friend_number, data, length, user_data):
     """
     Incoming lossless packet
     """
+    data = data[:length]
     plugin = PluginLoader.get_instance()
-    invoke_in_main_thread(plugin.callback_lossless, friend_number, data, length)
+    invoke_in_main_thread(plugin.callback_lossless, friend_number, data)
 
 
 def lossy_packet(tox, friend_number, data, length, user_data):
     """
     Incoming lossy packet
     """
+    data = data[:length]
     plugin = PluginLoader.get_instance()
-    invoke_in_main_thread(plugin.callback_lossy, friend_number, data, length)
+    invoke_in_main_thread(plugin.callback_lossy, friend_number, data)
 
 
 # -----------------------------------------------------------------------------------------------------------------

toxygen/contact.py

@@ -1,113 +1,286 @@
-import os
+from PyQt5 import QtCore, QtGui
-from settings import *
+from history import *
-try:
+import basecontact
-    from PySide import QtCore, QtGui
+import util
-except ImportError:
+from messages import *
-    from PyQt4 import QtCore, QtGui
+import file_transfers as ft
-from toxcore_enums_and_consts import TOX_PUBLIC_KEY_SIZE
+import re
 
 
-class Contact:
+class Contact(basecontact.BaseContact):
     """
     Class encapsulating TOX contact
-    Properties: name (alias of contact or name), status_message, status (connection status)
+    Properties: number, message getter, history etc. Base class for friend and gc classes
-    widget - widget for update
     """
 
-    def __init__(self, name, status_message, widget, tox_id):
+    def __init__(self, message_getter, number, name, status_message, widget, tox_id):
         """
-        :param name: name, example: 'Toxygen user'
+        :param message_getter: gets messages from db
-        :param status_message: status message, example: 'Toxing on Toxygen'
+        :param number: number of friend.
-        :param widget: ContactItem instance
-        :param tox_id: tox id of contact
         """
-        self._name, self._status_message = name, status_message
+        super().__init__(name, status_message, widget, tox_id)
-        self._status, self._widget = None, widget
+        self._number = number
-        self._widget.name.setText(name)
+        self._new_messages = False
-        self._widget.status_message.setText(status_message)
+        self._visible = True
-        self._tox_id = tox_id
+        self._alias = False
-        self.load_avatar()
+        self._message_getter = message_getter
+        self._corr = []
+        self._unsaved_messages = 0
+        self._history_loaded = self._new_actions = False
+        self._curr_text = self._search_string = ''
+        self._search_index = 0
+
+    def __del__(self):
+        self.set_visibility(False)
+        del self._widget
+        if hasattr(self, '_message_getter'):
+            del self._message_getter
 
     # -----------------------------------------------------------------------------------------------------------------
-    # name - current name or alias of user
+    # History support
     # -----------------------------------------------------------------------------------------------------------------
 
-    def get_name(self):
+    def load_corr(self, first_time=True):
-        return self._name
+        """
+        :param first_time: friend became active, load first part of messages
+        """
+        if (first_time and self._history_loaded) or (not hasattr(self, '_message_getter')):
+            return
+        if self._message_getter is None:
+            return
+        data = list(self._message_getter.get(PAGE_SIZE))
+        if data is not None and len(data):
+            data.reverse()
+        else:
+            return
+        data = list(map(lambda tupl: TextMessage(*tupl), data))
+        self._corr = data + self._corr
+        self._history_loaded = True
+
+    def load_all_corr(self):
+        """
+        Get all chat history from db for current friend
+        """
+        data = list(self._message_getter.get_all())
+        if data is not None and len(data):
+            data.reverse()
+            data = list(map(lambda tupl: TextMessage(*tupl), data))
+            self._corr = data + self._corr
+            self._history_loaded = True
+
+    def get_corr_for_saving(self):
+        """
+        Get data to save in db
+        :return: list of unsaved messages or []
+        """
+        messages = list(filter(lambda x: x.get_type() <= 1, self._corr))
+        return list(map(lambda x: x.get_data(), messages[-self._unsaved_messages:])) if self._unsaved_messages else []
+
+    def get_corr(self):
+        return self._corr[:]
+
+    def append_message(self, message):
+        """
+        :param message: text or file transfer message
+        """
+        self._corr.append(message)
+        if message.get_type() <= 1:
+            self._unsaved_messages += 1
+
+    def get_last_message_text(self):
+        messages = list(filter(lambda x: x.get_type() <= 1 and x.get_owner() != MESSAGE_OWNER['FRIEND'], self._corr))
+        if messages:
+            return messages[-1].get_data()[0]
+        else:
+            return ''
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Unsent messages
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def get_unsent_messages(self):
+        """
+        :return list of unsent messages
+        """
+        messages = filter(lambda x: x.get_owner() == MESSAGE_OWNER['NOT_SENT'], self._corr)
+        return list(messages)
+
+    def get_unsent_messages_for_saving(self):
+        """
+        :return list of unsent messages for saving
+        """
+        messages = filter(lambda x: x.get_type() <= 1 and x.get_owner() == MESSAGE_OWNER['NOT_SENT'], self._corr)
+        return list(map(lambda x: x.get_data(), messages))
+
+    def mark_as_sent(self):
+        try:
+            message = list(filter(lambda x: x.get_owner() == MESSAGE_OWNER['NOT_SENT'], self._corr))[0]
+            message.mark_as_sent()
+        except Exception as ex:
+            util.log('Mark as sent ex: ' + str(ex))
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Message deletion
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def delete_message(self, time):
+        elem = list(filter(lambda x: type(x) is TextMessage and x.get_data()[2] == time, self._corr))[0]
+        tmp = list(filter(lambda x: x.get_type() <= 1, self._corr))
+        if elem in tmp[-self._unsaved_messages:] and self._unsaved_messages:
+            self._unsaved_messages -= 1
+        self._corr.remove(elem)
+        self._message_getter.delete_one()
+        self._search_index = 0
+
+    def delete_old_messages(self):
+        """
+        Delete old messages (reduces RAM usage if messages saving is not enabled)
+        """
+        def save_message(x):
+            if x.get_type() == 2 and (x.get_status() >= 2 or x.get_status() is None):
+                return True
+            return x.get_owner() == MESSAGE_OWNER['NOT_SENT']
+
+        old = filter(save_message, self._corr[:-SAVE_MESSAGES])
+        self._corr = list(old) + self._corr[-SAVE_MESSAGES:]
+        text_messages = filter(lambda x: x.get_type() <= 1, self._corr)
+        self._unsaved_messages = min(self._unsaved_messages, len(list(text_messages)))
+        self._search_index = 0
+
+    def clear_corr(self, save_unsent=False):
+        """
+        Clear messages list
+        """
+        if hasattr(self, '_message_getter'):
+            del self._message_getter
+        self._search_index = 0
+        # don't delete data about active file transfer
+        if not save_unsent:
+            self._corr = list(filter(lambda x: x.get_type() == 2 and
+                                               x.get_status() in ft.ACTIVE_FILE_TRANSFERS, self._corr))
+            self._unsaved_messages = 0
+        else:
+            self._corr = list(filter(lambda x: (x.get_type() == 2 and x.get_status() in ft.ACTIVE_FILE_TRANSFERS)
+                                               or (x.get_type() <= 1 and x.get_owner() == MESSAGE_OWNER['NOT_SENT']),
+                                     self._corr))
+            self._unsaved_messages = len(self.get_unsent_messages())
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Chat history search
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def search_string(self, search_string):
+        self._search_string, self._search_index = search_string, 0
+        return self.search_prev()
+
+    def search_prev(self):
+        while True:
+            l = len(self._corr)
+            for i in range(self._search_index - 1, -l - 1, -1):
+                if self._corr[i].get_type() > 1:
+                    continue
+                message = self._corr[i].get_data()[0]
+                if re.search(self._search_string, message, re.IGNORECASE) is not None:
+                    self._search_index = i
+                    return i
+            self._search_index = -l
+            self.load_corr(False)
+            if len(self._corr) == l:
+                return None  # not found
+
+    def search_next(self):
+        if not self._search_index:
+            return None
+        for i in range(self._search_index + 1, 0):
+            if self._corr[i].get_type() > 1:
+                continue
+            message = self._corr[i].get_data()[0]
+            if re.search(self._search_string, message, re.IGNORECASE) is not None:
+                self._search_index = i
+                return i
+        return None  # not found
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Current text - text from message area
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def get_curr_text(self):
+        return self._curr_text
+
+    def set_curr_text(self, value):
+        self._curr_text = value
+
+    curr_text = property(get_curr_text, set_curr_text)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Alias support
+    # -----------------------------------------------------------------------------------------------------------------
 
     def set_name(self, value):
-        self._name = str(value, 'utf-8')
-        self._widget.name.setText(self._name)
-        self._widget.name.repaint()
-
-    name = property(get_name, set_name)
-
-    # -----------------------------------------------------------------------------------------------------------------
-    # Status message
-    # -----------------------------------------------------------------------------------------------------------------
-
-    def get_status_message(self):
-        return self._status_message
-
-    def set_status_message(self, value):
-        self._status_message = str(value, 'utf-8')
-        self._widget.status_message.setText(self._status_message)
-        self._widget.status_message.repaint()
-
-    status_message = property(get_status_message, set_status_message)
-
-    # -----------------------------------------------------------------------------------------------------------------
-    # Status
-    # -----------------------------------------------------------------------------------------------------------------
-
-    def get_status(self):
-        return self._status
-
-    def set_status(self, value):
-        self._status = value
-        self._widget.connection_status.update(value)
-
-    status = property(get_status, set_status)
-
-    # -----------------------------------------------------------------------------------------------------------------
-    # TOX ID. WARNING: for friend it will return public key, for profile - full address
-    # -----------------------------------------------------------------------------------------------------------------
-
-    def get_tox_id(self):
-        return self._tox_id
-
-    tox_id = property(get_tox_id)
-
-    # -----------------------------------------------------------------------------------------------------------------
-    # Avatars
-    # -----------------------------------------------------------------------------------------------------------------
-
-    def load_avatar(self):
         """
-        Tries to load avatar of contact or uses default avatar
+        Set new name or ignore if alias exists
+        :param value: new name
         """
-        avatar_path = '{}.png'.format(self._tox_id[:TOX_PUBLIC_KEY_SIZE * 2])
+        if not self._alias:
-        os.chdir(ProfileHelper.get_path() + 'avatars/')
+            super().set_name(value)
-        if not os.path.isfile(avatar_path):  # load default image
-            avatar_path = 'avatar.png'
-            os.chdir(curr_directory() + '/images/')
-        width = self._widget.avatar_label.width()
-        pixmap = QtGui.QPixmap(avatar_path)
-        self._widget.avatar_label.setPixmap(pixmap.scaled(width, width, QtCore.Qt.KeepAspectRatio,
-                                                          QtCore.Qt.SmoothTransformation))
-        self._widget.avatar_label.repaint()
 
-    def reset_avatar(self):
+    def set_alias(self, alias):
-        avatar_path = (ProfileHelper.get_path() + 'avatars/{}.png').format(self._tox_id[:TOX_PUBLIC_KEY_SIZE * 2])
+        self._alias = bool(alias)
-        if os.path.isfile(avatar_path):
-            os.remove(avatar_path)
-            self.load_avatar()
 
-    def set_avatar(self, avatar):
+    # -----------------------------------------------------------------------------------------------------------------
-        avatar_path = (ProfileHelper.get_path() + 'avatars/{}.png').format(self._tox_id[:TOX_PUBLIC_KEY_SIZE * 2])
+    # Visibility in friends' list
-        with open(avatar_path, 'wb') as f:
+    # -----------------------------------------------------------------------------------------------------------------
-            f.write(avatar)
-        self.load_avatar()
 
-    def get_pixmap(self):
+    def get_visibility(self):
-        return self._widget.avatar_label.pixmap()
+        return self._visible
+
+    def set_visibility(self, value):
+        self._visible = value
+
+    visibility = property(get_visibility, set_visibility)
+
+    def set_widget(self, widget):
+        self._widget = widget
+        self.init_widget()
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Unread messages and other actions from friend
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def get_actions(self):
+        return self._new_actions
+
+    def set_actions(self, value):
+        self._new_actions = value
+        self._widget.connection_status.update(self.status, value)
+
+    actions = property(get_actions, set_actions)  # unread messages, incoming files, av calls
+
+    def get_messages(self):
+        return self._new_messages
+
+    def inc_messages(self):
+        self._new_messages += 1
+        self._new_actions = True
+        self._widget.connection_status.update(self.status, True)
+        self._widget.messages.update(self._new_messages)
+
+    def reset_messages(self):
+        self._new_actions = False
+        self._new_messages = 0
+        self._widget.messages.update(self._new_messages)
+        self._widget.connection_status.update(self.status, False)
+
+    messages = property(get_messages)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Friend's number (can be used in toxcore)
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def get_number(self):
+        return self._number
+
+    def set_number(self, value):
+        self._number = value
+
+    number = property(get_number, set_number)

toxygen/file_transfers.py

@@ -4,11 +4,7 @@ from os import remove, rename, chdir
 from time import time, sleep
 from tox import Tox
 import settings
-try:
+from PyQt5 import QtCore
-    from PySide import QtCore
-except ImportError:
-    from PyQt4 import QtCore
-    QtCore.Signal = QtCore.pyqtSignal
 
 
 TOX_FILE_TRANSFER_STATE = {
@@ -32,14 +28,18 @@ SHOW_PROGRESS_BAR = (0, 1, 4)
 ALLOWED_FILES = ('toxygen_inline.png', 'utox-inline.png', 'sticker.png')
 
 
+def is_inline(file_name):
+    return file_name in ALLOWED_FILES or file_name.startswith('qTox_Screenshot_')
+
+
 class StateSignal(QtCore.QObject):
 
-    signal = QtCore.Signal(int, float, int)  # state, progress, time in sec
+    signal = QtCore.pyqtSignal(int, float, int)  # state, progress, time in sec
 
 
 class TransferFinishedSignal(QtCore.QObject):
 
-    signal = QtCore.Signal(int, int)  # friend number, file number
+    signal = QtCore.pyqtSignal(int, int)  # friend number, file number
 
 
 class FileTransfer(QtCore.QObject):
@@ -340,3 +340,8 @@ class ReceiveAvatar(ReceiveTransfer):
                 chdir(dirname(avatar_path))
                 remove(avatar_path)
             rename(self._path, avatar_path)
+            self.finished(True)
+
+    def finished(self, emit=False):
+        if emit:
+            super().finished()

toxygen/friend.py

@@ -1,37 +1,54 @@
 import contact
 from messages import *
-from history import *
+import os
-import util
-import file_transfers as ft
 
 
 class Friend(contact.Contact):
     """
-    Friend in list of friends. Can be hidden, properties 'has unread messages' and 'has alias' added
+    Friend in list of friends.
     """
 
-    def __init__(self, message_getter, number, *args):
+    def __init__(self, message_getter, number, name, status_message, widget, tox_id):
-        """
+        super().__init__(message_getter, number, name, status_message, widget, tox_id)
-        :param message_getter: gets messages from db
-        :param number: number of friend.
-        """
-        super(Friend, self).__init__(*args)
-        self._number = number
-        self._new_messages = False
-        self._visible = True
-        self._alias = False
-        self._message_getter = message_getter
-        self._corr = []
-        self._unsaved_messages = 0
-        self._history_loaded = self._new_actions = False
         self._receipts = 0
-        self._curr_text = ''
 
-    def __del__(self):
+    # -----------------------------------------------------------------------------------------------------------------
-        self.set_visibility(False)
+    # File transfers support
-        del self._widget
+    # -----------------------------------------------------------------------------------------------------------------
-        if hasattr(self, '_message_getter'):
+
-            del self._message_getter
+    def update_transfer_data(self, file_number, status, inline=None):
+        """
+        Update status of active transfer and load inline if needed
+        """
+        try:
+            tr = list(filter(lambda x: x.get_type() == MESSAGE_TYPE['FILE_TRANSFER'] and x.is_active(file_number),
+                             self._corr))[0]
+            tr.set_status(status)
+            i = self._corr.index(tr)
+            if inline:  # inline was loaded
+                self._corr.insert(i, inline)
+            return i - len(self._corr)
+        except:
+            pass
+
+    def get_unsent_files(self):
+        messages = filter(lambda x: type(x) is UnsentFile, self._corr)
+        return messages
+
+    def clear_unsent_files(self):
+        self._corr = list(filter(lambda x: type(x) is not UnsentFile, self._corr))
+
+    def remove_invalid_unsent_files(self):
+        def is_valid(message):
+            if type(message) is not UnsentFile:
+                return True
+            if message.get_data()[1] is not None:
+                return True
+            return os.path.exists(message.get_data()[0])
+        self._corr = list(filter(is_valid, self._corr))
+
+    def delete_one_unsent_file(self, time):
+        self._corr = list(filter(lambda x: not (type(x) is UnsentFile and x.get_data()[2] == time), self._corr))
 
     # -----------------------------------------------------------------------------------------------------------------
     # History support
@@ -49,203 +66,3 @@ class Friend(contact.Contact):
         if self._receipts:
             self._receipts -= 1
             self.mark_as_sent()
-
-    def load_corr(self, first_time=True):
-        """
-        :param first_time: friend became active, load first part of messages
-        """
-        if (first_time and self._history_loaded) or (not hasattr(self, '_message_getter')):
-            return
-        data = list(self._message_getter.get(PAGE_SIZE))
-        if data is not None and len(data):
-            data.reverse()
-        else:
-            return
-        data = list(map(lambda tupl: TextMessage(*tupl), data))
-        self._corr = data + self._corr
-        self._history_loaded = True
-
-    def load_all_corr(self):
-        data = list(self._message_getter.get_all())
-        if data is not None and len(data):
-            data.reverse()
-            data = list(map(lambda tupl: TextMessage(*tupl), data))
-            self._corr = data + self._corr
-            self._history_loaded = True
-
-    def get_corr_for_saving(self):
-        """
-        Get data to save in db
-        :return: list of unsaved messages or []
-        """
-        messages = list(filter(lambda x: x.get_type() <= 1, self._corr))
-        return list(map(lambda x: x.get_data(), messages[-self._unsaved_messages:])) if self._unsaved_messages else []
-
-    def get_corr(self):
-        return self._corr[:]
-
-    def append_message(self, message):
-        """
-        :param message: text or file transfer message
-        """
-        self._corr.append(message)
-        if message.get_type() <= 1:
-            self._unsaved_messages += 1
-
-    def get_last_message_text(self):
-        messages = list(filter(lambda x: x.get_type() <= 1 and x.get_owner() != MESSAGE_OWNER['FRIEND'], self._corr))
-        if messages:
-            return messages[-1].get_data()[0]
-        else:
-            return ''
-
-    def get_unsent_messages(self):
-        """
-        :return list of unsent messages
-        """
-        messages = filter(lambda x: x.get_owner() == MESSAGE_OWNER['NOT_SENT'], self._corr)
-        return list(messages)
-
-    def get_unsent_messages_for_saving(self):
-        """
-        :return list of unsent messages for saving
-        """
-        messages = filter(lambda x: x.get_type() <= 1 and x.get_owner() == MESSAGE_OWNER['NOT_SENT'], self._corr)
-        return list(map(lambda x: x.get_data(), messages))
-
-    def delete_message(self, time):
-        elem = list(filter(lambda x: type(x) is TextMessage and x.get_data()[2] == time, self._corr))[0]
-        tmp = list(filter(lambda x: x.get_type() <= 1, self._corr))
-        if elem in tmp[-self._unsaved_messages:]:
-            self._unsaved_messages -= 1
-        self._corr.remove(elem)
-
-    def mark_as_sent(self):
-        try:
-            message = list(filter(lambda x: x.get_owner() == MESSAGE_OWNER['NOT_SENT'], self._corr))[0]
-            message.mark_as_sent()
-        except Exception as ex:
-            util.log('Mark as sent ex: ' + str(ex))
-
-    def clear_corr(self, save_unsent=False):
-        """
-        Clear messages list
-        """
-        if hasattr(self, '_message_getter'):
-            del self._message_getter
-        # don't delete data about active file transfer
-        if not save_unsent:
-            self._corr = list(filter(lambda x: x.get_type() == 2 and
-                                               x.get_status() in ft.ACTIVE_FILE_TRANSFERS, self._corr))
-            self._unsaved_messages = 0
-        else:
-            self._corr = list(filter(lambda x: (x.get_type() == 2 and x.get_status() in ft.ACTIVE_FILE_TRANSFERS)
-                                               or (x.get_type() <= 1 and x.get_owner() == MESSAGE_OWNER['NOT_SENT']),
-                                     self._corr))
-            self._unsaved_messages = len(self.get_unsent_messages())
-
-    def get_curr_text(self):
-        return self._curr_text
-
-    def set_curr_text(self, value):
-        self._curr_text = value
-
-    curr_text = property(get_curr_text, set_curr_text)
-
-    # -----------------------------------------------------------------------------------------------------------------
-    # File transfers support
-    # -----------------------------------------------------------------------------------------------------------------
-
-    def update_transfer_data(self, file_number, status, inline=None):
-        """
-        Update status of active transfer and load inline if needed
-        """
-        try:
-            tr = list(filter(lambda x: x.get_type() == MESSAGE_TYPE['FILE_TRANSFER'] and x.is_active(file_number),
-                        self._corr))[0]
-            tr.set_status(status)
-            i = self._corr.index(tr)
-            if inline:  # inline was loaded
-                self._corr.insert(i, inline)
-            return i - len(self._corr)
-        except:
-            pass
-
-    def get_unsent_files(self):
-        messages = filter(lambda x: type(x) is UnsentFile, self._corr)
-        return messages
-
-    def clear_unsent_files(self):
-        self._corr = list(filter(lambda x: type(x) is not UnsentFile, self._corr))
-
-    def delete_one_unsent_file(self, time):
-        self._corr = list(filter(lambda x: not (type(x) is UnsentFile and x.get_data()[2] == time), self._corr))
-
-    # -----------------------------------------------------------------------------------------------------------------
-    # Alias support
-    # -----------------------------------------------------------------------------------------------------------------
-
-    def set_name(self, value):
-        """
-        Set new name or ignore if alias exists
-        :param value: new name
-        """
-        if not self._alias:
-            super(Friend, self).set_name(value)
-
-    def set_alias(self, alias):
-        self._alias = bool(alias)
-
-    # -----------------------------------------------------------------------------------------------------------------
-    # Visibility in friends' list
-    # -----------------------------------------------------------------------------------------------------------------
-
-    def get_visibility(self):
-        return self._visible
-
-    def set_visibility(self, value):
-        self._visible = value
-
-    visibility = property(get_visibility, set_visibility)
-
-    # -----------------------------------------------------------------------------------------------------------------
-    # Unread messages from friend
-    # -----------------------------------------------------------------------------------------------------------------
-
-    def get_actions(self):
-        return self._new_actions
-
-    def set_actions(self, value):
-        self._new_actions = value
-        self._widget.connection_status.update(self.status, value)
-
-    actions = property(get_actions, set_actions)  # unread messages, incoming files, av calls
-
-    def get_messages(self):
-        return self._new_messages
-
-    def inc_messages(self):
-        self._new_messages += 1
-        self._new_actions = True
-        self._widget.connection_status.update(self.status, True)
-        self._widget.messages.update(self._new_messages)
-
-    def reset_messages(self):
-        self._new_actions = False
-        self._new_messages = 0
-        self._widget.messages.update(self._new_messages)
-        self._widget.connection_status.update(self.status, False)
-
-    messages = property(get_messages)
-
-    # -----------------------------------------------------------------------------------------------------------------
-    # Friend's number (can be used in toxcore)
-    # -----------------------------------------------------------------------------------------------------------------
-
-    def get_number(self):
-        return self._number
-
-    def set_number(self, value):
-        self._number = value
-
-    number = property(get_number, set_number)

toxygen/history.py

@@ -1,13 +1,16 @@
-# coding=utf-8
 from sqlite3 import connect
 import settings
 from os import chdir
 import os.path
-from toxencryptsave import ToxEncryptSave
+from toxes import ToxES
 
 
 PAGE_SIZE = 42
 
+TIMEOUT = 11
+
+SAVE_MESSAGES = 250
+
 MESSAGE_OWNER = {
     'ME': 0,
     'FRIEND': 1,
@@ -22,7 +25,7 @@ class History:
         chdir(settings.ProfileHelper.get_path())
         path = settings.ProfileHelper.get_path() + self._name + '.hstr'
         if os.path.exists(path):
-            decr = ToxEncryptSave.get_instance()
+            decr = ToxES.get_instance()
             try:
                 with open(path, 'rb') as fin:
                     data = fin.read()
@@ -32,7 +35,7 @@ class History:
                         fout.write(data)
             except:
                 os.remove(path)
-        db = connect(name + '.hstr')
+        db = connect(name + '.hstr', timeout=TIMEOUT)
         cursor = db.cursor()
         cursor.execute('CREATE TABLE IF NOT EXISTS friends('
                        '    tox_id TEXT PRIMARY KEY'
@@ -40,7 +43,7 @@ class History:
         db.close()
 
     def save(self):
-        encr = ToxEncryptSave.get_instance()
+        encr = ToxES.get_instance()
         if encr.has_password():
             path = settings.ProfileHelper.get_path() + self._name + '.hstr'
             with open(path, 'rb') as fin:
@@ -54,7 +57,7 @@ class History:
         new_path = directory + self._name + '.hstr'
         with open(path, 'rb') as fin:
             data = fin.read()
-        encr = ToxEncryptSave.get_instance()
+        encr = ToxES.get_instance()
         if encr.has_password():
             data = encr.pass_encrypt(data)
         with open(new_path, 'wb') as fout:
@@ -62,7 +65,7 @@ class History:
 
     def add_friend_to_db(self, tox_id):
         chdir(settings.ProfileHelper.get_path())
-        db = connect(self._name + '.hstr')
+        db = connect(self._name + '.hstr', timeout=TIMEOUT)
         try:
             cursor = db.cursor()
             cursor.execute('INSERT INTO friends VALUES (?);', (tox_id, ))
@@ -75,28 +78,28 @@ class History:
                            ')')
             db.commit()
         except:
+            print('Database is locked!')
             db.rollback()
-            raise
         finally:
             db.close()
 
     def delete_friend_from_db(self, tox_id):
         chdir(settings.ProfileHelper.get_path())
-        db = connect(self._name + '.hstr')
+        db = connect(self._name + '.hstr', timeout=TIMEOUT)
         try:
             cursor = db.cursor()
             cursor.execute('DELETE FROM friends WHERE tox_id=?;', (tox_id, ))
             cursor.execute('DROP TABLE id' + tox_id + ';')
             db.commit()
         except:
+            print('Database is locked!')
             db.rollback()
-            raise
         finally:
             db.close()
 
     def friend_exists_in_db(self, tox_id):
         chdir(settings.ProfileHelper.get_path())
-        db = connect(self._name + '.hstr')
+        db = connect(self._name + '.hstr', timeout=TIMEOUT)
         cursor = db.cursor()
         cursor.execute('SELECT 0 FROM friends WHERE tox_id=?', (tox_id, ))
         result = cursor.fetchone()
@@ -105,56 +108,57 @@ class History:
 
     def save_messages_to_db(self, tox_id, messages_iter):
         chdir(settings.ProfileHelper.get_path())
-        db = connect(self._name + '.hstr')
+        db = connect(self._name + '.hstr', timeout=TIMEOUT)
         try:
             cursor = db.cursor()
             cursor.executemany('INSERT INTO id' + tox_id + '(message, owner, unix_time, message_type) '
                                'VALUES (?, ?, ?, ?);', messages_iter)
             db.commit()
         except:
+            print('Database is locked!')
             db.rollback()
-            raise
         finally:
             db.close()
 
     def update_messages(self, tox_id, unsent_time):
         chdir(settings.ProfileHelper.get_path())
-        db = connect(self._name + '.hstr')
+        db = connect(self._name + '.hstr', timeout=TIMEOUT)
         try:
             cursor = db.cursor()
             cursor.execute('UPDATE id' + tox_id + ' SET owner = 0 '
                            'WHERE unix_time < ' + str(unsent_time) + ' AND owner = 2;')
             db.commit()
         except:
+            print('Database is locked!')
             db.rollback()
-            raise
         finally:
             db.close()
-        pass
 
     def delete_message(self, tox_id, time):
+        start, end = str(time - 0.01), str(time + 0.01)
         chdir(settings.ProfileHelper.get_path())
-        db = connect(self._name + '.hstr')
+        db = connect(self._name + '.hstr', timeout=TIMEOUT)
         try:
             cursor = db.cursor()
-            cursor.execute('DELETE FROM id' + tox_id + ' WHERE unix_time = ' + str(time) + ';')
+            cursor.execute('DELETE FROM id' + tox_id + ' WHERE unix_time < ' + end + ' AND unix_time > ' +
+                           start + ';')
             db.commit()
         except:
+            print('Database is locked!')
             db.rollback()
-            raise
         finally:
             db.close()
 
     def delete_messages(self, tox_id):
         chdir(settings.ProfileHelper.get_path())
-        db = connect(self._name + '.hstr')
+        db = connect(self._name + '.hstr', timeout=TIMEOUT)
         try:
             cursor = db.cursor()
             cursor.execute('DELETE FROM id' + tox_id + ';')
             db.commit()
         except:
+            print('Database is locked!')
             db.rollback()
-            raise
         finally:
             db.close()
 
@@ -162,21 +166,50 @@ class History:
         return History.MessageGetter(self._name, tox_id)
 
     class MessageGetter:
+
         def __init__(self, name, tox_id):
+            self._count = 0
+            self._name = name
+            self._tox_id = tox_id
+            self._db = self._cursor = None
+
+        def connect(self):
             chdir(settings.ProfileHelper.get_path())
-            self._db = connect(name + '.hstr')
+            self._db = connect(self._name + '.hstr', timeout=TIMEOUT)
             self._cursor = self._db.cursor()
-            self._cursor.execute('SELECT message, owner, unix_time, message_type FROM id' + tox_id +
+            self._cursor.execute('SELECT message, owner, unix_time, message_type FROM id' + self._tox_id +
                                  ' ORDER BY unix_time DESC;')
 
+        def disconnect(self):
+            self._db.close()
+
         def get_one(self):
-            return self._cursor.fetchone()
+            self.connect()
+            self.skip()
+            data = self._cursor.fetchone()
+            self._count += 1
+            self.disconnect()
+            return data
 
         def get_all(self):
-            return self._cursor.fetchall()
+            self.connect()
+            data = self._cursor.fetchall()
+            self.disconnect()
+            self._count = len(data)
+            return data
 
         def get(self, count):
-            return self._cursor.fetchmany(count)
+            self.connect()
+            self.skip()
+            data = self._cursor.fetchmany(count)
+            self.disconnect()
+            self._count += len(data)
+            return data
 
-        def __del__(self):
+        def skip(self):
-            self._db.close()
+            if self._count:
+                self._cursor.fetchmany(self._count)
+
+        def delete_one(self):
+            if self._count:
+                self._count -= 1

toxygen/items_factory.py

@@ -0,0 +1,68 @@
+from PyQt5 import QtWidgets, QtCore
+from list_items import *
+
+
+class ItemsFactory:
+
+    def __init__(self, friends_list, messages):
+        self._friends = friends_list
+        self._messages = messages
+
+    def friend_item(self):
+        item = ContactItem()
+        elem = QtWidgets.QListWidgetItem(self._friends)
+        elem.setSizeHint(QtCore.QSize(250, item.height()))
+        self._friends.addItem(elem)
+        self._friends.setItemWidget(elem, item)
+        return item
+
+    def message_item(self, text, time, name, sent, message_type, append, pixmap):
+        item = MessageItem(text, time, name, sent, message_type, self._messages)
+        if pixmap is not None:
+            item.set_avatar(pixmap)
+        elem = QtWidgets.QListWidgetItem()
+        elem.setSizeHint(QtCore.QSize(self._messages.width(), item.height()))
+        if append:
+            self._messages.addItem(elem)
+        else:
+            self._messages.insertItem(0, elem)
+        self._messages.setItemWidget(elem, item)
+        return item
+
+    def inline_item(self, data, append):
+        elem = QtWidgets.QListWidgetItem()
+        item = InlineImageItem(data, self._messages.width(), elem)
+        elem.setSizeHint(QtCore.QSize(self._messages.width(), item.height()))
+        if append:
+            self._messages.addItem(elem)
+        else:
+            self._messages.insertItem(0, elem)
+        self._messages.setItemWidget(elem, item)
+        return item
+
+    def unsent_file_item(self, file_name, size, name, time, append):
+        item = UnsentFileItem(file_name,
+                              size,
+                              name,
+                              time,
+                              self._messages.width())
+        elem = QtWidgets.QListWidgetItem()
+        elem.setSizeHint(QtCore.QSize(self._messages.width() - 30, 34))
+        if append:
+            self._messages.addItem(elem)
+        else:
+            self._messages.insertItem(0, elem)
+        self._messages.setItemWidget(elem, item)
+        return item
+
+    def file_transfer_item(self, data, append):
+        data.append(self._messages.width())
+        item = FileTransferItem(*data)
+        elem = QtWidgets.QListWidgetItem()
+        elem.setSizeHint(QtCore.QSize(self._messages.width() - 30, 34))
+        if append:
+            self._messages.addItem(elem)
+        else:
+            self._messages.insertItem(0, elem)
+        self._messages.setItemWidget(elem, item)
+        return item

toxygen/libtox.py

@@ -8,6 +8,8 @@ class LibToxCore:
     def __init__(self):
         if system() == 'Windows':
             self._libtoxcore = CDLL(util.curr_directory() + '/libs/libtox.dll')
+        elif system() == 'Darwin':
+            self._libtoxcore = CDLL('libtoxcore.dylib')
         else:
             # libtoxcore and libsodium must be installed in your os
             try:
@@ -25,6 +27,8 @@ class LibToxAV:
         if system() == 'Windows':
             # on Windows av api is in libtox.dll
             self._libtoxav = CDLL(util.curr_directory() + '/libs/libtox.dll')
+        elif system() == 'Darwin':
+            self._libtoxav = CDLL('libtoxav.dylib')
         else:
             # /usr/lib/libtoxav.so must exists
             try:
@@ -42,6 +46,8 @@ class LibToxEncryptSave:
         if system() == 'Windows':
             # on Windows profile encryption api is in libtox.dll
             self._lib_tox_encrypt_save = CDLL(util.curr_directory() + '/libs/libtox.dll')
+        elif system() == 'Darwin':
+            self._lib_tox_encrypt_save = CDLL('libtoxencryptsave.dylib')
         else:
             # /usr/lib/libtoxencryptsave.so must exists
             try:

toxygen/list_items.py

@@ -1,9 +1,5 @@
 from toxcore_enums_and_consts import *
-try:
+from PyQt5 import QtCore, QtGui, QtWidgets
-    from PySide import QtCore, QtGui
-except ImportError:
-    from PyQt4 import QtCore, QtGui
-    QtCore.Slot = QtCore.pyqtSlot
 import profile
 from file_transfers import TOX_FILE_TRANSFER_STATE, PAUSED_FILE_TRANSFERS, DO_NOT_SHOW_ACCEPT_BUTTON, ACTIVE_FILE_TRANSFERS, SHOW_PROGRESS_BAR
 from util import curr_directory, convert_time, curr_time
@@ -11,9 +7,10 @@ from widgets import DataLabel, create_menu
 import html as h
 import smileys
 import settings
+import re
 
 
-class MessageEdit(QtGui.QTextBrowser):
+class MessageEdit(QtWidgets.QTextBrowser):
 
     def __init__(self, text, width, message_type, parent=None):
         super(MessageEdit, self).__init__(parent)
@@ -25,7 +22,9 @@ class MessageEdit(QtGui.QTextBrowser):
         self.setOpenExternalLinks(True)
         self.setAcceptRichText(True)
         self.setOpenLinks(False)
-        self.setSearchPaths([smileys.SmileyLoader.get_instance().get_smileys_path()])
+        path = smileys.SmileyLoader.get_instance().get_smileys_path()
+        if path is not None:
+            self.setSearchPaths([path])
         self.document().setDefaultStyleSheet('a { color: #306EFF; }')
         text = self.decoratedText(text)
         if message_type != TOX_MESSAGE_TYPE['NORMAL']:
@@ -43,7 +42,7 @@ class MessageEdit(QtGui.QTextBrowser):
 
     def contextMenuEvent(self, event):
         menu = create_menu(self.createStandardContextMenu(event.pos()))
-        quote = menu.addAction(QtGui.QApplication.translate("MainWindow", 'Quote selected text', None, QtGui.QApplication.UnicodeUTF8))
+        quote = menu.addAction(QtWidgets.QApplication.translate("MainWindow", 'Quote selected text'))
         quote.triggered.connect(self.quote_text)
         text = self.textCursor().selection().toPlainText()
         if not text:
@@ -52,7 +51,7 @@ class MessageEdit(QtGui.QTextBrowser):
             import plugin_support
             submenu = plugin_support.PluginLoader.get_instance().get_message_menu(menu, text)
             if len(submenu):
-                plug = menu.addMenu(QtGui.QApplication.translate("MainWindow", 'Plugins', None, QtGui.QApplication.UnicodeUTF8))
+                plug = menu.addMenu(QtWidgets.QApplication.translate("MainWindow", 'Plugins'))
                 plug.addActions(submenu)
         menu.popup(event.globalPos())
         menu.exec_(event.globalPos())
@@ -120,14 +119,14 @@ class MessageEdit(QtGui.QTextBrowser):
         return text
 
 
-class MessageItem(QtGui.QWidget):
+class MessageItem(QtWidgets.QWidget):
     """
     Message in messages list
     """
     def __init__(self, text, time, user='', sent=True, message_type=TOX_MESSAGE_TYPE['NORMAL'], parent=None):
-        QtGui.QWidget.__init__(self, parent)
+        QtWidgets.QWidget.__init__(self, parent)
         self.name = DataLabel(self)
-        self.name.setGeometry(QtCore.QRect(2, 2, 95, 20))
+        self.name.setGeometry(QtCore.QRect(2, 2, 95, 23))
         self.name.setTextFormat(QtCore.Qt.PlainText)
         font = QtGui.QFont()
         font.setFamily(settings.Settings.get_instance()['font'])
@@ -136,8 +135,8 @@ class MessageItem(QtGui.QWidget):
         self.name.setFont(font)
         self.name.setText(user)
 
-        self.time = QtGui.QLabel(self)
+        self.time = QtWidgets.QLabel(self)
-        self.time.setGeometry(QtCore.QRect(parent.width() - 50, 0, 50, 20))
+        self.time.setGeometry(QtCore.QRect(parent.width() - 60, 0, 50, 25))
         font.setPointSize(10)
         font.setBold(False)
         self.time.setFont(font)
@@ -151,19 +150,19 @@ class MessageItem(QtGui.QWidget):
             self.time.setText(convert_time(time))
             self.t = False
 
-        self.message = MessageEdit(text, parent.width() - 150, message_type, self)
+        self.message = MessageEdit(text, parent.width() - 160, message_type, self)
         if message_type != TOX_MESSAGE_TYPE['NORMAL']:
             self.name.setStyleSheet("QLabel { color: #5CB3FF; }")
             self.message.setAlignment(QtCore.Qt.AlignCenter)
             self.time.setStyleSheet("QLabel { color: #5CB3FF; }")
-        self.message.setGeometry(QtCore.QRect(100, 0, parent.width() - 150, self.message.height()))
+        self.message.setGeometry(QtCore.QRect(100, 0, parent.width() - 160, self.message.height()))
         self.setFixedHeight(self.message.height())
 
     def mouseReleaseEvent(self, event):
         if event.button() == QtCore.Qt.RightButton and event.x() > self.time.x():
-            self.listMenu = QtGui.QMenu()
+            self.listMenu = QtWidgets.QMenu()
-            delete_item = self.listMenu.addAction(QtGui.QApplication.translate("MainWindow", 'Delete message', None, QtGui.QApplication.UnicodeUTF8))
+            delete_item = self.listMenu.addAction(QtWidgets.QApplication.translate("MainWindow", 'Delete message'))
-            self.connect(delete_item, QtCore.SIGNAL("triggered()"), self.delete)
+            delete_item.triggered.connect(self.delete)
             parent_position = self.time.mapToGlobal(QtCore.QPoint(0, 0))
             self.listMenu.move(parent_position)
             self.listMenu.show()
@@ -187,17 +186,42 @@ class MessageItem(QtGui.QWidget):
         self.message.setFixedHeight(self.height())
         self.name.setPixmap(pixmap.scaled(30, 30, QtCore.Qt.KeepAspectRatio, QtCore.Qt.SmoothTransformation))
 
+    def select_text(self, text):
+        tmp = self.message.toHtml()
+        text = h.escape(text)
+        strings = re.findall(text, tmp, flags=re.IGNORECASE)
+        for s in strings:
+            tmp = self.replace_all(tmp, s)
+        self.message.setHtml(tmp)
 
-class ContactItem(QtGui.QWidget):
+    @staticmethod
+    def replace_all(text, substring):
+        i, l = 0, len(substring)
+        while i < len(text) - l + 1:
+            index = text[i:].find(substring)
+            if index == -1:
+                break
+            i += index
+            lgt, rgt = text[i:].find('<'), text[i:].find('>')
+            if rgt < lgt:
+                i += rgt + 1
+                continue
+            sub = '<font color="red"><b>{}</b></font>'.format(substring)
+            text = text[:i] + sub + text[i + l:]
+            i += len(sub)
+        return text
+
+
+class ContactItem(QtWidgets.QWidget):
     """
     Contact in friends list
     """
 
     def __init__(self, parent=None):
-        QtGui.QWidget.__init__(self, parent)
+        QtWidgets.QWidget.__init__(self, parent)
         mode = settings.Settings.get_instance()['compact_mode']
         self.setBaseSize(QtCore.QSize(250, 40 if mode else 70))
-        self.avatar_label = QtGui.QLabel(self)
+        self.avatar_label = QtWidgets.QLabel(self)
         size = 32 if mode else 64
         self.avatar_label.setGeometry(QtCore.QRect(3, 4, size, size))
         self.avatar_label.setScaledContents(False)
@@ -220,14 +244,14 @@ class ContactItem(QtGui.QWidget):
         self.messages.setGeometry(QtCore.QRect(20 if mode else 52, 20 if mode else 50, 30, 20))
 
 
-class StatusCircle(QtGui.QWidget):
+class StatusCircle(QtWidgets.QWidget):
     """
     Connection status
     """
     def __init__(self, parent):
-        QtGui.QWidget.__init__(self, parent)
+        QtWidgets.QWidget.__init__(self, parent)
         self.setGeometry(0, 0, 32, 32)
-        self.label = QtGui.QLabel(self)
+        self.label = QtWidgets.QLabel(self)
         self.label.setGeometry(QtCore.QRect(0, 0, 32, 32))
         self.unread = False
 
@@ -253,12 +277,12 @@ class StatusCircle(QtGui.QWidget):
         self.label.setPixmap(pixmap)
 
 
-class UnreadMessagesCount(QtGui.QWidget):
+class UnreadMessagesCount(QtWidgets.QWidget):
 
     def __init__(self, parent=None):
         super(UnreadMessagesCount, self).__init__(parent)
         self.resize(30, 20)
-        self.label = QtGui.QLabel(self)
+        self.label = QtWidgets.QLabel(self)
         self.label.setGeometry(QtCore.QRect(0, 0, 30, 20))
         self.label.setVisible(False)
         font = QtGui.QFont()
@@ -280,11 +304,11 @@ class UnreadMessagesCount(QtGui.QWidget):
             self.label.setVisible(False)
 
 
-class FileTransferItem(QtGui.QListWidget):
+class FileTransferItem(QtWidgets.QListWidget):
 
     def __init__(self, file_name, size, time, user, friend_number, file_number, state, width, parent=None):
 
-        QtGui.QListWidget.__init__(self, parent)
+        QtWidgets.QListWidget.__init__(self, parent)
         self.resize(QtCore.QSize(width, 34))
         if state == TOX_FILE_TRANSFER_STATE['CANCELLED']:
             self.setStyleSheet('QListWidget { border: 1px solid #B40404; }')
@@ -295,7 +319,7 @@ class FileTransferItem(QtGui.QListWidget):
         self.state = state
 
         self.name = DataLabel(self)
-        self.name.setGeometry(QtCore.QRect(3, 7, 95, 20))
+        self.name.setGeometry(QtCore.QRect(3, 7, 95, 25))
         self.name.setTextFormat(QtCore.Qt.PlainText)
         font = QtGui.QFont()
         font.setFamily(settings.Settings.get_instance()['font'])
@@ -304,15 +328,15 @@ class FileTransferItem(QtGui.QListWidget):
         self.name.setFont(font)
         self.name.setText(user)
 
-        self.time = QtGui.QLabel(self)
+        self.time = QtWidgets.QLabel(self)
-        self.time.setGeometry(QtCore.QRect(width - 53, 7, 50, 20))
+        self.time.setGeometry(QtCore.QRect(width - 60, 7, 50, 25))
         font.setPointSize(10)
         font.setBold(False)
         self.time.setFont(font)
         self.time.setText(convert_time(time))
 
-        self.cancel = QtGui.QPushButton(self)
+        self.cancel = QtWidgets.QPushButton(self)
-        self.cancel.setGeometry(QtCore.QRect(width - 120, 2, 30, 30))
+        self.cancel.setGeometry(QtCore.QRect(width - 125, 2, 30, 30))
         pixmap = QtGui.QPixmap(curr_directory() + '/images/decline.png')
         icon = QtGui.QIcon(pixmap)
         self.cancel.setIcon(icon)
@@ -321,7 +345,7 @@ class FileTransferItem(QtGui.QListWidget):
         self.cancel.clicked.connect(lambda: self.cancel_transfer(friend_number, file_number))
         self.cancel.setStyleSheet('QPushButton:hover { border: 1px solid #3A3939; background-color: none;}')
 
-        self.accept_or_pause = QtGui.QPushButton(self)
+        self.accept_or_pause = QtWidgets.QPushButton(self)
         self.accept_or_pause.setGeometry(QtCore.QRect(width - 170, 2, 30, 30))
         if state == TOX_FILE_TRANSFER_STATE['INCOMING_NOT_STARTED']:
             self.accept_or_pause.setVisible(True)
@@ -338,7 +362,7 @@ class FileTransferItem(QtGui.QListWidget):
 
         self.accept_or_pause.setStyleSheet('QPushButton:hover { border: 1px solid #3A3939; background-color: none}')
 
-        self.pb = QtGui.QProgressBar(self)
+        self.pb = QtWidgets.QProgressBar(self)
         self.pb.setGeometry(QtCore.QRect(100, 7, 100, 20))
         self.pb.setValue(0)
         self.pb.setStyleSheet('QProgressBar { background-color: #302F2F; }')
@@ -359,8 +383,8 @@ class FileTransferItem(QtGui.QListWidget):
         self.file_name.setText(file_data)
         self.file_name.setToolTip(file_name)
         self.saved_name = file_name
-        self.time_left = QtGui.QLabel(self)
+        self.time_left = QtWidgets.QLabel(self)
-        self.time_left.setGeometry(QtCore.QRect(width - 87, 7, 30, 20))
+        self.time_left.setGeometry(QtCore.QRect(width - 92, 7, 30, 20))
         font.setPointSize(10)
         self.time_left.setFont(font)
         self.time_left.setVisible(state == TOX_FILE_TRANSFER_STATE['RUNNING'])
@@ -377,10 +401,10 @@ class FileTransferItem(QtGui.QListWidget):
 
     def accept_or_pause_transfer(self, friend_number, file_number, size):
         if self.state == TOX_FILE_TRANSFER_STATE['INCOMING_NOT_STARTED']:
-            directory = QtGui.QFileDialog.getExistingDirectory(self,
+            directory = QtWidgets.QFileDialog.getExistingDirectory(self,
-                                                               QtGui.QApplication.translate("MainWindow", 'Choose folder', None, QtGui.QApplication.UnicodeUTF8),
+                                                               QtWidgets.QApplication.translate("MainWindow", 'Choose folder'),
                                                                curr_directory(),
-                                                               QtGui.QFileDialog.ShowDirsOnly | QtGui.QFileDialog.DontUseNativeDialog)
+                                                               QtWidgets.QFileDialog.ShowDirsOnly | QtWidgets.QFileDialog.DontUseNativeDialog)
             self.pb.setVisible(True)
             if directory:
                 pr = profile.Profile.get_instance()
@@ -404,8 +428,7 @@ class FileTransferItem(QtGui.QListWidget):
         self.accept_or_pause.setIcon(icon)
         self.accept_or_pause.setIconSize(QtCore.QSize(30, 30))
 
-    @QtCore.Slot(int, float, int)
+    def update_transfer_state(self, state, progress, time):
-    def update(self, state, progress, time):
         self.pb.setValue(int(progress * 100))
         if time + 1:
             m, s = divmod(time, 60)
@@ -468,14 +491,14 @@ class UnsentFileItem(FileTransferItem):
         pr.cancel_not_started_transfer(self._time)
 
 
-class InlineImageItem(QtGui.QScrollArea):
+class InlineImageItem(QtWidgets.QScrollArea):
 
     def __init__(self, data, width, elem):
 
-        QtGui.QScrollArea.__init__(self)
+        QtWidgets.QScrollArea.__init__(self)
         self.setFocusPolicy(QtCore.Qt.NoFocus)
         self._elem = elem
-        self._image_label = QtGui.QLabel(self)
+        self._image_label = QtWidgets.QLabel(self)
         self._image_label.raise_()
         self.setWidget(self._image_label)
         self._image_label.setScaledContents(False)
@@ -509,12 +532,11 @@ class InlineImageItem(QtGui.QScrollArea):
             self._full_size = not self._full_size
             self._elem.setSizeHint(QtCore.QSize(self.width(), self.height()))
         elif event.button() == QtCore.Qt.RightButton:  # save inline
-            directory = QtGui.QFileDialog.getExistingDirectory(self,
+            directory = QtWidgets.QFileDialog.getExistingDirectory(self,
-                                                               QtGui.QApplication.translate("MainWindow",
+                                                               QtWidgets.QApplication.translate("MainWindow",
-                                                                                            'Choose folder', None,
+                                                                                            'Choose folder'),
-                                                                                            QtGui.QApplication.UnicodeUTF8),
                                                                curr_directory(),
-                                                               QtGui.QFileDialog.ShowDirsOnly | QtGui.QFileDialog.DontUseNativeDialog)
+                                                               QtWidgets.QFileDialog.ShowDirsOnly | QtWidgets.QFileDialog.DontUseNativeDialog)
             if directory:
                 fl = QtCore.QFile(directory + '/toxygen_inline_' + curr_time().replace(':', '_') + '.png')
                 self._pixmap.save(fl, 'PNG')

toxygen/loginscreen.py

@@ -1,9 +1,4 @@
-# -*- coding: utf-8 -*-
+from PyQt5 import QtWidgets, QtCore
-
-try:
-    from PySide import QtCore, QtGui
-except ImportError:
-    from PyQt4 import QtCore, QtGui
 from widgets import *
 
 
@@ -31,25 +26,25 @@ class LoginScreen(CenteredWidget):
         self.resize(400, 200)
         self.setMinimumSize(QtCore.QSize(400, 200))
         self.setMaximumSize(QtCore.QSize(400, 200))
-        self.new_profile = QtGui.QPushButton(self)
+        self.new_profile = QtWidgets.QPushButton(self)
         self.new_profile.setGeometry(QtCore.QRect(20, 150, 171, 27))
         self.new_profile.clicked.connect(self.create_profile)
-        self.label = QtGui.QLabel(self)
+        self.label = QtWidgets.QLabel(self)
         self.label.setGeometry(QtCore.QRect(20, 70, 101, 17))
         self.new_name = NickEdit(self)
         self.new_name.setGeometry(QtCore.QRect(20, 100, 171, 31))
-        self.load_profile = QtGui.QPushButton(self)
+        self.load_profile = QtWidgets.QPushButton(self)
         self.load_profile.setGeometry(QtCore.QRect(220, 150, 161, 27))
         self.load_profile.clicked.connect(self.load_ex_profile)
-        self.default = QtGui.QCheckBox(self)
+        self.default = QtWidgets.QCheckBox(self)
         self.default.setGeometry(QtCore.QRect(220, 110, 131, 22))
-        self.groupBox = QtGui.QGroupBox(self)
+        self.groupBox = QtWidgets.QGroupBox(self)
         self.groupBox.setGeometry(QtCore.QRect(210, 40, 181, 151))
-        self.comboBox = QtGui.QComboBox(self.groupBox)
+        self.comboBox = QtWidgets.QComboBox(self.groupBox)
         self.comboBox.setGeometry(QtCore.QRect(10, 30, 161, 27))
-        self.groupBox_2 = QtGui.QGroupBox(self)
+        self.groupBox_2 = QtWidgets.QGroupBox(self)
         self.groupBox_2.setGeometry(QtCore.QRect(10, 40, 191, 151))
-        self.toxygen = QtGui.QLabel(self)
+        self.toxygen = QtWidgets.QLabel(self)
         self.groupBox.raise_()
         self.groupBox_2.raise_()
         self.comboBox.raise_()
@@ -71,15 +66,15 @@ class LoginScreen(CenteredWidget):
         QtCore.QMetaObject.connectSlotsByName(self)
 
     def retranslateUi(self):
-        self.new_name.setPlaceholderText(QtGui.QApplication.translate("login", "Profile name", None, QtGui.QApplication.UnicodeUTF8))
+        self.new_name.setPlaceholderText(QtWidgets.QApplication.translate("login", "Profile name"))
-        self.setWindowTitle(QtGui.QApplication.translate("login", "Log in", None, QtGui.QApplication.UnicodeUTF8))
+        self.setWindowTitle(QtWidgets.QApplication.translate("login", "Log in"))
-        self.new_profile.setText(QtGui.QApplication.translate("login", "Create", None, QtGui.QApplication.UnicodeUTF8))
+        self.new_profile.setText(QtWidgets.QApplication.translate("login", "Create"))
-        self.label.setText(QtGui.QApplication.translate("login", "Profile name:", None, QtGui.QApplication.UnicodeUTF8))
+        self.label.setText(QtWidgets.QApplication.translate("login", "Profile name:"))
-        self.load_profile.setText(QtGui.QApplication.translate("login", "Load profile", None, QtGui.QApplication.UnicodeUTF8))
+        self.load_profile.setText(QtWidgets.QApplication.translate("login", "Load profile"))
-        self.default.setText(QtGui.QApplication.translate("login", "Use as default", None, QtGui.QApplication.UnicodeUTF8))
+        self.default.setText(QtWidgets.QApplication.translate("login", "Use as default"))
-        self.groupBox.setTitle(QtGui.QApplication.translate("login", "Load existing profile", None, QtGui.QApplication.UnicodeUTF8))
+        self.groupBox.setTitle(QtWidgets.QApplication.translate("login", "Load existing profile"))
-        self.groupBox_2.setTitle(QtGui.QApplication.translate("login", "Create new profile", None, QtGui.QApplication.UnicodeUTF8))
+        self.groupBox_2.setTitle(QtWidgets.QApplication.translate("login", "Create new profile"))
-        self.toxygen.setText(QtGui.QApplication.translate("login", "toxygen", None, QtGui.QApplication.UnicodeUTF8))
+        self.toxygen.setText(QtWidgets.QApplication.translate("login", "toxygen"))
 
     def create_profile(self):
         self.type = 1

toxygen/main.py

@@ -2,26 +2,24 @@ import sys
 from loginscreen import LoginScreen
 import profile
 from settings import *
-try:
+from PyQt5 import QtCore, QtGui, QtWidgets
-    from PySide import QtCore, QtGui
-except ImportError:
-    from PyQt4 import QtCore, QtGui
 from bootstrap import node_generator
 from mainscreen import MainWindow
 from callbacks import init_callbacks, stop, start
-from util import curr_directory, program_version
+from util import curr_directory, program_version, remove, is_64_bit
 import styles.style
 import platform
-import toxencryptsave
+import toxes
 from passwordscreen import PasswordScreen, UnlockAppScreen, SetProfilePasswordScreen
 from plugin_support import PluginLoader
+import updater
 
 
 class Toxygen:
 
     def __init__(self, path_or_uri=None):
         super(Toxygen, self).__init__()
-        self.tox = self.ms = self.init = self.mainloop = self.avloop = None
+        self.tox = self.ms = self.init = self.app = self.tray = self.mainloop = self.avloop = None
         if path_or_uri is None:
             self.uri = self.path = None
         elif path_or_uri.startswith('tox:'):
@@ -36,9 +34,9 @@ class Toxygen:
         Show password screen
         """
         tmp = [data]
-        p = PasswordScreen(toxencryptsave.ToxEncryptSave.get_instance(), tmp)
+        p = PasswordScreen(toxes.ToxES.get_instance(), tmp)
         p.show()
-        self.app.connect(self.app, QtCore.SIGNAL("lastWindowClosed()"), self.app, QtCore.SLOT("quit()"))
+        self.app.lastWindowClosed.connect(self.app.quit)
         self.app.exec_()
         if tmp[0] == data:
             raise SystemExit()
@@ -49,7 +47,7 @@ class Toxygen:
         """
         Main function of app. loads login screen if needed and starts main screen
         """
-        app = QtGui.QApplication(sys.argv)
+        app = QtWidgets.QApplication(sys.argv)
         app.setWindowIcon(QtGui.QIcon(curr_directory() + '/images/icon.png'))
         self.app = app
 
@@ -61,7 +59,7 @@ class Toxygen:
             dark_style = fl.read()
         app.setStyleSheet(dark_style)
 
-        encrypt_save = toxencryptsave.ToxEncryptSave()
+        encrypt_save = toxes.ToxES()
 
         if self.path is not None:
             path = os.path.dirname(self.path) + '/'
@@ -91,7 +89,6 @@ class Toxygen:
                 _login = self.Login(profiles)
                 ls.update_on_close(_login.login_screen_close)
                 ls.show()
-                app.connect(app, QtCore.SIGNAL("lastWindowClosed()"), app, QtCore.SLOT("quit()"))
                 app.exec_()
                 if not _login.t:
                     return
@@ -100,44 +97,48 @@ class Toxygen:
                     name = _login.name if _login.name else 'toxygen_user'
                     pr = map(lambda x: x[1], ProfileHelper.find_profiles())
                     if name in list(pr):
-                        msgBox = QtGui.QMessageBox()
+                        msgBox = QtWidgets.QMessageBox()
                         msgBox.setWindowTitle(
-                            QtGui.QApplication.translate("MainWindow", "Error", None, QtGui.QApplication.UnicodeUTF8))
+                            QtWidgets.QApplication.translate("MainWindow", "Error"))
-                        text = (QtGui.QApplication.translate("MainWindow",
+                        text = (QtWidgets.QApplication.translate("MainWindow",
-                                                             'Profile with this name already exists',
+                                                             'Profile with this name already exists'))
-                                                             None, QtGui.QApplication.UnicodeUTF8))
                         msgBox.setText(text)
                         msgBox.exec_()
                         return
                     self.tox = profile.tox_factory()
                     self.tox.self_set_name(bytes(_login.name, 'utf-8') if _login.name else b'Toxygen User')
                     self.tox.self_set_status_message(b'Toxing on Toxygen')
-                    reply = QtGui.QMessageBox.question(None,
+                    reply = QtWidgets.QMessageBox.question(None,
                                                        'Profile {}'.format(name),
-                                                       QtGui.QApplication.translate("login",
+                                                       QtWidgets.QApplication.translate("login",
-                                                                                    'Do you want to set profile password?',
+                                                                                    'Do you want to set profile password?'),
-                                                                                    None,
+                                                           QtWidgets.QMessageBox.Yes,
-                                                                                    QtGui.QApplication.UnicodeUTF8),
+                                                           QtWidgets.QMessageBox.No)
-                                                       QtGui.QMessageBox.Yes,
+                    if reply == QtWidgets.QMessageBox.Yes:
-                                                       QtGui.QMessageBox.No)
-                    if reply == QtGui.QMessageBox.Yes:
                         set_pass = SetProfilePasswordScreen(encrypt_save)
                         set_pass.show()
-                        self.app.connect(self.app, QtCore.SIGNAL("lastWindowClosed()"), self.app, QtCore.SLOT("quit()"))
+                        self.app.lastWindowClosed.connect(self.app.quit)
                         self.app.exec_()
-                    reply = QtGui.QMessageBox.question(None,
+                    reply = QtWidgets.QMessageBox.question(None,
                                                        'Profile {}'.format(name),
-                                                       QtGui.QApplication.translate("login",
+                                                       QtWidgets.QApplication.translate("login",
-                                                                                    'Do you want to save profile in default folder? If no, profile will be saved in program folder',
+                                                                                    'Do you want to save profile in default folder? If no, profile will be saved in program folder'),
-                                                                                    None,
+                                                       QtWidgets.QMessageBox.Yes,
-                                                                                    QtGui.QApplication.UnicodeUTF8),
+                                                           QtWidgets.QMessageBox.No)
-                                                       QtGui.QMessageBox.Yes,
+                    if reply == QtWidgets.QMessageBox.Yes:
-                                                       QtGui.QMessageBox.No)
-                    if reply == QtGui.QMessageBox.Yes:
                         path = Settings.get_default_path()
                     else:
-                        path = curr_directory()
+                        path = curr_directory() + '/'
-                    ProfileHelper(path, name).save_profile(self.tox.get_savedata())
+                    try:
+                        ProfileHelper(path, name).save_profile(self.tox.get_savedata())
+                    except Exception as ex:
+                        print(str(ex))
+                        log('Profile creation exception: ' + str(ex))
+                        msgBox = QtWidgets.QMessageBox()
+                        msgBox.setText(QtWidgets.QApplication.translate("login",
+                                                                    'Profile saving error! Does Toxygen have permission to write to this directory?'))
+                        msgBox.exec_()
+                        return
                     path = Settings.get_default_path()
                     settings = Settings(name)
                     if curr_lang in langs:
@@ -161,12 +162,12 @@ class Toxygen:
                 self.tox = profile.tox_factory(data, settings)
 
         if Settings.is_active_profile(path, name):  # profile is in use
-            reply = QtGui.QMessageBox.question(None,
+            reply = QtWidgets.QMessageBox.question(None,
                                                'Profile {}'.format(name),
-                                               QtGui.QApplication.translate("login", 'Other instance of Toxygen uses this profile or profile was not properly closed. Continue?', None, QtGui.QApplication.UnicodeUTF8),
+                                               QtWidgets.QApplication.translate("login", 'Other instance of Toxygen uses this profile or profile was not properly closed. Continue?'),
-                                               QtGui.QMessageBox.Yes,
+                                                   QtWidgets.QMessageBox.Yes,
-                                               QtGui.QMessageBox.No)
+                                                   QtWidgets.QMessageBox.No)
-            if reply != QtGui.QMessageBox.Yes:
+            if reply != QtWidgets.QMessageBox.Yes:
                 return
         else:
             settings.set_active_profile()
@@ -178,19 +179,21 @@ class Toxygen:
         app.translator = translator
 
         # tray icon
-        self.tray = QtGui.QSystemTrayIcon(QtGui.QIcon(curr_directory() + '/images/icon.png'))
+        self.tray = QtWidgets.QSystemTrayIcon(QtGui.QIcon(curr_directory() + '/images/icon.png'))
         self.tray.setObjectName('tray')
 
         self.ms = MainWindow(self.tox, self.reset, self.tray)
+        app.aboutToQuit.connect(self.ms.close_window)
 
-        class Menu(QtGui.QMenu):
+        class Menu(QtWidgets.QMenu):
 
             def newStatus(self, status):
-                profile.Profile.get_instance().set_status(status)
+                if not Settings.get_instance().locked:
-                self.aboutToShow()
+                    profile.Profile.get_instance().set_status(status)
-                self.hide()
+                    self.aboutToShowHandler()
+                    self.hide()
 
-            def aboutToShow(self):
+            def aboutToShowHandler(self):
                 status = profile.Profile.get_instance().status
                 act = self.act
                 if status is None or Settings.get_instance().locked:
@@ -204,54 +207,60 @@ class Toxygen:
                 self.actions()[2].setVisible(not Settings.get_instance().locked)
 
             def languageChange(self, *args, **kwargs):
-                self.actions()[0].setText(QtGui.QApplication.translate('tray', 'Open Toxygen', None, QtGui.QApplication.UnicodeUTF8))
+                self.actions()[0].setText(QtWidgets.QApplication.translate('tray', 'Open Toxygen'))
-                self.actions()[1].setText(QtGui.QApplication.translate('tray', 'Set status', None, QtGui.QApplication.UnicodeUTF8))
+                self.actions()[1].setText(QtWidgets.QApplication.translate('tray', 'Set status'))
-                self.actions()[2].setText(QtGui.QApplication.translate('tray', 'Exit', None, QtGui.QApplication.UnicodeUTF8))
+                self.actions()[2].setText(QtWidgets.QApplication.translate('tray', 'Exit'))
-                self.act.actions()[0].setText(QtGui.QApplication.translate('tray', 'Online', None, QtGui.QApplication.UnicodeUTF8))
+                self.act.actions()[0].setText(QtWidgets.QApplication.translate('tray', 'Online'))
-                self.act.actions()[1].setText(QtGui.QApplication.translate('tray', 'Away', None, QtGui.QApplication.UnicodeUTF8))
+                self.act.actions()[1].setText(QtWidgets.QApplication.translate('tray', 'Away'))
-                self.act.actions()[2].setText(QtGui.QApplication.translate('tray', 'Busy', None, QtGui.QApplication.UnicodeUTF8))
+                self.act.actions()[2].setText(QtWidgets.QApplication.translate('tray', 'Busy'))
 
         m = Menu()
-        show = m.addAction(QtGui.QApplication.translate('tray', 'Open Toxygen', None, QtGui.QApplication.UnicodeUTF8))
+        show = m.addAction(QtWidgets.QApplication.translate('tray', 'Open Toxygen'))
-        sub = m.addMenu(QtGui.QApplication.translate('tray', 'Set status', None, QtGui.QApplication.UnicodeUTF8))
+        sub = m.addMenu(QtWidgets.QApplication.translate('tray', 'Set status'))
-        onl = sub.addAction(QtGui.QApplication.translate('tray', 'Online', None, QtGui.QApplication.UnicodeUTF8))
+        onl = sub.addAction(QtWidgets.QApplication.translate('tray', 'Online'))
-        away = sub.addAction(QtGui.QApplication.translate('tray', 'Away', None, QtGui.QApplication.UnicodeUTF8))
+        away = sub.addAction(QtWidgets.QApplication.translate('tray', 'Away'))
-        busy = sub.addAction(QtGui.QApplication.translate('tray', 'Busy', None, QtGui.QApplication.UnicodeUTF8))
+        busy = sub.addAction(QtWidgets.QApplication.translate('tray', 'Busy'))
         onl.setCheckable(True)
         away.setCheckable(True)
         busy.setCheckable(True)
         m.act = sub
-        exit = m.addAction(QtGui.QApplication.translate('tray', 'Exit', None, QtGui.QApplication.UnicodeUTF8))
+        exit = m.addAction(QtWidgets.QApplication.translate('tray', 'Exit'))
 
         def show_window():
+            s = Settings.get_instance()
+
             def show():
                 if not self.ms.isActiveWindow():
                     self.ms.setWindowState(self.ms.windowState() & ~QtCore.Qt.WindowMinimized | QtCore.Qt.WindowActive)
                     self.ms.activateWindow()
                 self.ms.show()
-            if not Settings.get_instance().locked:
+            if not s.locked:
                 show()
             else:
                 def correct_pass():
                     show()
-                    Settings.get_instance().locked = False
+                    s.locked = False
-                self.p = UnlockAppScreen(toxencryptsave.ToxEncryptSave.get_instance(), correct_pass)
+                    s.unlockScreen = False
-                self.p.show()
+                if not s.unlockScreen:
+                    s.unlockScreen = True
+                    self.p = UnlockAppScreen(toxes.ToxES.get_instance(), correct_pass)
+                    self.p.show()
 
         def tray_activated(reason):
-            if reason == QtGui.QSystemTrayIcon.DoubleClick:
+            if reason == QtWidgets.QSystemTrayIcon.DoubleClick:
                 show_window()
 
         def close_app():
-            settings.closing = True
+            if not Settings.get_instance().locked:
-            self.ms.close()
+                settings.closing = True
+                self.ms.close()
 
-        m.connect(show, QtCore.SIGNAL("triggered()"), show_window)
+        show.triggered.connect(show_window)
-        m.connect(exit, QtCore.SIGNAL("triggered()"), close_app)
+        exit.triggered.connect(close_app)
-        m.connect(m, QtCore.SIGNAL("aboutToShow()"), lambda: m.aboutToShow())
+        m.aboutToShow.connect(lambda: m.aboutToShowHandler())
-        sub.connect(onl, QtCore.SIGNAL("triggered()"), lambda: m.newStatus(0))
+        onl.triggered.connect(lambda: m.newStatus(0))
-        sub.connect(away, QtCore.SIGNAL("triggered()"), lambda: m.newStatus(1))
+        away.triggered.connect(lambda: m.newStatus(1))
-        sub.connect(busy, QtCore.SIGNAL("triggered()"), lambda: m.newStatus(2))
+        busy.triggered.connect(lambda: m.newStatus(2))
 
         self.tray.setContextMenu(m)
         self.tray.show()
@@ -259,6 +268,31 @@ class Toxygen:
 
         self.ms.show()
 
+        updating = False
+        if settings['update'] and updater.updater_available() and updater.connection_available():  # auto update
+            version = updater.check_for_updates()
+            if version is not None:
+                if settings['update'] == 2:
+                    updater.download(version)
+                    updating = True
+                else:
+                    reply = QtWidgets.QMessageBox.question(None,
+                                                       'Toxygen',
+                                                       QtWidgets.QApplication.translate("login",
+                                                                                    'Update for Toxygen was found. Download and install it?'),
+                                                           QtWidgets.QMessageBox.Yes,
+                                                           QtWidgets.QMessageBox.No)
+                    if reply == QtWidgets.QMessageBox.Yes:
+                        updater.download(version)
+                        updating = True
+
+        if updating:
+            data = self.tox.get_savedata()
+            ProfileHelper.get_instance().save_profile(data)
+            settings.close()
+            del self.tox
+            return
+
         plugin_helper = PluginLoader(self.tox, settings)  # plugin support
         plugin_helper.load()
 
@@ -276,8 +310,9 @@ class Toxygen:
         if self.uri is not None:
             self.ms.add_contact(self.uri)
 
-        app.connect(app, QtCore.SIGNAL("lastWindowClosed()"), app, QtCore.SLOT("quit()"))
+        app.lastWindowClosed.connect(app.quit)
         app.exec_()
+
         self.init.stop = True
         self.mainloop.stop = True
         self.avloop.stop = True
@@ -410,15 +445,13 @@ class Toxygen:
 def clean():
     """Removes all windows libs from libs folder"""
     d = curr_directory() + '/libs/'
-    for fl in ('libtox64.dll', 'libtox.dll', 'libsodium64.a', 'libsodium.a'):
+    remove(d)
-        if os.path.exists(d + fl):
-            os.remove(d + fl)
 
 
 def configure():
     """Removes unused libs"""
     d = curr_directory() + '/libs/'
-    is_64bits = sys.maxsize > 2 ** 32
+    is_64bits = is_64_bit()
     if not is_64bits:
         if os.path.exists(d + 'libtox64.dll'):
             os.remove(d + 'libtox64.dll')
@@ -436,6 +469,10 @@ def configure():
             pass
 
 
+def reset():
+    Settings.reset_auto_profile()
+
+
 def main():
     if len(sys.argv) == 1:
         toxygen = Toxygen()
@@ -445,7 +482,7 @@ def main():
             print('Toxygen v' + program_version)
             return
         elif arg == '--help':
-            print('Usage:\ntoxygen path_to_profile\ntoxygen tox_id\ntoxygen --version')
+            print('Usage:\ntoxygen path_to_profile\ntoxygen tox_id\ntoxygen --version\ntoxygen --reset')
             return
         elif arg == '--configure':
             configure()
@@ -453,6 +490,9 @@ def main():
         elif arg == '--clean':
             clean()
             return
+        elif arg == '--reset':
+            reset()
+            return
         else:
             toxygen = Toxygen(arg)
     toxygen.main()

toxygen/mainscreen.py

@@ -1,15 +1,15 @@
-# -*- coding: utf-8 -*-
-
 from menu import *
 from profile import *
 from list_items import *
-from widgets import MultilineEdit, LineEdit
+from widgets import MultilineEdit, ComboBox
 import plugin_support
 from mainscreen_widgets import *
 import settings
+import platform
+import toxes
 
 
-class MainWindow(QtGui.QMainWindow, Singleton):
+class MainWindow(QtWidgets.QMainWindow, Singleton):
 
     def __init__(self, tox, reset, tray):
         super().__init__()
@@ -18,46 +18,55 @@ class MainWindow(QtGui.QMainWindow, Singleton):
         self.tray = tray
         self.setAcceptDrops(True)
         self.initUI(tox)
+        self._saved = False
         if settings.Settings.get_instance()['show_welcome_screen']:
             self.ws = WelcomeScreen()
 
-    def setup_menu(self, MainWindow):
+    def setup_menu(self, Form):
-        self.menubar = QtGui.QMenuBar(MainWindow)
+        box = QtWidgets.QHBoxLayout()
-        self.menubar.setObjectName("menubar")
+        box.setContentsMargins(0, 0, 0, 0)
-        self.menubar.setNativeMenuBar(False)
+        box.setAlignment(QtCore.Qt.AlignLeft)
-        self.menubar.setMinimumSize(self.width(), 25)
+        self.profile_button = MainMenuButton(Form)
-        self.menubar.setMaximumSize(self.width(), 25)
+        box.addWidget(self.profile_button)
-        self.menubar.setBaseSize(self.width(), 25)
+        self.settings_button = MainMenuButton(Form)
+        box.addWidget(self.settings_button)
+        self.plugins_button = MainMenuButton(Form)
+        box.addWidget(self.plugins_button)
+        self.about_button = MainMenuButton(Form)
+        box.addWidget(self.about_button)
+        box.setSpacing(0)
 
-        self.menuProfile = QtGui.QMenu(self.menubar)
+        self.menuProfile = QtWidgets.QMenu()
         self.menuProfile.setObjectName("menuProfile")
-        self.menuSettings = QtGui.QMenu(self.menubar)
+        self.menuSettings = QtWidgets.QMenu()
         self.menuSettings.setObjectName("menuSettings")
-        self.menuPlugins = QtGui.QMenu(self.menubar)
+        self.menuPlugins = QtWidgets.QMenu()
         self.menuPlugins.setObjectName("menuPlugins")
-        self.menuAbout = QtGui.QMenu(self.menubar)
+        self.menuAbout = QtWidgets.QMenu()
         self.menuAbout.setObjectName("menuAbout")
 
-        self.actionAdd_friend = QtGui.QAction(MainWindow)
+        self.actionAdd_friend = QtWidgets.QAction(Form)
         self.actionAdd_friend.setObjectName("actionAdd_friend")
-        self.actionprofilesettings = QtGui.QAction(MainWindow)
+        self.actionprofilesettings = QtWidgets.QAction(Form)
         self.actionprofilesettings.setObjectName("actionprofilesettings")
-        self.actionPrivacy_settings = QtGui.QAction(MainWindow)
+        self.actionPrivacy_settings = QtWidgets.QAction(Form)
         self.actionPrivacy_settings.setObjectName("actionPrivacy_settings")
-        self.actionInterface_settings = QtGui.QAction(MainWindow)
+        self.actionInterface_settings = QtWidgets.QAction(Form)
         self.actionInterface_settings.setObjectName("actionInterface_settings")
-        self.actionNotifications = QtGui.QAction(MainWindow)
+        self.actionNotifications = QtWidgets.QAction(Form)
         self.actionNotifications.setObjectName("actionNotifications")
-        self.actionNetwork = QtGui.QAction(MainWindow)
+        self.actionNetwork = QtWidgets.QAction(Form)
         self.actionNetwork.setObjectName("actionNetwork")
-        self.actionAbout_program = QtGui.QAction(MainWindow)
+        self.actionAbout_program = QtWidgets.QAction(Form)
         self.actionAbout_program.setObjectName("actionAbout_program")
-        self.actionSettings = QtGui.QAction(MainWindow)
+        self.updateSettings = QtWidgets.QAction(Form)
+        self.actionSettings = QtWidgets.QAction(Form)
         self.actionSettings.setObjectName("actionSettings")
-        self.audioSettings = QtGui.QAction(MainWindow)
+        self.audioSettings = QtWidgets.QAction(Form)
-        self.pluginData = QtGui.QAction(MainWindow)
+        self.pluginData = QtWidgets.QAction(Form)
-        self.importPlugin = QtGui.QAction(MainWindow)
+        self.importPlugin = QtWidgets.QAction(Form)
-        self.lockApp = QtGui.QAction(MainWindow)
+        self.reloadPlugins = QtWidgets.QAction(Form)
+        self.lockApp = QtWidgets.QAction(Form)
         self.menuProfile.addAction(self.actionAdd_friend)
         self.menuProfile.addAction(self.actionSettings)
         self.menuProfile.addAction(self.lockApp)
@@ -66,13 +75,16 @@ class MainWindow(QtGui.QMainWindow, Singleton):
         self.menuSettings.addAction(self.actionNotifications)
         self.menuSettings.addAction(self.actionNetwork)
         self.menuSettings.addAction(self.audioSettings)
+        self.menuSettings.addAction(self.updateSettings)
         self.menuPlugins.addAction(self.pluginData)
         self.menuPlugins.addAction(self.importPlugin)
+        self.menuPlugins.addAction(self.reloadPlugins)
         self.menuAbout.addAction(self.actionAbout_program)
-        self.menubar.addAction(self.menuProfile.menuAction())
+
-        self.menubar.addAction(self.menuSettings.menuAction())
+        self.profile_button.setMenu(self.menuProfile)
-        self.menubar.addAction(self.menuPlugins.menuAction())
+        self.settings_button.setMenu(self.menuSettings)
-        self.menubar.addAction(self.menuAbout.menuAction())
+        self.plugins_button.setMenu(self.menuPlugins)
+        self.about_button.setMenu(self.menuAbout)
 
         self.actionAbout_program.triggered.connect(self.about_program)
         self.actionNetwork.triggered.connect(self.network_settings)
@@ -82,10 +94,14 @@ class MainWindow(QtGui.QMainWindow, Singleton):
         self.actionInterface_settings.triggered.connect(self.interface_settings)
         self.actionNotifications.triggered.connect(self.notification_settings)
         self.audioSettings.triggered.connect(self.audio_settings)
+        self.updateSettings.triggered.connect(self.update_settings)
         self.pluginData.triggered.connect(self.plugins_menu)
         self.lockApp.triggered.connect(self.lock_app)
         self.importPlugin.triggered.connect(self.import_plugin)
-        QtCore.QMetaObject.connectSlotsByName(MainWindow)
+        self.reloadPlugins.triggered.connect(self.reload_plugins)
+
+        Form.setLayout(box)
+        QtCore.QMetaObject.connectSlotsByName(Form)
 
     def languageChange(self, *args, **kwargs):
         self.retranslateUi()
@@ -97,29 +113,37 @@ class MainWindow(QtGui.QMainWindow, Singleton):
         return super(MainWindow, self).event(event)
 
     def retranslateUi(self):
-        self.lockApp.setText(QtGui.QApplication.translate("MainWindow", "Lock", None, QtGui.QApplication.UnicodeUTF8))
+        self.lockApp.setText(QtWidgets.QApplication.translate("MainWindow", "Lock"))
-        self.menuPlugins.setTitle(QtGui.QApplication.translate("MainWindow", "Plugins", None, QtGui.QApplication.UnicodeUTF8))
+        self.plugins_button.setText(QtWidgets.QApplication.translate("MainWindow", "Plugins"))
-        self.pluginData.setText(QtGui.QApplication.translate("MainWindow", "List of plugins", None, QtGui.QApplication.UnicodeUTF8))
+        self.pluginData.setText(QtWidgets.QApplication.translate("MainWindow", "List of plugins"))
-        self.menuProfile.setTitle(QtGui.QApplication.translate("MainWindow", "Profile", None, QtGui.QApplication.UnicodeUTF8))
+        self.profile_button.setText(QtWidgets.QApplication.translate("MainWindow", "Profile"))
-        self.menuSettings.setTitle(QtGui.QApplication.translate("MainWindow", "Settings", None, QtGui.QApplication.UnicodeUTF8))
+        self.settings_button.setText(QtWidgets.QApplication.translate("MainWindow", "Settings"))
-        self.menuAbout.setTitle(QtGui.QApplication.translate("MainWindow", "About", None, QtGui.QApplication.UnicodeUTF8))
+        self.about_button.setText(QtWidgets.QApplication.translate("MainWindow", "About"))
-        self.actionAdd_friend.setText(QtGui.QApplication.translate("MainWindow", "Add contact", None, QtGui.QApplication.UnicodeUTF8))
+        self.actionAdd_friend.setText(QtWidgets.QApplication.translate("MainWindow", "Add contact"))
-        self.actionprofilesettings.setText(QtGui.QApplication.translate("MainWindow", "Profile", None, QtGui.QApplication.UnicodeUTF8))
+        self.actionprofilesettings.setText(QtWidgets.QApplication.translate("MainWindow", "Profile"))
-        self.actionPrivacy_settings.setText(QtGui.QApplication.translate("MainWindow", "Privacy", None, QtGui.QApplication.UnicodeUTF8))
+        self.actionPrivacy_settings.setText(QtWidgets.QApplication.translate("MainWindow", "Privacy"))
-        self.actionInterface_settings.setText(QtGui.QApplication.translate("MainWindow", "Interface", None, QtGui.QApplication.UnicodeUTF8))
+        self.actionInterface_settings.setText(QtWidgets.QApplication.translate("MainWindow", "Interface"))
-        self.actionNotifications.setText(QtGui.QApplication.translate("MainWindow", "Notifications", None, QtGui.QApplication.UnicodeUTF8))
+        self.actionNotifications.setText(QtWidgets.QApplication.translate("MainWindow", "Notifications"))
-        self.actionNetwork.setText(QtGui.QApplication.translate("MainWindow", "Network", None, QtGui.QApplication.UnicodeUTF8))
+        self.actionNetwork.setText(QtWidgets.QApplication.translate("MainWindow", "Network"))
-        self.actionAbout_program.setText(QtGui.QApplication.translate("MainWindow", "About program", None, QtGui.QApplication.UnicodeUTF8))
+        self.actionAbout_program.setText(QtWidgets.QApplication.translate("MainWindow", "About program"))
-        self.actionSettings.setText(QtGui.QApplication.translate("MainWindow", "Settings", None, QtGui.QApplication.UnicodeUTF8))
+        self.actionSettings.setText(QtWidgets.QApplication.translate("MainWindow", "Settings"))
-        self.audioSettings.setText(QtGui.QApplication.translate("MainWindow", "Audio", None, QtGui.QApplication.UnicodeUTF8))
+        self.audioSettings.setText(QtWidgets.QApplication.translate("MainWindow", "Audio"))
-        self.contact_name.setPlaceholderText(QtGui.QApplication.translate("MainWindow", "Search", None, QtGui.QApplication.UnicodeUTF8))
+        self.updateSettings.setText(QtWidgets.QApplication.translate("MainWindow", "Updates"))
-        self.sendMessageButton.setToolTip(QtGui.QApplication.translate("MainWindow", "Send message", None, QtGui.QApplication.UnicodeUTF8))
+        self.contact_name.setPlaceholderText(QtWidgets.QApplication.translate("MainWindow", "Search"))
-        self.callButton.setToolTip(QtGui.QApplication.translate("MainWindow", "Start audio call with friend", None, QtGui.QApplication.UnicodeUTF8))
+        self.sendMessageButton.setToolTip(QtWidgets.QApplication.translate("MainWindow", "Send message"))
+        self.callButton.setToolTip(QtWidgets.QApplication.translate("MainWindow", "Start audio call with friend"))
         self.online_contacts.clear()
-        self.online_contacts.addItem(QtGui.QApplication.translate("MainWindow", "All", None, QtGui.QApplication.UnicodeUTF8))
+        self.online_contacts.addItem(QtWidgets.QApplication.translate("MainWindow", "All"))
-        self.online_contacts.addItem(QtGui.QApplication.translate("MainWindow", "Online", None, QtGui.QApplication.UnicodeUTF8))
+        self.online_contacts.addItem(QtWidgets.QApplication.translate("MainWindow", "Online"))
-        self.online_contacts.setCurrentIndex(int(Settings.get_instance()['show_online_friends']))
+        self.online_contacts.addItem(QtWidgets.QApplication.translate("MainWindow", "Online first"))
-        self.importPlugin.setText(QtGui.QApplication.translate("MainWindow", "Import plugin", None, QtGui.QApplication.UnicodeUTF8))
+        self.online_contacts.addItem(QtWidgets.QApplication.translate("MainWindow", "Name"))
+        self.online_contacts.addItem(QtWidgets.QApplication.translate("MainWindow", "Online and by name"))
+        self.online_contacts.addItem(QtWidgets.QApplication.translate("MainWindow", "Online first and by name"))
+        ind = Settings.get_instance()['sorting']
+        d = {0: 0, 1: 1, 2: 2, 3: 4, 1 | 4: 4, 2 | 4: 5}
+        self.online_contacts.setCurrentIndex(d[ind])
+        self.importPlugin.setText(QtWidgets.QApplication.translate("MainWindow", "Import plugin"))
+        self.reloadPlugins.setText(QtWidgets.QApplication.translate("MainWindow", "Reload plugins"))
 
     def setup_right_bottom(self, Form):
         Form.resize(650, 60)
@@ -127,11 +151,11 @@ class MainWindow(QtGui.QMainWindow, Singleton):
         self.messageEdit.setGeometry(QtCore.QRect(0, 3, 450, 55))
         self.messageEdit.setObjectName("messageEdit")
         font = QtGui.QFont()
-        font.setPointSize(10)
+        font.setPointSize(11)
         font.setFamily(settings.Settings.get_instance()['font'])
         self.messageEdit.setFont(font)
 
-        self.sendMessageButton = QtGui.QPushButton(Form)
+        self.sendMessageButton = QtWidgets.QPushButton(Form)
         self.sendMessageButton.setGeometry(QtCore.QRect(565, 3, 60, 55))
         self.sendMessageButton.setObjectName("sendMessageButton")
 
@@ -154,7 +178,7 @@ class MainWindow(QtGui.QMainWindow, Singleton):
 
     def setup_left_center_menu(self, Form):
         Form.resize(270, 25)
-        self.search_label = QtGui.QLabel(Form)
+        self.search_label = QtWidgets.QLabel(Form)
         self.search_label.setGeometry(QtCore.QRect(3, 2, 20, 20))
         pixmap = QtGui.QPixmap()
         pixmap.load(curr_directory() + '/images/search.png')
@@ -166,7 +190,7 @@ class MainWindow(QtGui.QMainWindow, Singleton):
         self.contact_name.setObjectName("contact_name")
         self.contact_name.textChanged.connect(self.filtering)
 
-        self.online_contacts = QtGui.QComboBox(Form)
+        self.online_contacts = ComboBox(Form)
         self.online_contacts.setGeometry(QtCore.QRect(150, 0, 120, 25))
         self.online_contacts.activated[int].connect(lambda x: self.filtering())
         self.search_label.raise_()
@@ -175,15 +199,15 @@ class MainWindow(QtGui.QMainWindow, Singleton):
 
     def setup_left_top(self, Form):
         Form.setCursor(QtCore.Qt.PointingHandCursor)
-        Form.setMinimumSize(QtCore.QSize(270, 100))
+        Form.setMinimumSize(QtCore.QSize(270, 75))
-        Form.setMaximumSize(QtCore.QSize(270, 100))
+        Form.setMaximumSize(QtCore.QSize(270, 75))
-        Form.setBaseSize(QtCore.QSize(270, 100))
+        Form.setBaseSize(QtCore.QSize(270, 75))
-        self.avatar_label = Form.avatar_label = QtGui.QLabel(Form)
+        self.avatar_label = Form.avatar_label = QtWidgets.QLabel(Form)
-        self.avatar_label.setGeometry(QtCore.QRect(5, 30, 64, 64))
+        self.avatar_label.setGeometry(QtCore.QRect(5, 5, 64, 64))
         self.avatar_label.setScaledContents(False)
         self.avatar_label.setAlignment(QtCore.Qt.AlignCenter)
         self.name = Form.name = DataLabel(Form)
-        Form.name.setGeometry(QtCore.QRect(75, 40, 150, 25))
+        Form.name.setGeometry(QtCore.QRect(75, 15, 150, 25))
         font = QtGui.QFont()
         font.setFamily(settings.Settings.get_instance()['font'])
         font.setPointSize(14)
@@ -191,13 +215,13 @@ class MainWindow(QtGui.QMainWindow, Singleton):
         Form.name.setFont(font)
         Form.name.setObjectName("name")
         self.status_message = Form.status_message = DataLabel(Form)
-        Form.status_message.setGeometry(QtCore.QRect(75, 60, 170, 25))
+        Form.status_message.setGeometry(QtCore.QRect(75, 35, 170, 25))
         font.setPointSize(12)
         font.setBold(False)
         Form.status_message.setFont(font)
         Form.status_message.setObjectName("status_message")
         self.connection_status = Form.connection_status = StatusCircle(Form)
-        Form.connection_status.setGeometry(QtCore.QRect(230, 35, 32, 32))
+        Form.connection_status.setGeometry(QtCore.QRect(230, 10, 32, 32))
         self.avatar_label.mouseReleaseEvent = self.profile_settings
         self.status_message.mouseReleaseEvent = self.profile_settings
         self.name.mouseReleaseEvent = self.profile_settings
@@ -205,12 +229,12 @@ class MainWindow(QtGui.QMainWindow, Singleton):
         Form.connection_status.setObjectName("connection_status")
 
     def setup_right_top(self, Form):
-        Form.resize(650, 100)
+        Form.resize(650, 75)
-        self.account_avatar = QtGui.QLabel(Form)
+        self.account_avatar = QtWidgets.QLabel(Form)
-        self.account_avatar.setGeometry(QtCore.QRect(10, 30, 64, 64))
+        self.account_avatar.setGeometry(QtCore.QRect(10, 5, 64, 64))
         self.account_avatar.setScaledContents(False)
         self.account_name = DataLabel(Form)
-        self.account_name.setGeometry(QtCore.QRect(100, 25, 400, 25))
+        self.account_name.setGeometry(QtCore.QRect(100, 0, 400, 25))
         self.account_name.setTextInteractionFlags(QtCore.Qt.LinksAccessibleByMouse)
         font = QtGui.QFont()
         font.setFamily(settings.Settings.get_instance()['font'])
@@ -219,23 +243,23 @@ class MainWindow(QtGui.QMainWindow, Singleton):
         self.account_name.setFont(font)
         self.account_name.setObjectName("account_name")
         self.account_status = DataLabel(Form)
-        self.account_status.setGeometry(QtCore.QRect(100, 45, 400, 25))
+        self.account_status.setGeometry(QtCore.QRect(100, 20, 400, 25))
         self.account_status.setTextInteractionFlags(QtCore.Qt.LinksAccessibleByMouse)
         font.setPointSize(12)
         font.setBold(False)
         self.account_status.setFont(font)
         self.account_status.setObjectName("account_status")
-        self.callButton = QtGui.QPushButton(Form)
+        self.callButton = QtWidgets.QPushButton(Form)
-        self.callButton.setGeometry(QtCore.QRect(550, 30, 50, 50))
+        self.callButton.setGeometry(QtCore.QRect(550, 5, 50, 50))
         self.callButton.setObjectName("callButton")
         self.callButton.clicked.connect(lambda: self.profile.call_click(True))
-        self.videocallButton = QtGui.QPushButton(Form)
+        self.videocallButton = QtWidgets.QPushButton(Form)
-        self.videocallButton.setGeometry(QtCore.QRect(550, 30, 50, 50))
+        self.videocallButton.setGeometry(QtCore.QRect(550, 5, 50, 50))
         self.videocallButton.setObjectName("videocallButton")
         self.videocallButton.clicked.connect(lambda: self.profile.call_click(True, True))
         self.update_call_state('call')
-        self.typing = QtGui.QLabel(Form)
+        self.typing = QtWidgets.QLabel(Form)
-        self.typing.setGeometry(QtCore.QRect(500, 50, 50, 30))
+        self.typing.setGeometry(QtCore.QRect(500, 25, 50, 30))
         pixmap = QtGui.QPixmap(QtCore.QSize(50, 30))
         pixmap.load(curr_directory() + '/images/typing.png')
         self.typing.setScaledContents(False)
@@ -244,31 +268,34 @@ class MainWindow(QtGui.QMainWindow, Singleton):
         QtCore.QMetaObject.connectSlotsByName(Form)
 
     def setup_left_center(self, widget):
-        self.friends_list = QtGui.QListWidget(widget)
+        self.friends_list = QtWidgets.QListWidget(widget)
         self.friends_list.setObjectName("friends_list")
         self.friends_list.setGeometry(0, 0, 270, 310)
         self.friends_list.clicked.connect(self.friend_click)
         self.friends_list.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
-        self.friends_list.connect(self.friends_list, QtCore.SIGNAL("customContextMenuRequested(QPoint)"),
+        self.friends_list.customContextMenuRequested.connect(self.friend_right_click)
-                                  self.friend_right_click)
+        self.friends_list.setVerticalScrollMode(QtWidgets.QAbstractItemView.ScrollPerPixel)
-        self.friends_list.setVerticalScrollMode(QtGui.QAbstractItemView.ScrollPerPixel)
+        self.friends_list.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOn)
+        self.friends_list.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
+        self.friends_list.verticalScrollBar().setContextMenuPolicy(QtCore.Qt.NoContextMenu)
 
     def setup_right_center(self, widget):
-        self.messages = QtGui.QListWidget(widget)
+        self.messages = QtWidgets.QListWidget(widget)
         self.messages.setGeometry(0, 0, 620, 310)
         self.messages.setObjectName("messages")
         self.messages.setSpacing(1)
         self.messages.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOn)
         self.messages.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
-        # self.messages.setFocusPolicy(QtCore.Qt.NoFocus)
+        self.messages.focusOutEvent = lambda event: self.messages.clearSelection()
+        self.messages.verticalScrollBar().setContextMenuPolicy(QtCore.Qt.NoContextMenu)
 
         def load(pos):
             if not pos:
                 self.profile.load_history()
                 self.messages.verticalScrollBar().setValue(1)
         self.messages.verticalScrollBar().valueChanged.connect(load)
-        self.messages.setVerticalScrollMode(QtGui.QAbstractItemView.ScrollPerPixel)
+        self.messages.setVerticalScrollMode(QtWidgets.QAbstractItemView.ScrollPerPixel)
-        self.messages.setSelectionMode(QtGui.QAbstractItemView.ExtendedSelection)
+        self.messages.setSelectionMode(QtWidgets.QAbstractItemView.ExtendedSelection)
 
     def initUI(self, tox):
         self.setMinimumSize(920, 500)
@@ -276,49 +303,53 @@ class MainWindow(QtGui.QMainWindow, Singleton):
         self.setGeometry(s['x'], s['y'], s['width'], s['height'])
         self.setWindowTitle('Toxygen')
         os.chdir(curr_directory() + '/images/')
-        main = QtGui.QWidget()
+        menu = QtWidgets.QWidget()
-        grid = QtGui.QGridLayout()
+        main = QtWidgets.QWidget()
-        search = QtGui.QWidget()
+        grid = QtWidgets.QGridLayout()
-        name = QtGui.QWidget()
+        search = QtWidgets.QWidget()
-        info = QtGui.QWidget()
+        name = QtWidgets.QWidget()
-        main_list = QtGui.QWidget()
+        info = QtWidgets.QWidget()
-        messages = QtGui.QWidget()
+        main_list = QtWidgets.QWidget()
-        message_buttons = QtGui.QWidget()
+        messages = QtWidgets.QWidget()
+        message_buttons = QtWidgets.QWidget()
         self.setup_left_center_menu(search)
         self.setup_left_top(name)
         self.setup_right_center(messages)
         self.setup_right_top(info)
         self.setup_right_bottom(message_buttons)
         self.setup_left_center(main_list)
+        self.setup_menu(menu)
         if not Settings.get_instance()['mirror_mode']:
-            grid.addWidget(search, 1, 0)
+            grid.addWidget(search, 2, 0)
-            grid.addWidget(name, 0, 0)
+            grid.addWidget(name, 1, 0)
-            grid.addWidget(messages, 1, 1, 2, 1)
+            grid.addWidget(messages, 2, 1, 2, 1)
-            grid.addWidget(info, 0, 1)
+            grid.addWidget(info, 1, 1)
-            grid.addWidget(message_buttons, 3, 1)
+            grid.addWidget(message_buttons, 4, 1)
-            grid.addWidget(main_list, 2, 0, 2, 1)
+            grid.addWidget(main_list, 3, 0, 2, 1)
             grid.setColumnMinimumWidth(1, 500)
             grid.setColumnMinimumWidth(0, 270)
         else:
-            grid.addWidget(search, 1, 1)
+            grid.addWidget(search, 2, 1)
-            grid.addWidget(name, 0, 1)
+            grid.addWidget(name, 1, 1)
-            grid.addWidget(messages, 1, 0, 2, 1)
+            grid.addWidget(messages, 2, 0, 2, 1)
-            grid.addWidget(info, 0, 0)
+            grid.addWidget(info, 1, 0)
-            grid.addWidget(message_buttons, 3, 0)
+            grid.addWidget(message_buttons, 4, 0)
-            grid.addWidget(main_list, 2, 1, 2, 1)
+            grid.addWidget(main_list, 3, 1, 2, 1)
             grid.setColumnMinimumWidth(0, 500)
             grid.setColumnMinimumWidth(1, 270)
+
+        grid.addWidget(menu, 0, 0, 1, 2)
         grid.setSpacing(0)
         grid.setContentsMargins(0, 0, 0, 0)
-        grid.setRowMinimumHeight(0, 100)
+        grid.setRowMinimumHeight(0, 25)
-        grid.setRowMinimumHeight(1, 25)
+        grid.setRowMinimumHeight(1, 75)
-        grid.setRowMinimumHeight(2, 320)
+        grid.setRowMinimumHeight(2, 25)
-        grid.setRowMinimumHeight(3, 55)
+        grid.setRowMinimumHeight(3, 320)
+        grid.setRowMinimumHeight(4, 55)
         grid.setColumnStretch(1, 1)
-        grid.setRowStretch(2, 1)
+        grid.setRowStretch(3, 1)
         main.setLayout(grid)
         self.setCentralWidget(main)
-        self.setup_menu(self)
         self.messageEdit.setFocus()
         self.user_info = name
         self.friend_info = info
@@ -328,47 +359,59 @@ class MainWindow(QtGui.QMainWindow, Singleton):
     def closeEvent(self, event):
         s = Settings.get_instance()
         if not s['close_to_tray'] or s.closing:
-            self.profile.save_history()
+            if not self._saved:
-            self.profile.close()
+                self._saved = True
-            s['x'] = self.geometry().x()
+                self.profile.save_history()
-            s['y'] = self.geometry().y()
+                self.profile.close()
-            s['width'] = self.width()
+                s['x'] = self.geometry().x()
-            s['height'] = self.height()
+                s['y'] = self.geometry().y()
-            s.save()
+                s['width'] = self.width()
-            QtGui.QApplication.closeAllWindows()
+                s['height'] = self.height()
-            event.accept()
+                s.save()
-        else:
+                QtWidgets.QApplication.closeAllWindows()
+                event.accept()
+        elif QtWidgets.QSystemTrayIcon.isSystemTrayAvailable():
             event.ignore()
             self.hide()
 
-    def resizeEvent(self, *args, **kwargs):
+    def close_window(self):
-        self.messages.setGeometry(0, 0, self.width() - 270, self.height() - 155)
+        Settings.get_instance().closing = True
-        self.friends_list.setGeometry(0, 0, 270, self.height() - 125)
+        self.close()
 
-        self.videocallButton.setGeometry(QtCore.QRect(self.width() - 330, 40, 50, 50))
+    def resizeEvent(self, *args, **kwargs):
-        self.callButton.setGeometry(QtCore.QRect(self.width() - 390, 40, 50, 50))
+        if platform.system() == 'Windows':
-        self.typing.setGeometry(QtCore.QRect(self.width() - 450, 50, 50, 30))
+            self.messages.setGeometry(0, 0, self.width() - 270, self.height() - 155)
+            self.friends_list.setGeometry(0, 0, 270, self.height() - 125)
+        else:
+            self.messages.setGeometry(0, 0, self.width() - 270, self.height() - 159)
+            self.friends_list.setGeometry(0, 0, 270, self.height() - 129)
+
+        self.videocallButton.setGeometry(QtCore.QRect(self.width() - 330, 10, 50, 50))
+        self.callButton.setGeometry(QtCore.QRect(self.width() - 390, 10, 50, 50))
+        self.typing.setGeometry(QtCore.QRect(self.width() - 450, 20, 50, 30))
 
         self.messageEdit.setGeometry(QtCore.QRect(55, 0, self.width() - 395, 55))
         self.menuButton.setGeometry(QtCore.QRect(0, 0, 55, 55))
         self.sendMessageButton.setGeometry(QtCore.QRect(self.width() - 340, 0, 70, 55))
 
-        self.account_name.setGeometry(QtCore.QRect(100, 40, self.width() - 560, 25))
+        self.account_name.setGeometry(QtCore.QRect(100, 15, self.width() - 560, 25))
-        self.account_status.setGeometry(QtCore.QRect(100, 60, self.width() - 560, 25))
+        self.account_status.setGeometry(QtCore.QRect(100, 35, self.width() - 560, 25))
         self.messageEdit.setFocus()
         self.profile.update()
 
     def keyPressEvent(self, event):
-        if event.key() == QtCore.Qt.Key_Escape:
+        if event.key() == QtCore.Qt.Key_Escape and QtWidgets.QSystemTrayIcon.isSystemTrayAvailable():
             self.hide()
         elif event.key() == QtCore.Qt.Key_C and event.modifiers() & QtCore.Qt.ControlModifier and self.messages.selectedIndexes():
             rows = list(map(lambda x: self.messages.row(x), self.messages.selectedItems()))
             indexes = (rows[0] - self.messages.count(), rows[-1] - self.messages.count())
             s = self.profile.export_history(self.profile.active_friend, True, indexes)
-            clipboard = QtGui.QApplication.clipboard()
+            clipboard = QtWidgets.QApplication.clipboard()
             clipboard.setText(s)
         elif event.key() == QtCore.Qt.Key_Z and event.modifiers() & QtCore.Qt.ControlModifier and self.messages.selectedIndexes():
             self.messages.clearSelection()
+        elif event.key() == QtCore.Qt.Key_F and event.modifiers() & QtCore.Qt.ControlModifier:
+            self.show_search_field()
         else:
             super(MainWindow, self).keyPressEvent(event)
 
@@ -378,9 +421,9 @@ class MainWindow(QtGui.QMainWindow, Singleton):
 
     def about_program(self):
         import util
-        msgBox = QtGui.QMessageBox()
+        msgBox = QtWidgets.QMessageBox()
-        msgBox.setWindowTitle(QtGui.QApplication.translate("MainWindow", "About", None, QtGui.QApplication.UnicodeUTF8))
+        msgBox.setWindowTitle(QtWidgets.QApplication.translate("MainWindow", "About"))
-        text = (QtGui.QApplication.translate("MainWindow", 'Toxygen is Tox client written on Python.\nVersion: ', None, QtGui.QApplication.UnicodeUTF8))
+        text = (QtWidgets.QApplication.translate("MainWindow", 'Toxygen is Tox client written on Python.\nVersion: '))
         msgBox.setText(text + util.program_version + '\nGitHub: https://github.com/toxygen-project/toxygen/')
         msgBox.exec_()
 
@@ -416,37 +459,42 @@ class MainWindow(QtGui.QMainWindow, Singleton):
         self.audio_s = AudioSettings()
         self.audio_s.show()
 
+    def update_settings(self):
+        self.update_s = UpdateSettings()
+        self.update_s.show()
+
+    def reload_plugins(self):
+        plugin_loader = plugin_support.PluginLoader.get_instance()
+        if plugin_loader is not None:
+            plugin_loader.reload()
+
     def import_plugin(self):
         import util
-        directory = QtGui.QFileDialog.getExistingDirectory(self,
+        directory = QtWidgets.QFileDialog.getExistingDirectory(self,
-                                                           QtGui.QApplication.translate("MainWindow", 'Choose folder with plugin',
+                                                           QtWidgets.QApplication.translate("MainWindow", 'Choose folder with plugin'),
-                                                                                        None,
-                                                                                        QtGui.QApplication.UnicodeUTF8),
                                                            util.curr_directory(),
-                                                           QtGui.QFileDialog.ShowDirsOnly | QtGui.QFileDialog.DontUseNativeDialog)
+                                                           QtWidgets.QFileDialog.ShowDirsOnly | QtWidgets.QFileDialog.DontUseNativeDialog)
         if directory:
             src = directory + '/'
             dest = curr_directory() + '/plugins/'
             util.copy(src, dest)
-            msgBox = QtGui.QMessageBox()
+            msgBox = QtWidgets.QMessageBox()
             msgBox.setWindowTitle(
-                QtGui.QApplication.translate("MainWindow", "Restart Toxygen", None, QtGui.QApplication.UnicodeUTF8))
+                QtWidgets.QApplication.translate("MainWindow", "Restart Toxygen"))
             msgBox.setText(
-                QtGui.QApplication.translate("MainWindow", 'Plugin will be loaded after restart', None,
+                QtWidgets.QApplication.translate("MainWindow", 'Plugin will be loaded after restart'))
-                                             QtGui.QApplication.UnicodeUTF8))
             msgBox.exec_()
 
     def lock_app(self):
-        if toxencryptsave.ToxEncryptSave.get_instance().has_password():
+        if toxes.ToxES.get_instance().has_password():
             Settings.get_instance().locked = True
             self.hide()
         else:
-            msgBox = QtGui.QMessageBox()
+            msgBox = QtWidgets.QMessageBox()
             msgBox.setWindowTitle(
-                QtGui.QApplication.translate("MainWindow", "Cannot lock app", None, QtGui.QApplication.UnicodeUTF8))
+                QtWidgets.QApplication.translate("MainWindow", "Cannot lock app"))
             msgBox.setText(
-                QtGui.QApplication.translate("MainWindow", 'Error. Profile password is not set.', None,
+                QtWidgets.QApplication.translate("MainWindow", 'Error. Profile password is not set.'))
-                                             QtGui.QApplication.UnicodeUTF8))
             msgBox.exec_()
 
     def show_menu(self):
@@ -469,8 +517,8 @@ class MainWindow(QtGui.QMainWindow, Singleton):
     def send_file(self):
         self.menu.hide()
         if self.profile.active_friend + 1:
-            choose = QtGui.QApplication.translate("MainWindow", 'Choose file', None, QtGui.QApplication.UnicodeUTF8)
+            choose = QtWidgets.QApplication.translate("MainWindow", 'Choose file')
-            name = QtGui.QFileDialog.getOpenFileName(self, choose, options=QtGui.QFileDialog.DontUseNativeDialog)
+            name = QtWidgets.QFileDialog.getOpenFileName(self, choose, options=QtWidgets.QFileDialog.DontUseNativeDialog)
             if name[0]:
                 self.profile.send_file(name[0])
 
@@ -497,9 +545,9 @@ class MainWindow(QtGui.QMainWindow, Singleton):
         if self.profile.active_friend + 1:
             self.sticker = StickerWindow(self)
             self.sticker.setGeometry(QtCore.QRect(self.x() if Settings.get_instance()['mirror_mode'] else 270 + self.x(),
-                                                 self.y() + self.height() - 200,
+                                                  self.y() + self.height() - 200,
-                                                 self.sticker.width(),
+                                                  self.sticker.width(),
-                                                 self.sticker.height()))
+                                                  self.sticker.height()))
             self.sticker.show()
 
     def active_call(self):
@@ -531,42 +579,47 @@ class MainWindow(QtGui.QMainWindow, Singleton):
         item = self.friends_list.itemAt(pos)
         num = self.friends_list.indexFromItem(item).row()
         friend = Profile.get_instance().get_friend(num)
+        if friend is None:
+            return
         settings = Settings.get_instance()
         allowed = friend.tox_id in settings['auto_accept_from_friends']
-        auto = QtGui.QApplication.translate("MainWindow", 'Disallow auto accept', None, QtGui.QApplication.UnicodeUTF8) if allowed else QtGui.QApplication.translate("MainWindow", 'Allow auto accept', None, QtGui.QApplication.UnicodeUTF8)
+        auto = QtWidgets.QApplication.translate("MainWindow", 'Disallow auto accept') if allowed else QtWidgets.QApplication.translate("MainWindow", 'Allow auto accept')
         if item is not None:
-            self.listMenu = QtGui.QMenu()
+            self.listMenu = QtWidgets.QMenu()
-            set_alias_item = self.listMenu.addAction(QtGui.QApplication.translate("MainWindow", 'Set alias', None, QtGui.QApplication.UnicodeUTF8))
+            set_alias_item = self.listMenu.addAction(QtWidgets.QApplication.translate("MainWindow", 'Set alias'))
 
-            history_menu = self.listMenu.addMenu(QtGui.QApplication.translate("MainWindow", 'Chat history', None, QtGui.QApplication.UnicodeUTF8))
+            history_menu = self.listMenu.addMenu(QtWidgets.QApplication.translate("MainWindow", 'Chat history'))
-            clear_history_item = history_menu.addAction(QtGui.QApplication.translate("MainWindow", 'Clear history', None, QtGui.QApplication.UnicodeUTF8))
+            clear_history_item = history_menu.addAction(QtWidgets.QApplication.translate("MainWindow", 'Clear history'))
-            export_to_text_item = history_menu.addAction(QtGui.QApplication.translate("MainWindow", 'Export as text', None, QtGui.QApplication.UnicodeUTF8))
+            export_to_text_item = history_menu.addAction(QtWidgets.QApplication.translate("MainWindow", 'Export as text'))
-            export_to_html_item = history_menu.addAction(QtGui.QApplication.translate("MainWindow", 'Export as HTML', None, QtGui.QApplication.UnicodeUTF8))
+            export_to_html_item = history_menu.addAction(QtWidgets.QApplication.translate("MainWindow", 'Export as HTML'))
 
-            copy_menu = self.listMenu.addMenu(QtGui.QApplication.translate("MainWindow", 'Copy', None, QtGui.QApplication.UnicodeUTF8))
+            copy_menu = self.listMenu.addMenu(QtWidgets.QApplication.translate("MainWindow", 'Copy'))
-            copy_name_item = copy_menu.addAction(QtGui.QApplication.translate("MainWindow", 'Name', None, QtGui.QApplication.UnicodeUTF8))
+            copy_name_item = copy_menu.addAction(QtWidgets.QApplication.translate("MainWindow", 'Name'))
-            copy_status_item = copy_menu.addAction(QtGui.QApplication.translate("MainWindow", 'Status message', None, QtGui.QApplication.UnicodeUTF8))
+            copy_status_item = copy_menu.addAction(QtWidgets.QApplication.translate("MainWindow", 'Status message'))
-            copy_key_item = copy_menu.addAction(QtGui.QApplication.translate("MainWindow", 'Public key', None, QtGui.QApplication.UnicodeUTF8))
+            copy_key_item = copy_menu.addAction(QtWidgets.QApplication.translate("MainWindow", 'Public key'))
 
             auto_accept_item = self.listMenu.addAction(auto)
-            remove_item = self.listMenu.addAction(QtGui.QApplication.translate("MainWindow", 'Remove friend', None, QtGui.QApplication.UnicodeUTF8))
+            remove_item = self.listMenu.addAction(QtWidgets.QApplication.translate("MainWindow", 'Remove friend'))
-            notes_item = self.listMenu.addAction(QtGui.QApplication.translate("MainWindow", 'Notes', None, QtGui.QApplication.UnicodeUTF8))
+            block_item = self.listMenu.addAction(QtWidgets.QApplication.translate("MainWindow", 'Block friend'))
+            notes_item = self.listMenu.addAction(QtWidgets.QApplication.translate("MainWindow", 'Notes'))
 
-            submenu = plugin_support.PluginLoader.get_instance().get_menu(self.listMenu, num)
+            plugins_loader = plugin_support.PluginLoader.get_instance()
-            if len(submenu):
+            if plugins_loader is not None:
-                plug = self.listMenu.addMenu(QtGui.QApplication.translate("MainWindow", 'Plugins', None, QtGui.QApplication.UnicodeUTF8))
+                submenu = plugins_loader.get_menu(self.listMenu, num)
-                plug.addActions(submenu)
+                if len(submenu):
-            self.connect(set_alias_item, QtCore.SIGNAL("triggered()"), lambda: self.set_alias(num))
+                    plug = self.listMenu.addMenu(QtWidgets.QApplication.translate("MainWindow", 'Plugins'))
-            self.connect(remove_item, QtCore.SIGNAL("triggered()"), lambda: self.remove_friend(num))
+                    plug.addActions(submenu)
-            self.connect(copy_key_item, QtCore.SIGNAL("triggered()"), lambda: self.copy_friend_key(num))
+            set_alias_item.triggered.connect(lambda: self.set_alias(num))
-            self.connect(clear_history_item, QtCore.SIGNAL("triggered()"), lambda: self.clear_history(num))
+            remove_item.triggered.connect(lambda: self.remove_friend(num))
-            self.connect(auto_accept_item, QtCore.SIGNAL("triggered()"), lambda: self.auto_accept(num, not allowed))
+            block_item.triggered.connect(lambda: self.block_friend(num))
-            self.connect(notes_item, QtCore.SIGNAL("triggered()"), lambda: self.show_note(friend))
+            copy_key_item.triggered.connect(lambda: self.copy_friend_key(num))
-            self.connect(copy_name_item, QtCore.SIGNAL("triggered()"), lambda: self.copy_name(friend))
+            clear_history_item.triggered.connect(lambda: self.clear_history(num))
-            self.connect(copy_status_item, QtCore.SIGNAL("triggered()"), lambda: self.copy_status(friend))
+            auto_accept_item.triggered.connect(lambda: self.auto_accept(num, not allowed))
-            self.connect(export_to_text_item, QtCore.SIGNAL("triggered()"), lambda: self.export_history(num))
+            notes_item.triggered.connect(lambda: self.show_note(friend))
-            self.connect(export_to_html_item, QtCore.SIGNAL("triggered()"),
+            copy_name_item.triggered.connect(lambda: self.copy_name(friend))
-                         lambda: self.export_history(num, False))
+            copy_status_item.triggered.connect(lambda: self.copy_status(friend))
+            export_to_text_item.triggered.connect(lambda: self.export_history(num))
+            export_to_html_item.triggered.connect(lambda: self.export_history(num, False))
             parent_position = self.friends_list.mapToGlobal(QtCore.QPoint(0, 0))
             self.listMenu.move(parent_position + pos)
             self.listMenu.show()
@@ -574,7 +627,7 @@ class MainWindow(QtGui.QMainWindow, Singleton):
     def show_note(self, friend):
         s = Settings.get_instance()
         note = s['notes'][friend.tox_id] if friend.tox_id in s['notes'] else ''
-        user = QtGui.QApplication.translate("MainWindow", 'Notes about user', None, QtGui.QApplication.UnicodeUTF8)
+        user = QtWidgets.QApplication.translate("MainWindow", 'Notes about user')
         user = '{} {}'.format(user, friend.name)
 
         def save_note(text):
@@ -588,12 +641,11 @@ class MainWindow(QtGui.QMainWindow, Singleton):
 
     def export_history(self, num, as_text=True):
         s = self.profile.export_history(num, as_text)
-        directory = QtGui.QFileDialog.getExistingDirectory(None,
+        directory = QtWidgets.QFileDialog.getExistingDirectory(None,
-                                                           QtGui.QApplication.translate("MainWindow", 'Choose folder',
+                                                           QtWidgets.QApplication.translate("MainWindow",
-                                                                                        None,
+                                                                                            'Choose folder'),
-                                                                                        QtGui.QApplication.UnicodeUTF8),
                                                            curr_directory(),
-                                                           QtGui.QFileDialog.ShowDirsOnly | QtGui.QFileDialog.DontUseNativeDialog)
+                                                           QtWidgets.QFileDialog.ShowDirsOnly | QtWidgets.QFileDialog.DontUseNativeDialog)
 
         if directory:
             name = 'exported_history_{}.{}'.format(convert_time(time.time()), 'txt' if as_text else 'html')
@@ -606,17 +658,21 @@ class MainWindow(QtGui.QMainWindow, Singleton):
     def remove_friend(self, num):
         self.profile.delete_friend(num)
 
+    def block_friend(self, num):
+        friend = self.profile.get_friend(num)
+        self.profile.block_user(friend.tox_id)
+
     def copy_friend_key(self, num):
         tox_id = self.profile.friend_public_key(num)
-        clipboard = QtGui.QApplication.clipboard()
+        clipboard = QtWidgets.QApplication.clipboard()
         clipboard.setText(tox_id)
 
     def copy_name(self, friend):
-        clipboard = QtGui.QApplication.clipboard()
+        clipboard = QtWidgets.QApplication.clipboard()
         clipboard.setText(friend.name)
 
     def copy_status(self, friend):
-        clipboard = QtGui.QApplication.clipboard()
+        clipboard = QtWidgets.QApplication.clipboard()
         clipboard.setText(friend.status_message)
 
     def clear_history(self, num):
@@ -647,5 +703,22 @@ class MainWindow(QtGui.QMainWindow, Singleton):
         else:
             super(MainWindow, self).mouseReleaseEvent(event)
 
+    def show(self):
+        super().show()
+        self.profile.update()
+
     def filtering(self):
-        self.profile.filtration(self.online_contacts.currentIndex() == 1, self.contact_name.text())
+        ind = self.online_contacts.currentIndex()
+        d = {0: 0, 1: 1, 2: 2, 3: 4, 4: 1 | 4, 5: 2 | 4}
+        self.profile.filtration_and_sorting(d[ind], self.contact_name.text())
+
+    def show_search_field(self):
+        if hasattr(self, 'search_field') and self.search_field.isVisible():
+            return
+        if self.profile.get_curr_friend() is None:
+            return
+        self.search_field = SearchScreen(self.messages, self.messages.width(), self.messages.parent())
+        x, y = self.messages.x(), self.messages.y() + self.messages.height() - 40
+        self.search_field.setGeometry(x, y, self.messages.width(), 40)
+        self.messages.setGeometry(x, self.messages.y(), self.messages.width(), self.messages.height() - 40)
+        self.search_field.show()

toxygen/mainscreen_widgets.py

@@ -1,14 +1,11 @@
-try:
+from PyQt5 import QtCore, QtGui, QtWidgets
-    from PySide import QtCore, QtGui
+from widgets import RubberBand, create_menu, QRightClickButton, CenteredWidget, LineEdit
-except ImportError:
-    from PyQt4 import QtCore, QtGui
-from widgets import RubberBand, create_menu, QRightClickButton, CenteredWidget
 from profile import Profile
 import smileys
 import util
 
 
-class MessageArea(QtGui.QPlainTextEdit):
+class MessageArea(QtWidgets.QPlainTextEdit):
     """User types messages here"""
 
     def __init__(self, parent, form):
@@ -20,7 +17,7 @@ class MessageArea(QtGui.QPlainTextEdit):
 
     def keyPressEvent(self, event):
         if event.matches(QtGui.QKeySequence.Paste):
-            mimeData = QtGui.QApplication.clipboard().mimeData()
+            mimeData = QtWidgets.QApplication.clipboard().mimeData()
             if mimeData.hasUrls():
                 for url in mimeData.urls():
                     self.pasteEvent(url.toString())
@@ -67,14 +64,14 @@ class MessageArea(QtGui.QPlainTextEdit):
             e.ignore()
 
     def pasteEvent(self, text=None):
-        text = text or QtGui.QApplication.clipboard().text()
+        text = text or QtWidgets.QApplication.clipboard().text()
         if text.startswith('file://'):
             self.parent.profile.send_file(text[7:])
         else:
             self.insertPlainText(text)
 
 
-class ScreenShotWindow(QtGui.QWidget):
+class ScreenShotWindow(QtWidgets.QWidget):
 
     def __init__(self, parent):
         super(ScreenShotWindow, self).__init__()
@@ -84,6 +81,8 @@ class ScreenShotWindow(QtGui.QWidget):
         self.showFullScreen()
         self.setWindowOpacity(0.5)
         self.rubberband = RubberBand()
+        self.rubberband.setWindowFlags(self.rubberband.windowFlags() | QtCore.Qt.FramelessWindowHint)
+        self.rubberband.setAttribute(QtCore.Qt.WA_TranslucentBackground)
 
     def closeEvent(self, *args):
         if self.parent.isHidden():
@@ -93,7 +92,7 @@ class ScreenShotWindow(QtGui.QWidget):
         self.origin = event.pos()
         self.rubberband.setGeometry(QtCore.QRect(self.origin, QtCore.QSize()))
         self.rubberband.show()
-        QtGui.QWidget.mousePressEvent(self, event)
+        QtWidgets.QWidget.mousePressEvent(self, event)
 
     def mouseMoveEvent(self, event):
         if self.rubberband.isVisible():
@@ -109,11 +108,12 @@ class ScreenShotWindow(QtGui.QWidget):
             self.rubberband.hide()
             rect = self.rubberband.geometry()
             if rect.width() and rect.height():
-                p = QtGui.QPixmap.grabWindow(QtGui.QApplication.desktop().winId(),
+                screen = QtWidgets.QApplication.primaryScreen()
-                                             rect.x() + 4,
+                p = screen.grabWindow(0,
-                                             rect.y() + 4,
+                                      rect.x() + 4,
-                                             rect.width() - 8,
+                                      rect.y() + 4,
-                                             rect.height() - 8)
+                                      rect.width() - 8,
+                                      rect.height() - 8)
                 byte_array = QtCore.QByteArray()
                 buffer = QtCore.QBuffer(byte_array)
                 buffer.open(QtCore.QIODevice.WriteOnly)
@@ -129,7 +129,7 @@ class ScreenShotWindow(QtGui.QWidget):
             super(ScreenShotWindow, self).keyPressEvent(event)
 
 
-class SmileyWindow(QtGui.QWidget):
+class SmileyWindow(QtWidgets.QWidget):
     """
     Smiley selection window
     """
@@ -151,7 +151,7 @@ class SmileyWindow(QtGui.QWidget):
         self.radio = []
         self.parent = parent
         for i in range(self.page_count):  # buttons with smileys
-            elem = QtGui.QRadioButton(self)
+            elem = QtWidgets.QRadioButton(self)
             elem.setGeometry(QtCore.QRect(i * 20 + 5, 180, 20, 20))
             elem.clicked.connect(lambda i=i: self.checked(i))
             self.radio.append(elem)
@@ -160,7 +160,7 @@ class SmileyWindow(QtGui.QWidget):
         self.setMinimumSize(width, 200)
         self.buttons = []
         for i in range(self.page_size):  # pages - radio buttons
-            b = QtGui.QPushButton(self)
+            b = QtWidgets.QPushButton(self)
             b.setGeometry(QtCore.QRect((i // 8) * 20 + 5, (i % 8) * 20, 20, 20))
             b.clicked.connect(lambda i=i: self.clicked(i))
             self.buttons.append(b)
@@ -190,7 +190,7 @@ class SmileyWindow(QtGui.QWidget):
         self.close()
 
 
-class MenuButton(QtGui.QPushButton):
+class MenuButton(QtWidgets.QPushButton):
 
     def __init__(self, parent, enter):
         super(MenuButton, self).__init__(parent)
@@ -201,7 +201,7 @@ class MenuButton(QtGui.QPushButton):
         super(MenuButton, self).enterEvent(event)
 
 
-class DropdownMenu(QtGui.QWidget):
+class DropdownMenu(QtWidgets.QWidget):
 
     def __init__(self, parent):
         super(DropdownMenu, self).__init__(parent)
@@ -213,20 +213,20 @@ class DropdownMenu(QtGui.QWidget):
         self.screenshotButton.setGeometry(QtCore.QRect(0, 60, 60, 60))
         self.screenshotButton.setObjectName("screenshotButton")
 
-        self.fileTransferButton = QtGui.QPushButton(self)
+        self.fileTransferButton = QtWidgets.QPushButton(self)
         self.fileTransferButton.setGeometry(QtCore.QRect(60, 60, 60, 60))
         self.fileTransferButton.setObjectName("fileTransferButton")
 
-        self.audioMessageButton = QtGui.QPushButton(self)
+        self.audioMessageButton = QtWidgets.QPushButton(self)
         self.audioMessageButton.setGeometry(QtCore.QRect(120, 60, 60, 60))
 
-        self.smileyButton = QtGui.QPushButton(self)
+        self.smileyButton = QtWidgets.QPushButton(self)
         self.smileyButton.setGeometry(QtCore.QRect(0, 0, 60, 60))
 
-        self.videoMessageButton = QtGui.QPushButton(self)
+        self.videoMessageButton = QtWidgets.QPushButton(self)
         self.videoMessageButton.setGeometry(QtCore.QRect(120, 0, 60, 60))
 
-        self.stickerButton = QtGui.QPushButton(self)
+        self.stickerButton = QtWidgets.QPushButton(self)
         self.stickerButton.setGeometry(QtCore.QRect(60, 0, 60, 60))
 
         pixmap = QtGui.QPixmap(util.curr_directory() + '/images/file.png')
@@ -254,16 +254,16 @@ class DropdownMenu(QtGui.QWidget):
         self.stickerButton.setIcon(icon)
         self.stickerButton.setIconSize(QtCore.QSize(55, 55))
 
-        self.screenshotButton.setToolTip(QtGui.QApplication.translate("MenuWindow", "Send screenshot", None, QtGui.QApplication.UnicodeUTF8))
+        self.screenshotButton.setToolTip(QtWidgets.QApplication.translate("MenuWindow", "Send screenshot"))
-        self.fileTransferButton.setToolTip(QtGui.QApplication.translate("MenuWindow", "Send file", None, QtGui.QApplication.UnicodeUTF8))
+        self.fileTransferButton.setToolTip(QtWidgets.QApplication.translate("MenuWindow", "Send file"))
-        self.audioMessageButton.setToolTip(QtGui.QApplication.translate("MenuWindow", "Send audio message", None, QtGui.QApplication.UnicodeUTF8))
+        self.audioMessageButton.setToolTip(QtWidgets.QApplication.translate("MenuWindow", "Send audio message"))
-        self.videoMessageButton.setToolTip(QtGui.QApplication.translate("MenuWindow", "Send video message", None, QtGui.QApplication.UnicodeUTF8))
+        self.videoMessageButton.setToolTip(QtWidgets.QApplication.translate("MenuWindow", "Send video message"))
-        self.smileyButton.setToolTip(QtGui.QApplication.translate("MenuWindow", "Add smiley", None, QtGui.QApplication.UnicodeUTF8))
+        self.smileyButton.setToolTip(QtWidgets.QApplication.translate("MenuWindow", "Add smiley"))
-        self.stickerButton.setToolTip(QtGui.QApplication.translate("MenuWindow", "Send sticker", None, QtGui.QApplication.UnicodeUTF8))
+        self.stickerButton.setToolTip(QtWidgets.QApplication.translate("MenuWindow", "Send sticker"))
 
         self.fileTransferButton.clicked.connect(parent.send_file)
         self.screenshotButton.clicked.connect(parent.send_screenshot)
-        self.connect(self.screenshotButton, QtCore.SIGNAL("rightClicked()"), lambda: parent.send_screenshot(True))
+        self.screenshotButton.rightClicked.connect(lambda: parent.send_screenshot(True))
         self.smileyButton.clicked.connect(parent.send_smiley)
         self.stickerButton.clicked.connect(parent.send_sticker)
 
@@ -276,11 +276,11 @@ class DropdownMenu(QtGui.QWidget):
         return False
 
 
-class StickerItem(QtGui.QWidget):
+class StickerItem(QtWidgets.QWidget):
 
     def __init__(self, fl):
         super(StickerItem, self).__init__()
-        self._image_label = QtGui.QLabel(self)
+        self._image_label = QtWidgets.QLabel(self)
         self.path = fl
         self.pixmap = QtGui.QPixmap()
         self.pixmap.load(fl)
@@ -290,7 +290,7 @@ class StickerItem(QtGui.QWidget):
         self._image_label.setPixmap(self.pixmap)
 
 
-class StickerWindow(QtGui.QWidget):
+class StickerWindow(QtWidgets.QWidget):
     """Sticker selection window"""
 
     def __init__(self, parent):
@@ -298,16 +298,16 @@ class StickerWindow(QtGui.QWidget):
         self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
         self.setMaximumSize(250, 200)
         self.setMinimumSize(250, 200)
-        self.list = QtGui.QListWidget(self)
+        self.list = QtWidgets.QListWidget(self)
         self.list.setGeometry(QtCore.QRect(0, 0, 250, 200))
         self.arr = smileys.sticker_loader()
         for sticker in self.arr:
             item = StickerItem(sticker)
-            elem = QtGui.QListWidgetItem()
+            elem = QtWidgets.QListWidgetItem()
             elem.setSizeHint(QtCore.QSize(250, item.height()))
             self.list.addItem(elem)
             self.list.setItemWidget(elem, item)
-        self.list.setVerticalScrollMode(QtGui.QAbstractItemView.ScrollPerPixel)
+        self.list.setVerticalScrollMode(QtWidgets.QAbstractItemView.ScrollPerPixel)
         self.list.setSpacing(3)
         self.list.clicked.connect(self.click)
         self.parent = parent
@@ -329,60 +329,44 @@ class WelcomeScreen(CenteredWidget):
         self.setMinimumSize(250, 200)
         self.center()
         self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
-        self.text = QtGui.QTextBrowser(self)
+        self.text = QtWidgets.QTextBrowser(self)
         self.text.setGeometry(QtCore.QRect(0, 0, 250, 170))
         self.text.setOpenExternalLinks(True)
-        self.checkbox = QtGui.QCheckBox(self)
+        self.checkbox = QtWidgets.QCheckBox(self)
         self.checkbox.setGeometry(QtCore.QRect(5, 170, 240, 30))
-        self.checkbox.setText(QtGui.QApplication.translate('WelcomeScreen', "Don't show again",
+        self.checkbox.setText(QtWidgets.QApplication.translate('WelcomeScreen', "Don't show again"))
-                                                           None, QtGui.QApplication.UnicodeUTF8))
+        self.setWindowTitle(QtWidgets.QApplication.translate('WelcomeScreen', 'Tip of the day'))
-        self.setWindowTitle(QtGui.QApplication.translate('WelcomeScreen', 'Tip of the day',
-                                                         None, QtGui.QApplication.UnicodeUTF8))
         import random
         num = random.randint(0, 10)
         if num == 0:
-            text = QtGui.QApplication.translate('WelcomeScreen', 'Press Esc if you want hide app to tray.',
+            text = QtWidgets.QApplication.translate('WelcomeScreen', 'Press Esc if you want hide app to tray.')
-                                                None, QtGui.QApplication.UnicodeUTF8)
         elif num == 1:
-            text = QtGui.QApplication.translate('WelcomeScreen',
+            text = QtWidgets.QApplication.translate('WelcomeScreen',
-                                                'Right click on screenshot button hides app to tray during screenshot.',
+                                                'Right click on screenshot button hides app to tray during screenshot.')
-                                                None, QtGui.QApplication.UnicodeUTF8)
         elif num == 2:
-            text = QtGui.QApplication.translate('WelcomeScreen',
+            text = QtWidgets.QApplication.translate('WelcomeScreen',
-                                                'You can use Tox over Tor. For more info read <a href="https://wiki.tox.chat/users/tox_over_tor_tot">this post</a>',
+                                                'You can use Tox over Tor. For more info read <a href="https://wiki.tox.chat/users/tox_over_tor_tot">this post</a>')
-                                                None, QtGui.QApplication.UnicodeUTF8)
         elif num == 3:
-            text = QtGui.QApplication.translate('WelcomeScreen',
+            text = QtWidgets.QApplication.translate('WelcomeScreen',
-                                                'Use Settings -> Interface to customize interface.',
+                                                'Use Settings -> Interface to customize interface.')
-                                                None, QtGui.QApplication.UnicodeUTF8)
         elif num == 4:
-            text = QtGui.QApplication.translate('WelcomeScreen',
+            text = QtWidgets.QApplication.translate('WelcomeScreen',
-                                                'Set profile password via Profile -> Settings. Password allows Toxygen encrypt your history and settings.',
+                                                'Set profile password via Profile -> Settings. Password allows Toxygen encrypt your history and settings.')
-                                                None, QtGui.QApplication.UnicodeUTF8)
         elif num == 5:
-            text = QtGui.QApplication.translate('WelcomeScreen',
+            text = QtWidgets.QApplication.translate('WelcomeScreen',
-                                                'Since v0.1.3 Toxygen supports plugins. <a href="https://github.com/xveduk/toxygen/blob/master/docs/plugins.md">Read more</a>',
+                                                'Since v0.1.3 Toxygen supports plugins. <a href="https://github.com/xveduk/toxygen/blob/master/docs/plugins.md">Read more</a>')
-                                                None, QtGui.QApplication.UnicodeUTF8)
+        elif num in (6, 7):
-        elif num == 6:
+            text = QtWidgets.QApplication.translate('WelcomeScreen',
-            text = QtGui.QApplication.translate('WelcomeScreen',
+                                                'Toxygen supports faux offline messages and file transfers. Send message or file to offline friend and he will get it later.')
-                                                'New in Toxygen v0.2.4:<br>File transfers update<br>Autoreconnection<br>Improvements<br>Bug fixes',
-                                                None, QtGui.QApplication.UnicodeUTF8)
-        elif num == 7:
-            text = QtGui.QApplication.translate('WelcomeScreen',
-                                                'Toxygen supports faux offline messages and file transfers. Send message or file to offline friend and he will get it later.',
-                                                None, QtGui.QApplication.UnicodeUTF8)
         elif num == 8:
-            text = QtGui.QApplication.translate('WelcomeScreen',
+            text = QtWidgets.QApplication.translate('WelcomeScreen',
-                                                'Delete single message in chat: make right click on spinner or message time and choose "Delete" in menu',
+                                                'Delete single message in chat: make right click on spinner or message time and choose "Delete" in menu')
-                                                None, QtGui.QApplication.UnicodeUTF8)
         elif num == 9:
-            text = QtGui.QApplication.translate('WelcomeScreen',
+            text = QtWidgets.QApplication.translate('WelcomeScreen',
-                                                'Use right click on inline image to save it',
+                                                'Use right click on inline image to save it')
-                                                None, QtGui.QApplication.UnicodeUTF8)
         else:
-            text = QtGui.QApplication.translate('WelcomeScreen',
+            text = QtWidgets.QApplication.translate('WelcomeScreen',
-                                                'Set new NoSpam to avoid spam friend requests: Profile -> Settings -> Set new NoSpam.',
+                                                'Set new NoSpam to avoid spam friend requests: Profile -> Settings -> Set new NoSpam.')
-                                                None, QtGui.QApplication.UnicodeUTF8)
         self.text.setHtml(text)
         self.checkbox.stateChanged.connect(self.not_show)
         QtCore.QTimer.singleShot(1000, self.show)
@@ -392,3 +376,139 @@ class WelcomeScreen(CenteredWidget):
         s = settings.Settings.get_instance()
         s['show_welcome_screen'] = False
         s.save()
+
+
+class MainMenuButton(QtWidgets.QPushButton):
+
+    def __init__(self, *args):
+        super().__init__(*args)
+        self.setObjectName("mainmenubutton")
+
+    def setText(self, text):
+        metrics = QtGui.QFontMetrics(self.font())
+        self.setFixedWidth(metrics.size(QtCore.Qt.TextSingleLine, text).width() + 20)
+        super().setText(text)
+
+
+class ClickableLabel(QtWidgets.QLabel):
+
+    clicked = QtCore.pyqtSignal()
+
+    def __init__(self, *args):
+        super().__init__(*args)
+
+    def mouseReleaseEvent(self, ev):
+        self.clicked.emit()
+
+
+class SearchScreen(QtWidgets.QWidget):
+
+    def __init__(self, messages, width, *args):
+        super().__init__(*args)
+        self.setMaximumSize(width, 40)
+        self.setMinimumSize(width, 40)
+        self._messages = messages
+
+        self.search_text = LineEdit(self)
+        self.search_text.setGeometry(0, 0, width - 160, 40)
+
+        self.search_button = ClickableLabel(self)
+        self.search_button.setGeometry(width - 160, 0, 40, 40)
+        pixmap = QtGui.QPixmap()
+        pixmap.load(util.curr_directory() + '/images/search.png')
+        self.search_button.setScaledContents(False)
+        self.search_button.setAlignment(QtCore.Qt.AlignCenter)
+        self.search_button.setPixmap(pixmap)
+        self.search_button.clicked.connect(self.search)
+
+        font = QtGui.QFont()
+        font.setPointSize(32)
+        font.setBold(True)
+
+        self.prev_button = QtWidgets.QPushButton(self)
+        self.prev_button.setGeometry(width - 120, 0, 40, 40)
+        self.prev_button.clicked.connect(self.prev)
+        self.prev_button.setText('\u25B2')
+
+        self.next_button = QtWidgets.QPushButton(self)
+        self.next_button.setGeometry(width - 80, 0, 40, 40)
+        self.next_button.clicked.connect(self.next)
+        self.next_button.setText('\u25BC')
+
+        self.close_button = QtWidgets.QPushButton(self)
+        self.close_button.setGeometry(width - 40, 0, 40, 40)
+        self.close_button.clicked.connect(self.close)
+        self.close_button.setText('×')
+        self.close_button.setFont(font)
+
+        font.setPointSize(18)
+        self.next_button.setFont(font)
+        self.prev_button.setFont(font)
+
+        self.retranslateUi()
+
+    def retranslateUi(self):
+        self.search_text.setPlaceholderText(QtWidgets.QApplication.translate("MainWindow", "Search"))
+
+    def show(self):
+        super().show()
+        self.search_text.setFocus()
+
+    def search(self):
+        Profile.get_instance().update()
+        text = self.search_text.text()
+        friend = Profile.get_instance().get_curr_friend()
+        if text and friend and util.is_re_valid(text):
+            index = friend.search_string(text)
+            self.load_messages(index)
+
+    def prev(self):
+        friend = Profile.get_instance().get_curr_friend()
+        if friend is not None:
+            index = friend.search_prev()
+            self.load_messages(index)
+
+    def next(self):
+        friend = Profile.get_instance().get_curr_friend()
+        text = self.search_text.text()
+        if friend is not None:
+            index = friend.search_next()
+            if index is not None:
+                count = self._messages.count()
+                index += count
+                item = self._messages.item(index)
+                self._messages.scrollToItem(item)
+                self._messages.itemWidget(item).select_text(text)
+            else:
+                self.not_found(text)
+
+    def load_messages(self, index):
+        text = self.search_text.text()
+        if index is not None:
+            profile = Profile.get_instance()
+            count = self._messages.count()
+            while count + index < 0:
+                profile.load_history()
+                count = self._messages.count()
+            index += count
+            item = self._messages.item(index)
+            self._messages.scrollToItem(item)
+            self._messages.itemWidget(item).select_text(text)
+        else:
+            self.not_found(text)
+
+    def closeEvent(self, *args):
+        Profile.get_instance().update()
+        self._messages.setGeometry(0, 0, self._messages.width(), self._messages.height() + 40)
+        super().closeEvent(*args)
+
+    @staticmethod
+    def not_found(text):
+        mbox = QtWidgets.QMessageBox()
+        mbox_text = QtWidgets.QApplication.translate("MainWindow",
+                                                     'Text "{}" was not found')
+
+        mbox.setText(mbox_text.format(text))
+        mbox.setWindowTitle(QtWidgets.QApplication.translate("MainWindow",
+                                                             'Not found'))
+        mbox.exec_()

toxygen/menu.py

@@ -1,14 +1,12 @@
-try:
+from PyQt5 import QtCore, QtGui, QtWidgets
-    from PySide import QtCore, QtGui
-except ImportError:
-    from PyQt4 import QtCore, QtGui
 from settings import *
 from profile import Profile
 from util import curr_directory, copy
 from widgets import CenteredWidget, DataLabel, LineEdit
 import pyaudio
-import toxencryptsave
+import toxes
 import plugin_support
+import updater
 
 
 class AddContact(CenteredWidget):
@@ -22,7 +20,7 @@ class AddContact(CenteredWidget):
     def initUI(self, tox_id):
         self.setObjectName('AddContact')
         self.resize(568, 306)
-        self.sendRequestButton = QtGui.QPushButton(self)
+        self.sendRequestButton = QtWidgets.QPushButton(self)
         self.sendRequestButton.setGeometry(QtCore.QRect(50, 270, 471, 31))
         self.sendRequestButton.setMinimumSize(QtCore.QSize(0, 0))
         self.sendRequestButton.setBaseSize(QtCore.QSize(0, 0))
@@ -32,7 +30,7 @@ class AddContact(CenteredWidget):
         self.tox_id.setGeometry(QtCore.QRect(50, 40, 471, 27))
         self.tox_id.setObjectName("lineEdit")
         self.tox_id.setText(tox_id)
-        self.label = QtGui.QLabel(self)
+        self.label = QtWidgets.QLabel(self)
         self.label.setGeometry(QtCore.QRect(50, 10, 80, 20))
         self.error_label = DataLabel(self)
         self.error_label.setGeometry(QtCore.QRect(120, 10, 420, 20))
@@ -43,10 +41,10 @@ class AddContact(CenteredWidget):
         self.error_label.setFont(font)
         self.error_label.setStyleSheet("QLabel { color: #BC1C1C; }")
         self.label.setObjectName("label")
-        self.message_edit = QtGui.QTextEdit(self)
+        self.message_edit = QtWidgets.QTextEdit(self)
         self.message_edit.setGeometry(QtCore.QRect(50, 110, 471, 151))
         self.message_edit.setObjectName("textEdit")
-        self.message = QtGui.QLabel(self)
+        self.message = QtWidgets.QLabel(self)
         self.message.setGeometry(QtCore.QRect(50, 70, 101, 31))
         self.message.setFont(font)
         self.message.setObjectName("label_2")
@@ -72,11 +70,11 @@ class AddContact(CenteredWidget):
             self.error_label.setText(send)
 
     def retranslateUi(self):
-        self.setWindowTitle(QtGui.QApplication.translate('AddContact', "Add contact", None, QtGui.QApplication.UnicodeUTF8))
+        self.setWindowTitle(QtWidgets.QApplication.translate('AddContact', "Add contact"))
-        self.sendRequestButton.setText(QtGui.QApplication.translate("Form", "Send request", None, QtGui.QApplication.UnicodeUTF8))
+        self.sendRequestButton.setText(QtWidgets.QApplication.translate("Form", "Send request"))
-        self.label.setText(QtGui.QApplication.translate('AddContact', "TOX ID:", None, QtGui.QApplication.UnicodeUTF8))
+        self.label.setText(QtWidgets.QApplication.translate('AddContact', "TOX ID:"))
-        self.message.setText(QtGui.QApplication.translate('AddContact', "Message:", None, QtGui.QApplication.UnicodeUTF8))
+        self.message.setText(QtWidgets.QApplication.translate('AddContact', "Message:"))
-        self.tox_id.setPlaceholderText(QtGui.QApplication.translate('AddContact', "TOX ID or public key of contact", None, QtGui.QApplication.UnicodeUTF8))
+        self.tox_id.setPlaceholderText(QtWidgets.QApplication.translate('AddContact', "TOX ID or public key of contact"))
 
 
 class ProfileSettings(CenteredWidget):
@@ -94,12 +92,12 @@ class ProfileSettings(CenteredWidget):
         self.nick.setGeometry(QtCore.QRect(30, 60, 350, 27))
         profile = Profile.get_instance()
         self.nick.setText(profile.name)
-        self.status = QtGui.QComboBox(self)
+        self.status = QtWidgets.QComboBox(self)
         self.status.setGeometry(QtCore.QRect(400, 60, 200, 27))
         self.status_message = LineEdit(self)
         self.status_message.setGeometry(QtCore.QRect(30, 130, 350, 27))
         self.status_message.setText(profile.status_message)
-        self.label = QtGui.QLabel(self)
+        self.label = QtWidgets.QLabel(self)
         self.label.setGeometry(QtCore.QRect(40, 30, 91, 25))
         font = QtGui.QFont()
         font.setFamily(Settings.get_instance()['font'])
@@ -107,59 +105,59 @@ class ProfileSettings(CenteredWidget):
         font.setWeight(75)
         font.setBold(True)
         self.label.setFont(font)
-        self.label_2 = QtGui.QLabel(self)
+        self.label_2 = QtWidgets.QLabel(self)
         self.label_2.setGeometry(QtCore.QRect(40, 100, 100, 25))
         self.label_2.setFont(font)
-        self.label_3 = QtGui.QLabel(self)
+        self.label_3 = QtWidgets.QLabel(self)
         self.label_3.setGeometry(QtCore.QRect(40, 180, 100, 25))
         self.label_3.setFont(font)
-        self.tox_id = QtGui.QLabel(self)
+        self.tox_id = QtWidgets.QLabel(self)
         self.tox_id.setGeometry(QtCore.QRect(15, 210, 685, 21))
         font.setPointSize(10)
         self.tox_id.setFont(font)
         s = profile.tox_id
         self.tox_id.setText(s)
-        self.copyId = QtGui.QPushButton(self)
+        self.copyId = QtWidgets.QPushButton(self)
         self.copyId.setGeometry(QtCore.QRect(40, 250, 180, 30))
         self.copyId.clicked.connect(self.copy)
-        self.export = QtGui.QPushButton(self)
+        self.export = QtWidgets.QPushButton(self)
         self.export.setGeometry(QtCore.QRect(230, 250, 180, 30))
         self.export.clicked.connect(self.export_profile)
-        self.new_nospam = QtGui.QPushButton(self)
+        self.new_nospam = QtWidgets.QPushButton(self)
         self.new_nospam.setGeometry(QtCore.QRect(420, 250, 180, 30))
         self.new_nospam.clicked.connect(self.new_no_spam)
-        self.copy_pk = QtGui.QPushButton(self)
+        self.copy_pk = QtWidgets.QPushButton(self)
         self.copy_pk.setGeometry(QtCore.QRect(40, 300, 180, 30))
         self.copy_pk.clicked.connect(self.copy_public_key)
-        self.new_avatar = QtGui.QPushButton(self)
+        self.new_avatar = QtWidgets.QPushButton(self)
         self.new_avatar.setGeometry(QtCore.QRect(230, 300, 180, 30))
-        self.delete_avatar = QtGui.QPushButton(self)
+        self.delete_avatar = QtWidgets.QPushButton(self)
         self.delete_avatar.setGeometry(QtCore.QRect(420, 300, 180, 30))
         self.delete_avatar.clicked.connect(self.reset_avatar)
         self.new_avatar.clicked.connect(self.set_avatar)
-        self.profilepass = QtGui.QLabel(self)
+        self.profilepass = QtWidgets.QLabel(self)
         self.profilepass.setGeometry(QtCore.QRect(40, 340, 300, 30))
         font.setPointSize(18)
         self.profilepass.setFont(font)
         self.password = LineEdit(self)
         self.password.setGeometry(QtCore.QRect(40, 380, 300, 30))
-        self.password.setEchoMode(QtGui.QLineEdit.EchoMode.Password)
+        self.password.setEchoMode(QtWidgets.QLineEdit.Password)
-        self.leave_blank = QtGui.QLabel(self)
+        self.leave_blank = QtWidgets.QLabel(self)
         self.leave_blank.setGeometry(QtCore.QRect(350, 380, 300, 30))
         self.confirm_password = LineEdit(self)
         self.confirm_password.setGeometry(QtCore.QRect(40, 420, 300, 30))
-        self.confirm_password.setEchoMode(QtGui.QLineEdit.EchoMode.Password)
+        self.confirm_password.setEchoMode(QtWidgets.QLineEdit.Password)
-        self.set_password = QtGui.QPushButton(self)
+        self.set_password = QtWidgets.QPushButton(self)
         self.set_password.setGeometry(QtCore.QRect(40, 470, 300, 30))
         self.set_password.clicked.connect(self.new_password)
-        self.not_match = QtGui.QLabel(self)
+        self.not_match = QtWidgets.QLabel(self)
         self.not_match.setGeometry(QtCore.QRect(350, 420, 300, 30))
         self.not_match.setVisible(False)
         self.not_match.setStyleSheet('QLabel { color: #BC1C1C; }')
-        self.warning = QtGui.QLabel(self)
+        self.warning = QtWidgets.QLabel(self)
         self.warning.setGeometry(QtCore.QRect(40, 510, 500, 30))
         self.warning.setStyleSheet('QLabel { color: #BC1C1C; }')
-        self.default = QtGui.QPushButton(self)
+        self.default = QtWidgets.QPushButton(self)
         self.default.setGeometry(QtCore.QRect(40, 550, 620, 30))
         path, name = Settings.get_auto_profile()
         self.auto = path + name == ProfileHelper.get_path() + Settings.get_instance().name
@@ -172,30 +170,30 @@ class ProfileSettings(CenteredWidget):
         QtCore.QMetaObject.connectSlotsByName(self)
 
     def retranslateUi(self):
-        self.export.setText(QtGui.QApplication.translate("ProfileSettingsForm", "Export profile", None, QtGui.QApplication.UnicodeUTF8))
+        self.export.setText(QtWidgets.QApplication.translate("ProfileSettingsForm", "Export profile"))
-        self.setWindowTitle(QtGui.QApplication.translate("ProfileSettingsForm", "Profile settings", None, QtGui.QApplication.UnicodeUTF8))
+        self.setWindowTitle(QtWidgets.QApplication.translate("ProfileSettingsForm", "Profile settings"))
-        self.label.setText(QtGui.QApplication.translate("ProfileSettingsForm", "Name:", None, QtGui.QApplication.UnicodeUTF8))
+        self.label.setText(QtWidgets.QApplication.translate("ProfileSettingsForm", "Name:"))
-        self.label_2.setText(QtGui.QApplication.translate("ProfileSettingsForm", "Status:", None, QtGui.QApplication.UnicodeUTF8))
+        self.label_2.setText(QtWidgets.QApplication.translate("ProfileSettingsForm", "Status:"))
-        self.label_3.setText(QtGui.QApplication.translate("ProfileSettingsForm", "TOX ID:", None, QtGui.QApplication.UnicodeUTF8))
+        self.label_3.setText(QtWidgets.QApplication.translate("ProfileSettingsForm", "TOX ID:"))
-        self.copyId.setText(QtGui.QApplication.translate("ProfileSettingsForm", "Copy TOX ID", None, QtGui.QApplication.UnicodeUTF8))
+        self.copyId.setText(QtWidgets.QApplication.translate("ProfileSettingsForm", "Copy TOX ID"))
-        self.new_avatar.setText(QtGui.QApplication.translate("ProfileSettingsForm", "New avatar", None, QtGui.QApplication.UnicodeUTF8))
+        self.new_avatar.setText(QtWidgets.QApplication.translate("ProfileSettingsForm", "New avatar"))
-        self.delete_avatar.setText(QtGui.QApplication.translate("ProfileSettingsForm", "Reset avatar", None, QtGui.QApplication.UnicodeUTF8))
+        self.delete_avatar.setText(QtWidgets.QApplication.translate("ProfileSettingsForm", "Reset avatar"))
-        self.new_nospam.setText(QtGui.QApplication.translate("ProfileSettingsForm", "New NoSpam", None, QtGui.QApplication.UnicodeUTF8))
+        self.new_nospam.setText(QtWidgets.QApplication.translate("ProfileSettingsForm", "New NoSpam"))
-        self.profilepass.setText(QtGui.QApplication.translate("ProfileSettingsForm", "Profile password", None, QtGui.QApplication.UnicodeUTF8))
+        self.profilepass.setText(QtWidgets.QApplication.translate("ProfileSettingsForm", "Profile password"))
-        self.password.setPlaceholderText(QtGui.QApplication.translate("ProfileSettingsForm", "Password (at least 8 symbols)", None, QtGui.QApplication.UnicodeUTF8))
+        self.password.setPlaceholderText(QtWidgets.QApplication.translate("ProfileSettingsForm", "Password (at least 8 symbols)"))
-        self.confirm_password.setPlaceholderText(QtGui.QApplication.translate("ProfileSettingsForm", "Confirm password", None, QtGui.QApplication.UnicodeUTF8))
+        self.confirm_password.setPlaceholderText(QtWidgets.QApplication.translate("ProfileSettingsForm", "Confirm password"))
-        self.set_password.setText(QtGui.QApplication.translate("ProfileSettingsForm", "Set password", None, QtGui.QApplication.UnicodeUTF8))
+        self.set_password.setText(QtWidgets.QApplication.translate("ProfileSettingsForm", "Set password"))
-        self.not_match.setText(QtGui.QApplication.translate("ProfileSettingsForm", "Passwords do not match", None, QtGui.QApplication.UnicodeUTF8))
+        self.not_match.setText(QtWidgets.QApplication.translate("ProfileSettingsForm", "Passwords do not match"))
-        self.leave_blank.setText(QtGui.QApplication.translate("ProfileSettingsForm", "Leaving blank will reset current password", None, QtGui.QApplication.UnicodeUTF8))
+        self.leave_blank.setText(QtWidgets.QApplication.translate("ProfileSettingsForm", "Leaving blank will reset current password"))
-        self.warning.setText(QtGui.QApplication.translate("ProfileSettingsForm", "There is no way to recover lost passwords", None, QtGui.QApplication.UnicodeUTF8))
+        self.warning.setText(QtWidgets.QApplication.translate("ProfileSettingsForm", "There is no way to recover lost passwords"))
-        self.status.addItem(QtGui.QApplication.translate("ProfileSettingsForm", "Online", None, QtGui.QApplication.UnicodeUTF8))
+        self.status.addItem(QtWidgets.QApplication.translate("ProfileSettingsForm", "Online"))
-        self.status.addItem(QtGui.QApplication.translate("ProfileSettingsForm", "Away", None, QtGui.QApplication.UnicodeUTF8))
+        self.status.addItem(QtWidgets.QApplication.translate("ProfileSettingsForm", "Away"))
-        self.status.addItem(QtGui.QApplication.translate("ProfileSettingsForm", "Busy", None, QtGui.QApplication.UnicodeUTF8))
+        self.status.addItem(QtWidgets.QApplication.translate("ProfileSettingsForm", "Busy"))
-        self.copy_pk.setText(QtGui.QApplication.translate("ProfileSettingsForm", "Copy public key", None, QtGui.QApplication.UnicodeUTF8))
+        self.copy_pk.setText(QtWidgets.QApplication.translate("ProfileSettingsForm", "Copy public key"))
         if self.auto:
-            self.default.setText(QtGui.QApplication.translate("ProfileSettingsForm", "Mark as not default profile", None, QtGui.QApplication.UnicodeUTF8))
+            self.default.setText(QtWidgets.QApplication.translate("ProfileSettingsForm", "Mark as not default profile"))
         else:
-            self.default.setText(QtGui.QApplication.translate("ProfileSettingsForm", "Mark as default profile", None, QtGui.QApplication.UnicodeUTF8))
+            self.default.setText(QtWidgets.QApplication.translate("ProfileSettingsForm", "Mark as default profile"))
 
     def auto_profile(self):
         if self.auto:
@@ -204,31 +202,27 @@ class ProfileSettings(CenteredWidget):
             Settings.set_auto_profile(ProfileHelper.get_path(), Settings.get_instance().name)
         self.auto = not self.auto
         if self.auto:
-            self.default.setText(QtGui.QApplication.translate("ProfileSettingsForm", "Mark as not default profile", None,
+            self.default.setText(QtWidgets.QApplication.translate("ProfileSettingsForm", "Mark as not default profile"))
-                                                              QtGui.QApplication.UnicodeUTF8))
         else:
             self.default.setText(
-                QtGui.QApplication.translate("ProfileSettingsForm", "Mark as default profile", None,
+                QtWidgets.QApplication.translate("ProfileSettingsForm", "Mark as default profile"))
-                                             QtGui.QApplication.UnicodeUTF8))
 
     def new_password(self):
         if self.password.text() == self.confirm_password.text():
             if not len(self.password.text()) or len(self.password.text()) >= 8:
-                e = toxencryptsave.ToxEncryptSave.get_instance()
+                e = toxes.ToxES.get_instance()
                 e.set_password(self.password.text())
                 self.close()
             else:
                 self.not_match.setText(
-                    QtGui.QApplication.translate("ProfileSettingsForm", "Password must be at least 8 symbols", None,
+                    QtWidgets.QApplication.translate("ProfileSettingsForm", "Password must be at least 8 symbols"))
-                                                 QtGui.QApplication.UnicodeUTF8))
             self.not_match.setVisible(True)
         else:
-            self.not_match.setText(QtGui.QApplication.translate("ProfileSettingsForm", "Passwords do not match", None,
+            self.not_match.setText(QtWidgets.QApplication.translate("ProfileSettingsForm", "Passwords do not match"))
-                                                                QtGui.QApplication.UnicodeUTF8))
             self.not_match.setVisible(True)
 
     def copy(self):
-        clipboard = QtGui.QApplication.clipboard()
+        clipboard = QtWidgets.QApplication.clipboard()
         profile = Profile.get_instance()
         clipboard.setText(profile.tox_id)
         pixmap = QtGui.QPixmap(curr_directory() + '/images/accept.png')
@@ -237,7 +231,7 @@ class ProfileSettings(CenteredWidget):
         self.copyId.setIconSize(QtCore.QSize(10, 10))
 
     def copy_public_key(self):
-        clipboard = QtGui.QApplication.clipboard()
+        clipboard = QtWidgets.QApplication.clipboard()
         profile = Profile.get_instance()
         clipboard.setText(profile.tox_id[:64])
         pixmap = QtGui.QPixmap(curr_directory() + '/images/accept.png')
@@ -252,13 +246,13 @@ class ProfileSettings(CenteredWidget):
         Profile.get_instance().reset_avatar()
 
     def set_avatar(self):
-        choose = QtGui.QApplication.translate("ProfileSettingsForm", "Choose avatar", None, QtGui.QApplication.UnicodeUTF8)
+        choose = QtWidgets.QApplication.translate("ProfileSettingsForm", "Choose avatar")
-        name = QtGui.QFileDialog.getOpenFileName(self, choose, None, 'Images (*.png)',
+        name = QtWidgets.QFileDialog.getOpenFileName(self, choose, None, None, 'Images (*.png)',
-                                                 options=QtGui.QFileDialog.DontUseNativeDialog)
+                                                     QtWidgets.QFileDialog.DontUseNativeDialog)
         if name[0]:
             bitmap = QtGui.QPixmap(name[0])
-            bitmap.scaled(QtCore.QSize(128, 128), aspectMode=QtCore.Qt.KeepAspectRatio,
+            bitmap.scaled(128, 128, QtCore.Qt.KeepAspectRatio,
-                          mode=QtCore.Qt.SmoothTransformation)
+                          QtCore.Qt.SmoothTransformation)
 
             byte_array = QtCore.QByteArray()
             buffer = QtCore.QBuffer(byte_array)
@@ -267,25 +261,22 @@ class ProfileSettings(CenteredWidget):
             Profile.get_instance().set_avatar(bytes(byte_array.data()))
 
     def export_profile(self):
-        directory = QtGui.QFileDialog.getExistingDirectory(options=QtGui.QFileDialog.DontUseNativeDialog,
+        directory = QtWidgets.QFileDialog.getExistingDirectory(self, '', curr_directory() + '/',
-                                                           dir=curr_directory()) + '/'
+                                                               QtWidgets.QFileDialog.ShowDirsOnly | QtWidgets.QFileDialog.DontUseNativeDialog)
+
         if directory != '/':
-            reply = QtGui.QMessageBox.question(None,
+            reply = QtWidgets.QMessageBox.question(None,
-                                               QtGui.QApplication.translate("ProfileSettingsForm",
+                                               QtWidgets.QApplication.translate("ProfileSettingsForm",
-                                                                            'Use new path',
+                                                                                'Use new path'),
-                                                                            None,
+                                               QtWidgets.QApplication.translate("ProfileSettingsForm",
-                                                                            QtGui.QApplication.UnicodeUTF8),
+                                                                                'Do you want to move your profile to this location?'),
-                                               QtGui.QApplication.translate("ProfileSettingsForm",
+                                               QtWidgets.QMessageBox.Yes,
-                                                                            'Do you want to move your profile to this location?',
+                                               QtWidgets.QMessageBox.No)
-                                                                            None,
-                                                                            QtGui.QApplication.UnicodeUTF8),
-                                               QtGui.QMessageBox.Yes,
-                                               QtGui.QMessageBox.No)
             settings = Settings.get_instance()
             settings.export(directory)
             profile = Profile.get_instance()
             profile.export_db(directory)
-            ProfileHelper.get_instance().export_profile(directory, reply == QtGui.QMessageBox.Yes)
+            ProfileHelper.get_instance().export_profile(directory, reply == QtWidgets.QMessageBox.Yes)
 
     def closeEvent(self, event):
         profile = Profile.get_instance()
@@ -308,15 +299,15 @@ class NetworkSettings(CenteredWidget):
         self.setMinimumSize(QtCore.QSize(300, 330))
         self.setMaximumSize(QtCore.QSize(300, 330))
         self.setBaseSize(QtCore.QSize(300, 330))
-        self.ipv = QtGui.QCheckBox(self)
+        self.ipv = QtWidgets.QCheckBox(self)
         self.ipv.setGeometry(QtCore.QRect(20, 10, 97, 22))
         self.ipv.setObjectName("ipv")
-        self.udp = QtGui.QCheckBox(self)
+        self.udp = QtWidgets.QCheckBox(self)
         self.udp.setGeometry(QtCore.QRect(150, 10, 97, 22))
         self.udp.setObjectName("udp")
-        self.proxy = QtGui.QCheckBox(self)
+        self.proxy = QtWidgets.QCheckBox(self)
         self.proxy.setGeometry(QtCore.QRect(20, 40, 97, 22))
-        self.http = QtGui.QCheckBox(self)
+        self.http = QtWidgets.QCheckBox(self)
         self.http.setGeometry(QtCore.QRect(20, 70, 97, 22))
         self.proxy.setObjectName("proxy")
         self.proxyip = LineEdit(self)
@@ -325,11 +316,11 @@ class NetworkSettings(CenteredWidget):
         self.proxyport = LineEdit(self)
         self.proxyport.setGeometry(QtCore.QRect(40, 190, 231, 27))
         self.proxyport.setObjectName("proxyport")
-        self.label = QtGui.QLabel(self)
+        self.label = QtWidgets.QLabel(self)
         self.label.setGeometry(QtCore.QRect(40, 100, 66, 17))
-        self.label_2 = QtGui.QLabel(self)
+        self.label_2 = QtWidgets.QLabel(self)
         self.label_2.setGeometry(QtCore.QRect(40, 165, 66, 17))
-        self.reconnect = QtGui.QPushButton(self)
+        self.reconnect = QtWidgets.QPushButton(self)
         self.reconnect.setGeometry(QtCore.QRect(40, 230, 231, 30))
         self.reconnect.clicked.connect(self.restart_core)
         settings = Settings.get_instance()
@@ -339,7 +330,7 @@ class NetworkSettings(CenteredWidget):
         self.proxyip.setText(settings['proxy_host'])
         self.proxyport.setText(str(settings['proxy_port']))
         self.http.setChecked(settings['proxy_type'] == 1)
-        self.warning = QtGui.QLabel(self)
+        self.warning = QtWidgets.QLabel(self)
         self.warning.setGeometry(QtCore.QRect(5, 270, 290, 60))
         self.warning.setStyleSheet('QLabel { color: #BC1C1C; }')
         self.retranslateUi()
@@ -348,16 +339,15 @@ class NetworkSettings(CenteredWidget):
         QtCore.QMetaObject.connectSlotsByName(self)
 
     def retranslateUi(self):
-        self.setWindowTitle(QtGui.QApplication.translate("NetworkSettings", "Network settings", None, QtGui.QApplication.UnicodeUTF8))
+        self.setWindowTitle(QtWidgets.QApplication.translate("NetworkSettings", "Network settings"))
-        self.ipv.setText(QtGui.QApplication.translate("Form", "IPv6", None, QtGui.QApplication.UnicodeUTF8))
+        self.ipv.setText(QtWidgets.QApplication.translate("Form", "IPv6"))
-        self.udp.setText(QtGui.QApplication.translate("Form", "UDP", None, QtGui.QApplication.UnicodeUTF8))
+        self.udp.setText(QtWidgets.QApplication.translate("Form", "UDP"))
-        self.proxy.setText(QtGui.QApplication.translate("Form", "Proxy", None, QtGui.QApplication.UnicodeUTF8))
+        self.proxy.setText(QtWidgets.QApplication.translate("Form", "Proxy"))
-        self.label.setText(QtGui.QApplication.translate("Form", "IP:", None, QtGui.QApplication.UnicodeUTF8))
+        self.label.setText(QtWidgets.QApplication.translate("Form", "IP:"))
-        self.label_2.setText(QtGui.QApplication.translate("Form", "Port:", None, QtGui.QApplication.UnicodeUTF8))
+        self.label_2.setText(QtWidgets.QApplication.translate("Form", "Port:"))
-        self.reconnect.setText(QtGui.QApplication.translate("NetworkSettings", "Restart TOX core", None, QtGui.QApplication.UnicodeUTF8))
+        self.reconnect.setText(QtWidgets.QApplication.translate("NetworkSettings", "Restart TOX core"))
-        self.http.setText(QtGui.QApplication.translate("Form", "HTTP", None, QtGui.QApplication.UnicodeUTF8))
+        self.http.setText(QtWidgets.QApplication.translate("Form", "HTTP"))
-        self.warning.setText(QtGui.QApplication.translate("Form", "WARNING:\nusing proxy with enabled UDP\ncan produce IP leak",
+        self.warning.setText(QtWidgets.QApplication.translate("Form", "WARNING:\nusing proxy with enabled UDP\ncan produce IP leak"))
-                                                          None, QtGui.QApplication.UnicodeUTF8))
 
     def activate(self):
         bl = self.proxy.isChecked()
@@ -394,23 +384,23 @@ class PrivacySettings(CenteredWidget):
         self.resize(370, 600)
         self.setMinimumSize(QtCore.QSize(370, 600))
         self.setMaximumSize(QtCore.QSize(370, 600))
-        self.saveHistory = QtGui.QCheckBox(self)
+        self.saveHistory = QtWidgets.QCheckBox(self)
         self.saveHistory.setGeometry(QtCore.QRect(10, 20, 350, 22))
-        self.saveUnsentOnly = QtGui.QCheckBox(self)
+        self.saveUnsentOnly = QtWidgets.QCheckBox(self)
         self.saveUnsentOnly.setGeometry(QtCore.QRect(10, 60, 350, 22))
 
-        self.fileautoaccept = QtGui.QCheckBox(self)
+        self.fileautoaccept = QtWidgets.QCheckBox(self)
         self.fileautoaccept.setGeometry(QtCore.QRect(10, 100, 350, 22))
 
-        self.typingNotifications = QtGui.QCheckBox(self)
+        self.typingNotifications = QtWidgets.QCheckBox(self)
         self.typingNotifications.setGeometry(QtCore.QRect(10, 140, 350, 30))
-        self.inlines = QtGui.QCheckBox(self)
+        self.inlines = QtWidgets.QCheckBox(self)
         self.inlines.setGeometry(QtCore.QRect(10, 180, 350, 30))
-        self.auto_path = QtGui.QLabel(self)
+        self.auto_path = QtWidgets.QLabel(self)
         self.auto_path.setGeometry(QtCore.QRect(10, 230, 350, 30))
-        self.path = QtGui.QPlainTextEdit(self)
+        self.path = QtWidgets.QPlainTextEdit(self)
         self.path.setGeometry(QtCore.QRect(10, 265, 350, 45))
-        self.change_path = QtGui.QPushButton(self)
+        self.change_path = QtWidgets.QPushButton(self)
         self.change_path.setGeometry(QtCore.QRect(10, 320, 350, 30))
         settings = Settings.get_instance()
         self.typingNotifications.setChecked(settings['typing_notifications'])
@@ -422,37 +412,37 @@ class PrivacySettings(CenteredWidget):
         self.saveHistory.stateChanged.connect(self.update)
         self.path.setPlainText(settings['auto_accept_path'] or curr_directory())
         self.change_path.clicked.connect(self.new_path)
-        self.block_user_label = QtGui.QLabel(self)
+        self.block_user_label = QtWidgets.QLabel(self)
         self.block_user_label.setGeometry(QtCore.QRect(10, 360, 350, 30))
-        self.block_id = QtGui.QPlainTextEdit(self)
+        self.block_id = QtWidgets.QPlainTextEdit(self)
         self.block_id.setGeometry(QtCore.QRect(10, 390, 350, 30))
-        self.block = QtGui.QPushButton(self)
+        self.block = QtWidgets.QPushButton(self)
         self.block.setGeometry(QtCore.QRect(10, 430, 350, 30))
         self.block.clicked.connect(lambda: Profile.get_instance().block_user(self.block_id.toPlainText()) or self.close())
-        self.blocked_users_label = QtGui.QLabel(self)
+        self.blocked_users_label = QtWidgets.QLabel(self)
         self.blocked_users_label.setGeometry(QtCore.QRect(10, 470, 350, 30))
-        self.comboBox = QtGui.QComboBox(self)
+        self.comboBox = QtWidgets.QComboBox(self)
         self.comboBox.setGeometry(QtCore.QRect(10, 500, 350, 30))
         self.comboBox.addItems(settings['blocked'])
-        self.unblock = QtGui.QPushButton(self)
+        self.unblock = QtWidgets.QPushButton(self)
         self.unblock.setGeometry(QtCore.QRect(10, 540, 350, 30))
         self.unblock.clicked.connect(lambda: self.unblock_user())
         self.retranslateUi()
         QtCore.QMetaObject.connectSlotsByName(self)
 
     def retranslateUi(self):
-        self.setWindowTitle(QtGui.QApplication.translate("privacySettings", "Privacy settings", None, QtGui.QApplication.UnicodeUTF8))
+        self.setWindowTitle(QtWidgets.QApplication.translate("privacySettings", "Privacy settings"))
-        self.saveHistory.setText(QtGui.QApplication.translate("privacySettings", "Save chat history", None, QtGui.QApplication.UnicodeUTF8))
+        self.saveHistory.setText(QtWidgets.QApplication.translate("privacySettings", "Save chat history"))
-        self.fileautoaccept.setText(QtGui.QApplication.translate("privacySettings", "Allow file auto accept", None, QtGui.QApplication.UnicodeUTF8))
+        self.fileautoaccept.setText(QtWidgets.QApplication.translate("privacySettings", "Allow file auto accept"))
-        self.typingNotifications.setText(QtGui.QApplication.translate("privacySettings", "Send typing notifications", None, QtGui.QApplication.UnicodeUTF8))
+        self.typingNotifications.setText(QtWidgets.QApplication.translate("privacySettings", "Send typing notifications"))
-        self.auto_path.setText(QtGui.QApplication.translate("privacySettings", "Auto accept default path:", None, QtGui.QApplication.UnicodeUTF8))
+        self.auto_path.setText(QtWidgets.QApplication.translate("privacySettings", "Auto accept default path:"))
-        self.change_path.setText(QtGui.QApplication.translate("privacySettings", "Change", None, QtGui.QApplication.UnicodeUTF8))
+        self.change_path.setText(QtWidgets.QApplication.translate("privacySettings", "Change"))
-        self.inlines.setText(QtGui.QApplication.translate("privacySettings", "Allow inlines", None, QtGui.QApplication.UnicodeUTF8))
+        self.inlines.setText(QtWidgets.QApplication.translate("privacySettings", "Allow inlines"))
-        self.block_user_label.setText(QtGui.QApplication.translate("privacySettings", "Block by public key:", None, QtGui.QApplication.UnicodeUTF8))
+        self.block_user_label.setText(QtWidgets.QApplication.translate("privacySettings", "Block by public key:"))
-        self.blocked_users_label.setText(QtGui.QApplication.translate("privacySettings", "Blocked users:", None, QtGui.QApplication.UnicodeUTF8))
+        self.blocked_users_label.setText(QtWidgets.QApplication.translate("privacySettings", "Blocked users:"))
-        self.unblock.setText(QtGui.QApplication.translate("privacySettings", "Unblock", None, QtGui.QApplication.UnicodeUTF8))
+        self.unblock.setText(QtWidgets.QApplication.translate("privacySettings", "Unblock"))
-        self.block.setText(QtGui.QApplication.translate("privacySettings", "Block user", None, QtGui.QApplication.UnicodeUTF8))
+        self.block.setText(QtWidgets.QApplication.translate("privacySettings", "Block user"))
-        self.saveUnsentOnly.setText(QtGui.QApplication.translate("privacySettings", "Save unsent messages only", None, QtGui.QApplication.UnicodeUTF8))
+        self.saveUnsentOnly.setText(QtWidgets.QApplication.translate("privacySettings", "Save unsent messages only"))
 
     def update(self, new_state):
         self.saveUnsentOnly.setEnabled(new_state)
@@ -462,10 +452,10 @@ class PrivacySettings(CenteredWidget):
     def unblock_user(self):
         if not self.comboBox.count():
             return
-        title = QtGui.QApplication.translate("privacySettings", "Add to friend list", None, QtGui.QApplication.UnicodeUTF8)
+        title = QtWidgets.QApplication.translate("privacySettings", "Add to friend list")
-        info = QtGui.QApplication.translate("privacySettings", "Do you want to add this user to friend list?", None, QtGui.QApplication.UnicodeUTF8)
+        info = QtWidgets.QApplication.translate("privacySettings", "Do you want to add this user to friend list?")
-        reply = QtGui.QMessageBox.question(None, title, info, QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)
+        reply = QtWidgets.QMessageBox.question(None, title, info, QtWidgets.QMessageBox.Yes, QtWidgets.QMessageBox.No)
-        Profile.get_instance().unblock_user(self.comboBox.currentText(), reply == QtGui.QMessageBox.Yes)
+        Profile.get_instance().unblock_user(self.comboBox.currentText(), reply == QtWidgets.QMessageBox.Yes)
         self.close()
 
     def closeEvent(self, event):
@@ -474,31 +464,27 @@ class PrivacySettings(CenteredWidget):
         settings['allow_auto_accept'] = self.fileautoaccept.isChecked()
 
         if settings['save_history'] and not self.saveHistory.isChecked():  # clear history
-            reply = QtGui.QMessageBox.question(None,
+            reply = QtWidgets.QMessageBox.question(None,
-                                               QtGui.QApplication.translate("privacySettings",
+                                               QtWidgets.QApplication.translate("privacySettings",
-                                                                            'Chat history',
+                                                                            'Chat history'),
-                                                                            None, QtGui.QApplication.UnicodeUTF8),
+                                               QtWidgets.QApplication.translate("privacySettings",
-                                               QtGui.QApplication.translate("privacySettings",
+                                                                            'History will be cleaned! Continue?'),
-                                                                            'History will be cleaned! Continue?',
+                                               QtWidgets.QMessageBox.Yes,
-                                                                            None, QtGui.QApplication.UnicodeUTF8),
+                                               QtWidgets.QMessageBox.No)
-                                               QtGui.QMessageBox.Yes,
+            if reply == QtWidgets.QMessageBox.Yes:
-                                               QtGui.QMessageBox.No)
-            if reply == QtGui.QMessageBox.Yes:
                 Profile.get_instance().clear_history()
                 settings['save_history'] = self.saveHistory.isChecked()
         else:
             settings['save_history'] = self.saveHistory.isChecked()
         if self.saveUnsentOnly.isChecked() and not settings['save_unsent_only']:
-            reply = QtGui.QMessageBox.question(None,
+            reply = QtWidgets.QMessageBox.question(None,
-                                               QtGui.QApplication.translate("privacySettings",
+                                               QtWidgets.QApplication.translate("privacySettings",
-                                                                            'Chat history',
+                                                                            'Chat history'),
-                                                                            None, QtGui.QApplication.UnicodeUTF8),
+                                               QtWidgets.QApplication.translate("privacySettings",
-                                               QtGui.QApplication.translate("privacySettings",
+                                                                            'History will be cleaned! Continue?'),
-                                                                            'History will be cleaned! Continue?',
+                                               QtWidgets.QMessageBox.Yes,
-                                                                            None, QtGui.QApplication.UnicodeUTF8),
+                                               QtWidgets.QMessageBox.No)
-                                               QtGui.QMessageBox.Yes,
+            if reply == QtWidgets.QMessageBox.Yes:
-                                               QtGui.QMessageBox.No)
-            if reply == QtGui.QMessageBox.Yes:
                 Profile.get_instance().clear_history(None, True)
                 settings['save_unsent_only'] = self.saveUnsentOnly.isChecked()
         else:
@@ -508,7 +494,8 @@ class PrivacySettings(CenteredWidget):
         settings.save()
 
     def new_path(self):
-        directory = QtGui.QFileDialog.getExistingDirectory(options=QtGui.QFileDialog.DontUseNativeDialog) + '/'
+        directory = QtWidgets.QFileDialog.getExistingDirectory(self, '', curr_directory() + '/',
+                                                               QtWidgets.QFileDialog.ShowDirsOnly | QtWidgets.QFileDialog.DontUseNativeDialog) + '/'
         if directory != '/':
             self.path.setPlainText(directory)
 
@@ -526,11 +513,11 @@ class NotificationsSettings(CenteredWidget):
         self.resize(350, 180)
         self.setMinimumSize(QtCore.QSize(350, 180))
         self.setMaximumSize(QtCore.QSize(350, 180))
-        self.enableNotifications = QtGui.QCheckBox(self)
+        self.enableNotifications = QtWidgets.QCheckBox(self)
         self.enableNotifications.setGeometry(QtCore.QRect(10, 20, 340, 18))
-        self.callsSound = QtGui.QCheckBox(self)
+        self.callsSound = QtWidgets.QCheckBox(self)
         self.callsSound.setGeometry(QtCore.QRect(10, 120, 340, 18))
-        self.soundNotifications = QtGui.QCheckBox(self)
+        self.soundNotifications = QtWidgets.QCheckBox(self)
         self.soundNotifications.setGeometry(QtCore.QRect(10, 70, 340, 18))
         font = QtGui.QFont()
         s = Settings.get_instance()
@@ -546,10 +533,10 @@ class NotificationsSettings(CenteredWidget):
         QtCore.QMetaObject.connectSlotsByName(self)
 
     def retranslateUi(self):
-        self.setWindowTitle(QtGui.QApplication.translate("notificationsForm", "Notification settings", None, QtGui.QApplication.UnicodeUTF8))
+        self.setWindowTitle(QtWidgets.QApplication.translate("notificationsForm", "Notification settings"))
-        self.enableNotifications.setText(QtGui.QApplication.translate("notificationsForm", "Enable notifications", None, QtGui.QApplication.UnicodeUTF8))
+        self.enableNotifications.setText(QtWidgets.QApplication.translate("notificationsForm", "Enable notifications"))
-        self.callsSound.setText(QtGui.QApplication.translate("notificationsForm", "Enable call\'s sound", None, QtGui.QApplication.UnicodeUTF8))
+        self.callsSound.setText(QtWidgets.QApplication.translate("notificationsForm", "Enable call\'s sound"))
-        self.soundNotifications.setText(QtGui.QApplication.translate("notificationsForm", "Enable sound notifications", None, QtGui.QApplication.UnicodeUTF8))
+        self.soundNotifications.setText(QtWidgets.QApplication.translate("notificationsForm", "Enable sound notifications"))
 
     def closeEvent(self, *args, **kwargs):
         settings = Settings.get_instance()
@@ -570,7 +557,7 @@ class InterfaceSettings(CenteredWidget):
         self.setObjectName("interfaceForm")
         self.setMinimumSize(QtCore.QSize(400, 650))
         self.setMaximumSize(QtCore.QSize(400, 650))
-        self.label = QtGui.QLabel(self)
+        self.label = QtWidgets.QLabel(self)
         self.label.setGeometry(QtCore.QRect(30, 10, 370, 20))
         settings = Settings.get_instance()
         font = QtGui.QFont()
@@ -578,7 +565,7 @@ class InterfaceSettings(CenteredWidget):
         font.setBold(True)
         font.setFamily(settings['font'])
         self.label.setFont(font)
-        self.themeSelect = QtGui.QComboBox(self)
+        self.themeSelect = QtWidgets.QComboBox(self)
         self.themeSelect.setGeometry(QtCore.QRect(30, 40, 120, 30))
         list_of_themes = ['dark']
         self.themeSelect.addItems(list_of_themes)
@@ -588,26 +575,26 @@ class InterfaceSettings(CenteredWidget):
         else:
             index = 0
         self.themeSelect.setCurrentIndex(index)
-        self.lang_choose = QtGui.QComboBox(self)
+        self.lang_choose = QtWidgets.QComboBox(self)
         self.lang_choose.setGeometry(QtCore.QRect(30, 110, 120, 30))
         supported = sorted(Settings.supported_languages().keys(), reverse=True)
         for key in supported:
             self.lang_choose.insertItem(0, key)
             if settings['language'] == key:
                 self.lang_choose.setCurrentIndex(0)
-        self.lang = QtGui.QLabel(self)
+        self.lang = QtWidgets.QLabel(self)
         self.lang.setGeometry(QtCore.QRect(30, 80, 370, 20))
         self.lang.setFont(font)
-        self.mirror_mode = QtGui.QCheckBox(self)
+        self.mirror_mode = QtWidgets.QCheckBox(self)
         self.mirror_mode.setGeometry(QtCore.QRect(30, 160, 370, 20))
         self.mirror_mode.setChecked(settings['mirror_mode'])
-        self.smileys = QtGui.QCheckBox(self)
+        self.smileys = QtWidgets.QCheckBox(self)
         self.smileys.setGeometry(QtCore.QRect(30, 190, 120, 20))
         self.smileys.setChecked(settings['smileys'])
-        self.smiley_pack_label = QtGui.QLabel(self)
+        self.smiley_pack_label = QtWidgets.QLabel(self)
         self.smiley_pack_label.setGeometry(QtCore.QRect(30, 230, 370, 20))
         self.smiley_pack_label.setFont(font)
-        self.smiley_pack = QtGui.QComboBox(self)
+        self.smiley_pack = QtWidgets.QComboBox(self)
         self.smiley_pack.setGeometry(QtCore.QRect(30, 260, 160, 30))
         sm = smileys.SmileyLoader.get_instance()
         self.smiley_pack.addItems(sm.get_packs_list())
@@ -616,39 +603,39 @@ class InterfaceSettings(CenteredWidget):
         except:
             ind = sm.get_packs_list().index('default')
         self.smiley_pack.setCurrentIndex(ind)
-        self.messages_font_size_label = QtGui.QLabel(self)
+        self.messages_font_size_label = QtWidgets.QLabel(self)
         self.messages_font_size_label.setGeometry(QtCore.QRect(30, 300, 370, 20))
         self.messages_font_size_label.setFont(font)
-        self.messages_font_size = QtGui.QComboBox(self)
+        self.messages_font_size = QtWidgets.QComboBox(self)
         self.messages_font_size.setGeometry(QtCore.QRect(30, 330, 160, 30))
         self.messages_font_size.addItems([str(x) for x in range(10, 19)])
         self.messages_font_size.setCurrentIndex(settings['message_font_size'] - 10)
 
-        self.unread = QtGui.QPushButton(self)
+        self.unread = QtWidgets.QPushButton(self)
         self.unread.setGeometry(QtCore.QRect(30, 470, 340, 30))
         self.unread.clicked.connect(self.select_color)
 
-        self.compact_mode = QtGui.QCheckBox(self)
+        self.compact_mode = QtWidgets.QCheckBox(self)
         self.compact_mode.setGeometry(QtCore.QRect(30, 380, 370, 20))
         self.compact_mode.setChecked(settings['compact_mode'])
 
-        self.close_to_tray = QtGui.QCheckBox(self)
+        self.close_to_tray = QtWidgets.QCheckBox(self)
         self.close_to_tray.setGeometry(QtCore.QRect(30, 410, 370, 20))
         self.close_to_tray.setChecked(settings['close_to_tray'])
 
-        self.show_avatars = QtGui.QCheckBox(self)
+        self.show_avatars = QtWidgets.QCheckBox(self)
         self.show_avatars.setGeometry(QtCore.QRect(30, 440, 370, 20))
         self.show_avatars.setChecked(settings['show_avatars'])
 
-        self.choose_font = QtGui.QPushButton(self)
+        self.choose_font = QtWidgets.QPushButton(self)
         self.choose_font.setGeometry(QtCore.QRect(30, 510, 340, 30))
         self.choose_font.clicked.connect(self.new_font)
 
-        self.import_smileys = QtGui.QPushButton(self)
+        self.import_smileys = QtWidgets.QPushButton(self)
         self.import_smileys.setGeometry(QtCore.QRect(30, 550, 340, 30))
         self.import_smileys.clicked.connect(self.import_sm)
 
-        self.import_stickers = QtGui.QPushButton(self)
+        self.import_stickers = QtWidgets.QPushButton(self)
         self.import_stickers.setGeometry(QtCore.QRect(30, 590, 340, 30))
         self.import_stickers.clicked.connect(self.import_st)
 
@@ -656,29 +643,27 @@ class InterfaceSettings(CenteredWidget):
         QtCore.QMetaObject.connectSlotsByName(self)
 
     def retranslateUi(self):
-        self.show_avatars.setText(QtGui.QApplication.translate("interfaceForm", "Show avatars in chat", None, QtGui.QApplication.UnicodeUTF8))
+        self.show_avatars.setText(QtWidgets.QApplication.translate("interfaceForm", "Show avatars in chat"))
-        self.setWindowTitle(QtGui.QApplication.translate("interfaceForm", "Interface settings", None, QtGui.QApplication.UnicodeUTF8))
+        self.setWindowTitle(QtWidgets.QApplication.translate("interfaceForm", "Interface settings"))
-        self.label.setText(QtGui.QApplication.translate("interfaceForm", "Theme:", None, QtGui.QApplication.UnicodeUTF8))
+        self.label.setText(QtWidgets.QApplication.translate("interfaceForm", "Theme:"))
-        self.lang.setText(QtGui.QApplication.translate("interfaceForm", "Language:", None, QtGui.QApplication.UnicodeUTF8))
+        self.lang.setText(QtWidgets.QApplication.translate("interfaceForm", "Language:"))
-        self.smileys.setText(QtGui.QApplication.translate("interfaceForm", "Smileys", None, QtGui.QApplication.UnicodeUTF8))
+        self.smileys.setText(QtWidgets.QApplication.translate("interfaceForm", "Smileys"))
-        self.smiley_pack_label.setText(QtGui.QApplication.translate("interfaceForm", "Smiley pack:", None, QtGui.QApplication.UnicodeUTF8))
+        self.smiley_pack_label.setText(QtWidgets.QApplication.translate("interfaceForm", "Smiley pack:"))
-        self.mirror_mode.setText(QtGui.QApplication.translate("interfaceForm", "Mirror mode", None, QtGui.QApplication.UnicodeUTF8))
+        self.mirror_mode.setText(QtWidgets.QApplication.translate("interfaceForm", "Mirror mode"))
-        self.messages_font_size_label.setText(QtGui.QApplication.translate("interfaceForm", "Messages font size:", None, QtGui.QApplication.UnicodeUTF8))
+        self.messages_font_size_label.setText(QtWidgets.QApplication.translate("interfaceForm", "Messages font size:"))
-        self.unread.setText(QtGui.QApplication.translate("interfaceForm", "Select unread messages notification color", None, QtGui.QApplication.UnicodeUTF8))
+        self.unread.setText(QtWidgets.QApplication.translate("interfaceForm", "Select unread messages notification color"))
-        self.compact_mode.setText(QtGui.QApplication.translate("interfaceForm", "Compact contact list", None, QtGui.QApplication.UnicodeUTF8))
+        self.compact_mode.setText(QtWidgets.QApplication.translate("interfaceForm", "Compact contact list"))
-        self.import_smileys.setText(QtGui.QApplication.translate("interfaceForm", "Import smiley pack", None, QtGui.QApplication.UnicodeUTF8))
+        self.import_smileys.setText(QtWidgets.QApplication.translate("interfaceForm", "Import smiley pack"))
-        self.import_stickers.setText(QtGui.QApplication.translate("interfaceForm", "Import sticker pack", None, QtGui.QApplication.UnicodeUTF8))
+        self.import_stickers.setText(QtWidgets.QApplication.translate("interfaceForm", "Import sticker pack"))
-        self.close_to_tray.setText(QtGui.QApplication.translate("interfaceForm", "Close to tray", None, QtGui.QApplication.UnicodeUTF8))
+        self.close_to_tray.setText(QtWidgets.QApplication.translate("interfaceForm", "Close to tray"))
-        self.choose_font.setText(QtGui.QApplication.translate("interfaceForm", "Select font", None, QtGui.QApplication.UnicodeUTF8))
+        self.choose_font.setText(QtWidgets.QApplication.translate("interfaceForm", "Select font"))
 
     def import_st(self):
-        directory = QtGui.QFileDialog.getExistingDirectory(self,
+        directory = QtWidgets.QFileDialog.getExistingDirectory(self,
-                                                           QtGui.QApplication.translate("MainWindow",
+                                                               QtWidgets.QApplication.translate("MainWindow",
-                                                                                        'Choose folder with sticker pack',
+                                                                                                'Choose folder with sticker pack'),
-                                                                                        None,
+                                                               curr_directory(),
-                                                                                        QtGui.QApplication.UnicodeUTF8),
+                                                               QtWidgets.QFileDialog.ShowDirsOnly | QtWidgets.QFileDialog.DontUseNativeDialog)
-                                                           curr_directory(),
-                                                           QtGui.QFileDialog.ShowDirsOnly | QtGui.QFileDialog.DontUseNativeDialog)
 
         if directory:
             src = directory + '/'
@@ -686,13 +671,11 @@ class InterfaceSettings(CenteredWidget):
             copy(src, dest)
 
     def import_sm(self):
-        directory = QtGui.QFileDialog.getExistingDirectory(self,
+        directory = QtWidgets.QFileDialog.getExistingDirectory(self,
-                                                           QtGui.QApplication.translate("MainWindow",
+                                                           QtWidgets.QApplication.translate("MainWindow",
-                                                                                        'Choose folder with smiley pack',
+                                                                                        'Choose folder with smiley pack'),
-                                                                                        None,
-                                                                                        QtGui.QApplication.UnicodeUTF8),
                                                            curr_directory(),
-                                                           QtGui.QFileDialog.ShowDirsOnly | QtGui.QFileDialog.DontUseNativeDialog)
+                                                           QtWidgets.QFileDialog.ShowDirsOnly | QtWidgets.QFileDialog.DontUseNativeDialog)
 
         if directory:
             src = directory + '/'
@@ -701,23 +684,21 @@ class InterfaceSettings(CenteredWidget):
 
     def new_font(self):
         settings = Settings.get_instance()
-        font, ok = QtGui.QFontDialog.getFont(QtGui.QFont(settings['font'], 10), self)
+        font, ok = QtWidgets.QFontDialog.getFont(QtGui.QFont(settings['font'], 10), self)
         if ok:
             settings['font'] = font.family()
             settings.save()
-            msgBox = QtGui.QMessageBox()
+            msgBox = QtWidgets.QMessageBox()
-            text = QtGui.QApplication.translate("interfaceForm", 'Restart app to apply settings', None,
+            text = QtWidgets.QApplication.translate("interfaceForm", 'Restart app to apply settings')
-                                                QtGui.QApplication.UnicodeUTF8)
+            msgBox.setWindowTitle(QtWidgets.QApplication.translate("interfaceForm", 'Restart required'))
-            msgBox.setWindowTitle(QtGui.QApplication.translate("interfaceForm", 'Restart required', None,
-                                                               QtGui.QApplication.UnicodeUTF8))
             msgBox.setText(text)
             msgBox.exec_()
 
     def select_color(self):
-        col = QtGui.QColorDialog.getColor()
+        settings = Settings.get_instance()
+        col = QtWidgets.QColorDialog.getColor(QtGui.QColor(settings['unread_color']))
 
         if col.isValid():
-            settings = Settings.get_instance()
             name = col.name()
             settings['unread_color'] = name
             settings.save()
@@ -744,7 +725,7 @@ class InterfaceSettings(CenteredWidget):
             settings['language'] = language
             text = self.lang_choose.currentText()
             path = Settings.supported_languages()[text]
-            app = QtGui.QApplication.instance()
+            app = QtWidgets.QApplication.instance()
             app.removeTranslator(app.translator)
             app.translator.load(curr_directory() + '/translations/' + path)
             app.installTranslator(app.translator)
@@ -752,11 +733,9 @@ class InterfaceSettings(CenteredWidget):
         Profile.get_instance().update()
         settings.save()
         if restart:
-            msgBox = QtGui.QMessageBox()
+            msgBox = QtWidgets.QMessageBox()
-            text = QtGui.QApplication.translate("interfaceForm", 'Restart app to apply settings', None,
+            text = QtWidgets.QApplication.translate("interfaceForm", 'Restart app to apply settings')
-                                                QtGui.QApplication.UnicodeUTF8)
+            msgBox.setWindowTitle(QtWidgets.QApplication.translate("interfaceForm", 'Restart required'))
-            msgBox.setWindowTitle(QtGui.QApplication.translate("interfaceForm", 'Restart required', None,
-                                                               QtGui.QApplication.UnicodeUTF8))
             msgBox.setText(text)
             msgBox.exec_()
 
@@ -777,9 +756,9 @@ class AudioSettings(CenteredWidget):
         self.resize(400, 150)
         self.setMinimumSize(QtCore.QSize(400, 150))
         self.setMaximumSize(QtCore.QSize(400, 150))
-        self.in_label = QtGui.QLabel(self)
+        self.in_label = QtWidgets.QLabel(self)
         self.in_label.setGeometry(QtCore.QRect(25, 5, 350, 20))
-        self.out_label = QtGui.QLabel(self)
+        self.out_label = QtWidgets.QLabel(self)
         self.out_label.setGeometry(QtCore.QRect(25, 65, 350, 20))
         settings = Settings.get_instance()
         font = QtGui.QFont()
@@ -788,9 +767,9 @@ class AudioSettings(CenteredWidget):
         font.setFamily(settings['font'])
         self.in_label.setFont(font)
         self.out_label.setFont(font)
-        self.input = QtGui.QComboBox(self)
+        self.input = QtWidgets.QComboBox(self)
         self.input.setGeometry(QtCore.QRect(25, 30, 350, 30))
-        self.output = QtGui.QComboBox(self)
+        self.output = QtWidgets.QComboBox(self)
         self.output.setGeometry(QtCore.QRect(25, 90, 350, 30))
         p = pyaudio.PyAudio()
         self.in_indexes, self.out_indexes = [], []
@@ -807,9 +786,9 @@ class AudioSettings(CenteredWidget):
         QtCore.QMetaObject.connectSlotsByName(self)
 
     def retranslateUi(self):
-        self.setWindowTitle(QtGui.QApplication.translate("audioSettingsForm", "Audio settings", None, QtGui.QApplication.UnicodeUTF8))
+        self.setWindowTitle(QtWidgets.QApplication.translate("audioSettingsForm", "Audio settings"))
-        self.in_label.setText(QtGui.QApplication.translate("audioSettingsForm", "Input device:", None, QtGui.QApplication.UnicodeUTF8))
+        self.in_label.setText(QtWidgets.QApplication.translate("audioSettingsForm", "Input device:"))
-        self.out_label.setText(QtGui.QApplication.translate("audioSettingsForm", "Output device:", None, QtGui.QApplication.UnicodeUTF8))
+        self.out_label.setText(QtWidgets.QApplication.translate("audioSettingsForm", "Output device:"))
 
     def closeEvent(self, event):
         settings = Settings.get_instance()
@@ -833,15 +812,15 @@ class PluginsSettings(CenteredWidget):
         self.resize(400, 210)
         self.setMinimumSize(QtCore.QSize(400, 210))
         self.setMaximumSize(QtCore.QSize(400, 210))
-        self.comboBox = QtGui.QComboBox(self)
+        self.comboBox = QtWidgets.QComboBox(self)
         self.comboBox.setGeometry(QtCore.QRect(30, 10, 340, 30))
-        self.label = QtGui.QLabel(self)
+        self.label = QtWidgets.QLabel(self)
         self.label.setGeometry(QtCore.QRect(30, 40, 340, 90))
         self.label.setWordWrap(True)
-        self.button = QtGui.QPushButton(self)
+        self.button = QtWidgets.QPushButton(self)
         self.button.setGeometry(QtCore.QRect(30, 130, 340, 30))
         self.button.clicked.connect(self.button_click)
-        self.open = QtGui.QPushButton(self)
+        self.open = QtWidgets.QPushButton(self)
         self.open.setGeometry(QtCore.QRect(30, 170, 340, 30))
         self.open.clicked.connect(self.open_plugin)
         self.pl_loader = plugin_support.PluginLoader.get_instance()
@@ -850,8 +829,8 @@ class PluginsSettings(CenteredWidget):
         self.show_data()
 
     def retranslateUi(self):
-        self.setWindowTitle(QtGui.QApplication.translate('PluginsForm', "Plugins", None, QtGui.QApplication.UnicodeUTF8))
+        self.setWindowTitle(QtWidgets.QApplication.translate('PluginsForm', "Plugins"))
-        self.open.setText(QtGui.QApplication.translate('PluginsForm', "Open selected plugin", None, QtGui.QApplication.UnicodeUTF8))
+        self.open.setText(QtWidgets.QApplication.translate('PluginsForm', "Open selected plugin"))
 
     def open_plugin(self):
         ind = self.comboBox.currentIndex()
@@ -861,11 +840,9 @@ class PluginsSettings(CenteredWidget):
             self.window = window
             self.window.show()
         else:
-            msgBox = QtGui.QMessageBox()
+            msgBox = QtWidgets.QMessageBox()
-            text = QtGui.QApplication.translate("PluginsForm", 'No GUI found for this plugin', None,
+            text = QtWidgets.QApplication.translate("PluginsForm", 'No GUI found for this plugin')
-                                                QtGui.QApplication.UnicodeUTF8)
+            msgBox.setWindowTitle(QtWidgets.QApplication.translate("PluginsForm", 'Error'))
-            msgBox.setWindowTitle(QtGui.QApplication.translate("PluginsForm", 'Error', None,
-                                                               QtGui.QApplication.UnicodeUTF8))
             msgBox.setText(text)
             msgBox.exec_()
 
@@ -879,16 +856,16 @@ class PluginsSettings(CenteredWidget):
         ind = self.comboBox.currentIndex()
         if len(self.data):
             plugin = self.data[ind]
-            descr = plugin[2] or QtGui.QApplication.translate("PluginsForm", "No description available", None, QtGui.QApplication.UnicodeUTF8)
+            descr = plugin[2] or QtWidgets.QApplication.translate("PluginsForm", "No description available")
             self.label.setText(descr)
             if plugin[1]:
-                self.button.setText(QtGui.QApplication.translate("PluginsForm", "Disable plugin", None, QtGui.QApplication.UnicodeUTF8))
+                self.button.setText(QtWidgets.QApplication.translate("PluginsForm", "Disable plugin"))
             else:
-                self.button.setText(QtGui.QApplication.translate("PluginsForm", "Enable plugin", None, QtGui.QApplication.UnicodeUTF8))
+                self.button.setText(QtWidgets.QApplication.translate("PluginsForm", "Enable plugin"))
         else:
             self.open.setVisible(False)
             self.button.setVisible(False)
-            self.label.setText(QtGui.QApplication.translate("PluginsForm", "No plugins found", None, QtGui.QApplication.UnicodeUTF8))
+            self.label.setText(QtWidgets.QApplication.translate("PluginsForm", "No plugins found"))
 
     def button_click(self):
         ind = self.comboBox.currentIndex()
@@ -896,6 +873,83 @@ class PluginsSettings(CenteredWidget):
         self.pl_loader.toggle_plugin(plugin[-1])
         plugin[1] = not plugin[1]
         if plugin[1]:
-            self.button.setText(QtGui.QApplication.translate("PluginsForm", "Disable plugin", None, QtGui.QApplication.UnicodeUTF8))
+            self.button.setText(QtWidgets.QApplication.translate("PluginsForm", "Disable plugin"))
         else:
-            self.button.setText(QtGui.QApplication.translate("PluginsForm", "Enable plugin", None, QtGui.QApplication.UnicodeUTF8))
+            self.button.setText(QtWidgets.QApplication.translate("PluginsForm", "Enable plugin"))
+
+
+class UpdateSettings(CenteredWidget):
+    """
+    Updates settings form
+    """
+
+    def __init__(self):
+        super(UpdateSettings, self).__init__()
+        self.initUI()
+        self.center()
+
+    def initUI(self):
+        self.setObjectName("updateSettingsForm")
+        self.resize(400, 150)
+        self.setMinimumSize(QtCore.QSize(400, 120))
+        self.setMaximumSize(QtCore.QSize(400, 120))
+        self.in_label = QtWidgets.QLabel(self)
+        self.in_label.setGeometry(QtCore.QRect(25, 5, 350, 20))
+        settings = Settings.get_instance()
+        font = QtGui.QFont()
+        font.setPointSize(16)
+        font.setBold(True)
+        font.setFamily(settings['font'])
+        self.in_label.setFont(font)
+        self.autoupdate = QtWidgets.QComboBox(self)
+        self.autoupdate.setGeometry(QtCore.QRect(25, 30, 350, 30))
+        self.button = QtWidgets.QPushButton(self)
+        self.button.setGeometry(QtCore.QRect(25, 70, 350, 30))
+        self.button.setEnabled(settings['update'])
+        self.button.clicked.connect(self.update_client)
+
+        self.retranslateUi()
+        self.autoupdate.setCurrentIndex(settings['update'])
+        QtCore.QMetaObject.connectSlotsByName(self)
+
+    def retranslateUi(self):
+        self.setWindowTitle(QtWidgets.QApplication.translate("updateSettingsForm", "Update settings"))
+        self.in_label.setText(QtWidgets.QApplication.translate("updateSettingsForm", "Select update mode:"))
+        self.button.setText(QtWidgets.QApplication.translate("updateSettingsForm", "Update Toxygen"))
+        self.autoupdate.addItem(QtWidgets.QApplication.translate("updateSettingsForm", "Disabled"))
+        self.autoupdate.addItem(QtWidgets.QApplication.translate("updateSettingsForm", "Manual"))
+        self.autoupdate.addItem(QtWidgets.QApplication.translate("updateSettingsForm", "Auto"))
+
+    def closeEvent(self, event):
+        settings = Settings.get_instance()
+        settings['update'] = self.autoupdate.currentIndex()
+        settings.save()
+
+    def update_client(self):
+        if not updater.connection_available():
+            msgBox = QtWidgets.QMessageBox()
+            msgBox.setWindowTitle(
+                QtWidgets.QApplication.translate("updateSettingsForm", "Error"))
+            text = (QtWidgets.QApplication.translate("updateSettingsForm", 'Problems with internet connection'))
+            msgBox.setText(text)
+            msgBox.exec_()
+            return
+        if not updater.updater_available():
+            msgBox = QtWidgets.QMessageBox()
+            msgBox.setWindowTitle(
+                QtWidgets.QApplication.translate("updateSettingsForm", "Error"))
+            text = (QtWidgets.QApplication.translate("updateSettingsForm", 'Updater not found'))
+            msgBox.setText(text)
+            msgBox.exec_()
+            return
+        version = updater.check_for_updates()
+        if version is not None:
+            updater.download(version)
+            QtWidgets.QApplication.closeAllWindows()
+        else:
+            msgBox = QtWidgets.QMessageBox()
+            msgBox.setWindowTitle(
+                QtWidgets.QApplication.translate("updateSettingsForm", "No updates found"))
+            text = (QtWidgets.QApplication.translate("updateSettingsForm", 'Toxygen is up to date'))
+            msgBox.setText(text)
+            msgBox.exec_()

toxygen/notifications.py

@@ -1,7 +1,4 @@
-try:
+from PyQt5 import QtCore, QtWidgets
-    from PySide import QtCore, QtGui
-except ImportError:
-    from PyQt4 import QtCore, QtGui
 from util import curr_directory
 import wave
 import pyaudio
@@ -23,16 +20,16 @@ def tray_notification(title, text, tray, window):
     :param tray: ref to tray icon
     :param window: main window
     """
-    if QtGui.QSystemTrayIcon.isSystemTrayAvailable():
+    if QtWidgets.QSystemTrayIcon.isSystemTrayAvailable():
         if len(text) > 30:
             text = text[:27] + '...'
-        tray.showMessage(title, text, QtGui.QSystemTrayIcon.NoIcon, 3000)
+        tray.showMessage(title, text, QtWidgets.QSystemTrayIcon.NoIcon, 3000)
-        QtGui.QApplication.alert(window, 0)
+        QtWidgets.QApplication.alert(window, 0)
 
         def message_clicked():
             window.setWindowState(window.windowState() & ~QtCore.Qt.WindowMinimized | QtCore.Qt.WindowActive)
             window.activateWindow()
-        tray.connect(tray, QtCore.SIGNAL("messageClicked()"), message_clicked)
+        tray.messageClicked.connect(message_clicked)
 
 
 class AudioFile:
@@ -45,8 +42,7 @@ class AudioFile:
             format=self.p.get_format_from_width(self.wf.getsampwidth()),
             channels=self.wf.getnchannels(),
             rate=self.wf.getframerate(),
-            output=True
+            output=True)
-        )
 
     def play(self):
         data = self.wf.readframes(self.chunk)

toxygen/passwordscreen.py

@@ -1,8 +1,5 @@
 from widgets import CenteredWidget, LineEdit
-try:
+from PyQt5 import QtCore, QtWidgets
-    from PySide import QtCore, QtGui
-except ImportError:
-    from PyQt4 import QtCore, QtGui
 
 
 class PasswordArea(LineEdit):
@@ -10,7 +7,7 @@ class PasswordArea(LineEdit):
     def __init__(self, parent):
         super(PasswordArea, self).__init__(parent)
         self.parent = parent
-        self.setEchoMode(QtGui.QLineEdit.EchoMode.Password)
+        self.setEchoMode(QtWidgets.QLineEdit.Password)
 
     def keyPressEvent(self, event):
         if event.key() == QtCore.Qt.Key_Return:
@@ -31,18 +28,18 @@ class PasswordScreenBase(CenteredWidget):
         self.setMinimumSize(QtCore.QSize(360, 170))
         self.setMaximumSize(QtCore.QSize(360, 170))
 
-        self.enter_pass = QtGui.QLabel(self)
+        self.enter_pass = QtWidgets.QLabel(self)
         self.enter_pass.setGeometry(QtCore.QRect(30, 10, 300, 30))
 
         self.password = PasswordArea(self)
         self.password.setGeometry(QtCore.QRect(30, 50, 300, 30))
 
-        self.button = QtGui.QPushButton(self)
+        self.button = QtWidgets.QPushButton(self)
         self.button.setGeometry(QtCore.QRect(30, 90, 300, 30))
         self.button.setText('OK')
         self.button.clicked.connect(self.button_click)
 
-        self.warning = QtGui.QLabel(self)
+        self.warning = QtWidgets.QLabel(self)
         self.warning.setGeometry(QtCore.QRect(30, 130, 300, 30))
         self.warning.setStyleSheet('QLabel { color: #F70D1A; }')
         self.warning.setVisible(False)
@@ -61,9 +58,9 @@ class PasswordScreenBase(CenteredWidget):
             super(PasswordScreenBase, self).keyPressEvent(event)
 
     def retranslateUi(self):
-        self.setWindowTitle(QtGui.QApplication.translate("pass", "Enter password", None, QtGui.QApplication.UnicodeUTF8))
+        self.setWindowTitle(QtWidgets.QApplication.translate("pass", "Enter password"))
-        self.enter_pass.setText(QtGui.QApplication.translate("pass", "Password:", None, QtGui.QApplication.UnicodeUTF8))
+        self.enter_pass.setText(QtWidgets.QApplication.translate("pass", "Password:"))
-        self.warning.setText(QtGui.QApplication.translate("pass", "Incorrect password", None, QtGui.QApplication.UnicodeUTF8))
+        self.warning.setText(QtWidgets.QApplication.translate("pass", "Incorrect password"))
 
 
 class PasswordScreen(PasswordScreenBase):
@@ -116,37 +113,32 @@ class SetProfilePasswordScreen(CenteredWidget):
         self.setMaximumSize(QtCore.QSize(700, 200))
         self.password = LineEdit(self)
         self.password.setGeometry(QtCore.QRect(40, 10, 300, 30))
-        self.password.setEchoMode(QtGui.QLineEdit.EchoMode.Password)
+        self.password.setEchoMode(QtWidgets.QLineEdit.Password)
         self.confirm_password = LineEdit(self)
         self.confirm_password.setGeometry(QtCore.QRect(40, 50, 300, 30))
-        self.confirm_password.setEchoMode(QtGui.QLineEdit.EchoMode.Password)
+        self.confirm_password.setEchoMode(QtWidgets.QLineEdit.Password)
-        self.set_password = QtGui.QPushButton(self)
+        self.set_password = QtWidgets.QPushButton(self)
         self.set_password.setGeometry(QtCore.QRect(40, 100, 300, 30))
         self.set_password.clicked.connect(self.new_password)
-        self.not_match = QtGui.QLabel(self)
+        self.not_match = QtWidgets.QLabel(self)
         self.not_match.setGeometry(QtCore.QRect(350, 50, 300, 30))
         self.not_match.setVisible(False)
         self.not_match.setStyleSheet('QLabel { color: #BC1C1C; }')
-        self.warning = QtGui.QLabel(self)
+        self.warning = QtWidgets.QLabel(self)
         self.warning.setGeometry(QtCore.QRect(40, 160, 500, 30))
         self.warning.setStyleSheet('QLabel { color: #BC1C1C; }')
 
     def retranslateUi(self):
-        self.setWindowTitle(QtGui.QApplication.translate("PasswordScreen", "Profile password", None,
+        self.setWindowTitle(QtWidgets.QApplication.translate("PasswordScreen", "Profile password"))
-                                                              QtGui.QApplication.UnicodeUTF8))
         self.password.setPlaceholderText(
-            QtGui.QApplication.translate("PasswordScreen", "Password (at least 8 symbols)", None,
+            QtWidgets.QApplication.translate("PasswordScreen", "Password (at least 8 symbols)"))
-                                         QtGui.QApplication.UnicodeUTF8))
         self.confirm_password.setPlaceholderText(
-            QtGui.QApplication.translate("PasswordScreen", "Confirm password", None,
+            QtWidgets.QApplication.translate("PasswordScreen", "Confirm password"))
-                                         QtGui.QApplication.UnicodeUTF8))
         self.set_password.setText(
-            QtGui.QApplication.translate("PasswordScreen", "Set password", None, QtGui.QApplication.UnicodeUTF8))
+            QtWidgets.QApplication.translate("PasswordScreen", "Set password"))
-        self.not_match.setText(QtGui.QApplication.translate("PasswordScreen", "Passwords do not match", None,
+        self.not_match.setText(QtWidgets.QApplication.translate("PasswordScreen", "Passwords do not match"))
-                                                            QtGui.QApplication.UnicodeUTF8))
         self.warning.setText(
-            QtGui.QApplication.translate("PasswordScreen", "There is no way to recover lost passwords", None,
+            QtWidgets.QApplication.translate("PasswordScreen", "There is no way to recover lost passwords"))
-                                         QtGui.QApplication.UnicodeUTF8))
 
     def new_password(self):
         if self.password.text() == self.confirm_password.text():
@@ -155,10 +147,8 @@ class SetProfilePasswordScreen(CenteredWidget):
                 self.close()
             else:
                 self.not_match.setText(
-                    QtGui.QApplication.translate("PasswordScreen", "Password must be at least 8 symbols", None,
+                    QtWidgets.QApplication.translate("PasswordScreen", "Password must be at least 8 symbols"))
-                                                 QtGui.QApplication.UnicodeUTF8))
             self.not_match.setVisible(True)
         else:
-            self.not_match.setText(QtGui.QApplication.translate("PasswordScreen", "Passwords do not match", None,
+            self.not_match.setText(QtWidgets.QApplication.translate("PasswordScreen", "Passwords do not match"))
-                                                                QtGui.QApplication.UnicodeUTF8))
             self.not_match.setVisible(True)

toxygen/plugin_support.py

@@ -4,7 +4,7 @@ import os
 import importlib
 import inspect
 import plugins.plugin_super_class as pl
-import toxencryptsave
+import toxes
 import sys
 
 
@@ -16,7 +16,7 @@ class PluginLoader(util.Singleton):
         self._settings = settings
         self._plugins = {}  # dict. key - plugin unique short name, value - tuple (plugin instance, is active)
         self._tox = tox
-        self._encr = toxencryptsave.ToxEncryptSave.get_instance()
+        self._encr = toxes.ToxES.get_instance()
 
     def set_tox(self, tox):
         """
@@ -51,7 +51,8 @@ class PluginLoader(util.Singleton):
                 continue
             for elem in dir(module):
                 obj = getattr(module, elem)
-                if inspect.isclass(obj) and hasattr(obj, 'is_plugin') and obj.is_plugin:  # looking for plugin class in module
+                # looking for plugin class in module
+                if inspect.isclass(obj) and hasattr(obj, 'is_plugin') and obj.is_plugin:
                     print('Plugin', elem)
                     try:  # create instance of plugin class
                         inst = obj(self._tox, self._profile, self._settings, self._encr)
@@ -64,23 +65,23 @@ class PluginLoader(util.Singleton):
                     self._plugins[inst.get_short_name()] = [inst, autostart]  # (inst, is active)
                     break
 
-    def callback_lossless(self, friend_number, data, length):
+    def callback_lossless(self, friend_number, data):
         """
         New incoming custom lossless packet (callback)
         """
         l = data[0] - pl.LOSSLESS_FIRST_BYTE
         name = ''.join(chr(x) for x in data[1:l + 1])
         if name in self._plugins and self._plugins[name][1]:
-            self._plugins[name][0].lossless_packet(''.join(chr(x) for x in data[l + 1:length]), friend_number)
+            self._plugins[name][0].lossless_packet(''.join(chr(x) for x in data[l + 1:]), friend_number)
 
-    def callback_lossy(self, friend_number, data, length):
+    def callback_lossy(self, friend_number, data):
         """
         New incoming custom lossy packet (callback)
         """
         l = data[0] - pl.LOSSY_FIRST_BYTE
         name = ''.join(chr(x) for x in data[1:l + 1])
         if name in self._plugins and self._plugins[name][1]:
-            self._plugins[name][0].lossy_packet(''.join(chr(x) for x in data[l + 1:length]), friend_number)
+            self._plugins[name][0].lossy_packet(''.join(chr(x) for x in data[l + 1:]), friend_number)
 
     def friend_online(self, friend_number):
         """
@@ -165,3 +166,8 @@ class PluginLoader(util.Singleton):
             if self._plugins[key][1]:
                 self._plugins[key][0].close()
             del self._plugins[key]
+
+    def reload(self):
+        print('Reloading plugins')
+        self.stop()
+        self.load()

toxygen/plugins/plugin_super_class.py

@@ -1,8 +1,5 @@
 import os
-try:
+from PyQt5 import QtCore, QtWidgets
-    from PySide import QtCore, QtGui
-except ImportError:
-    from PyQt4 import QtCore, QtGui
 
 
 MAX_SHORT_NAME_LENGTH = 5
@@ -26,12 +23,12 @@ def log(name, data):
     :param data: data for saving in log
     """
     with open(path_to_data(name) + 'logs.txt', 'a') as fl:
-        fl.write(bytes(data, 'utf-8') + b'\n')
+        fl.write(str(data) + '\n')
 
 
 class PluginSuperClass:
     """
-    Superclass for all plugins. Plugin is python module with at least one class derived from PluginSuperClass.
+    Superclass for all plugins. Plugin is Python3 module with at least one class derived from PluginSuperClass.
     """
     is_plugin = True
 
@@ -43,7 +40,7 @@ class PluginSuperClass:
         :param tox: tox instance
         :param profile: profile instance
         :param settings: profile settings
-        :param encrypt_save: LibToxEncryptSave instance.
+        :param encrypt_save: ToxES instance.
         """
         self._settings = settings
         self._profile = profile
@@ -129,7 +126,7 @@ class PluginSuperClass:
         """
         App is closing
         """
-        pass
+        self.stop()
 
     def command(self, command):
         """
@@ -137,10 +134,10 @@ class PluginSuperClass:
         :param command: string with command
         """
         if command == 'help':
-            msgbox = QtGui.QMessageBox()
+            msgbox = QtWidgets.QMessageBox()
-            title = QtGui.QApplication.translate("PluginWindow", "List of commands for plugin {}", None, QtGui.QApplication.UnicodeUTF8)
+            title = QtWidgets.QApplication.translate("PluginWindow", "List of commands for plugin {}")
             msgbox.setWindowTitle(title.format(self._name))
-            msgbox.setText(QtGui.QApplication.translate("PluginWindow", "No commands available", None, QtGui.QApplication.UnicodeUTF8))
+            msgbox.setText(QtWidgets.QApplication.translate("PluginWindow", "No commands available"))
             msgbox.exec_()
 
     # -----------------------------------------------------------------------------------------------------------------
@@ -151,7 +148,7 @@ class PluginSuperClass:
         """
         This method loads translations for GUI
         """
-        app = QtGui.QApplication.instance()
+        app = QtWidgets.QApplication.instance()
         langs = self._settings.supported_languages()
         curr_lang = self._settings['language']
         if curr_lang in langs:
@@ -169,6 +166,7 @@ class PluginSuperClass:
     def load_settings(self):
         """
         This method loads settings of plugin and returns raw data
+        If file doesn't exist this method raises exception
         """
         with open(path_to_data(self._short_name) + 'settings.json', 'rb') as fl:
             data = fl.read()

toxygen/profile.py

@@ -1,8 +1,5 @@
 from list_items import *
-try:
+from PyQt5 import QtGui, QtWidgets
-    from PySide import QtCore, QtGui
-except ImportError:
-    from PyQt4 import QtCore, QtGui
 from friend import *
 from settings import *
 from toxcore_enums_and_consts import *
@@ -15,9 +12,11 @@ import time
 import calls
 import avwidgets
 import plugin_support
+import basecontact
+import items_factory
 
 
-class Profile(contact.Contact, Singleton):
+class Profile(basecontact.BaseContact, Singleton):
     """
     Profile of current toxygen user. Contains friends list, tox instance
     """
@@ -26,11 +25,11 @@ class Profile(contact.Contact, Singleton):
         :param tox: tox instance
         :param screen: ref to main screen
         """
-        contact.Contact.__init__(self,
+        basecontact.BaseContact.__init__(self,
-                                 tox.self_get_name(),
+                                         tox.self_get_name(),
-                                 tox.self_get_status_message(),
+                                         tox.self_get_status_message(),
-                                 screen.user_info,
+                                         screen.user_info,
-                                 tox.self_get_address())
+                                         tox.self_get_address())
         Singleton.__init__(self)
         self._screen = screen
         self._messages = screen.messages
@@ -39,17 +38,20 @@ class Profile(contact.Contact, Singleton):
         self._call = calls.AV(tox.AV)  # object with data about calls
         self._incoming_calls = set()
         self._load_history = True
+        self._waiting_for_reconnection = False
+        self._factory = items_factory.ItemsFactory(self._screen.friends_list, self._messages)
         settings = Settings.get_instance()
-        self._show_online = settings['show_online_friends']
+        self._sorting = settings['sorting']
         self._show_avatars = settings['show_avatars']
+        self._filter_string = ''
         self._friend_item_height = 40 if settings['compact_mode'] else 70
         self._paused_file_transfers = dict(settings['paused_file_transfers'])
         # key - file id, value: [path, friend number, is incoming, start position]
-        screen.online_contacts.setCurrentIndex(int(self._show_online))
+        screen.online_contacts.setCurrentIndex(int(self._sorting))
         aliases = settings['friends_aliases']
         data = tox.self_get_friend_list()
         self._history = History(tox.self_get_public_key())  # connection to db
-        self._friends, self._active_friend = [], -1
+        self._contacts, self._active_friend = [], -1
         for i in data:  # creates list of friends
             tox_id = tox.friend_get_public_key(i)
             try:
@@ -64,8 +66,8 @@ class Profile(contact.Contact, Singleton):
             message_getter = self._history.messages_getter(tox_id)
             friend = Friend(message_getter, i, name, status_message, item, tox_id)
             friend.set_alias(alias)
-            self._friends.append(friend)
+            self._contacts.append(friend)
-        self.filtration(self._show_online)
+        self.filtration_and_sorting(self._sorting)
 
     # -----------------------------------------------------------------------------------------------------------------
     # Edit current user's data
@@ -82,8 +84,8 @@ class Profile(contact.Contact, Singleton):
         super(Profile, self).set_status(status)
         if status is not None:
             self._tox.self_set_status(status)
-        else:
+        elif not self._waiting_for_reconnection:
-            QtCore.QTimer.singleShot(30000, self.reconnect)
+            QtCore.QTimer.singleShot(50000, self.reconnect)
 
     def set_name(self, value):
         if self.name == value:
@@ -91,10 +93,9 @@ class Profile(contact.Contact, Singleton):
         tmp = self.name
         super(Profile, self).set_name(value.encode('utf-8'))
         self._tox.self_set_name(self._name.encode('utf-8'))
-        message = QtGui.QApplication.translate("MainWindow", 'User {} is now known as {}', None,
+        message = QtWidgets.QApplication.translate("MainWindow", 'User {} is now known as {}')
-                                               QtGui.QApplication.UnicodeUTF8)
         message = message.format(tmp, value)
-        for friend in self._friends:
+        for friend in self._contacts:
             friend.append_message(InfoMessage(message, time.time()))
         if self._active_friend + 1:
             self.create_message_item(message, time.time(), '', MESSAGE_TYPE['INFO_MESSAGE'])
@@ -115,37 +116,72 @@ class Profile(contact.Contact, Singleton):
     # Filtration
     # -----------------------------------------------------------------------------------------------------------------
 
-    def filtration(self, show_online=True, filter_str=''):
+    def filtration_and_sorting(self, sorting=0, filter_str=''):
         """
         Filtration of friends list
-        :param show_online: show online only contacts
+        :param sorting: 0 - no sort, 1 - online only, 2 - online first, 4 - by name
         :param filter_str: show contacts which name contains this substring
         """
         filter_str = filter_str.lower()
         settings = Settings.get_instance()
-        for index, friend in enumerate(self._friends):
+        number = self.get_active_number()
-            friend.visibility = (friend.status is not None or not show_online) and (filter_str in friend.name.lower())
+        if sorting > 1:
+            if sorting & 2:
+                self._contacts = sorted(self._contacts, key=lambda x: int(x.status is not None), reverse=True)
+            if sorting & 4:
+                if not sorting & 2:
+                    self._contacts = sorted(self._contacts, key=lambda x: x.name.lower())
+                else:  # save results of prev sorting
+                    online_friends = filter(lambda x: x.status is not None, self._contacts)
+                    count = len(list(online_friends))
+                    part1 = self._contacts[:count]
+                    part2 = self._contacts[count:]
+                    part1 = sorted(part1, key=lambda x: x.name.lower())
+                    part2 = sorted(part2, key=lambda x: x.name.lower())
+                    self._contacts = part1 + part2
+            else:  # sort by number
+                online_friends = filter(lambda x: x.status is not None, self._contacts)
+                count = len(list(online_friends))
+                part1 = self._contacts[:count]
+                part2 = self._contacts[count:]
+                part1 = sorted(part1, key=lambda x: x.number)
+                part2 = sorted(part2, key=lambda x: x.number)
+                self._contacts = part1 + part2
+            self._screen.friends_list.clear()
+            for contact in self._contacts:
+                contact.set_widget(self.create_friend_item())
+        for index, friend in enumerate(self._contacts):
+            friend.visibility = (friend.status is not None or not (sorting & 1)) and (filter_str in friend.name.lower())
             friend.visibility = friend.visibility or friend.messages or friend.actions
             if friend.visibility:
-                self._screen.friends_list.item(index).setSizeHint(QtCore.QSize(250,
+                self._screen.friends_list.item(index).setSizeHint(QtCore.QSize(250, self._friend_item_height))
-                                                                               self._friend_item_height))
             else:
                 self._screen.friends_list.item(index).setSizeHint(QtCore.QSize(250, 0))
-        self._show_online, self._filter_string = show_online, filter_str
+        self._sorting, self._filter_string = sorting, filter_str
-        settings['show_online_friends'] = self._show_online
+        settings['sorting'] = self._sorting
         settings.save()
+        self.set_active_by_number(number)
 
     def update_filtration(self):
         """
         Update list of contacts when 1 of friends change connection status
         """
-        self.filtration(self._show_online, self._filter_string)
+        self.filtration_and_sorting(self._sorting, self._filter_string)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Friend getters
+    # -----------------------------------------------------------------------------------------------------------------
 
     def get_friend_by_number(self, num):
-        return list(filter(lambda x: x.number == num, self._friends))[0]
+        return list(filter(lambda x: x.number == num, self._contacts))[0]
 
     def get_friend(self, num):
-        return self._friends[num]
+        if num < 0 or num >= len(self._contacts):
+            return None
+        return self._contacts[num]
+
+    def get_curr_friend(self):
+        return self._contacts[self._active_friend] if self._active_friend + 1 else None
 
     # -----------------------------------------------------------------------------------------------------------------
     # Work with active friend
@@ -175,14 +211,17 @@ class Profile(contact.Contact, Singleton):
             if value is not None:
                 if self._active_friend + 1 and self._active_friend != value:
                     try:
-                        self._friends[self._active_friend].curr_text = self._screen.messageEdit.toPlainText()
+                        self.get_curr_friend().curr_text = self._screen.messageEdit.toPlainText()
                     except:
                         pass
-                friend = self._friends[value]
+                friend = self._contacts[value]
+                friend.remove_invalid_unsent_files()
                 if self._active_friend != value:
                     self._screen.messageEdit.setPlainText(friend.curr_text)
                 self._active_friend = value
-                self._friends[value].reset_messages()
+                friend.reset_messages()
+                if not Settings.get_instance()['save_history']:
+                    friend.delete_old_messages()
                 self._messages.clear()
                 friend.load_corr()
                 messages = friend.get_corr()[-PAGE_SIZE:]
@@ -202,7 +241,7 @@ class Profile(contact.Contact, Singleton):
                         if message.get_status() in ACTIVE_FILE_TRANSFERS:  # active file transfer
                             try:
                                 ft = self._file_transfers[(message.get_friend_number(), message.get_file_number())]
-                                ft.set_state_changed_handler(item.update)
+                                ft.set_state_changed_handler(item.update_transfer_state)
                                 ft.signal()
                             except:
                                 print('Incoming not started transfer - no info found')
@@ -223,7 +262,7 @@ class Profile(contact.Contact, Singleton):
                 else:
                     self._screen.call_finished()
             else:
-                friend = self._friends[self._active_friend]
+                friend = self.get_curr_friend()
 
             self._screen.account_name.setText(friend.name)
             self._screen.account_status.setText(friend.status_message)
@@ -234,25 +273,33 @@ class Profile(contact.Contact, Singleton):
             pixmap = QtGui.QPixmap(avatar_path)
             self._screen.account_avatar.setPixmap(pixmap.scaled(64, 64, QtCore.Qt.KeepAspectRatio,
                                                                 QtCore.Qt.SmoothTransformation))
-            self.update_filtration()
         except Exception as ex:  # no friend found. ignore
             log('Friend value: ' + str(value))
-            log('Error: ' + str(ex))
+            log('Error in set active: ' + str(ex))
             raise
 
+    def set_active_by_number(self, number):
+        for i in range(len(self._contacts)):
+            if self._contacts[i].number == number:
+                self._active_friend = i
+                break
+
     active_friend = property(get_active, set_active)
 
     def get_last_message(self):
-        return self._friends[self._active_friend].get_last_message_text()
+        if self._active_friend + 1:
+            return self.get_curr_friend().get_last_message_text()
+        else:
+            return ''
 
     def get_active_number(self):
-        return self._friends[self._active_friend].number if self._active_friend + 1 else -1
+        return self.get_curr_friend().number if self._active_friend + 1 else -1
 
     def get_active_name(self):
-        return self._friends[self._active_friend].name if self._active_friend + 1 else ''
+        return self.get_curr_friend().name if self._active_friend + 1 else ''
 
     def is_active_online(self):
-        return self._active_friend + 1 and self._friends[self._active_friend].status is not None
+        return self._active_friend + 1 and self.get_curr_friend().status is not None
 
     def new_name(self, number, name):
         friend = self.get_friend_by_number(number)
@@ -260,7 +307,7 @@ class Profile(contact.Contact, Singleton):
         friend.set_name(name)
         name = str(name, 'utf-8')
         if friend.name == name and tmp != name:
-            message = QtGui.QApplication.translate("MainWindow", 'User {} is now known as {}', None, QtGui.QApplication.UnicodeUTF8)
+            message = QtWidgets.QApplication.translate("MainWindow", 'User {} is now known as {}')
             message = message.format(tmp, name)
             friend.append_message(InfoMessage(message, time.time()))
             friend.actions = True
@@ -279,6 +326,7 @@ class Profile(contact.Contact, Singleton):
 
     def send_files(self, friend_number):
         friend = self.get_friend_by_number(friend_number)
+        friend.remove_invalid_unsent_files()
         files = friend.get_unsent_files()
         try:
             for fl in files:
@@ -313,7 +361,7 @@ class Profile(contact.Contact, Singleton):
                 ft = self._file_transfers[(friend_num, file_num)]
                 if type(ft) is SendTransfer:
                     self._paused_file_transfers[ft.get_id()] = [ft.get_path(), friend_num, False, -1]
-                elif type(ft) is ReceiveTransfer:
+                elif type(ft) is ReceiveTransfer and ft.state != TOX_FILE_TRANSFER_STATE['INCOMING_NOT_STARTED']:
                     self._paused_file_transfers[ft.get_id()] = [ft.get_path(), friend_num, True, ft.total_size()]
                 self.cancel_transfer(friend_num, file_num, True)
 
@@ -327,7 +375,7 @@ class Profile(contact.Contact, Singleton):
         """
         if Settings.get_instance()['typing_notifications'] and self._active_friend + 1:
             try:
-                friend = self._friends[self._active_friend]
+                friend = self.get_curr_friend()
                 if friend.status is not None:
                     self._tox.self_set_typing(friend.number, typing)
             except:
@@ -360,25 +408,25 @@ class Profile(contact.Contact, Singleton):
             for message in messages:
                 self.split_and_send(friend_number, message.get_data()[-1], message.get_data()[0].encode('utf-8'))
                 friend.inc_receipts()
-        except:
+        except Exception as ex:
-            pass
+            log('Sending pending messages failed with ' + str(ex))
 
     def split_and_send(self, number, message_type, message):
         """
-        Message splitting
+        Message splitting. Message length cannot be > TOX_MAX_MESSAGE_LENGTH
         :param number: friend's number
         :param message_type: type of message
         :param message: message text
         """
         while len(message) > TOX_MAX_MESSAGE_LENGTH:
-            size = TOX_MAX_MESSAGE_LENGTH * 4 / 5
+            size = TOX_MAX_MESSAGE_LENGTH * 4 // 5
             last_part = message[size:TOX_MAX_MESSAGE_LENGTH]
-            if ' ' in last_part:
+            if b' ' in last_part:
-                index = last_part.index(' ')
+                index = last_part.index(b' ')
-            elif ',' in last_part:
+            elif b',' in last_part:
-                index = last_part.index(',')
+                index = last_part.index(b',')
-            elif '.' in last_part:
+            elif b'.' in last_part:
-                index = last_part.index('.')
+                index = last_part.index(b'.')
             else:
                 index = TOX_MAX_MESSAGE_LENGTH - size - 1
             index += size + 1
@@ -397,7 +445,7 @@ class Profile(contact.Contact, Singleton):
             t = time.time()
             self.create_message_item(message, t, MESSAGE_OWNER['FRIEND'], message_type)
             self._messages.scrollToBottom()
-            self._friends[self._active_friend].append_message(
+            self.get_curr_friend().append_message(
                 TextMessage(message, MESSAGE_OWNER['FRIEND'], t, message_type))
         else:
             friend = self.get_friend_by_number(friend_num)
@@ -436,7 +484,7 @@ class Profile(contact.Contact, Singleton):
             friend.append_message(TextMessage(text, MESSAGE_OWNER['NOT_SENT'], t, message_type))
 
     def delete_message(self, time):
-        friend = self._friends[self._active_friend]
+        friend = self.get_curr_friend()
         friend.delete_message(time)
         self._history.delete_message(friend.tox_id, time)
         self.update()
@@ -452,7 +500,7 @@ class Profile(contact.Contact, Singleton):
         s = Settings.get_instance()
         if hasattr(self, '_history'):
             if s['save_history']:
-                for friend in self._friends:
+                for friend in self._contacts:
                     if not self._history.friend_exists_in_db(friend.tox_id):
                         self._history.add_friend_to_db(friend.tox_id)
                     if not s['save_unsent_only']:
@@ -472,13 +520,13 @@ class Profile(contact.Contact, Singleton):
         Clear chat history
         """
         if num is not None:
-            friend = self._friends[num]
+            friend = self._contacts[num]
             friend.clear_corr(save_unsent)
             if self._history.friend_exists_in_db(friend.tox_id):
                 self._history.delete_messages(friend.tox_id)
                 self._history.delete_friend_from_db(friend.tox_id)
         else:  # clear all history
-            for number in range(len(self._friends)):
+            for number in range(len(self._contacts)):
                 self.clear_history(number, save_unsent)
         if num is None or num == self.get_active_number():
             self.update()
@@ -490,7 +538,7 @@ class Profile(contact.Contact, Singleton):
         if not self._load_history:
             return
         self._load_history = False
-        friend = self._friends[self._active_friend]
+        friend = self.get_curr_friend()
         friend.load_corr(False)
         data = friend.get_corr()
         if not data:
@@ -513,7 +561,7 @@ class Profile(contact.Contact, Singleton):
                 if message.get_status() in ACTIVE_FILE_TRANSFERS:  # active file transfer
                     try:
                         ft = self._file_transfers[(message.get_friend_number(), message.get_file_number())]
-                        ft.set_state_changed_handler(item.update)
+                        ft.set_state_changed_handler(item.update_transfer_state)
                         ft.signal()
                     except:
                         print('Incoming not started transfer - no info found')
@@ -532,10 +580,9 @@ class Profile(contact.Contact, Singleton):
         self._history.export(directory)
 
     def export_history(self, num, as_text=True, _range=None):
-        friend = self._friends[num]
+        friend = self._contacts[num]
         if _range is None:
             friend.load_all_corr()
-        if _range is None:
             corr = friend.get_corr()
         elif _range[1] + 1:
             corr = friend.get_corr()[_range[0]:_range[1] + 1]
@@ -554,10 +601,12 @@ class Profile(contact.Contact, Singleton):
                                     friend.name if data[1] == MESSAGE_OWNER['FRIEND'] else self.name,
                                     data[0]))
         s = new_line.join(arr)
+        if not as_text:
+            s = '<html><head><meta charset="UTF-8"><title>{}</title></head><body>{}</body></html>'.format(friend.name, s)
         return s
 
     # -----------------------------------------------------------------------------------------------------------------
-    # Factories for friend, message and file transfer items
+    # Friend, message and file transfer items creation
     # -----------------------------------------------------------------------------------------------------------------
 
     def create_friend_item(self):
@@ -565,12 +614,7 @@ class Profile(contact.Contact, Singleton):
         Method-factory
         :return: new widget for friend instance
         """
-        item = ContactItem()
+        return self._factory.friend_item()
-        elem = QtGui.QListWidgetItem(self._screen.friends_list)
-        elem.setSizeHint(QtCore.QSize(250, item.height()))
-        self._screen.friends_list.addItem(elem)
-        self._screen.friends_list.setItemWidget(elem, item)
-        return item
 
     def create_message_item(self, text, time, owner, message_type, append=True):
         if message_type == MESSAGE_TYPE['INFO_MESSAGE']:
@@ -579,56 +623,30 @@ class Profile(contact.Contact, Singleton):
             name = self.get_active_name()
         else:
             name = self._name
-        item = MessageItem(text, time, name, owner != MESSAGE_OWNER['NOT_SENT'], message_type, self._messages)
+        pixmap = None
         if self._show_avatars:
-            item.set_avatar(self._friends[self._active_friend].get_pixmap() if owner == MESSAGE_OWNER[
+            if owner == MESSAGE_OWNER['FRIEND']:
-                'FRIEND'] else self.get_pixmap())
+                pixmap = self.get_curr_friend().get_pixmap()
-        elem = QtGui.QListWidgetItem()
+            else:
-        elem.setSizeHint(QtCore.QSize(self._messages.width(), item.height()))
+                pixmap = self.get_pixmap()
-        if append:
+        return self._factory.message_item(text, time, name, owner != MESSAGE_OWNER['NOT_SENT'],
-            self._messages.addItem(elem)
+                                          message_type, append, pixmap)
-        else:
-            self._messages.insertItem(0, elem)
-        self._messages.setItemWidget(elem, item)
 
     def create_file_transfer_item(self, tm, append=True):
         data = list(tm.get_data())
         data[3] = self.get_friend_by_number(data[4]).name if data[3] else self._name
-        data.append(self._messages.width())
+        return self._factory.file_transfer_item(data, append)
-        item = FileTransferItem(*data)
-        elem = QtGui.QListWidgetItem()
-        elem.setSizeHint(QtCore.QSize(self._messages.width() - 30, 34))
-        if append:
-            self._messages.addItem(elem)
-        else:
-            self._messages.insertItem(0, elem)
-        self._messages.setItemWidget(elem, item)
-        return item
 
     def create_unsent_file_item(self, message, append=True):
         data = message.get_data()
-        item = UnsentFileItem(os.path.basename(data[0]),
+        return self._factory.unsent_file_item(os.path.basename(data[0]),
-                              os.path.getsize(data[0]) if data[1] is None else len(data[1]),
+                                              os.path.getsize(data[0]) if data[1] is None else len(data[1]),
-                              self.name,
+                                              self.name,
-                              data[2],
+                                              data[2],
-                              self._messages.width())
+                                              append)
-        elem = QtGui.QListWidgetItem()
-        elem.setSizeHint(QtCore.QSize(self._messages.width() - 30, 34))
-        if append:
-            self._messages.addItem(elem)
-        else:
-            self._messages.insertItem(0, elem)
-        self._messages.setItemWidget(elem, item)
 
     def create_inline_item(self, data, append=True):
-        elem = QtGui.QListWidgetItem()
+        return self._factory.inline_item(data, append)
-        item = InlineImageItem(data, self._messages.width(), elem)
-        elem.setSizeHint(QtCore.QSize(self._messages.width(), item.height()))
-        if append:
-            self._messages.addItem(elem)
-        else:
-            self._messages.insertItem(0, elem)
-        self._messages.setItemWidget(elem, item)
 
     # -----------------------------------------------------------------------------------------------------------------
     # Work with friends (remove, block, set alias, get public key)
@@ -638,19 +656,17 @@ class Profile(contact.Contact, Singleton):
         """
         Set new alias for friend
         """
-        friend = self._friends[num]
+        friend = self._contacts[num]
         name = friend.name
-        dialog = QtGui.QApplication.translate('MainWindow',
+        dialog = QtWidgets.QApplication.translate('MainWindow',
-                                              "Enter new alias for friend {} or leave empty to use friend's name:",
+                                              "Enter new alias for friend {} or leave empty to use friend's name:")
-                                              None, QtGui.QApplication.UnicodeUTF8)
         dialog = dialog.format(name)
-        title = QtGui.QApplication.translate('MainWindow',
+        title = QtWidgets.QApplication.translate('MainWindow',
-                                             'Set alias',
+                                             'Set alias')
-                                             None, QtGui.QApplication.UnicodeUTF8)
         text, ok = QtGui.QInputDialog.getText(None,
                                               title,
                                               dialog,
-                                              QtGui.QLineEdit.Normal,
+                                              QtWidgets.QLineEdit.Normal,
                                               name)
         if ok:
             settings = Settings.get_instance()
@@ -676,14 +692,14 @@ class Profile(contact.Contact, Singleton):
             self.update()
 
     def friend_public_key(self, num):
-        return self._friends[num].tox_id
+        return self._contacts[num].tox_id
 
     def delete_friend(self, num):
         """
         Removes friend from contact list
         :param num: number of friend in list
         """
-        friend = self._friends[num]
+        friend = self._contacts[num]
         settings = Settings.get_instance()
         try:
             index = list(map(lambda x: x[0], settings['friends_aliases'])).index(friend.tox_id)
@@ -697,10 +713,10 @@ class Profile(contact.Contact, Singleton):
         if self._history.friend_exists_in_db(friend.tox_id):
             self._history.delete_friend_from_db(friend.tox_id)
         self._tox.friend_delete(friend.number)
-        del self._friends[num]
+        del self._contacts[num]
         self._screen.friends_list.takeItem(num)
         if num == self._active_friend:  # active friend was deleted
-            if not len(self._friends):  # last friend was deleted
+            if not len(self._contacts):  # last friend was deleted
                 self.set_active(-1)
             else:
                 self.set_active(0)
@@ -721,7 +737,7 @@ class Profile(contact.Contact, Singleton):
             log('Accept friend request failed! ' + str(ex))
             message_getter = None
         friend = Friend(message_getter, num, tox_id, '', item, tox_id)
-        self._friends.append(friend)
+        self._contacts.append(friend)
 
     def block_user(self, tox_id):
         """
@@ -775,9 +791,9 @@ class Profile(contact.Contact, Singleton):
                     raise Exception('TOX DNS lookup failed')
             if len(tox_id) == TOX_PUBLIC_KEY_SIZE * 2:  # public key
                 self.add_friend(tox_id)
-                msgBox = QtGui.QMessageBox()
+                msgBox = QtWidgets.QMessageBox()
-                msgBox.setWindowTitle(QtGui.QApplication.translate("MainWindow", "Friend added", None, QtGui.QApplication.UnicodeUTF8))
+                msgBox.setWindowTitle(QtWidgets.QApplication.translate("MainWindow", "Friend added"))
-                text = (QtGui.QApplication.translate("MainWindow", 'Friend added without sending friend request', None, QtGui.QApplication.UnicodeUTF8))
+                text = (QtWidgets.QApplication.translate("MainWindow", 'Friend added without sending friend request'))
                 msgBox.setText(text)
                 msgBox.exec_()
             else:
@@ -788,7 +804,7 @@ class Profile(contact.Contact, Singleton):
                     self._history.add_friend_to_db(tox_id)
                 message_getter = self._history.messages_getter(tox_id)
                 friend = Friend(message_getter, result, tox_id, '', item, tox_id)
-                self._friends.append(friend)
+                self._contacts.append(friend)
             data = self._tox.get_savedata()
             ProfileHelper.get_instance().save_profile(data)
             return True
@@ -803,11 +819,11 @@ class Profile(contact.Contact, Singleton):
         :param message: message
         """
         try:
-            text = QtGui.QApplication.translate('MainWindow', 'User {} wants to add you to contact list. Message:\n{}', None, QtGui.QApplication.UnicodeUTF8)
+            text = QtWidgets.QApplication.translate('MainWindow', 'User {} wants to add you to contact list. Message:\n{}')
             info = text.format(tox_id, message)
-            fr_req = QtGui.QApplication.translate('MainWindow', 'Friend request', None, QtGui.QApplication.UnicodeUTF8)
+            fr_req = QtWidgets.QApplication.translate('MainWindow', 'Friend request')
-            reply = QtGui.QMessageBox.question(None, fr_req, info, QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)
+            reply = QtWidgets.QMessageBox.question(None, fr_req, info, QtWidgets.QMessageBox.Yes, QtWidgets.QMessageBox.No)
-            if reply == QtGui.QMessageBox.Yes:  # accepted
+            if reply == QtWidgets.QMessageBox.Yes:  # accepted
                 self.add_friend(tox_id)
                 data = self._tox.get_savedata()
                 ProfileHelper.get_instance().save_profile(data)
@@ -823,7 +839,7 @@ class Profile(contact.Contact, Singleton):
         Recreate tox instance
         :param restart: method which calls restart and returns new tox instance
         """
-        for friend in self._friends:
+        for friend in self._contacts:
             self.friend_exit(friend.number)
         self._call.stop()
         del self._call
@@ -831,20 +847,22 @@ class Profile(contact.Contact, Singleton):
         self._tox = restart()
         self._call = calls.AV(self._tox.AV)
         self.status = None
-        for friend in self._friends:
+        for friend in self._contacts:
             friend.number = self._tox.friend_by_public_key(friend.tox_id)  # numbers update
         self.update_filtration()
 
     def reconnect(self):
-        if self.status is None or all(list(map(lambda x: x.status is None, self._friends))):
+        self._waiting_for_reconnection = False
+        if self.status is None or all(list(map(lambda x: x.status is None, self._contacts))) and len(self._contacts):
+            self._waiting_for_reconnection = True
             self.reset(self._screen.reset)
-            QtCore.QTimer.singleShot(30000, self.reconnect)
+            QtCore.QTimer.singleShot(50000, self.reconnect)
 
     def close(self):
-        for friend in self._friends:
+        for friend in self._contacts:
             self.friend_exit(friend.number)
-        for i in range(len(self._friends)):
+        for i in range(len(self._contacts)):
-            del self._friends[0]
+            del self._contacts[0]
         if hasattr(self, '_call'):
             self._call.stop()
             del self._call
@@ -867,7 +885,7 @@ class Profile(contact.Contact, Singleton):
         settings = Settings.get_instance()
         friend = self.get_friend_by_number(friend_number)
         auto = settings['allow_auto_accept'] and friend.tox_id in settings['auto_accept_from_friends']
-        inline = (file_name in ALLOWED_FILES) and settings['allow_inline']
+        inline = is_inline(file_name) and settings['allow_inline']
         file_id = self._tox.file_get_file_id(friend_number, file_number)
         accepted = True
         if file_id in self._paused_file_transfers:
@@ -917,7 +935,7 @@ class Profile(contact.Contact, Singleton):
         if friend_number == self.get_active_number():
             item = self.create_file_transfer_item(tm)
             if accepted:
-                self._file_transfers[(friend_number, file_number)].set_state_changed_handler(item.update)
+                self._file_transfers[(friend_number, file_number)].set_state_changed_handler(item.update_transfer_state)
             self._messages.scrollToBottom()
         else:
             friend.actions = True
@@ -952,7 +970,7 @@ class Profile(contact.Contact, Singleton):
                                                                                0, -1)
 
     def cancel_not_started_transfer(self, time):
-        self._friends[self._active_friend].delete_one_unsent_file(time)
+        self.get_curr_friend().delete_one_unsent_file(time)
         self.update()
 
     def pause_transfer(self, friend_number, file_number, by_friend=False):
@@ -1006,7 +1024,7 @@ class Profile(contact.Contact, Singleton):
         self._file_transfers[(friend_number, file_number)] = rt
         self._tox.file_control(friend_number, file_number, TOX_FILE_CONTROL['RESUME'])
         if item is not None:
-            rt.set_state_changed_handler(item.update)
+            rt.set_state_changed_handler(item.update_transfer_state)
         self.get_friend_by_number(friend_number).update_transfer_data(file_number,
                                                                       TOX_FILE_TRANSFER_STATE['RUNNING'])
 
@@ -1045,7 +1063,7 @@ class Profile(contact.Contact, Singleton):
                              st.get_file_number())
         item = self.create_file_transfer_item(tm)
         friend.append_message(tm)
-        st.set_state_changed_handler(item.update)
+        st.set_state_changed_handler(item.update_transfer_state)
         self._messages.scrollToBottom()
 
     def send_file(self, path, number=None, is_resend=False, file_id=None):
@@ -1078,9 +1096,9 @@ class Profile(contact.Contact, Singleton):
                              st.get_file_number())
         if friend_number == self.get_active_number():
             item = self.create_file_transfer_item(tm)
-            st.set_state_changed_handler(item.update)
+            st.set_state_changed_handler(item.update_transfer_state)
             self._messages.scrollToBottom()
-        self._friends[friend_number].append_message(tm)
+        self._contacts[friend_number].append_message(tm)
 
     def incoming_chunk(self, friend_number, file_number, position, data):
         """
@@ -1094,13 +1112,13 @@ class Profile(contact.Contact, Singleton):
         """
         self._file_transfers[(friend_number, file_number)].send_chunk(position, size)
 
-    @QtCore.Slot(int, int)
     def transfer_finished(self, friend_number, file_number):
         transfer = self._file_transfers[(friend_number, file_number)]
         t = type(transfer)
         if t is ReceiveAvatar:
             self.get_friend_by_number(friend_number).load_avatar()
-            self.set_active(None)
+            if friend_number == self.get_active_number():
+                self.set_active(None)
         elif t is ReceiveToBuffer or (t is SendFromBuffer and Settings.get_instance()['allow_inline']):  # inline image
             print('inline')
             inline = InlineImage(transfer.get_data())
@@ -1110,11 +1128,12 @@ class Profile(contact.Contact, Singleton):
             if friend_number == self.get_active_number():
                 count = self._messages.count()
                 if count + i + 1 >= 0:
-                    elem = QtGui.QListWidgetItem()
+                    elem = QtWidgets.QListWidgetItem()
                     item = InlineImageItem(transfer.get_data(), self._messages.width(), elem)
                     elem.setSizeHint(QtCore.QSize(self._messages.width(), item.height()))
                     self._messages.insertItem(count + i + 1, elem)
                     self._messages.setItemWidget(elem, item)
+                    self._messages.scrollToBottom()
         elif t is not SendAvatar:
             self.get_friend_by_number(friend_number).update_transfer_data(file_number,
                                                                           TOX_FILE_TRANSFER_STATE['FINISHED'])
@@ -1145,6 +1164,7 @@ class Profile(contact.Contact, Singleton):
         ra = ReceiveAvatar(self._tox, friend_number, size, file_number)
         if ra.state != TOX_FILE_TRANSFER_STATE['CANCELLED']:
             self._file_transfers[(friend_number, file_number)] = ra
+            ra.set_transfer_finished_handler(self.transfer_finished)
         else:
             self.get_friend_by_number(friend_number).load_avatar()
             if self.get_active_number() == friend_number:
@@ -1152,12 +1172,12 @@ class Profile(contact.Contact, Singleton):
 
     def reset_avatar(self):
         super(Profile, self).reset_avatar()
-        for friend in filter(lambda x: x.status is not None, self._friends):
+        for friend in filter(lambda x: x.status is not None, self._contacts):
             self.send_avatar(friend.number)
 
     def set_avatar(self, data):
         super(Profile, self).set_avatar(data)
-        for friend in filter(lambda x: x.status is not None, self._friends):
+        for friend in filter(lambda x: x.status is not None, self._contacts):
             self.send_avatar(friend.number)
 
     # -----------------------------------------------------------------------------------------------------------------
@@ -1178,12 +1198,10 @@ class Profile(contact.Contact, Singleton):
             self._call(num, audio, video)
             self._screen.active_call()
             if video:
-                text = QtGui.QApplication.translate("incoming_call", "Outgoing video call", None,
+                text = QtWidgets.QApplication.translate("incoming_call", "Outgoing video call")
-                                                    QtGui.QApplication.UnicodeUTF8)
             else:
-                text = QtGui.QApplication.translate("incoming_call", "Outgoing audio call", None,
+                text = QtWidgets.QApplication.translate("incoming_call", "Outgoing audio call")
-                                                    QtGui.QApplication.UnicodeUTF8)
+            self.get_curr_friend().append_message(InfoMessage(text, time.time()))
-            self._friends[self._active_friend].append_message(InfoMessage(text, time.time()))
             self.create_message_item(text, time.time(), '', MESSAGE_TYPE['INFO_MESSAGE'])
             self._messages.scrollToBottom()
         elif num in self._call:  # finish or cancel call if you call with active friend
@@ -1197,11 +1215,9 @@ class Profile(contact.Contact, Singleton):
             return
         friend = self.get_friend_by_number(friend_number)
         if video:
-            text = QtGui.QApplication.translate("incoming_call", "Incoming video call", None,
+            text = QtWidgets.QApplication.translate("incoming_call", "Incoming video call")
-                                                QtGui.QApplication.UnicodeUTF8)
         else:
-            text = QtGui.QApplication.translate("incoming_call", "Incoming audio call", None,
+            text = QtWidgets.QApplication.translate("incoming_call", "Incoming audio call")
-                                                QtGui.QApplication.UnicodeUTF8)
         friend.append_message(InfoMessage(text, time.time()))
         self._incoming_calls.add(friend_number)
         if friend_number == self.get_active_number():
@@ -1221,7 +1237,8 @@ class Profile(contact.Contact, Singleton):
         """
         self._call.accept_call(friend_number, audio, video)
         self._screen.active_call()
-        self._incoming_calls.remove(friend_number)
+        if friend_number in self._incoming_calls:
+            self._incoming_calls.remove(friend_number)
         if hasattr(self, '_call_widget'):
             del self._call_widget
 
@@ -1231,9 +1248,9 @@ class Profile(contact.Contact, Singleton):
         """
         if friend_number in self._incoming_calls:
             self._incoming_calls.remove(friend_number)
-            text = QtGui.QApplication.translate("incoming_call", "Call declined", None, QtGui.QApplication.UnicodeUTF8)
+            text = QtWidgets.QApplication.translate("incoming_call", "Call declined")
         else:
-            text = QtGui.QApplication.translate("incoming_call", "Call finished", None, QtGui.QApplication.UnicodeUTF8)
+            text = QtWidgets.QApplication.translate("incoming_call", "Call finished")
         self._screen.call_finished()
         self._call.finish_call(friend_number, by_friend)  # finish or decline call
         if hasattr(self, '_call_widget'):

toxygen/settings.py

@@ -1,9 +1,9 @@
 from platform import system
 import json
 import os
-from util import Singleton, curr_directory, log, copy
+from util import Singleton, curr_directory, log, copy, append_slash
 import pyaudio
-from toxencryptsave import ToxEncryptSave
+from toxes import ToxES
 import smileys
 
 
@@ -19,7 +19,7 @@ class Settings(dict, Singleton):
         if os.path.isfile(self.path):
             with open(self.path, 'rb') as fl:
                 data = fl.read()
-            inst = ToxEncryptSave.get_instance()
+            inst = ToxES.get_instance()
             try:
                 if inst.is_data_encrypted(data):
                     data = inst.pass_decrypt(data)
@@ -35,6 +35,7 @@ class Settings(dict, Singleton):
         smileys.SmileyLoader(self)
         self.locked = False
         self.closing = False
+        self.unlockScreen = False
         p = pyaudio.PyAudio()
         input_devices = output_devices = 0
         for i in range(p.get_device_count()):
@@ -49,9 +50,9 @@ class Settings(dict, Singleton):
 
     @staticmethod
     def get_auto_profile():
-        path = Settings.get_default_path() + 'toxygen.json'
+        p = Settings.get_global_settings_path()
-        if os.path.isfile(path):
+        if os.path.isfile(p):
-            with open(path) as fl:
+            with open(p) as fl:
                 data = fl.read()
             auto = json.loads(data)
             if 'path' in auto and 'name' in auto:
@@ -60,10 +61,13 @@ class Settings(dict, Singleton):
 
     @staticmethod
     def set_auto_profile(path, name):
-        p = Settings.get_default_path() + 'toxygen.json'
+        p = Settings.get_global_settings_path()
-        with open(p) as fl:
+        if os.path.isfile(p):
-            data = fl.read()
+            with open(p) as fl:
-        data = json.loads(data)
+                data = fl.read()
+            data = json.loads(data)
+        else:
+            data = {}
         data['path'] = str(path)
         data['name'] = str(name)
         with open(p, 'w') as fl:
@@ -71,10 +75,13 @@ class Settings(dict, Singleton):
 
     @staticmethod
     def reset_auto_profile():
-        p = Settings.get_default_path() + 'toxygen.json'
+        p = Settings.get_global_settings_path()
-        with open(p) as fl:
+        if os.path.isfile(p):
-            data = fl.read()
+            with open(p) as fl:
-        data = json.loads(data)
+                data = fl.read()
+            data = json.loads(data)
+        else:
+            data = {}
         if 'path' in data:
             del data['path']
             del data['name']
@@ -83,15 +90,8 @@ class Settings(dict, Singleton):
 
     @staticmethod
     def is_active_profile(path, name):
-        path = path + name + '.tox'
+        path = path + name + '.lock'
-        settings = Settings.get_default_path() + 'toxygen.json'
+        return os.path.isfile(path)
-        if os.path.isfile(settings):
-            with open(settings) as fl:
-                data = fl.read()
-            data = json.loads(data)
-            if 'active_profile' in data:
-                return path in data['active_profile']
-        return False
 
     @staticmethod
     def get_default_settings():
@@ -115,7 +115,7 @@ class Settings(dict, Singleton):
             'allow_inline': True,
             'allow_auto_accept': True,
             'auto_accept_path': None,
-            'show_online_friends': False,
+            'sorting': 0,
             'auto_accept_from_friends': [],
             'paused_file_transfers': {},
             'resend_files': True,
@@ -139,7 +139,8 @@ class Settings(dict, Singleton):
             'compact_mode': False,
             'show_welcome_screen': True,
             'close_to_tray': False,
-            'font': 'Times New Roman'
+            'font': 'Times New Roman',
+            'update': 1
         }
 
     @staticmethod
@@ -160,7 +161,7 @@ class Settings(dict, Singleton):
 
     def save(self):
         text = json.dumps(self)
-        inst = ToxEncryptSave.get_instance()
+        inst = ToxES.get_instance()
         if inst.has_password():
             text = bytes(inst.pass_encrypt(bytes(text, 'utf-8')))
         else:
@@ -169,37 +170,19 @@ class Settings(dict, Singleton):
             fl.write(text)
 
     def close(self):
-        path = Settings.get_default_path() + 'toxygen.json'
+        profile_path = ProfileHelper.get_path()
+        path = str(profile_path + str(self.name) + '.lock')
         if os.path.isfile(path):
-            with open(path) as fl:
+            os.remove(path)
-                data = fl.read()
-            app_settings = json.loads(data)
-            try:
-                app_settings['active_profile'].remove(str(ProfileHelper.get_path() + self.name + '.tox'))
-            except:
-                pass
-            data = json.dumps(app_settings)
-            with open(path, 'w') as fl:
-                fl.write(data)
 
     def set_active_profile(self):
         """
         Mark current profile as active
         """
-        path = Settings.get_default_path() + 'toxygen.json'
+        profile_path = ProfileHelper.get_path()
-        if os.path.isfile(path):
+        path = str(profile_path + str(self.name) + '.lock')
-            with open(path) as fl:
-                data = fl.read()
-            app_settings = json.loads(data)
-        else:
-            app_settings = {}
-        if 'active_profile' not in app_settings:
-            app_settings['active_profile'] = []
-        profilepath = ProfileHelper.get_path()
-        app_settings['active_profile'].append(str(profilepath + str(self.name) + '.tox'))
-        data = json.dumps(app_settings)
         with open(path, 'w') as fl:
-            fl.write(data)
+            fl.write('active')
 
     def export(self, path):
         text = json.dumps(self)
@@ -209,6 +192,10 @@ class Settings(dict, Singleton):
     def update_path(self):
         self.path = ProfileHelper.get_path() + self.name + '.json'
 
+    @staticmethod
+    def get_global_settings_path():
+        return curr_directory() + '/toxygen.json'
+
     @staticmethod
     def get_default_path():
         if system() == 'Windows':
@@ -225,6 +212,7 @@ class ProfileHelper(Singleton):
     """
     def __init__(self, path, name):
         Singleton.__init__(self)
+        path = append_slash(path)
         self._path = path + name + '.tox'
         self._directory = path
         # create /avatars if not exists:
@@ -244,7 +232,7 @@ class ProfileHelper(Singleton):
         return self._directory
 
     def save_profile(self, data):
-        inst = ToxEncryptSave.get_instance()
+        inst = ToxES.get_instance()
         if inst.has_password():
             data = inst.pass_encrypt(data)
         with open(self._path, 'wb') as fl:

toxygen/smileys.py

@@ -2,10 +2,7 @@ import util
 import json
 import os
 from collections import OrderedDict
-try:
+from PyQt5 import QtCore
-    from PySide import QtCore
-except ImportError:
-    from PyQt4 import QtCore
 
 
 class SmileyLoader(util.Singleton):
@@ -48,7 +45,7 @@ class SmileyLoader(util.Singleton):
                 print('Smiley pack {} was not loaded. Error: {}'.format(pack_name, ex))
 
     def get_smileys_path(self):
-        return util.curr_directory() + '/smileys/' + self._curr_pack + '/'
+        return util.curr_directory() + '/smileys/' + self._curr_pack + '/' if self._curr_pack is not None else None
 
     def get_packs_list(self):
         d = util.curr_directory() + '/smileys/'

toxygen/styles/style.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 try:
-    from PySide import QtCore
+    from PyQt5 import QtCore
 except ImportError:
     from PyQt4 import QtCore
 

toxygen/styles/style.qss

@@ -1070,12 +1070,6 @@ QToolButton::menu-arrow:open {
     border: 1px solid #3A3939;
 }
 
-QPushButton::menu-indicator  {
-    subcontrol-origin: padding;
-    subcontrol-position: bottom right;
-    left: 8px;
-}
-
 QTableView
 {
     border: 1px solid #444;
@@ -1286,4 +1280,45 @@ QListWidget > QLabel
 #contact_name
 {
     padding-left: 22px;
-}
+}
+
+#mainmenubutton
+{
+    border: 1px solid #3A3939;
+    color: silver;
+    margin: 0px;
+    text-align: center;
+}
+
+#mainmenubutton:hover
+{
+    background: transparent;
+    border: 1px solid #A9A9A9;
+    background-color: #302F2F;
+}
+
+#mainmenubutton:pressed
+{
+    background: transparent;
+    border: 1px solid #A9A9A9;
+    background-color: #302F2F;
+}
+
+#mainmenubutton::menu-indicator
+{
+    image: none;
+    width: 0px;
+    height: 0px;
+}
+
+ClickableLabel:focus
+{
+    border-width: 1px;
+    border-color: #4A4949;
+    border-style: solid;
+}
+
+ClickableLabel:hover
+{
+    background-color: #4A4949;
+}

toxygen/tox_dns.py

@@ -2,10 +2,7 @@ import json
 import urllib.request
 from util import log
 import settings
-try:
+from PyQt5 import QtNetwork, QtCore
-    from PySide import QtNetwork, QtCore
-except:
-    from PyQt4 import QtNetwork, QtCore
 
 
 def tox_dns(email):

toxygen/toxencryptsave.py

@@ -1,64 +1,25 @@
 import libtox
-import util
 from ctypes import c_size_t, create_string_buffer, byref, c_int, ArgumentError, c_char_p, c_bool
+from toxencryptsave_enums_and_consts import *
 
 
-TOX_ERR_ENCRYPTION = {
+class ToxEncryptSave:
-    # The function returned successfully.
-    'OK': 0,
-    # Some input data, or maybe the output pointer, was null.
-    'NULL': 1,
-    # The crypto lib was unable to derive a key from the given passphrase, which is usually a lack of memory issue. The
-    # functions accepting keys do not produce this error.
-    'KEY_DERIVATION_FAILED': 2,
-    # The encryption itself failed.
-    'FAILED': 3
-}
-
-TOX_ERR_DECRYPTION = {
-    # The function returned successfully.
-    'OK': 0,
-    # Some input data, or maybe the output pointer, was null.
-    'NULL': 1,
-    # The input data was shorter than TOX_PASS_ENCRYPTION_EXTRA_LENGTH bytes
-    'INVALID_LENGTH': 2,
-    # The input data is missing the magic number (i.e. wasn't created by this module, or is corrupted)
-    'BAD_FORMAT': 3,
-    # The crypto lib was unable to derive a key from the given passphrase, which is usually a lack of memory issue. The
-    # functions accepting keys do not produce this error.
-    'KEY_DERIVATION_FAILED': 4,
-    # The encrypted byte array could not be decrypted. Either the data was corrupt or the password/key was incorrect.
-    'FAILED': 5,
-}
-
-TOX_PASS_ENCRYPTION_EXTRA_LENGTH = 80
-
-
-class ToxEncryptSave(util.Singleton):
 
     def __init__(self):
-        super().__init__()
         self.libtoxencryptsave = libtox.LibToxEncryptSave()
-        self._passphrase = None
-
-    def set_password(self, passphrase):
-        self._passphrase = passphrase
-
-    def has_password(self):
-        return bool(self._passphrase)
-
-    def is_password(self, password):
-        return self._passphrase == password
 
     def is_data_encrypted(self, data):
+        """
+        Checks if given data is encrypted
+        """
         func = self.libtoxencryptsave.tox_is_data_encrypted
         func.restype = c_bool
         result = func(c_char_p(bytes(data)))
         return result
 
-    def pass_encrypt(self, data):
+    def pass_encrypt(self, data, password):
         """
-        Encrypts the given data with the given passphrase.
+        Encrypts the given data with the given password.
 
         :return: output array
         """
@@ -66,8 +27,8 @@ class ToxEncryptSave(util.Singleton):
         tox_err_encryption = c_int()
         self.libtoxencryptsave.tox_pass_encrypt(c_char_p(data),
                                                 c_size_t(len(data)),
-                                                c_char_p(bytes(self._passphrase, 'utf-8')),
+                                                c_char_p(bytes(password, 'utf-8')),
-                                                c_size_t(len(self._passphrase)),
+                                                c_size_t(len(password)),
                                                 out,
                                                 byref(tox_err_encryption))
         tox_err_encryption = tox_err_encryption.value
@@ -81,9 +42,9 @@ class ToxEncryptSave(util.Singleton):
         elif tox_err_encryption == TOX_ERR_ENCRYPTION['FAILED']:
             raise RuntimeError('The encryption itself failed.')
 
-    def pass_decrypt(self, data):
+    def pass_decrypt(self, data, password):
         """
-        Decrypts the given data with the given passphrase.
+        Decrypts the given data with the given password.
 
         :return: output array
         """
@@ -91,8 +52,8 @@ class ToxEncryptSave(util.Singleton):
         tox_err_decryption = c_int()
         self.libtoxencryptsave.tox_pass_decrypt(c_char_p(bytes(data)),
                                                 c_size_t(len(data)),
-                                                c_char_p(bytes(self._passphrase, 'utf-8')),
+                                                c_char_p(bytes(password, 'utf-8')),
-                                                c_size_t(len(self._passphrase)),
+                                                c_size_t(len(password)),
                                                 out,
                                                 byref(tox_err_decryption))
         tox_err_decryption = tox_err_decryption.value

toxygen/toxencryptsave_enums_and_consts.py

@@ -0,0 +1,29 @@
+TOX_ERR_ENCRYPTION = {
+    # The function returned successfully.
+    'OK': 0,
+    # Some input data, or maybe the output pointer, was null.
+    'NULL': 1,
+    # The crypto lib was unable to derive a key from the given passphrase, which is usually a lack of memory issue. The
+    # functions accepting keys do not produce this error.
+    'KEY_DERIVATION_FAILED': 2,
+    # The encryption itself failed.
+    'FAILED': 3
+}
+
+TOX_ERR_DECRYPTION = {
+    # The function returned successfully.
+    'OK': 0,
+    # Some input data, or maybe the output pointer, was null.
+    'NULL': 1,
+    # The input data was shorter than TOX_PASS_ENCRYPTION_EXTRA_LENGTH bytes
+    'INVALID_LENGTH': 2,
+    # The input data is missing the magic number (i.e. wasn't created by this module, or is corrupted)
+    'BAD_FORMAT': 3,
+    # The crypto lib was unable to derive a key from the given passphrase, which is usually a lack of memory issue. The
+    # functions accepting keys do not produce this error.
+    'KEY_DERIVATION_FAILED': 4,
+    # The encrypted byte array could not be decrypted. Either the data was corrupt or the password/key was incorrect.
+    'FAILED': 5,
+}
+
+TOX_PASS_ENCRYPTION_EXTRA_LENGTH = 80

toxygen/toxes.py

@@ -0,0 +1,28 @@
+import util
+import toxencryptsave
+
+
+class ToxES(util.Singleton):
+
+    def __init__(self):
+        super().__init__()
+        self._toxencryptsave = toxencryptsave.ToxEncryptSave()
+        self._passphrase = None
+
+    def set_password(self, passphrase):
+        self._passphrase = passphrase
+
+    def has_password(self):
+        return bool(self._passphrase)
+
+    def is_password(self, password):
+        return self._passphrase == password
+
+    def is_data_encrypted(self, data):
+        return len(data) > 0 and self._toxencryptsave.is_data_encrypted(data)
+
+    def pass_encrypt(self, data):
+        return self._toxencryptsave.pass_encrypt(data, self._passphrase)
+
+    def pass_decrypt(self, data):
+        return self._toxencryptsave.pass_decrypt(data, self._passphrase)

toxygen/toxygen.pro

@@ -1,2 +1,2 @@
-SOURCES = main.py  profile.py  menu.py  list_items.py  loginscreen.py  mainscreen.py plugins/plugin_super_class.py callbacks.py widgets.py avwidgets.py mainscreen_widgets.py
+SOURCES = main.py  profile.py  menu.py  list_items.py  loginscreen.py  mainscreen.py plugins/plugin_super_class.py callbacks.py widgets.py avwidgets.py mainscreen_widgets.py passwordscreen.py
 TRANSLATIONS = translations/en_GB.ts  translations/ru_RU.ts  translations/fr_FR.ts

toxygen/updater.py

@@ -0,0 +1,106 @@
+import util
+import os
+import settings
+import platform
+import urllib
+from PyQt5 import QtNetwork, QtCore
+import subprocess
+
+
+def connection_available():
+    try:
+        urllib.request.urlopen('http://216.58.192.142', timeout=1)  # google.com
+        return True
+    except:
+        return False
+
+
+def updater_available():
+    if is_from_sources():
+        return os.path.exists(util.curr_directory() + '/toxygen_updater.py')
+    elif platform.system() == 'Windows':
+        return os.path.exists(util.curr_directory() + '/toxygen_updater.exe')
+    else:
+        return os.path.exists(util.curr_directory() + '/toxygen_updater')
+
+
+def check_for_updates():
+    current_version = util.program_version
+    major, minor, patch = list(map(lambda x: int(x), current_version.split('.')))
+    versions = generate_versions(major, minor, patch)
+    for version in versions:
+        if send_request(version):
+            return version
+    return None  # no new version was found
+
+
+def is_from_sources():
+    return __file__.endswith('.py')
+
+
+def test_url(version):
+    return 'https://github.com/toxygen-project/toxygen/releases/tag/v' + version
+
+
+def get_url(version):
+    if is_from_sources():
+        return 'https://github.com/toxygen-project/toxygen/archive/v' + version + '.zip'
+    else:
+        if platform.system() == 'Windows':
+            name = 'toxygen_windows.zip'
+        elif util.is_64_bit():
+            name = 'toxygen_linux_64.tar.gz'
+        else:
+            name = 'toxygen_linux.tar.gz'
+        return 'https://github.com/toxygen-project/toxygen/releases/download/v{}/{}'.format(version, name)
+
+
+def get_params(url, version):
+    if is_from_sources():
+        return ['python3', 'toxygen_updater.py', url, version]
+    elif platform.system() == 'Windows':
+        return [util.curr_directory() + '/toxygen_updater.exe', url, version]
+    else:
+        return ['./toxygen_updater', url, version]
+
+
+def download(version):
+    os.chdir(util.curr_directory())
+    url = get_url(version)
+    params = get_params(url, version)
+    print('Updating Toxygen')
+    util.log('Updating Toxygen')
+    try:
+        subprocess.Popen(params)
+    except Exception as ex:
+        util.log('Exception: running updater failed with ' + str(ex))
+
+
+def send_request(version):
+    s = settings.Settings.get_instance()
+    netman = QtNetwork.QNetworkAccessManager()
+    proxy = QtNetwork.QNetworkProxy()
+    if s['proxy_type']:
+        proxy.setType(QtNetwork.QNetworkProxy.Socks5Proxy if s['proxy_type'] == 2 else QtNetwork.QNetworkProxy.HttpProxy)
+        proxy.setHostName(s['proxy_host'])
+        proxy.setPort(s['proxy_port'])
+        netman.setProxy(proxy)
+    url = test_url(version)
+    try:
+        request = QtNetwork.QNetworkRequest(url)
+        reply = netman.get(request)
+        while not reply.isFinished():
+            QtCore.QThread.msleep(1)
+            QtCore.QCoreApplication.processEvents()
+        attr = reply.attribute(QtNetwork.QNetworkRequest.HttpStatusCodeAttribute)
+        return attr is not None and 200 <= attr < 300
+    except Exception as ex:
+        util.log('TOXYGEN UPDATER ERROR: ' + str(ex))
+        return False
+
+
+def generate_versions(major, minor, patch):
+    new_major = '.'.join([str(major + 1), '0', '0'])
+    new_minor = '.'.join([str(major), str(minor + 1), '0'])
+    new_patch = '.'.join([str(major), str(minor), str(patch + 1)])
+    return new_major, new_minor, new_patch

toxygen/util.py

@@ -1,8 +1,10 @@
 import os
 import time
 import shutil
+import sys
+import re
 
-program_version = '0.2.4'
+program_version = '0.2.8'
 
 
 def log(data):
@@ -30,14 +32,53 @@ def copy(src, dest):
             copy(full_file_name, os.path.join(dest, file_name))
 
 
+def remove(folder):
+    if os.path.isdir(folder):
+        shutil.rmtree(folder)
+
+
 def convert_time(t):
-    sec = int(t) - time.timezone
+    offset = time.timezone + time_offset() * 60
+    sec = int(t) - offset
     m, s = divmod(sec, 60)
     h, m = divmod(m, 60)
     d, h = divmod(h, 24)
     return '%02d:%02d' % (h, m)
 
 
+def time_offset():
+    if hasattr(time_offset, 'offset'):
+        return time_offset.offset
+    hours = int(time.strftime('%H'))
+    minutes = int(time.strftime('%M'))
+    sec = int(time.time()) - time.timezone
+    m, s = divmod(sec, 60)
+    h, m = divmod(m, 60)
+    d, h = divmod(h, 24)
+    result = hours * 60 + minutes - h * 60 - m
+    time_offset.offset = result
+    return result
+
+
+def append_slash(s):
+    if len(s) and s[-1] not in ('\\', '/'):
+        s += '/'
+    return s
+
+
+def is_64_bit():
+    return sys.maxsize > 2 ** 32
+
+
+def is_re_valid(regex):
+    try:
+        re.compile(regex)
+    except re.error:
+        return False
+    else:
+        return True
+
+
 class Singleton:
     _instance = None
 

toxygen/widgets.py

@@ -1,21 +1,25 @@
-try:
+from PyQt5 import QtCore, QtGui, QtWidgets
-    from PySide import QtCore, QtGui
-except ImportError:
-    from PyQt4 import QtCore, QtGui
 
 
-class DataLabel(QtGui.QLabel):
+class DataLabel(QtWidgets.QLabel):
     """
     Label with elided text
     """
     def setText(self, text):
-        text = ''.join(c if c <= '\U0010FFFF' else '\u25AF' for c in text)
+        text = ''.join('\u25AF' if len(bytes(c, 'utf-8')) >= 4 else c for c in text)
         metrics = QtGui.QFontMetrics(self.font())
         text = metrics.elidedText(text, QtCore.Qt.ElideRight, self.width())
         super().setText(text)
 
 
-class CenteredWidget(QtGui.QWidget):
+class ComboBox(QtWidgets.QComboBox):
+
+    def __init__(self, *args):
+        super().__init__(*args)
+        self.view().setSizePolicy(QtWidgets.QSizePolicy.MinimumExpanding, QtWidgets.QSizePolicy.Expanding)
+
+
+class CenteredWidget(QtWidgets.QWidget):
 
     def __init__(self):
         super(CenteredWidget, self).__init__()
@@ -23,12 +27,12 @@ class CenteredWidget(QtGui.QWidget):
 
     def center(self):
         qr = self.frameGeometry()
-        cp = QtGui.QDesktopWidget().availableGeometry().center()
+        cp = QtWidgets.QDesktopWidget().availableGeometry().center()
         qr.moveCenter(cp)
         self.move(qr.topLeft())
 
 
-class LineEdit(QtGui.QLineEdit):
+class LineEdit(QtWidgets.QLineEdit):
 
     def __init__(self, parent=None):
         super(LineEdit, self).__init__(parent)
@@ -39,25 +43,27 @@ class LineEdit(QtGui.QLineEdit):
         del menu
 
 
-class QRightClickButton(QtGui.QPushButton):
+class QRightClickButton(QtWidgets.QPushButton):
     """
     Button with right click support
     """
 
+    rightClicked = QtCore.pyqtSignal()
+
     def __init__(self, parent):
         super(QRightClickButton, self).__init__(parent)
 
     def mousePressEvent(self, event):
         if event.button() == QtCore.Qt.RightButton:
-            self.emit(QtCore.SIGNAL("rightClicked()"))
+            self.rightClicked.emit()
         else:
             super(QRightClickButton, self).mousePressEvent(event)
 
 
-class RubberBand(QtGui.QRubberBand):
+class RubberBand(QtWidgets.QRubberBand):
 
     def __init__(self):
-        super(RubberBand, self).__init__(QtGui.QRubberBand.Rectangle, None)
+        super(RubberBand, self).__init__(QtWidgets.QRubberBand.Rectangle, None)
         self.setPalette(QtGui.QPalette(QtCore.Qt.transparent))
         self.pen = QtGui.QPen(QtCore.Qt.blue, 4)
         self.pen.setStyle(QtCore.Qt.SolidLine)
@@ -79,29 +85,21 @@ def create_menu(menu):
         text = action.text()
         if 'Link Location' in text:
             text = text.replace('Copy &Link Location',
-                                QtGui.QApplication.translate("MainWindow", "Copy link location", None,
+                                QtWidgets.QApplication.translate("MainWindow", "Copy link location"))
-                                                             QtGui.QApplication.UnicodeUTF8))
         elif '&Copy' in text:
-            text = text.replace('&Copy', QtGui.QApplication.translate("MainWindow", "Copy", None,
+            text = text.replace('&Copy', QtWidgets.QApplication.translate("MainWindow", "Copy"))
-                                                                      QtGui.QApplication.UnicodeUTF8))
         elif 'All' in text:
-            text = text.replace('Select All', QtGui.QApplication.translate("MainWindow", "Select all", None,
+            text = text.replace('Select All', QtWidgets.QApplication.translate("MainWindow", "Select all"))
-                                                                           QtGui.QApplication.UnicodeUTF8))
         elif 'Delete' in text:
-            text = text.replace('Delete', QtGui.QApplication.translate("MainWindow", "Delete", None,
+            text = text.replace('Delete', QtWidgets.QApplication.translate("MainWindow", "Delete"))
-                                                                       QtGui.QApplication.UnicodeUTF8))
         elif '&Paste' in text:
-            text = text.replace('&Paste', QtGui.QApplication.translate("MainWindow", "Paste", None,
+            text = text.replace('&Paste', QtWidgets.QApplication.translate("MainWindow", "Paste"))
-                                                                       QtGui.QApplication.UnicodeUTF8))
         elif 'Cu&t' in text:
-            text = text.replace('Cu&t', QtGui.QApplication.translate("MainWindow", "Cut", None,
+            text = text.replace('Cu&t', QtWidgets.QApplication.translate("MainWindow", "Cut"))
-                                                                     QtGui.QApplication.UnicodeUTF8))
         elif '&Undo' in text:
-            text = text.replace('&Undo', QtGui.QApplication.translate("MainWindow", "Undo", None,
+            text = text.replace('&Undo', QtWidgets.QApplication.translate("MainWindow", "Undo"))
-                                                                      QtGui.QApplication.UnicodeUTF8))
         elif '&Redo' in text:
-            text = text.replace('&Redo', QtGui.QApplication.translate("MainWindow", "Redo", None,
+            text = text.replace('&Redo', QtWidgets.QApplication.translate("MainWindow", "Redo"))
-                                                                      QtGui.QApplication.UnicodeUTF8))
         else:
             menu.removeAction(action)
             continue
@@ -117,12 +115,12 @@ class MultilineEdit(CenteredWidget):
         self.setMinimumSize(QtCore.QSize(350, 200))
         self.setMaximumSize(QtCore.QSize(350, 200))
         self.setWindowTitle(title)
-        self.edit = QtGui.QTextEdit(self)
+        self.edit = QtWidgets.QTextEdit(self)
         self.edit.setGeometry(QtCore.QRect(0, 0, 350, 150))
         self.edit.setText(text)
-        self.button = QtGui.QPushButton(self)
+        self.button = QtWidgets.QPushButton(self)
         self.button.setGeometry(QtCore.QRect(0, 150, 350, 50))
-        self.button.setText(QtGui.QApplication.translate("MainWindow", "Save", None, QtGui.QApplication.UnicodeUTF8))
+        self.button.setText(QtWidgets.QApplication.translate("MainWindow", "Save"))
         self.button.clicked.connect(self.button_click)
         self.center()
         self.save = save