reconnection bug fixed

Fix markdown formatting

.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

@@ -0,0 +1,43 @@
+language: python
+python:
+  - "3.4"
+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
+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
+  - git checkout tags/1.0.3
+  - ./autogen.sh
+  - ./configure && make -j$(nproc)
+  - sudo checkinstall --install --pkgname libsodium --pkgversion 1.0.0 --nodoc -y
+  - sudo ldconfig
+  - cd ..
+# Toxcore
+  - git clone https://github.com/irungentoo/toxcore.git
+  - cd toxcore
+  - autoreconf -if
+  - ./configure
+  - make -j$(nproc)
+  - sudo make install
+  - echo '/usr/local/lib/' | sudo tee -a /etc/ld.so.conf.d/locallib.conf
+  - sudo ldconfig
+  - cd ..
+script:
+  - py.test tests/travis.py
+  - py.test tests/tests.py

README.md

@@ -1,20 +1,24 @@
 # Toxygen
-Toxygen is cross-platform [Tox](https://tox.chat/) client written in Python3
 
-[![Release](https://img.shields.io/github/release/xveduk/toxygen.svg?style=flat)](https://github.com/xveduk/toxygen/releases/latest)
+Toxygen is powerful cross-platform [Tox](https://tox.chat/) client written in pure Python3.
-[![Open issues](https://img.shields.io/github/issues/xveduk/toxygen.svg?style=flat)](https://github.com/xveduk/toxygen/issues)
-[![License](https://img.shields.io/badge/license-GPLv3-blue.svg?style=flat)](https://raw.githubusercontent.com/xveduk/toxygen/master/LICENSE.md)
 
-### [Install](/docs/install.md) - [Contribute](/docs/contributing.md) - [Plugins](/docs/plugins.md)
+[![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/toxygen-project/toxygen.svg?style=flat)](https://github.com/toxygen-project/toxygen/stargazers)
+[![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) - [Updater](https://github.com/toxygen-project/toxygen_updater)
 
 ### Supported OS:
-- Windows
-- Linux
 
-###Features
+![Linux, Windows and OS X](/docs/os.png)
+
+### Features:
+
 - [x] 1v1 messages
 - [x] File transfers
-- [x] Audio
+- [x] Audio calls
 - [x] Plugins support
 - [x] Chat history
 - [x] Emoticons
@@ -38,23 +42,25 @@ Toxygen is cross-platform [Tox](https://tox.chat/) client written in Python3
 - [x] Changing nospam
 - [x] File resuming
 - [x] Read receipts
-- [ ] Video
+- [ ] Video calls
 - [ ] Desktop sharing
 - [ ] Group chats
 
-###Downloads
+### Downloads
-[Releases](https://github.com/xveduk/toxygen/releases)
+[Releases](https://github.com/toxygen-project/toxygen/releases)
 
-[Download last stable version](https://github.com/xveduk/toxygen/archive/master.zip)
+[Download last stable version](https://github.com/toxygen-project/toxygen/archive/master.zip)
 
-[Download develop version](https://github.com/xveduk/toxygen/archive/develop.zip)
+[Download develop version](https://github.com/toxygen-project/toxygen/archive/develop.zip)
 
-###Screenshots
+### Screenshots
 *Toxygen on Ubuntu and Windows*
 ![Ubuntu](/docs/ubuntu.png)
 ![Windows](/docs/windows.png)
 
-
+### Docs
-###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

@@ -1,10 +1,11 @@
-#Compile Toxygen
+# Compile Toxygen
 
 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/ (and /libs/libtox.dll, /libs/libsodium.a on Windows) to /dist/main/
+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/contact.md

@@ -0,0 +1,5 @@
+# Contact us:
+
+1) Using GitHub - open issue
+
+2) Use Toxygen Tox Group - add bot kalina@toxme.io (or 12EDB939AA529641CE53830B518D6EB30241868EE0E5023C46A372363CAEC91C2C948AEFE4EB)

docs/contributing.md

@@ -1,20 +1,20 @@
-#Issues
+# Issues
 
 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
+# Pull requests
 
 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
+# Translations
 
 Help us translate Toxygen! Translation can be created using pyside-lupdate (``pyside-lupdate toxygen.pro``) and QT Linguist.

docs/install.md

@@ -1,9 +1,9 @@
 # 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
+## Using pip3
 
 ### Windows
 
@@ -21,17 +21,32 @@ Run app using ``toxygen`` command.
 ``sudo pip3.4 install toxygen``
 5. Run toxygen using ``toxygen`` command.
 
+### OS X
+
+1. Install [toxcore](https://github.com/irungentoo/toxcore/blob/master/INSTALL.md) with toxav support in your system
+2. Install PortAudio:
+``brew install portaudio``
+3. Install toxygen: 
+``pip3.4 install toxygen``
+4. Run toxygen using ``toxygen`` command.
+
+## Packages
+
+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)
 
 ### Windows
 
 1. [Download and install latest Python 3.4](https://www.python.org/downloads/windows/)
-2. [Install PySide](https://pypi.python.org/pypi/PySide/1.2.4) (recommended) or [PyQt4](https://riverbankcomputing.com/software/pyqt/download)
+2. [Install PySide](https://pypi.python.org/pypi/PySide/1.2.4#installing-pyside-on-a-windows-system) (recommended) or [PyQt4](https://riverbankcomputing.com/software/pyqt/download)
 3. Install PyAudio: ``pip3.4 install pyaudio``
 4. [Download toxygen](https://github.com/xveduk/toxygen/archive/master.zip)
 5. Unpack archive  
 6. Download latest libtox.dll build, download latest libsodium.a build, put it into \src\libs\
-7. Run \src\main.py.
+7. Run \toxygen\main.py.
 
 Optional: install toxygen using setup.py: ``python3.4 setup.py install``
 
@@ -47,7 +62,7 @@ Optional: install toxygen using setup.py: ``python3.4 setup.py install``
 
 1. Install latest Python3: 
 ``sudo apt-get install python3``
-2. Install PySide: ``sudo apt-get install python3-pyside`` or install [PyQt4](https://riverbankcomputing.com/software/pyqt/download).
+2. Install PySide: ``sudo apt-get install python3-pyside`` or install [PyQt4](https://riverbankcomputing.com/software/pyqt/download) (``sudo apt-get install python3-pyqt4``).
 3. Install [toxcore](https://github.com/irungentoo/toxcore/blob/master/INSTALL.md) with toxav support in your system (install in /usr/lib/)
 4. Install PyAudio: 
 ``sudo apt-get install portaudio19-dev`` and ``sudo apt-get install python3-pyaudio`` (or ``pip3 install pyaudio``)
@@ -56,7 +71,18 @@ Optional: install toxygen using setup.py: ``python3.4 setup.py install``
 7. Run app:
 ``python3.4 main.py``
 
-Optional: install toxygen using setup.py: ``python3 setup.py install``
+Optional: install toxygen using setup.py: ``python3.4 setup.py install``
 
-## Compile Toxygen
+### OS X
-Check [compile.md](/docs/compile.md) for more info
+
+1. [Download and install latest Python 3.4](https://www.python.org/downloads/mac-osx/)
+2. [Install PySide](https://pypi.python.org/pypi/PySide/1.2.4#installing-pyside-on-a-mac-os-x-system) (recommended) or [PyQt4](https://riverbankcomputing.com/software/pyqt/download)
+3. Install PortAudio:
+``brew install portaudio``
+4. Install PyAudio: ``pip3 install pyaudio``
+5. Install [toxcore](https://github.com/irungentoo/toxcore/blob/master/INSTALL.md) with toxav support in your system
+6. [Download toxygen](https://github.com/xveduk/toxygen/archive/master.zip)
+7. Unpack archive  
+8. Run \toxygen\main.py.
+
+Optional: install toxygen using setup.py: ``python3 setup.py install``

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. 
@@ -12,12 +12,13 @@ All plugin's data should be stored in following structure:
 |---plugin_short_name.py
 |---/plugin_short_name/
 	|---settings.json
+	|---readme.txt
 	|---logs.txt
 	|---other_files
 ```
 
 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. 
@@ -50,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

@@ -1,4 +1,4 @@
-#Smileys
+# Smileys
 
 Toxygen support smileys. Smiley is small picture which replaces some symbol or combination of symbols. If you want to create your own smiley pack, create directory in src/smileys/. This directory must contain images with smileys and config.json. Example of config.json:
 
@@ -6,8 +6,8 @@ Toxygen support smileys. Smiley is small picture which replaces some symbol or c
 
 Animated smileys (.gif) are supported too.
 
-#Stickers
+# Stickers
 
 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

@@ -3,14 +3,20 @@ from setuptools.command.install import install
 from platform import system
 from subprocess import call
 from toxygen.util import program_version
+import sys
 
 
 version = program_version + '.0'
 
-MODULES = ['PyAudio']
+MODULES = []
 
-if system() == 'Windows':
+if system() in ('Windows', 'Darwin'):
-    MODULES.append('PySide')
+    MODULES = ['PyAudio', 'PySide']
+else:
+    try:
+        import pyaudio
+    except ImportError:
+        MODULES = ['PyAudio']
 
 
 class InstallScript(install):
@@ -18,17 +24,31 @@ class InstallScript(install):
 
     def run(self):
         install.run(self)
-        OS = system()
+        try:
-        if OS == 'Windows':
+            if system() == 'Windows':
                 call(["toxygen", "--configure"])
-        elif OS == 'Linux':
+            else:
                 call(["toxygen", "--clean"])
+        except:
+            try:
+                params = list(filter(lambda x: x.startswith('--prefix='), sys.argv))
+                if params:
+                    path = params[0][len('--prefix='):]
+                    if path[-1] not in ('/', '\\'):
+                        path += '/'
+                    path += 'bin/toxygen'
+                    if system() == 'Windows':
+                        call([path, "--configure"])
+                    else:
+                        call([path, "--clean"])
+            except:
+                pass
 
 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',
@@ -38,8 +58,6 @@ setup(name='Toxygen',
       include_package_data=True,
       classifiers=[
           'Programming Language :: Python :: 3 :: Only',
-          'Programming Language :: Python :: 3.2',
-          'Programming Language :: Python :: 3.3',
           'Programming Language :: Python :: 3.4',
       ],
       entry_points={

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'):
+            lib.set_password(password)
             copy_data = data[:]
-        data = lib.pass_encrypt(data)
+            new_data = lib.pass_encrypt(data)
-        data = lib.pass_decrypt(data)
+            assert lib.is_data_encrypted(new_data)
-        assert copy_data == 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

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

toxygen/avwidgets.py

@@ -23,7 +23,7 @@ class IncomingCallWidget(widgets.CenteredWidget):
         self.name = widgets.DataLabel(self)
         self.name.setGeometry(QtCore.QRect(90, 20, 300, 25))
         font = QtGui.QFont()
-        font.setFamily("Times New Roman")
+        font.setFamily(settings.Settings.get_instance()['font'])
         font.setPointSize(16)
         font.setBold(True)
         self.name.setFont(font)
@@ -63,6 +63,7 @@ class IncomingCallWidget(widgets.CenteredWidget):
 
             def __init__(self):
                 QtCore.QThread.__init__(self)
+                self.a = None
 
             def run(self):
                 class AudioFile:

toxygen/basecontact.py

@@ -0,0 +1,121 @@
+from settings import *
+try:
+    from PySide import QtCore, QtGui
+except ImportError:
+    from PyQt4 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

@@ -9,6 +9,14 @@ from toxcore_enums_and_consts import *
 from toxav_enums import *
 from tox import bin_to_string
 from plugin_support import PluginLoader
+import queue
+import threading
+import util
+
+
+# -----------------------------------------------------------------------------------------------------------------
+# Threads
+# -----------------------------------------------------------------------------------------------------------------
 
 
 class InvokeEvent(QtCore.QEvent):
@@ -33,6 +41,44 @@ _invoker = Invoker()
 def invoke_in_main_thread(fn, *args, **kwargs):
     QtCore.QCoreApplication.postEvent(_invoker, InvokeEvent(fn, *args, **kwargs))
 
+
+class FileTransfersThread(threading.Thread):
+
+    def __init__(self):
+        self._queue = queue.Queue()
+        self._timeout = 0.01
+        self._continue = True
+        super().__init__()
+
+    def execute(self, function, *args, **kwargs):
+        self._queue.put((function, args, kwargs))
+
+    def stop(self):
+        self._continue = False
+
+    def run(self):
+        while self._continue:
+            try:
+                function, args, kwargs = self._queue.get(timeout=self._timeout)
+                function(*args, **kwargs)
+            except queue.Empty:
+                pass
+            except queue.Full:
+                util.log('Queue is Full in _thread')
+            except Exception as ex:
+                util.log('Exception in _thread: ' + str(ex))
+
+_thread = FileTransfersThread()
+
+
+def start():
+    _thread.start()
+
+
+def stop():
+    _thread.stop()
+    _thread.join()
+
 # -----------------------------------------------------------------------------------------------------------------
 # Callbacks - current user
 # -----------------------------------------------------------------------------------------------------------------
@@ -68,7 +114,7 @@ def friend_status(tox, friend_num, new_status, user_data):
     if friend.status is None and Settings.get_instance()['sound_notifications'] and profile.status != TOX_USER_STATUS['BUSY']:
         sound_notification(SOUND_NOTIFICATION['FRIEND_CONNECTION_STATUS'])
     invoke_in_main_thread(friend.set_status, new_status)
-    invoke_in_main_thread(profile.send_files, friend_num)
+    invoke_in_main_thread(QtCore.QTimer.singleShot, 5000, lambda: profile.send_files(friend_num))
     invoke_in_main_thread(profile.update_filtration)
 
 
@@ -197,28 +243,15 @@ def file_recv_chunk(tox, friend_number, file_number, position, chunk, length, us
     """
     Incoming chunk
     """
-    if not length:
+    _thread.execute(Profile.get_instance().incoming_chunk, friend_number, file_number, position,
-        invoke_in_main_thread(Profile.get_instance().incoming_chunk,
+                    chunk[:length] if length else None)
-                              friend_number,
-                              file_number,
-                              position,
-                              None)
-    else:
-        Profile.get_instance().incoming_chunk(friend_number, file_number, position, chunk[:length])
 
 
 def file_chunk_request(tox, friend_number, file_number, position, size, user_data):
     """
     Outgoing chunk
     """
-    if size:
     Profile.get_instance().outgoing_chunk(friend_number, file_number, position, size)
-    else:
-        invoke_in_main_thread(Profile.get_instance().outgoing_chunk,
-                              friend_number,
-                              file_number,
-                              position,
-                              size)
 
 
 def file_recv_control(tox, friend_number, file_number, file_control, user_data):
@@ -241,16 +274,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)
 
 
 # -----------------------------------------------------------------------------------------------------------------
@@ -280,7 +315,6 @@ def callback_audio(toxav, friend_number, samples, audio_samples_per_channel, aud
     """
     New audio chunk
     """
-    # print(audio_samples_per_channel, audio_channels_count, rate)
     Profile.get_instance().call.chunk(
         bytes(samples[:audio_samples_per_channel * 2 * audio_channels_count]),
         audio_channels_count,

toxygen/calls.py

@@ -141,4 +141,3 @@ class AV:
 
             if state & TOXAV_FRIEND_CALL_STATE['ACCEPTING_A']:
                 self._calls[friend_number] |= 1
-

toxygen/contact.py

@@ -1,114 +1,289 @@
-import os
-from settings import *
 try:
     from PySide import QtCore, QtGui
 except ImportError:
     from PyQt4 import QtCore, QtGui
-from toxcore_enums_and_consts import TOX_PUBLIC_KEY_SIZE
+from history import *
+import basecontact
+import util
+from messages import *
+import file_transfers as ft
+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(QtCore.QSize(width, width))
-        pixmap.load(avatar_path)
-        self._widget.avatar_label.setScaledContents(False)
-        self._widget.avatar_label.setPixmap(pixmap.scaled(width, width, QtCore.Qt.KeepAspectRatio))
-        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

@@ -8,8 +8,7 @@ try:
     from PySide import QtCore
 except ImportError:
     from PyQt4 import QtCore
-
+    QtCore.Signal = QtCore.pyqtSignal
-# TODO: threads!
 
 
 TOX_FILE_TRANSFER_STATE = {
@@ -33,11 +32,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):
-    try:
+
-        signal = QtCore.Signal(int, float, int)  # state and progress
+    signal = QtCore.Signal(int, float, int)  # state, progress, time in sec
-    except:
+
-        signal = QtCore.pyqtSignal(int, float, int)  # state and progress - pyqt4
+
+class TransferFinishedSignal(QtCore.QObject):
+
+    signal = QtCore.Signal(int, int)  # friend number, file number
 
 
 class FileTransfer(QtCore.QObject):
@@ -56,6 +62,8 @@ class FileTransfer(QtCore.QObject):
         self._size = float(size)
         self._done = 0
         self._state_changed = StateSignal()
+        self._finished = TransferFinishedSignal()
+        self._file_id = None
 
     def set_tox(self, tox):
         self._tox = tox
@@ -63,6 +71,9 @@ class FileTransfer(QtCore.QObject):
     def set_state_changed_handler(self, handler):
         self._state_changed.signal.connect(handler)
 
+    def set_transfer_finished_handler(self, handler):
+        self._finished.signal.connect(handler)
+
     def signal(self):
         percentage = self._done / self._size if self._size else 0
         if self._creation_time is None or not percentage:
@@ -71,12 +82,21 @@ class FileTransfer(QtCore.QObject):
             t = ((time() - self._creation_time) / percentage) * (1 - percentage)
         self._state_changed.signal.emit(self.state, percentage, int(t))
 
+    def finished(self):
+        self._finished.signal.emit(self._friend_number, self._file_number)
+
     def get_file_number(self):
         return self._file_number
 
     def get_friend_number(self):
         return self._friend_number
 
+    def get_id(self):
+        return self._file_id
+
+    def get_path(self):
+        return self._path
+
     def cancel(self):
         self.send_control(TOX_FILE_CONTROL['CANCEL'])
         if hasattr(self, '_file'):
@@ -122,6 +142,7 @@ class SendTransfer(FileTransfer):
         self.state = TOX_FILE_TRANSFER_STATE['OUTGOING_NOT_STARTED']
         self._file_number = tox.file_send(friend_number, kind, size, file_id,
                                           bytes(basename(path), 'utf-8') if path else b'')
+        self._file_id = self.get_file_id()
 
     def send_chunk(self, position, size):
         """
@@ -136,11 +157,11 @@ class SendTransfer(FileTransfer):
             data = self._file.read(size)
             self._tox.file_send_chunk(self._friend_number, self._file_number, position, data)
             self._done += size
-            self.signal()
         else:
             if hasattr(self, '_file'):
                 self._file.close()
             self.state = TOX_FILE_TRANSFER_STATE['FINISHED']
+            self.finished()
         self.signal()
 
 
@@ -180,9 +201,9 @@ class SendFromBuffer(FileTransfer):
             data = self._data[position:position + size]
             self._tox.file_send_chunk(self._friend_number, self._file_number, position, data)
             self._done += size
-            self.signal()
         else:
             self.state = TOX_FILE_TRANSFER_STATE['FINISHED']
+            self.finished()
         self.signal()
 
 
@@ -204,16 +225,23 @@ class SendFromFileBuffer(SendTransfer):
 
 class ReceiveTransfer(FileTransfer):
 
-    def __init__(self, path, tox, friend_number, size, file_number):
+    def __init__(self, path, tox, friend_number, size, file_number, position=0):
         super(ReceiveTransfer, self).__init__(path, tox, friend_number, size, file_number)
         self._file = open(self._path, 'wb')
-        self._file.truncate(0)
+        self._file_size = position
-        self._file_size = 0
+        self._file.truncate(position)
+        self._missed = set()
+        self._file_id = self.get_file_id()
+        self._done = position
 
     def cancel(self):
         super(ReceiveTransfer, self).cancel()
         remove(self._path)
 
+    def total_size(self):
+        self._missed.add(self._file_size)
+        return min(self._missed)
+
     def write_chunk(self, position, data):
         """
         Incoming chunk
@@ -225,12 +253,15 @@ class ReceiveTransfer(FileTransfer):
         if data is None:
             self._file.close()
             self.state = TOX_FILE_TRANSFER_STATE['FINISHED']
-            self.signal()
+            self.finished()
         else:
             data = bytearray(data)
             if self._file_size < position:
                 self._file.seek(0, 2)
                 self._file.write(b'\0' * (position - self._file_size))
+                self._missed.add(self._file_size)
+            else:
+                self._missed.discard(position)
             self._file.seek(position)
             self._file.write(data)
             l = len(data)
@@ -258,6 +289,7 @@ class ReceiveToBuffer(FileTransfer):
             self._creation_time = time()
         if data is None:
             self.state = TOX_FILE_TRANSFER_STATE['FINISHED']
+            self.finished()
         else:
             data = bytes(data)
             l = len(data)
@@ -312,3 +344,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,148 +1,16 @@
 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)
-        del self._widget
-        if hasattr(self, '_message_getter'):
-            del self._message_getter
-
-    # -----------------------------------------------------------------------------------------------------------------
-    # History support
-    # -----------------------------------------------------------------------------------------------------------------
-
-    def get_receipts(self):
-        return self._receipts
-
-    receipts = property(get_receipts)  # read receipts
-
-    def inc_receipts(self):
-        self._receipts += 1
-
-    def dec_receipt(self):
-        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 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
@@ -170,74 +38,31 @@ class Friend(contact.Contact):
     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))
 
     # -----------------------------------------------------------------------------------------------------------------
-    # Alias support
+    # History support
     # -----------------------------------------------------------------------------------------------------------------
 
-    def set_name(self, value):
+    def get_receipts(self):
-        """
+        return self._receipts
-        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):
+    receipts = property(get_receipts)  # read receipts
-        self._alias = bool(alias)
 
-    # -----------------------------------------------------------------------------------------------------------------
+    def inc_receipts(self):
-    # Visibility in friends' list
+        self._receipts += 1
-    # -----------------------------------------------------------------------------------------------------------------
 
-    def get_visibility(self):
+    def dec_receipt(self):
-        return self._visible
+        if self._receipts:
-
+            self._receipts -= 1
-    def set_visibility(self, value):
+            self.mark_as_sent()
-        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,19 @@
-# coding=utf-8
+# -*- 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 +28,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 +38,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 +46,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 +60,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 +68,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 +81,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 +111,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 +169,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,71 @@
+try:
+    from PySide import QtCore, QtGui
+except ImportError:
+    from PyQt4 import QtCore, QtGui
+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 = QtGui.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 = QtGui.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 = QtGui.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 = 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 file_transfer_item(self, data, append):
+        data.append(self._messages.width())
+        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

toxygen/libtox.py

@@ -6,13 +6,16 @@ import util
 class LibToxCore:
 
     def __init__(self):
-        if system() == 'Linux':
+        if system() == 'Windows':
-            # libtoxcore and libsodium must be installed in your os
-            self._libtoxcore = CDLL('libtoxcore.so')
-        elif system() == 'Windows':
             self._libtoxcore = CDLL(util.curr_directory() + '/libs/libtox.dll')
+        elif system() == 'Darwin':
+            self._libtoxcore = CDLL('libtoxcore.dylib')
         else:
-            raise OSError('Unknown system.')
+            # libtoxcore and libsodium must be installed in your os
+            try:
+                self._libtoxcore = CDLL('libtoxcore.so')
+            except:
+                self._libtoxcore = CDLL(util.curr_directory() + '/libs/libtoxcore.so')
 
     def __getattr__(self, item):
         return self._libtoxcore.__getattr__(item)
@@ -21,14 +24,17 @@ class LibToxCore:
 class LibToxAV:
 
     def __init__(self):
-        if system() == 'Linux':
+        if system() == 'Windows':
-            # that /usr/lib/libtoxav.so must exists
-            self._libtoxav = CDLL('libtoxav.so')
-        elif 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:
-            raise OSError('Unknown system.')
+            # /usr/lib/libtoxav.so must exists
+            try:
+                self._libtoxav = CDLL('libtoxav.so')
+            except:
+                self._libtoxav = CDLL(util.curr_directory() + '/libs/libtoxav.so')
 
     def __getattr__(self, item):
         return self._libtoxav.__getattr__(item)
@@ -37,14 +43,17 @@ class LibToxAV:
 class LibToxEncryptSave:
 
     def __init__(self):
-        if system() == 'Linux':
+        if system() == 'Windows':
-            # /usr/lib/libtoxencryptsave.so must exists
-            self._lib_tox_encrypt_save = CDLL('libtoxencryptsave.so')
-        elif 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:
-            raise OSError('Unknown system.')
+            # /usr/lib/libtoxencryptsave.so must exists
+            try:
+                self._lib_tox_encrypt_save = CDLL('libtoxencryptsave.so')
+            except:
+                self._lib_tox_encrypt_save = CDLL(util.curr_directory() + '/libs/libtoxencryptsave.so')
 
     def __getattr__(self, item):
         return self._lib_tox_encrypt_save.__getattr__(item)

toxygen/list_items.py

@@ -3,6 +3,7 @@ try:
     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
@@ -10,6 +11,7 @@ from widgets import DataLabel, create_menu
 import html as h
 import smileys
 import settings
+import re
 
 
 class MessageEdit(QtGui.QTextBrowser):
@@ -24,7 +26,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']:
@@ -32,7 +36,7 @@ class MessageEdit(QtGui.QTextBrowser):
         else:
             self.setHtml(text)
         font = QtGui.QFont()
-        font.setFamily("Times New Roman")
+        font.setFamily(settings.Settings.get_instance()['font'])
         font.setPixelSize(settings.Settings.get_instance()['message_font_size'])
         font.setBold(False)
         self.setFont(font)
@@ -42,10 +46,31 @@ 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.triggered.connect(self.quote_text)
+        text = self.textCursor().selection().toPlainText()
+        if not text:
+            quote.setEnabled(False)
+        else:
+            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.addActions(submenu)
         menu.popup(event.globalPos())
         menu.exec_(event.globalPos())
         del menu
 
+    def quote_text(self):
+        text = self.textCursor().selection().toPlainText()
+        if text:
+            import mainscreen
+            window = mainscreen.MainWindow.get_instance()
+            text = '>' + '\n>'.join(text.split('\n'))
+            if window.messageEdit.toPlainText():
+                text = '\n' + text
+            window.messageEdit.appendPlainText(text)
+
     def on_anchor_clicked(self, url):
         text = str(url.toString())
         if text.startswith('tox:'):
@@ -105,19 +130,17 @@ class MessageItem(QtGui.QWidget):
     def __init__(self, text, time, user='', sent=True, message_type=TOX_MESSAGE_TYPE['NORMAL'], parent=None):
         QtGui.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("Times New Roman")
+        font.setFamily(settings.Settings.get_instance()['font'])
         font.setPointSize(11)
         font.setBold(True)
         self.name.setFont(font)
         self.name.setText(user)
 
         self.time = QtGui.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 = QtGui.QFont()
-        font.setFamily("Times New Roman")
         font.setPointSize(10)
         font.setBold(False)
         self.time.setFont(font)
@@ -131,12 +154,12 @@ 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):
@@ -165,7 +188,32 @@ class MessageItem(QtGui.QWidget):
         self.setFixedHeight(max(self.height(), 36))
         self.name.setFixedHeight(self.height())
         self.message.setFixedHeight(self.height())
-        self.name.setPixmap(pixmap.scaled(30, 30, QtCore.Qt.KeepAspectRatio))
+        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)
+
+    @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(QtGui.QWidget):
@@ -180,12 +228,12 @@ class ContactItem(QtGui.QWidget):
         self.avatar_label = QtGui.QLabel(self)
         size = 32 if mode else 64
         self.avatar_label.setGeometry(QtCore.QRect(3, 4, size, size))
-        self.avatar_label.setScaledContents(True)
+        self.avatar_label.setScaledContents(False)
         self.avatar_label.setAlignment(QtCore.Qt.AlignCenter)
         self.name = DataLabel(self)
         self.name.setGeometry(QtCore.QRect(50 if mode else 75, 3 if mode else 10, 150, 15 if mode else 25))
         font = QtGui.QFont()
-        font.setFamily("Times New Roman")
+        font.setFamily(settings.Settings.get_instance()['font'])
         font.setPointSize(10 if mode else 12)
         font.setBold(True)
         self.name.setFont(font)
@@ -242,7 +290,7 @@ class UnreadMessagesCount(QtGui.QWidget):
         self.label.setGeometry(QtCore.QRect(0, 0, 30, 20))
         self.label.setVisible(False)
         font = QtGui.QFont()
-        font.setFamily("Times New Roman")
+        font.setFamily(settings.Settings.get_instance()['font'])
         font.setPointSize(12)
         font.setBold(True)
         self.label.setFont(font)
@@ -275,24 +323,24 @@ 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("Times New Roman")
+        font.setFamily(settings.Settings.get_instance()['font'])
         font.setPointSize(11)
         font.setBold(True)
         self.name.setFont(font)
         self.name.setText(user)
 
         self.time = QtGui.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.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)
@@ -340,7 +388,7 @@ class FileTransferItem(QtGui.QListWidget):
         self.file_name.setToolTip(file_name)
         self.saved_name = file_name
         self.time_left = QtGui.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'])
@@ -390,7 +438,7 @@ class FileTransferItem(QtGui.QListWidget):
         if time + 1:
             m, s = divmod(time, 60)
             self.time_left.setText('{0:02d}:{1:02d}'.format(m, s))
-        if self.state != state:
+        if self.state != state and self.state in ACTIVE_FILE_TRANSFERS:
             if state == TOX_FILE_TRANSFER_STATE['CANCELLED']:
                 self.setStyleSheet('QListWidget { border: 1px solid #B40404; }')
                 self.cancel.setVisible(False)

toxygen/main.py

@@ -1,3 +1,5 @@
+# -*- coding: utf-8 -*-
+
 import sys
 from loginscreen import LoginScreen
 import profile
@@ -8,20 +10,21 @@ except ImportError:
     from PyQt4 import QtCore, QtGui
 from bootstrap import node_generator
 from mainscreen import MainWindow
-from callbacks import init_callbacks
+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,7 +39,7 @@ 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.exec_()
@@ -61,7 +64,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) + '/'
@@ -125,7 +128,30 @@ class Toxygen:
                         set_pass.show()
                         self.app.connect(self.app, QtCore.SIGNAL("lastWindowClosed()"), self.app, QtCore.SLOT("quit()"))
                         self.app.exec_()
-                    ProfileHelper(Settings.get_default_path(), name).save_profile(self.tox.get_savedata())
+                    reply = QtGui.QMessageBox.question(None,
+                                                       'Profile {}'.format(name),
+                                                       QtGui.QApplication.translate("login",
+                                                                                    'Do you want to save profile in default folder? If no, profile will be saved in program folder',
+                                                                                    None,
+                                                                                    QtGui.QApplication.UnicodeUTF8),
+                                                       QtGui.QMessageBox.Yes,
+                                                       QtGui.QMessageBox.No)
+                    if reply == QtGui.QMessageBox.Yes:
+                        path = Settings.get_default_path()
+                    else:
+                        path = curr_directory() + '/'
+                    try:
+                        ProfileHelper(path, name).save_profile(self.tox.get_savedata())
+                    except Exception as ex:
+                        print(str(ex))
+                        log('Profile creation exception: ' + str(ex))
+                        msgBox = QtGui.QMessageBox()
+                        msgBox.setText(QtGui.QApplication.translate("login",
+                                                                    'Profile saving error! Does Toxygen have permission to write to this directory?',
+                                                                    None,
+                                                                    QtGui.QApplication.UnicodeUTF8))
+                        msgBox.exec_()
+                        return
                     path = Settings.get_default_path()
                     settings = Settings(name)
                     if curr_lang in langs:
@@ -170,10 +196,12 @@ class Toxygen:
         self.tray.setObjectName('tray')
 
         self.ms = MainWindow(self.tox, self.reset, self.tray)
+        app.aboutToQuit.connect(self.ms.close_window)
 
         class Menu(QtGui.QMenu):
 
             def newStatus(self, status):
+                if not Settings.get_instance().locked:
                     profile.Profile.get_instance().set_status(status)
                     self.aboutToShow()
                     self.hide()
@@ -212,22 +240,36 @@ class Toxygen:
         exit = m.addAction(QtGui.QApplication.translate('tray', 'Exit', None, QtGui.QApplication.UnicodeUTF8))
 
         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
+                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:
+                show_window()
+
+        def close_app():
+            if not Settings.get_instance().locked:
+                settings.closing = True
+                self.ms.close()
+
         m.connect(show, QtCore.SIGNAL("triggered()"), show_window)
-        m.connect(exit, QtCore.SIGNAL("triggered()"), lambda: app.exit())
+        m.connect(exit, QtCore.SIGNAL("triggered()"), close_app)
         m.connect(m, QtCore.SIGNAL("aboutToShow()"), lambda: m.aboutToShow())
         sub.connect(onl, QtCore.SIGNAL("triggered()"), lambda: m.newStatus(0))
         sub.connect(away, QtCore.SIGNAL("triggered()"), lambda: m.newStatus(1))
@@ -235,12 +277,41 @@ class Toxygen:
 
         self.tray.setContextMenu(m)
         self.tray.show()
+        self.tray.activated.connect(tray_activated)
 
         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 = QtGui.QMessageBox.question(None,
+                                                       'Toxygen',
+                                                       QtGui.QApplication.translate("login",
+                                                                                    'Update for Toxygen was found. Download and install it?',
+                                                                                    None,
+                                                                                    QtGui.QApplication.UnicodeUTF8),
+                                                       QtGui.QMessageBox.Yes,
+                                                       QtGui.QMessageBox.No)
+                    if reply == QtGui.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()
 
+        start()
         # init thread
         self.init = self.InitThread(self.tox, self.ms, self.tray)
         self.init.start()
@@ -256,10 +327,12 @@ class Toxygen:
 
         app.connect(app, QtCore.SIGNAL("lastWindowClosed()"), app, QtCore.SLOT("quit()"))
         app.exec_()
+
         self.init.stop = True
         self.mainloop.stop = True
         self.avloop.stop = True
         plugin_helper.stop()
+        stop()
         self.mainloop.wait()
         self.init.wait()
         self.avloop.wait()
@@ -387,15 +460,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')
@@ -413,16 +484,20 @@ def configure():
             pass
 
 
+def reset():
+    Settings.reset_auto_profile()
+
+
 def main():
     if len(sys.argv) == 1:
         toxygen = Toxygen()
     else:  # started with argument(s)
         arg = sys.argv[1]
         if arg == '--version':
-            print('Toxygen ' + program_version)
+            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()
@@ -430,6 +505,9 @@ def main():
         elif arg == '--clean':
             clean()
             return
+        elif arg == '--reset':
+            reset()
+            return
         else:
             toxygen = Toxygen(arg)
     toxygen.main()

toxygen/mainscreen.py

@@ -1,61 +1,72 @@
-# -*- coding: utf-8 -*-
-
 from menu import *
 from profile import *
 from list_items import *
-from widgets import MultilineEdit, LineEdit
+from widgets import MultilineEdit, LineEdit, ComboBox
 import plugin_support
 from mainscreen_widgets import *
+import settings
+import platform
+import toxes
 
 
-class MainWindow(QtGui.QMainWindow):
+class MainWindow(QtGui.QMainWindow, Singleton):
 
     def __init__(self, tox, reset, tray):
-        super(MainWindow, self).__init__()
+        super().__init__()
+        Singleton.__init__(self)
         self.reset = reset
         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 = QtGui.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 = QtGui.QMenu()
         self.menuProfile.setObjectName("menuProfile")
-        self.menuSettings = QtGui.QMenu(self.menubar)
+        self.menuSettings = QtGui.QMenu()
         self.menuSettings.setObjectName("menuSettings")
-        self.menuPlugins = QtGui.QMenu(self.menubar)
+        self.menuPlugins = QtGui.QMenu()
         self.menuPlugins.setObjectName("menuPlugins")
-        self.menuAbout = QtGui.QMenu(self.menubar)
+        self.menuAbout = QtGui.QMenu()
         self.menuAbout.setObjectName("menuAbout")
 
-        self.actionAdd_friend = QtGui.QAction(MainWindow)
+        self.actionAdd_friend = QtGui.QAction(Form)
         self.actionAdd_friend.setObjectName("actionAdd_friend")
-        self.actionprofilesettings = QtGui.QAction(MainWindow)
+        self.actionprofilesettings = QtGui.QAction(Form)
         self.actionprofilesettings.setObjectName("actionprofilesettings")
-        self.actionPrivacy_settings = QtGui.QAction(MainWindow)
+        self.actionPrivacy_settings = QtGui.QAction(Form)
         self.actionPrivacy_settings.setObjectName("actionPrivacy_settings")
-        self.actionInterface_settings = QtGui.QAction(MainWindow)
+        self.actionInterface_settings = QtGui.QAction(Form)
         self.actionInterface_settings.setObjectName("actionInterface_settings")
-        self.actionNotifications = QtGui.QAction(MainWindow)
+        self.actionNotifications = QtGui.QAction(Form)
         self.actionNotifications.setObjectName("actionNotifications")
-        self.actionNetwork = QtGui.QAction(MainWindow)
+        self.actionNetwork = QtGui.QAction(Form)
         self.actionNetwork.setObjectName("actionNetwork")
-        self.actionAbout_program = QtGui.QAction(MainWindow)
+        self.actionAbout_program = QtGui.QAction(Form)
         self.actionAbout_program.setObjectName("actionAbout_program")
-        self.actionSettings = QtGui.QAction(MainWindow)
+        self.updateSettings = QtGui.QAction(Form)
+        self.actionSettings = QtGui.QAction(Form)
         self.actionSettings.setObjectName("actionSettings")
-        self.audioSettings = QtGui.QAction(MainWindow)
+        self.audioSettings = QtGui.QAction(Form)
-        self.pluginData = QtGui.QAction(MainWindow)
+        self.pluginData = QtGui.QAction(Form)
-        self.importPlugin = QtGui.QAction(MainWindow)
+        self.importPlugin = QtGui.QAction(Form)
-        self.lockApp = QtGui.QAction(MainWindow)
+        self.reloadPlugins = QtGui.QAction(Form)
+        self.lockApp = QtGui.QAction(Form)
         self.menuProfile.addAction(self.actionAdd_friend)
         self.menuProfile.addAction(self.actionSettings)
         self.menuProfile.addAction(self.lockApp)
@@ -64,26 +75,33 @@ class MainWindow(QtGui.QMainWindow):
         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)
         self.actionAdd_friend.triggered.connect(self.add_contact)
-        self.actionSettings.triggered.connect(self.profilesettings)
+        self.actionSettings.triggered.connect(self.profile_settings)
         self.actionPrivacy_settings.triggered.connect(self.privacy_settings)
         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()
@@ -91,15 +109,16 @@ class MainWindow(QtGui.QMainWindow):
     def event(self, event):
         if event.type() == QtCore.QEvent.WindowActivate:
             self.tray.setIcon(QtGui.QIcon(curr_directory() + '/images/icon.png'))
+            self.messages.repaint()
         return super(MainWindow, self).event(event)
 
     def retranslateUi(self):
         self.lockApp.setText(QtGui.QApplication.translate("MainWindow", "Lock", None, QtGui.QApplication.UnicodeUTF8))
-        self.menuPlugins.setTitle(QtGui.QApplication.translate("MainWindow", "Plugins", None, QtGui.QApplication.UnicodeUTF8))
+        self.plugins_button.setText(QtGui.QApplication.translate("MainWindow", "Plugins", None, QtGui.QApplication.UnicodeUTF8))
         self.pluginData.setText(QtGui.QApplication.translate("MainWindow", "List of plugins", None, QtGui.QApplication.UnicodeUTF8))
-        self.menuProfile.setTitle(QtGui.QApplication.translate("MainWindow", "Profile", None, QtGui.QApplication.UnicodeUTF8))
+        self.profile_button.setText(QtGui.QApplication.translate("MainWindow", "Profile", None, QtGui.QApplication.UnicodeUTF8))
-        self.menuSettings.setTitle(QtGui.QApplication.translate("MainWindow", "Settings", None, QtGui.QApplication.UnicodeUTF8))
+        self.settings_button.setText(QtGui.QApplication.translate("MainWindow", "Settings", None, QtGui.QApplication.UnicodeUTF8))
-        self.menuAbout.setTitle(QtGui.QApplication.translate("MainWindow", "About", None, QtGui.QApplication.UnicodeUTF8))
+        self.about_button.setText(QtGui.QApplication.translate("MainWindow", "About", None, QtGui.QApplication.UnicodeUTF8))
         self.actionAdd_friend.setText(QtGui.QApplication.translate("MainWindow", "Add contact", None, QtGui.QApplication.UnicodeUTF8))
         self.actionprofilesettings.setText(QtGui.QApplication.translate("MainWindow", "Profile", None, QtGui.QApplication.UnicodeUTF8))
         self.actionPrivacy_settings.setText(QtGui.QApplication.translate("MainWindow", "Privacy", None, QtGui.QApplication.UnicodeUTF8))
@@ -109,14 +128,22 @@ class MainWindow(QtGui.QMainWindow):
         self.actionAbout_program.setText(QtGui.QApplication.translate("MainWindow", "About program", None, QtGui.QApplication.UnicodeUTF8))
         self.actionSettings.setText(QtGui.QApplication.translate("MainWindow", "Settings", None, QtGui.QApplication.UnicodeUTF8))
         self.audioSettings.setText(QtGui.QApplication.translate("MainWindow", "Audio", None, QtGui.QApplication.UnicodeUTF8))
+        self.updateSettings.setText(QtGui.QApplication.translate("MainWindow", "Updates", None, QtGui.QApplication.UnicodeUTF8))
         self.contact_name.setPlaceholderText(QtGui.QApplication.translate("MainWindow", "Search", None, QtGui.QApplication.UnicodeUTF8))
         self.sendMessageButton.setToolTip(QtGui.QApplication.translate("MainWindow", "Send message", None, QtGui.QApplication.UnicodeUTF8))
         self.callButton.setToolTip(QtGui.QApplication.translate("MainWindow", "Start audio call with friend", None, QtGui.QApplication.UnicodeUTF8))
         self.online_contacts.clear()
         self.online_contacts.addItem(QtGui.QApplication.translate("MainWindow", "All", None, QtGui.QApplication.UnicodeUTF8))
         self.online_contacts.addItem(QtGui.QApplication.translate("MainWindow", "Online", None, QtGui.QApplication.UnicodeUTF8))
-        self.online_contacts.setCurrentIndex(int(Settings.get_instance()['show_online_friends']))
+        self.online_contacts.addItem(QtGui.QApplication.translate("MainWindow", "Online first", None, QtGui.QApplication.UnicodeUTF8))
+        self.online_contacts.addItem(QtGui.QApplication.translate("MainWindow", "Name", None, QtGui.QApplication.UnicodeUTF8))
+        self.online_contacts.addItem(QtGui.QApplication.translate("MainWindow", "Online and by name", None, QtGui.QApplication.UnicodeUTF8))
+        self.online_contacts.addItem(QtGui.QApplication.translate("MainWindow", "Online first and by name", None, QtGui.QApplication.UnicodeUTF8))
+        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(QtGui.QApplication.translate("MainWindow", "Import plugin", None, QtGui.QApplication.UnicodeUTF8))
+        self.reloadPlugins.setText(QtGui.QApplication.translate("MainWindow", "Reload plugins", None, QtGui.QApplication.UnicodeUTF8))
 
     def setup_right_bottom(self, Form):
         Form.resize(650, 60)
@@ -124,7 +151,8 @@ class MainWindow(QtGui.QMainWindow):
         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)
@@ -162,7 +190,7 @@ class MainWindow(QtGui.QMainWindow):
         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_()
@@ -171,67 +199,67 @@ class MainWindow(QtGui.QMainWindow):
 
     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.setGeometry(QtCore.QRect(5, 30, 64, 64))
+        self.avatar_label.setGeometry(QtCore.QRect(5, 5, 64, 64))
-        self.avatar_label.setScaledContents(True)
+        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("Times New Roman")
+        font.setFamily(settings.Settings.get_instance()['font'])
         font.setPointSize(14)
         font.setBold(True)
         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.profilesettings
+        self.avatar_label.mouseReleaseEvent = self.profile_settings
-        self.status_message.mouseReleaseEvent = self.profilesettings
+        self.status_message.mouseReleaseEvent = self.profile_settings
-        self.name.mouseReleaseEvent = self.profilesettings
+        self.name.mouseReleaseEvent = self.profile_settings
         self.connection_status.raise_()
         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.setGeometry(QtCore.QRect(10, 30, 64, 64))
+        self.account_avatar.setGeometry(QtCore.QRect(10, 5, 64, 64))
-        self.account_avatar.setScaledContents(True)
+        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("Times New Roman")
+        font.setFamily(settings.Settings.get_instance()['font'])
         font.setPointSize(14)
         font.setBold(True)
         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.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.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.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)
@@ -248,6 +276,9 @@ class MainWindow(QtGui.QMainWindow):
         self.friends_list.connect(self.friends_list, QtCore.SIGNAL("customContextMenuRequested(QPoint)"),
                                   self.friend_right_click)
         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)
@@ -256,7 +287,8 @@ class MainWindow(QtGui.QMainWindow):
         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:
@@ -264,6 +296,7 @@ class MainWindow(QtGui.QMainWindow):
                 self.messages.verticalScrollBar().setValue(1)
         self.messages.verticalScrollBar().valueChanged.connect(load)
         self.messages.setVerticalScrollMode(QtGui.QAbstractItemView.ScrollPerPixel)
+        self.messages.setSelectionMode(QtGui.QAbstractItemView.ExtendedSelection)
 
     def initUI(self, tox):
         self.setMinimumSize(920, 500)
@@ -271,6 +304,7 @@ class MainWindow(QtGui.QMainWindow):
         self.setGeometry(s['x'], s['y'], s['width'], s['height'])
         self.setWindowTitle('Toxygen')
         os.chdir(curr_directory() + '/images/')
+        menu = QtGui.QWidget()
         main = QtGui.QWidget()
         grid = QtGui.QGridLayout()
         search = QtGui.QWidget()
@@ -285,72 +319,100 @@ class MainWindow(QtGui.QMainWindow):
         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
         self.retranslateUi()
         self.profile = Profile(tox, self)
 
-    def closeEvent(self, *args, **kwargs):
+    def closeEvent(self, event):
+        s = Settings.get_instance()
+        if not s['close_to_tray'] or s.closing:
+            if not self._saved:
+                self._saved = True
                 self.profile.save_history()
                 self.profile.close()
-        s = Settings.get_instance()
+                s['x'] = self.geometry().x()
-        s['x'] = self.pos().x()
+                s['y'] = self.geometry().y()
-        s['y'] = self.pos().y()
                 s['width'] = self.width()
                 s['height'] = self.height()
                 s.save()
                 QtGui.QApplication.closeAllWindows()
+                event.accept()
+        elif QtGui.QSystemTrayIcon.isSystemTrayAvailable():
+            event.ignore()
+            self.hide()
+
+    def close_window(self):
+        Settings.get_instance().closing = True
+        self.close()
 
     def resizeEvent(self, *args, **kwargs):
+        if platform.system() == 'Windows':
             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, 40, 50, 50))
+        self.videocallButton.setGeometry(QtCore.QRect(self.width() - 330, 10, 50, 50))
-        self.callButton.setGeometry(QtCore.QRect(self.width() - 390, 40, 50, 50))
+        self.callButton.setGeometry(QtCore.QRect(self.width() - 390, 10, 50, 50))
-        self.typing.setGeometry(QtCore.QRect(self.width() - 450, 50, 50, 30))
+        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 QtGui.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.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)
 
@@ -363,7 +425,7 @@ class MainWindow(QtGui.QMainWindow):
         msgBox = QtGui.QMessageBox()
         msgBox.setWindowTitle(QtGui.QApplication.translate("MainWindow", "About", None, QtGui.QApplication.UnicodeUTF8))
         text = (QtGui.QApplication.translate("MainWindow", 'Toxygen is Tox client written on Python.\nVersion: ', None, QtGui.QApplication.UnicodeUTF8))
-        msgBox.setText(text + util.program_version + '\nGitHub: github.com/xveduk/toxygen/')
+        msgBox.setText(text + util.program_version + '\nGitHub: https://github.com/toxygen-project/toxygen/')
         msgBox.exec_()
 
     def network_settings(self):
@@ -375,10 +437,10 @@ class MainWindow(QtGui.QMainWindow):
         self.p_s.show()
 
     def add_contact(self, link=''):
-        self.a_c = AddContact(link)
+        self.a_c = AddContact(link or '')
         self.a_c.show()
 
-    def profilesettings(self, *args):
+    def profile_settings(self, *args):
         self.p_s = ProfileSettings()
         self.p_s.show()
 
@@ -398,6 +460,15 @@ class MainWindow(QtGui.QMainWindow):
         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,
@@ -419,7 +490,7 @@ class MainWindow(QtGui.QMainWindow):
             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:
@@ -513,13 +584,20 @@ class MainWindow(QtGui.QMainWindow):
         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)
         if item is not None:
             self.listMenu = QtGui.QMenu()
             set_alias_item = self.listMenu.addAction(QtGui.QApplication.translate("MainWindow", 'Set alias', None, QtGui.QApplication.UnicodeUTF8))
-            clear_history_item = self.listMenu.addAction(QtGui.QApplication.translate("MainWindow", 'Clear history', None, QtGui.QApplication.UnicodeUTF8))
+
+            history_menu = self.listMenu.addMenu(QtGui.QApplication.translate("MainWindow", 'Chat history', None, QtGui.QApplication.UnicodeUTF8))
+            clear_history_item = history_menu.addAction(QtGui.QApplication.translate("MainWindow", 'Clear history', None, QtGui.QApplication.UnicodeUTF8))
+            export_to_text_item = history_menu.addAction(QtGui.QApplication.translate("MainWindow", 'Export as text', None, QtGui.QApplication.UnicodeUTF8))
+            export_to_html_item = history_menu.addAction(QtGui.QApplication.translate("MainWindow", 'Export as HTML', None, QtGui.QApplication.UnicodeUTF8))
+
             copy_menu = self.listMenu.addMenu(QtGui.QApplication.translate("MainWindow", 'Copy', None, QtGui.QApplication.UnicodeUTF8))
             copy_name_item = copy_menu.addAction(QtGui.QApplication.translate("MainWindow", 'Name', None, QtGui.QApplication.UnicodeUTF8))
             copy_status_item = copy_menu.addAction(QtGui.QApplication.translate("MainWindow", 'Status message', None, QtGui.QApplication.UnicodeUTF8))
@@ -527,20 +605,27 @@ class MainWindow(QtGui.QMainWindow):
 
             auto_accept_item = self.listMenu.addAction(auto)
             remove_item = self.listMenu.addAction(QtGui.QApplication.translate("MainWindow", 'Remove friend', None, QtGui.QApplication.UnicodeUTF8))
+            block_item = self.listMenu.addAction(QtGui.QApplication.translate("MainWindow", 'Block friend', None, QtGui.QApplication.UnicodeUTF8))
             notes_item = self.listMenu.addAction(QtGui.QApplication.translate("MainWindow", 'Notes', None, QtGui.QApplication.UnicodeUTF8))
 
-            submenu = plugin_support.PluginLoader.get_instance().get_menu(self.listMenu, num)
+            plugins_loader = plugin_support.PluginLoader.get_instance()
+            if plugins_loader is not None:
+                submenu = plugins_loader.get_menu(self.listMenu, num)
                 if len(submenu):
                     plug = self.listMenu.addMenu(QtGui.QApplication.translate("MainWindow", 'Plugins', None, QtGui.QApplication.UnicodeUTF8))
                     plug.addActions(submenu)
             self.connect(set_alias_item, QtCore.SIGNAL("triggered()"), lambda: self.set_alias(num))
             self.connect(remove_item, QtCore.SIGNAL("triggered()"), lambda: self.remove_friend(num))
+            self.connect(block_item, QtCore.SIGNAL("triggered()"), lambda: self.block_friend(num))
             self.connect(copy_key_item, QtCore.SIGNAL("triggered()"), lambda: self.copy_friend_key(num))
             self.connect(clear_history_item, QtCore.SIGNAL("triggered()"), lambda: self.clear_history(num))
             self.connect(auto_accept_item, QtCore.SIGNAL("triggered()"), lambda: self.auto_accept(num, not allowed))
             self.connect(notes_item, QtCore.SIGNAL("triggered()"), lambda: self.show_note(friend))
             self.connect(copy_name_item, QtCore.SIGNAL("triggered()"), lambda: self.copy_name(friend))
             self.connect(copy_status_item, QtCore.SIGNAL("triggered()"), lambda: self.copy_status(friend))
+            self.connect(export_to_text_item, QtCore.SIGNAL("triggered()"), lambda: self.export_history(num))
+            self.connect(export_to_html_item, QtCore.SIGNAL("triggered()"),
+                         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()
@@ -560,12 +645,30 @@ class MainWindow(QtGui.QMainWindow):
         self.note = MultilineEdit(user, note, save_note)
         self.note.show()
 
+    def export_history(self, num, as_text=True):
+        s = self.profile.export_history(num, as_text)
+        directory = QtGui.QFileDialog.getExistingDirectory(None,
+                                                           QtGui.QApplication.translate("MainWindow", 'Choose folder',
+                                                                                        None,
+                                                                                        QtGui.QApplication.UnicodeUTF8),
+                                                           curr_directory(),
+                                                           QtGui.QFileDialog.ShowDirsOnly | QtGui.QFileDialog.DontUseNativeDialog)
+
+        if directory:
+            name = 'exported_history_{}.{}'.format(convert_time(time.time()), 'txt' if as_text else 'html')
+            with open(directory + '/' + name, 'wt') as fl:
+                fl.write(s)
+
     def set_alias(self, num):
         self.profile.set_alias(num)
 
     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()
@@ -607,6 +710,22 @@ class MainWindow(QtGui.QMainWindow):
         else:
             super(MainWindow, self).mouseReleaseEvent(event)
 
-    def filtering(self):
+    def show(self):
-        self.profile.filtration(self.online_contacts.currentIndex() == 1, self.contact_name.text())
+        super().show()
+        self.profile.update()
 
+    def filtering(self):
+        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

@@ -2,7 +2,7 @@ try:
     from PySide import QtCore, QtGui
 except ImportError:
     from PyQt4 import QtCore, QtGui
-from widgets import RubberBand, create_menu, QRightClickButton, CenteredWidget
+from widgets import RubberBand, create_menu, QRightClickButton, CenteredWidget, LineEdit
 from profile import Profile
 import smileys
 import util
@@ -20,6 +20,11 @@ class MessageArea(QtGui.QPlainTextEdit):
 
     def keyPressEvent(self, event):
         if event.matches(QtGui.QKeySequence.Paste):
+            mimeData = QtGui.QApplication.clipboard().mimeData()
+            if mimeData.hasUrls():
+                for url in mimeData.urls():
+                    self.pasteEvent(url.toString())
+            else:
                 self.pasteEvent()
         elif event.key() in (QtCore.Qt.Key_Return, QtCore.Qt.Key_Enter):
             modifiers = event.modifiers()
@@ -51,9 +56,13 @@ class MessageArea(QtGui.QPlainTextEdit):
         e.accept()
 
     def dropEvent(self, e):
-        if e.mimeData().hasFormat('text/plain'):
+        if e.mimeData().hasFormat('text/plain') or e.mimeData().hasFormat('text/html'):
             e.accept()
             self.pasteEvent(e.mimeData().text())
+        elif e.mimeData().hasUrls():
+            for url in e.mimeData().urls():
+                self.pasteEvent(url.toString())
+            e.accept()
         else:
             e.ignore()
 
@@ -354,11 +363,7 @@ class WelcomeScreen(CenteredWidget):
             text = QtGui.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>',
                                                 None, QtGui.QApplication.UnicodeUTF8)
-        elif num == 6:
+        elif num in (6, 7):
-            text = QtGui.QApplication.translate('WelcomeScreen',
-                                                'New in Toxygen v0.2.3:<br>TCS compliance<br>Plugins, smileys and stickers import<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)
@@ -384,3 +389,141 @@ class WelcomeScreen(CenteredWidget):
         s['show_welcome_screen'] = False
         s.save()
 
+
+class MainMenuButton(QtGui.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(QtGui.QLabel):
+
+    def __init__(self, *args):
+        super().__init__(*args)
+
+    def mouseReleaseEvent(self, ev):
+        self.emit(QtCore.SIGNAL('clicked()'))
+
+
+class SearchScreen(QtGui.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.connect(self.search_button, QtCore.SIGNAL('clicked()'), self.search)
+
+        font = QtGui.QFont()
+        font.setPointSize(32)
+        font.setBold(True)
+
+        self.prev_button = QtGui.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 = QtGui.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 = QtGui.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(QtGui.QApplication.translate("MainWindow", "Search", None,
+                                                                         QtGui.QApplication.UnicodeUTF8))
+
+    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 = QtGui.QMessageBox()
+        mbox_text = QtGui.QApplication.translate("MainWindow",
+                                                 'Text "{}" was not found',
+                                                 None,
+                                                 QtGui.QApplication.UnicodeUTF8)
+
+        mbox.setText(mbox_text.format(text))
+        mbox.setWindowTitle(QtGui.QApplication.translate("MainWindow",
+                                                         'Not found',
+                                                         None,
+                                                         QtGui.QApplication.UnicodeUTF8))
+        mbox.exec_()

toxygen/menu.py

@@ -7,8 +7,9 @@ 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):
@@ -37,6 +38,7 @@ class AddContact(CenteredWidget):
         self.error_label = DataLabel(self)
         self.error_label.setGeometry(QtCore.QRect(120, 10, 420, 20))
         font = QtGui.QFont()
+        font.setFamily(Settings.get_instance()['font'])
         font.setPointSize(10)
         font.setWeight(30)
         self.error_label.setFont(font)
@@ -51,7 +53,6 @@ class AddContact(CenteredWidget):
         self.message.setObjectName("label_2")
         self.retranslateUi()
         self.message_edit.setText('Hello! Add me to your contact list please')
-        font = QtGui.QFont()
         font.setPointSize(12)
         font.setBold(True)
         self.label.setFont(font)
@@ -102,6 +103,7 @@ class ProfileSettings(CenteredWidget):
         self.label = QtGui.QLabel(self)
         self.label.setGeometry(QtCore.QRect(40, 30, 91, 25))
         font = QtGui.QFont()
+        font.setFamily(Settings.get_instance()['font'])
         font.setPointSize(18)
         font.setWeight(75)
         font.setBold(True)
@@ -213,7 +215,7 @@ class ProfileSettings(CenteredWidget):
     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:
@@ -266,13 +268,25 @@ 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 = QtGui.QFileDialog.getExistingDirectory(options=QtGui.QFileDialog.DontUseNativeDialog,
+                                                           dir=curr_directory()) + '/'
         if directory != '/':
-            ProfileHelper.get_instance().export_profile(directory)
+            reply = QtGui.QMessageBox.question(None,
+                                               QtGui.QApplication.translate("ProfileSettingsForm",
+                                                                            'Use new path',
+                                                                            None,
+                                                                            QtGui.QApplication.UnicodeUTF8),
+                                               QtGui.QApplication.translate("ProfileSettingsForm",
+                                                                            'Do you want to move your profile to this location?',
+                                                                            None,
+                                                                            QtGui.QApplication.UnicodeUTF8),
+                                               QtGui.QMessageBox.Yes,
+                                               QtGui.QMessageBox.No)
             settings = Settings.get_instance()
             settings.export(directory)
             profile = Profile.get_instance()
-            profile.export_history(directory)
+            profile.export_db(directory)
+            ProfileHelper.get_instance().export_profile(directory, reply == QtGui.QMessageBox.Yes)
 
     def closeEvent(self, event):
         profile = Profile.get_instance()
@@ -520,11 +534,12 @@ class NotificationsSettings(CenteredWidget):
         self.soundNotifications = QtGui.QCheckBox(self)
         self.soundNotifications.setGeometry(QtCore.QRect(10, 70, 340, 18))
         font = QtGui.QFont()
+        s = Settings.get_instance()
+        font.setFamily(s['font'])
         font.setPointSize(12)
         self.callsSound.setFont(font)
         self.soundNotifications.setFont(font)
         self.enableNotifications.setFont(font)
-        s = Settings.get_instance()
         self.enableNotifications.setChecked(s['notifications'])
         self.soundNotifications.setChecked(s['sound_notifications'])
         self.callsSound.setChecked(s['calls_sound'])
@@ -554,19 +569,20 @@ class InterfaceSettings(CenteredWidget):
 
     def initUI(self):
         self.setObjectName("interfaceForm")
-        self.setMinimumSize(QtCore.QSize(400, 580))
+        self.setMinimumSize(QtCore.QSize(400, 650))
-        self.setMaximumSize(QtCore.QSize(400, 580))
+        self.setMaximumSize(QtCore.QSize(400, 650))
         self.label = QtGui.QLabel(self)
         self.label.setGeometry(QtCore.QRect(30, 10, 370, 20))
+        settings = Settings.get_instance()
         font = QtGui.QFont()
         font.setPointSize(14)
         font.setBold(True)
+        font.setFamily(settings['font'])
         self.label.setFont(font)
         self.themeSelect = QtGui.QComboBox(self)
         self.themeSelect.setGeometry(QtCore.QRect(30, 40, 120, 30))
         list_of_themes = ['dark']
         self.themeSelect.addItems(list_of_themes)
-        settings = Settings.get_instance()
         theme = settings['theme']
         if theme in list_of_themes:
             index = list_of_themes.index(theme)
@@ -610,23 +626,31 @@ class InterfaceSettings(CenteredWidget):
         self.messages_font_size.setCurrentIndex(settings['message_font_size'] - 10)
 
         self.unread = QtGui.QPushButton(self)
-        self.unread.setGeometry(QtCore.QRect(30, 465, 340, 30))
+        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.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.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.setGeometry(QtCore.QRect(30, 410, 370, 20))
+        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.setGeometry(QtCore.QRect(30, 510, 340, 30))
+        self.choose_font.clicked.connect(self.new_font)
+
         self.import_smileys = QtGui.QPushButton(self)
-        self.import_smileys.setGeometry(QtCore.QRect(30, 505, 340, 30))
+        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.setGeometry(QtCore.QRect(30, 545, 340, 30))
+        self.import_stickers.setGeometry(QtCore.QRect(30, 590, 340, 30))
         self.import_stickers.clicked.connect(self.import_st)
 
         self.retranslateUi()
@@ -645,6 +669,8 @@ class InterfaceSettings(CenteredWidget):
         self.compact_mode.setText(QtGui.QApplication.translate("interfaceForm", "Compact contact list", None, QtGui.QApplication.UnicodeUTF8))
         self.import_smileys.setText(QtGui.QApplication.translate("interfaceForm", "Import smiley pack", None, QtGui.QApplication.UnicodeUTF8))
         self.import_stickers.setText(QtGui.QApplication.translate("interfaceForm", "Import sticker pack", None, QtGui.QApplication.UnicodeUTF8))
+        self.close_to_tray.setText(QtGui.QApplication.translate("interfaceForm", "Close to tray", None, QtGui.QApplication.UnicodeUTF8))
+        self.choose_font.setText(QtGui.QApplication.translate("interfaceForm", "Select font", None, QtGui.QApplication.UnicodeUTF8))
 
     def import_st(self):
         directory = QtGui.QFileDialog.getExistingDirectory(self,
@@ -674,11 +700,25 @@ class InterfaceSettings(CenteredWidget):
             dest = curr_directory() + '/smileys/' + os.path.basename(directory) + '/'
             copy(src, dest)
 
+    def new_font(self):
+        settings = Settings.get_instance()
+        font, ok = QtGui.QFontDialog.getFont(QtGui.QFont(settings['font'], 10), self)
+        if ok:
+            settings['font'] = font.family()
+            settings.save()
+            msgBox = QtGui.QMessageBox()
+            text = QtGui.QApplication.translate("interfaceForm", 'Restart app to apply settings', None,
+                                                QtGui.QApplication.UnicodeUTF8)
+            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 = QtGui.QColorDialog.getColor(settings['unread_color'])
 
         if col.isValid():
-            settings = Settings.get_instance()
             name = col.name()
             settings['unread_color'] = name
             settings.save()
@@ -698,6 +738,7 @@ class InterfaceSettings(CenteredWidget):
             settings['show_avatars'] = self.show_avatars.isChecked()
             restart = True
         settings['smiley_pack'] = self.smiley_pack.currentText()
+        settings['close_to_tray'] = self.close_to_tray.isChecked()
         smileys.SmileyLoader.get_instance().load_pack()
         language = self.lang_choose.currentText()
         if settings['language'] != language:
@@ -741,9 +782,11 @@ class AudioSettings(CenteredWidget):
         self.in_label.setGeometry(QtCore.QRect(25, 5, 350, 20))
         self.out_label = QtGui.QLabel(self)
         self.out_label.setGeometry(QtCore.QRect(25, 65, 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.out_label.setFont(font)
         self.input = QtGui.QComboBox(self)
@@ -751,7 +794,6 @@ class AudioSettings(CenteredWidget):
         self.output = QtGui.QComboBox(self)
         self.output.setGeometry(QtCore.QRect(25, 90, 350, 30))
         p = pyaudio.PyAudio()
-        settings = Settings.get_instance()
         self.in_indexes, self.out_indexes = [], []
         for i in range(p.get_device_count()):
             device = p.get_device_info_by_index(i)
@@ -858,3 +900,85 @@ class PluginsSettings(CenteredWidget):
             self.button.setText(QtGui.QApplication.translate("PluginsForm", "Disable plugin", None, QtGui.QApplication.UnicodeUTF8))
         else:
             self.button.setText(QtGui.QApplication.translate("PluginsForm", "Enable plugin", None, QtGui.QApplication.UnicodeUTF8))
+
+
+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 = QtGui.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 = QtGui.QComboBox(self)
+        self.autoupdate.setGeometry(QtCore.QRect(25, 30, 350, 30))
+        self.button = QtGui.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(QtGui.QApplication.translate("updateSettingsForm", "Update settings", None, QtGui.QApplication.UnicodeUTF8))
+        self.in_label.setText(QtGui.QApplication.translate("updateSettingsForm", "Select update mode:", None, QtGui.QApplication.UnicodeUTF8))
+        self.button.setText(QtGui.QApplication.translate("updateSettingsForm", "Update Toxygen", None, QtGui.QApplication.UnicodeUTF8))
+        self.autoupdate.addItem(QtGui.QApplication.translate("updateSettingsForm", "Disabled", None, QtGui.QApplication.UnicodeUTF8))
+        self.autoupdate.addItem(QtGui.QApplication.translate("updateSettingsForm", "Manual", None, QtGui.QApplication.UnicodeUTF8))
+        self.autoupdate.addItem(QtGui.QApplication.translate("updateSettingsForm", "Auto", None, QtGui.QApplication.UnicodeUTF8))
+
+    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 = QtGui.QMessageBox()
+            msgBox.setWindowTitle(
+                QtGui.QApplication.translate("updateSettingsForm", "Error", None,
+                                             QtGui.QApplication.UnicodeUTF8))
+            text = (QtGui.QApplication.translate("updateSettingsForm", 'Problems with internet connection', None,
+                                                 QtGui.QApplication.UnicodeUTF8))
+            msgBox.setText(text)
+            msgBox.exec_()
+            return
+        if not updater.updater_available():
+            msgBox = QtGui.QMessageBox()
+            msgBox.setWindowTitle(
+                QtGui.QApplication.translate("updateSettingsForm", "Error", None,
+                                             QtGui.QApplication.UnicodeUTF8))
+            text = (QtGui.QApplication.translate("updateSettingsForm", 'Updater not found', None,
+                                                 QtGui.QApplication.UnicodeUTF8))
+            msgBox.setText(text)
+            msgBox.exec_()
+            return
+        version = updater.check_for_updates()
+        if version is not None:
+            updater.download(version)
+            QtGui.QApplication.closeAllWindows()
+        else:
+            msgBox = QtGui.QMessageBox()
+            msgBox.setWindowTitle(
+                QtGui.QApplication.translate("updateSettingsForm", "No updates found", None, QtGui.QApplication.UnicodeUTF8))
+            text = (QtGui.QApplication.translate("updateSettingsForm", 'Toxygen is up to date', None,
+                                                 QtGui.QApplication.UnicodeUTF8))
+            msgBox.setText(text)
+            msgBox.exec_()

toxygen/notifications.py

@@ -45,8 +45,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/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):
         """
@@ -147,6 +148,16 @@ class PluginLoader(util.Singleton):
                     continue
         return result
 
+    def get_message_menu(self, menu, selected_text):
+        result = []
+        for elem in self._plugins.values():
+            if elem[1]:
+                try:
+                    result.extend(elem[0].get_message_menu(menu, selected_text))
+                except:
+                    continue
+        return result
+
     def stop(self):
         """
         App is closing, stop all plugins
@@ -155,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

@@ -26,12 +26,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 +43,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
@@ -88,6 +88,15 @@ class PluginSuperClass:
         """
         return []
 
+    def get_message_menu(self, menu, text):
+        """
+        This method creates items for menu which called on right click in message
+        :param menu: menu instance
+        :param text: selected text
+        :return list of QAction's
+        """
+        return []
+
     def get_window(self):
         """
         This method should return window for plugins with GUI or None
@@ -120,7 +129,7 @@ class PluginSuperClass:
         """
         App is closing
         """
-        pass
+        self.stop()
 
     def command(self, command):
         """
@@ -160,6 +169,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

@@ -15,9 +15,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,7 +28,7 @@ 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_status_message(),
                                          screen.user_info,
@@ -39,15 +41,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
-        screen.online_contacts.setCurrentIndex(int(self._show_online))
+        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._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:
@@ -62,8 +69,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
@@ -80,6 +87,9 @@ class Profile(contact.Contact, Singleton):
         super(Profile, self).set_status(status)
         if status is not None:
             self._tox.self_set_status(status)
+        elif not self._waiting_for_reconnection:
+            self._waiting_for_reconnection = True
+            QtCore.QTimer.singleShot(50000, self.reconnect)
 
     def set_name(self, value):
         if self.name == value:
@@ -90,7 +100,7 @@ class Profile(contact.Contact, Singleton):
         message = QtGui.QApplication.translate("MainWindow", 'User {} is now known as {}', None,
                                                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'])
@@ -111,37 +121,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
@@ -169,15 +214,19 @@ class Profile(contact.Contact, Singleton):
             self.send_typing(False)
             self._screen.typing.setVisible(False)
             if value is not None:
-                if self._active_friend + 1:
+                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
-                self._active_friend = value
+                friend = self._contacts[value]
-                friend = self._friends[value]
+                friend.remove_invalid_unsent_files()
-                self._friends[value].reset_messages()
+                if self._active_friend != value:
                     self._screen.messageEdit.setPlainText(friend.curr_text)
+                self._active_friend = value
+                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:]
@@ -218,7 +267,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)
@@ -226,30 +275,36 @@ class Profile(contact.Contact, Singleton):
             if not os.path.isfile(avatar_path):  # load default image
                 avatar_path = curr_directory() + '/images/avatar.png'
             os.chdir(os.path.dirname(avatar_path))
-            pixmap = QtGui.QPixmap(QtCore.QSize(64, 64))
+            pixmap = QtGui.QPixmap(avatar_path)
-            pixmap.load(avatar_path)
+            self._screen.account_avatar.setPixmap(pixmap.scaled(64, 64, QtCore.Qt.KeepAspectRatio,
-            self._screen.account_avatar.setScaledContents(False)
+                                                                QtCore.Qt.SmoothTransformation))
-            self._screen.account_avatar.setPixmap(pixmap.scaled(64, 64, QtCore.Qt.KeepAspectRatio))
-            self._screen.account_avatar.repaint()  # comment?
-            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)
@@ -276,6 +331,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:
@@ -285,6 +341,13 @@ class Profile(contact.Contact, Singleton):
                 else:
                     self.send_file(data[0], friend_number, True)
             friend.clear_unsent_files()
+            for key in list(self._paused_file_transfers.keys()):
+                data = self._paused_file_transfers[key]
+                if not os.path.exists(data[0]):
+                    del self._paused_file_transfers[key]
+                elif data[1] == friend_number and not data[2]:
+                    self.send_file(data[0], friend_number, True, key)
+                    del self._paused_file_transfers[key]
             if friend_number == self.get_active_number():
                 self.update()
         except Exception as ex:
@@ -294,11 +357,18 @@ class Profile(contact.Contact, Singleton):
         """
         Friend with specified number quit
         """
-        # TODO: fix and add full file resuming support
         self.get_friend_by_number(friend_number).status = None
         self.friend_typing(friend_number, False)
         if friend_number in self._call:
             self._call.finish_call(friend_number, True)
+        for friend_num, file_num in list(self._file_transfers.keys()):
+            if friend_num == friend_number:
+                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 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)
 
     # -----------------------------------------------------------------------------------------------------------------
     # Typing notifications
@@ -309,9 +379,12 @@ class Profile(contact.Contact, Singleton):
         Send typing notification to a friend
         """
         if Settings.get_instance()['typing_notifications'] and self._active_friend + 1:
-            friend = self._friends[self._active_friend]
+            try:
+                friend = self.get_curr_friend()
                 if friend.status is not None:
                     self._tox.self_set_typing(friend.number, typing)
+            except:
+                pass
 
     def friend_typing(self, friend_number, typing):
         """
@@ -340,25 +413,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
@@ -377,7 +450,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)
@@ -416,7 +489,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()
@@ -432,7 +505,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']:
@@ -452,13 +525,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()
@@ -470,7 +543,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:
@@ -485,7 +558,7 @@ class Profile(contact.Contact, Singleton):
                                          data[1],
                                          data[3],
                                          False)
-            elif message.get_type() == MESSAGE_TYPE['FILE_TRANSFER']:
+            elif message.get_type() == MESSAGE_TYPE['FILE_TRANSFER']:  # file transfer
                 if message.get_status() is None:
                     self.create_unsent_file_item(message)
                     continue
@@ -497,21 +570,48 @@ class Profile(contact.Contact, Singleton):
                         ft.signal()
                     except:
                         print('Incoming not started transfer - no info found')
-            elif message.get_type() == MESSAGE_TYPE['INLINE']:  # inline
+            elif message.get_type() == MESSAGE_TYPE['INLINE']:  # inline image
-                self.create_inline_item(message.get_data())
+                self.create_inline_item(message.get_data(), False)
             else:  # info message
                 data = message.get_data()
                 self.create_message_item(data[0],
                                          data[2],
                                          '',
-                                         data[3])
+                                         data[3],
+                                         False)
         self._load_history = True
 
-    def export_history(self, directory):
+    def export_db(self, directory):
         self._history.export(directory)
 
+    def export_history(self, num, as_text=True, _range=None):
+        friend = self._contacts[num]
+        if _range is None:
+            friend.load_all_corr()
+            corr = friend.get_corr()
+        elif _range[1] + 1:
+            corr = friend.get_corr()[_range[0]:_range[1] + 1]
+        else:
+            corr = friend.get_corr()[_range[0]:]
+        arr = []
+        new_line = '\n' if as_text else '<br>'
+        for message in corr:
+            if type(message) is TextMessage:
+                data = message.get_data()
+                if as_text:
+                    x = '[{}] {}: {}\n'
+                else:
+                    x = '[{}] <b>{}:</b> {}<br>'
+                arr.append(x.format(convert_time(data[2]) if data[1] != MESSAGE_OWNER['NOT_SENT'] else 'Unsent',
+                                    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):
@@ -519,12 +619,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']:
@@ -533,56 +628,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()
-        elem.setSizeHint(QtCore.QSize(self._messages.width(), item.height()))
-        if append:
-            self._messages.addItem(elem)
             else:
-            self._messages.insertItem(0, elem)
+                pixmap = self.get_pixmap()
-        self._messages.setItemWidget(elem, item)
+        return self._factory.message_item(text, time, name, owner != MESSAGE_OWNER['NOT_SENT'],
+                                          message_type, append, pixmap)
 
     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]),
                                               self.name,
                                               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)
@@ -592,7 +661,7 @@ 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',
                                               "Enter new alias for friend {} or leave empty to use friend's name:",
@@ -630,14 +699,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)
@@ -651,10 +720,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)
@@ -675,7 +744,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):
         """
@@ -742,7 +811,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
@@ -777,24 +846,36 @@ class Profile(contact.Contact, Singleton):
         Recreate tox instance
         :param restart: method which calls restart and returns new tox instance
         """
-        # TODO: file transfers!!
+        for friend in self._contacts:
-        for key in list(self._file_transfers.keys()):
+            self.friend_exit(friend.number)
-            self._file_transfers[key].cancelled()
-            del self._file_transfers[key]
         self._call.stop()
+        del self._call
         del self._tox
         self._tox = restart()
+        self._call = calls.AV(self._tox.AV)
         self.status = None
-        for friend in self._friends:
+        for friend in self._contacts:
-            friend.status = None
+            friend.number = self._tox.friend_by_public_key(friend.tox_id)  # numbers update
         self.update_filtration()
 
+    def reconnect(self):
+        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(50000, self.reconnect)
+
     def close(self):
+        for friend in self._contacts:
+            self.friend_exit(friend.number)
+        for i in range(len(self._contacts)):
+            del self._contacts[0]
         if hasattr(self, '_call'):
             self._call.stop()
             del self._call
-        for i in range(len(self._friends)):
+        s = Settings.get_instance()
-            del self._friends[0]
+        s['paused_file_transfers'] = dict(self._paused_file_transfers) if s['resend_files'] else {}
+        s.save()
 
     # -----------------------------------------------------------------------------------------------------------------
     # File transfers support
@@ -811,8 +892,25 @@ 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']
-        if inline and size < 1024 * 1024:
+        file_id = self._tox.file_get_file_id(friend_number, file_number)
+        accepted = True
+        if file_id in self._paused_file_transfers:
+            data = self._paused_file_transfers[file_id]
+            pos = data[-1] if os.path.exists(data[0]) else 0
+            if pos >= size:
+                self._tox.file_control(friend_number, file_number, TOX_FILE_CONTROL['CANCEL'])
+                return
+            self._tox.file_seek(friend_number, file_number, pos)
+            self.accept_transfer(None, data[0], friend_number, file_number, size, False, pos)
+            tm = TransferMessage(MESSAGE_OWNER['FRIEND'],
+                                 time.time(),
+                                 TOX_FILE_TRANSFER_STATE['RUNNING'],
+                                 size,
+                                 file_name,
+                                 friend_number,
+                                 file_number)
+        elif inline and size < 1024 * 1024:
             self.accept_transfer(None, '', friend_number, file_number, size, True)
             tm = TransferMessage(MESSAGE_OWNER['FRIEND'],
                                  time.time(),
@@ -840,9 +938,10 @@ class Profile(contact.Contact, Singleton):
                                  file_name,
                                  friend_number,
                                  file_number)
+            accepted = False
         if friend_number == self.get_active_number():
             item = self.create_file_transfer_item(tm)
-            if (inline and size < 1024 * 1024) or auto:
+            if accepted:
                 self._file_transfers[(friend_number, file_number)].set_state_changed_handler(item.update)
             self._messages.scrollToBottom()
         else:
@@ -878,7 +977,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):
@@ -896,18 +995,14 @@ class Profile(contact.Contact, Singleton):
         """
         self.get_friend_by_number(friend_number).update_transfer_data(file_number,
                                                                       TOX_FILE_TRANSFER_STATE['RUNNING'])
-        # if (friend_number, file_number) not in self._file_transfers:
-        #     print self._file_transfers
-        #     print (friend_number, file_number)
-        #     return
         tr = self._file_transfers[(friend_number, file_number)]
         if by_friend:
             tr.state = TOX_FILE_TRANSFER_STATE['RUNNING']
             tr.signal()
-        else:  # send seek control?
+        else:
             tr.send_control(TOX_FILE_CONTROL['RESUME'])
 
-    def accept_transfer(self, item, path, friend_number, file_number, size, inline=False):
+    def accept_transfer(self, item, path, friend_number, file_number, size, inline=False, from_position=0):
         """
         :param item: transfer item.
         :param path: path for saving
@@ -915,9 +1010,11 @@ class Profile(contact.Contact, Singleton):
         :param file_number: file number
         :param size: file size
         :param inline: is inline image
+        :param from_position: position for start
         """
         path, file_name = os.path.split(path)
         new_file_name, i = file_name, 1
+        if not from_position:
             while os.path.isfile(path + '/' + new_file_name):  # file with same name already exists
                 if '.' in file_name:  # has extension
                     d = file_name.rindex('.')
@@ -927,9 +1024,10 @@ class Profile(contact.Contact, Singleton):
                 i += 1
         path = os.path.join(path, new_file_name)
         if not inline:
-            rt = ReceiveTransfer(path, self._tox, friend_number, size, file_number)
+            rt = ReceiveTransfer(path, self._tox, friend_number, size, file_number, from_position)
         else:
             rt = ReceiveToBuffer(self._tox, friend_number, size, file_number)
+        rt.set_transfer_finished_handler(self.transfer_finished)
         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:
@@ -961,6 +1059,7 @@ class Profile(contact.Contact, Singleton):
         elif friend.status is None and is_resend:
             raise RuntimeError()
         st = SendFromBuffer(self._tox, friend.number, data, file_name)
+        st.set_transfer_finished_handler(self.transfer_finished)
         self._file_transfers[(friend.number, st.get_file_number())] = st
         tm = TransferMessage(MESSAGE_OWNER['ME'],
                              time.time(),
@@ -974,14 +1073,15 @@ class Profile(contact.Contact, Singleton):
         st.set_state_changed_handler(item.update)
         self._messages.scrollToBottom()
 
-    def send_file(self, path, number=None, is_resend=False):
+    def send_file(self, path, number=None, is_resend=False, file_id=None):
         """
         Send file to current active friend
         :param path: file path
         :param number: friend_number
         :param is_resend: is 'offline' message
+        :param file_id: file id of transfer
         """
-        friend_number = number or self.get_active_number()
+        friend_number = self.get_active_number() if number is None else number
         friend = self.get_friend_by_number(friend_number)
         if friend.status is None and not is_resend:
             m = UnsentFile(path, None, time.time())
@@ -991,7 +1091,8 @@ class Profile(contact.Contact, Singleton):
         elif friend.status is None and is_resend:
             print('Error in sending')
             raise RuntimeError()
-        st = SendTransfer(path, self._tox, friend_number)
+        st = SendTransfer(path, self._tox, friend_number, TOX_FILE_KIND['DATA'], file_id)
+        st.set_transfer_finished_handler(self.transfer_finished)
         self._file_transfers[(friend_number, st.get_file_number())] = st
         tm = TransferMessage(MESSAGE_OWNER['ME'],
                              time.time(),
@@ -1000,23 +1101,33 @@ class Profile(contact.Contact, Singleton):
                              os.path.basename(path),
                              friend_number,
                              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)
-        self._friends[self._active_friend].append_message(tm)
             self._messages.scrollToBottom()
+        self._contacts[friend_number].append_message(tm)
 
     def incoming_chunk(self, friend_number, file_number, position, data):
         """
         Incoming chunk
         """
-        if (friend_number, file_number) in self._file_transfers:
+        self._file_transfers[(friend_number, file_number)].write_chunk(position, data)
+
+    def outgoing_chunk(self, friend_number, file_number, position, size):
+        """
+        Outgoing chunk
+        """
+        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)]
-            transfer.write_chunk(position, data)
+        t = type(transfer)
-            if transfer.state not in ACTIVE_FILE_TRANSFERS:  # finished or cancelled
+        if t is ReceiveAvatar:
-                if type(transfer) is ReceiveAvatar:
             self.get_friend_by_number(friend_number).load_avatar()
+            if friend_number == self.get_active_number():
                 self.set_active(None)
-                elif type(transfer) is ReceiveToBuffer:  # inline image
+        elif t is ReceiveToBuffer or (t is SendFromBuffer and Settings.get_instance()['allow_inline']):  # inline image
             print('inline')
             inline = InlineImage(transfer.get_data())
             i = self.get_friend_by_number(friend_number).update_transfer_data(file_number,
@@ -1030,39 +1141,12 @@ class Profile(contact.Contact, Singleton):
                     elem.setSizeHint(QtCore.QSize(self._messages.width(), item.height()))
                     self._messages.insertItem(count + i + 1, elem)
                     self._messages.setItemWidget(elem, item)
-                else:
+                    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'])
         del self._file_transfers[(friend_number, file_number)]
-
+        del transfer
-    def outgoing_chunk(self, friend_number, file_number, position, size):
-        """
-        Outgoing chunk
-        """
-        if (friend_number, file_number) in self._file_transfers:
-            transfer = self._file_transfers[(friend_number, file_number)]
-            transfer.send_chunk(position, size)
-            if transfer.state not in ACTIVE_FILE_TRANSFERS:  # finished or cancelled
-                del self._file_transfers[(friend_number, file_number)]
-                if type(transfer) is not SendAvatar:
-                    if type(transfer) is SendFromBuffer and Settings.get_instance()['allow_inline']:  # inline
-                        inline = InlineImage(transfer.get_data())
-                        print('inline')
-                        i = self.get_friend_by_number(friend_number).update_transfer_data(file_number,
-                                                                                          TOX_FILE_TRANSFER_STATE[
-                                                                                              'FINISHED'],
-                                                                                          inline)
-                        if friend_number == self.get_active_number():
-                            count = self._messages.count()
-                            if count + i + 1 >= 0:
-                                elem = QtGui.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)
-                    else:
-                        self.get_friend_by_number(friend_number).update_transfer_data(file_number,
-                                                                                      TOX_FILE_TRANSFER_STATE['FINISHED'])
 
     # -----------------------------------------------------------------------------------------------------------------
     # Avatars support
@@ -1088,6 +1172,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:
@@ -1095,12 +1180,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)
 
     # -----------------------------------------------------------------------------------------------------------------
@@ -1116,6 +1201,8 @@ class Profile(contact.Contact, Singleton):
         """User clicked audio button in main window"""
         num = self.get_active_number()
         if num not in self._call and self.is_active_online():  # start call
+            if not Settings.get_instance().audio['enabled']:
+                return
             self._call(num, audio, video)
             self._screen.active_call()
             if video:
@@ -1124,7 +1211,7 @@ class Profile(contact.Contact, Singleton):
             else:
                 text = QtGui.QApplication.translate("incoming_call", "Outgoing audio call", None,
                                                     QtGui.QApplication.UnicodeUTF8)
-            self._friends[self._active_friend].append_message(InfoMessage(text, time.time()))
+            self.get_curr_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
@@ -1134,6 +1221,8 @@ class Profile(contact.Contact, Singleton):
         """
         Incoming call from friend. Only audio is supported now
         """
+        if not Settings.get_instance().audio['enabled']:
+            return
         friend = self.get_friend_by_number(friend_number)
         if video:
             text = QtGui.QApplication.translate("incoming_call", "Incoming video call", None,
@@ -1149,6 +1238,7 @@ class Profile(contact.Contact, Singleton):
             self._messages.scrollToBottom()
         else:
             friend.actions = True
+        # TODO: dict of widgets
         self._call_widget = avwidgets.IncomingCallWidget(friend_number, text, friend.name)
         self._call_widget.set_pixmap(friend.get_pixmap())
         self._call_widget.show()
@@ -1159,6 +1249,7 @@ class Profile(contact.Contact, Singleton):
         """
         self._call.accept_call(friend_number, audio, video)
         self._screen.active_call()
+        if friend_number in self._incoming_calls:
             self._incoming_calls.remove(friend_number)
         if hasattr(self, '_call_widget'):
             del self._call_widget
@@ -1175,6 +1266,7 @@ class Profile(contact.Contact, Singleton):
         self._screen.call_finished()
         self._call.finish_call(friend_number, by_friend)  # finish or decline call
         if hasattr(self, '_call_widget'):
+            self._call_widget.close()
             del self._call_widget
         friend = self.get_friend_by_number(friend_number)
         friend.append_message(InfoMessage(text, time.time()))

toxygen/settings.py

@@ -1,10 +1,9 @@
 from platform import system
 import json
 import os
-import locale
+from util import Singleton, curr_directory, log, copy, append_slash
-from util import Singleton, curr_directory, log
 import pyaudio
-from toxencryptsave import ToxEncryptSave
+from toxes import ToxES
 import smileys
 
 
@@ -20,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)
@@ -34,16 +33,26 @@ class Settings(dict, Singleton):
             super(Settings, self).__init__(Settings.get_default_settings())
             self.save()
         smileys.SmileyLoader(self)
-        p = pyaudio.PyAudio()
         self.locked = False
-        self.audio = {'input': p.get_default_input_device_info()['index'],
+        self.closing = False
-                      'output': p.get_default_output_device_info()['index']}
+        self.unlockScreen = False
+        p = pyaudio.PyAudio()
+        input_devices = output_devices = 0
+        for i in range(p.get_device_count()):
+            device = p.get_device_info_by_index(i)
+            if device["maxInputChannels"]:
+                input_devices += 1
+            if device["maxOutputChannels"]:
+                output_devices += 1
+        self.audio = {'input': p.get_default_input_device_info()['index'] if input_devices else -1,
+                      'output': p.get_default_output_device_info()['index'] if output_devices else -1,
+                      'enabled': input_devices and output_devices}
 
     @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:
@@ -52,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()
+        if os.path.isfile(p):
             with open(p) as fl:
                 data = fl.read()
             data = json.loads(data)
+        else:
+            data = {}
         data['path'] = str(path)
         data['name'] = str(name)
         with open(p, 'w') as fl:
@@ -63,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()
+        if os.path.isfile(p):
             with open(p) as fl:
                 data = fl.read()
             data = json.loads(data)
+        else:
+            data = {}
         if 'path' in data:
             del data['path']
             del data['name']
@@ -75,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():
@@ -107,8 +115,10 @@ 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,
             'friends_aliases': [],
             'show_avatars': False,
             'typing_notifications': False,
@@ -127,7 +137,10 @@ class Settings(dict, Singleton):
             'unread_color': 'red',
             'save_unsent_only': False,
             'compact_mode': False,
-            'show_welcome_screen': True
+            'show_welcome_screen': True,
+            'close_to_tray': False,
+            'font': 'Times New Roman',
+            'update': 1
         }
 
     @staticmethod
@@ -148,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:
@@ -157,49 +170,40 @@ 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)
         with open(path + str(self.name) + '.json', 'w') as fl:
             fl.write(text)
 
+    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() == 'Linux':
+        if system() == 'Windows':
-            return os.getenv('HOME') + '/.config/tox/'
-        elif system() == 'Windows':
             return os.getenv('APPDATA') + '/Tox/'
+        elif system() == 'Darwin':
+            return os.getenv('HOME') + '/Library/Application Support/Tox/'
+        else:
+            return os.getenv('HOME') + '/.config/tox/'
 
 
 class ProfileHelper(Singleton):
@@ -208,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:
@@ -227,20 +232,25 @@ 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:
             fl.write(data)
         print('Profile saved successfully')
 
-    def export_profile(self, new_path):
+    def export_profile(self, new_path, use_new_path):
-        new_path += os.path.basename(self._path)
+        path = new_path + os.path.basename(self._path)
         with open(self._path, 'rb') as fin:
             data = fin.read()
-        with open(new_path, 'wb') as fout:
+        with open(path, 'wb') as fout:
             fout.write(data)
         print('Profile exported successfully')
+        copy(self._directory + 'avatars', new_path + 'avatars')
+        if use_new_path:
+            self._path = new_path + os.path.basename(self._path)
+            self._directory = new_path
+            Settings.get_instance().update_path()
 
     @staticmethod
     def find_profiles():

toxygen/smileys.py

@@ -48,7 +48,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.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;
@@ -1245,10 +1239,20 @@ QPushButton:hover
 }
 
 #messages:item:selected
+{
+    background-color: #1E90FF;
+}
+
+MessageEdit 
 {
     background-color: transparent;
 }
 
+#messages:item:selected QListWidgetItem
+{
+    background-color: #1E90FF;
+}
+
 #friends_list:item:selected
 {
     background-color: #333333;
@@ -1277,3 +1281,44 @@ QListWidget > QLabel
 {
     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/toxav.py

@@ -12,8 +12,6 @@ class ToxAV:
     peers.
     """
 
-    libtoxav = LibToxAV()
-
     # -----------------------------------------------------------------------------------------------------------------
     # Creation and destruction
     # -----------------------------------------------------------------------------------------------------------------
@@ -24,9 +22,10 @@ class ToxAV:
 
         :param tox_pointer: pointer to Tox instance
         """
+        self.libtoxav = LibToxAV()
         toxav_err_new = c_int()
-        ToxAV.libtoxav.toxav_new.restype = POINTER(c_void_p)
+        self.libtoxav.toxav_new.restype = POINTER(c_void_p)
-        self._toxav_pointer = ToxAV.libtoxav.toxav_new(tox_pointer, byref(toxav_err_new))
+        self._toxav_pointer = self.libtoxav.toxav_new(tox_pointer, byref(toxav_err_new))
         toxav_err_new = toxav_err_new.value
         if toxav_err_new == TOXAV_ERR_NEW['NULL']:
             raise ArgumentError('One of the arguments to the function was NULL when it was not expected.')
@@ -48,7 +47,7 @@ class ToxAV:
         If any calls were ongoing, these will be forcibly terminated without notifying peers. After calling this
         function, no other functions may be called and the av pointer becomes invalid.
         """
-        ToxAV.libtoxav.toxav_kill(self._toxav_pointer)
+        self.libtoxav.toxav_kill(self._toxav_pointer)
 
     def get_tox_pointer(self):
         """
@@ -56,8 +55,8 @@ class ToxAV:
 
         :return: pointer to the Tox instance
         """
-        ToxAV.libtoxav.toxav_get_tox.restype = POINTER(c_void_p)
+        self.libtoxav.toxav_get_tox.restype = POINTER(c_void_p)
-        return ToxAV.libtoxav.toxav_get_tox(self._toxav_pointer)
+        return self.libtoxav.toxav_get_tox(self._toxav_pointer)
 
     # -----------------------------------------------------------------------------------------------------------------
     # A/V event loop
@@ -70,14 +69,14 @@ class ToxAV:
 
         :return: interval in milliseconds
         """
-        return ToxAV.libtoxav.toxav_iteration_interval(self._toxav_pointer)
+        return self.libtoxav.toxav_iteration_interval(self._toxav_pointer)
 
     def iterate(self):
         """
         Main loop for the session. This function needs to be called in intervals of toxav_iteration_interval()
         milliseconds. It is best called in the separate thread from tox_iterate.
         """
-        ToxAV.libtoxav.toxav_iterate(self._toxav_pointer)
+        self.libtoxav.toxav_iterate(self._toxav_pointer)
 
     # -----------------------------------------------------------------------------------------------------------------
     # Call setup
@@ -97,7 +96,7 @@ class ToxAV:
         :return: True on success.
         """
         toxav_err_call = c_int()
-        result = ToxAV.libtoxav.toxav_call(self._toxav_pointer, c_uint32(friend_number), c_uint32(audio_bit_rate),
+        result = self.libtoxav.toxav_call(self._toxav_pointer, c_uint32(friend_number), c_uint32(audio_bit_rate),
                                            c_uint32(video_bit_rate), byref(toxav_err_call))
         toxav_err_call = toxav_err_call.value
         if toxav_err_call == TOXAV_ERR_CALL['OK']:
@@ -131,7 +130,7 @@ class ToxAV:
         """
         c_callback = CFUNCTYPE(None, c_void_p, c_uint32, c_bool, c_bool, c_void_p)
         self.call_cb = c_callback(callback)
-        ToxAV.libtoxav.toxav_callback_call(self._toxav_pointer, self.call_cb, user_data)
+        self.libtoxav.toxav_callback_call(self._toxav_pointer, self.call_cb, user_data)
 
     def answer(self, friend_number, audio_bit_rate, video_bit_rate):
         """
@@ -146,7 +145,7 @@ class ToxAV:
         :return: True on success.
         """
         toxav_err_answer = c_int()
-        result = ToxAV.libtoxav.toxav_answer(self._toxav_pointer, c_uint32(friend_number), c_uint32(audio_bit_rate),
+        result = self.libtoxav.toxav_answer(self._toxav_pointer, c_uint32(friend_number), c_uint32(audio_bit_rate),
                                              c_uint32(video_bit_rate), byref(toxav_err_answer))
         toxav_err_answer = toxav_err_answer.value
         if toxav_err_answer == TOXAV_ERR_ANSWER['OK']:
@@ -184,7 +183,7 @@ class ToxAV:
         """
         c_callback = CFUNCTYPE(None, c_void_p, c_uint32, c_uint32, c_void_p)
         self.call_state_cb = c_callback(callback)
-        ToxAV.libtoxav.toxav_callback_call_state(self._toxav_pointer, self.call_state_cb, user_data)
+        self.libtoxav.toxav_callback_call_state(self._toxav_pointer, self.call_state_cb, user_data)
 
     # -----------------------------------------------------------------------------------------------------------------
     # Call control
@@ -199,7 +198,7 @@ class ToxAV:
         :return: True on success.
         """
         toxav_err_call_control = c_int()
-        result = ToxAV.libtoxav.toxav_call_control(self._toxav_pointer, c_uint32(friend_number), c_int(control),
+        result = self.libtoxav.toxav_call_control(self._toxav_pointer, c_uint32(friend_number), c_int(control),
                                                    byref(toxav_err_call_control))
         toxav_err_call_control = toxav_err_call_control.value
         if toxav_err_call_control == TOXAV_ERR_CALL_CONTROL['OK']:
@@ -241,7 +240,7 @@ class ToxAV:
         24000, or 48000.
         """
         toxav_err_send_frame = c_int()
-        result = ToxAV.libtoxav.toxav_audio_send_frame(self._toxav_pointer, c_uint32(friend_number),
+        result = self.libtoxav.toxav_audio_send_frame(self._toxav_pointer, c_uint32(friend_number),
                                                        cast(pcm, c_void_p),
                                                        c_size_t(sample_count), c_uint8(channels),
                                                        c_uint32(sampling_rate), byref(toxav_err_send_frame))
@@ -281,7 +280,7 @@ class ToxAV:
         :param v: V (Chroma) plane data.
         """
         toxav_err_send_frame = c_int()
-        result = ToxAV.libtoxav.toxav_video_send_frame(self._toxav_pointer, c_uint32(friend_number), c_uint16(width),
+        result = self.libtoxav.toxav_video_send_frame(self._toxav_pointer, c_uint32(friend_number), c_uint16(width),
                                                        c_uint16(height), c_char_p(y), c_char_p(u), c_char_p(v),
                                                        byref(toxav_err_send_frame))
         toxav_err_send_frame = toxav_err_send_frame.value
@@ -328,7 +327,7 @@ class ToxAV:
         """
         c_callback = CFUNCTYPE(None, c_void_p, c_uint32, POINTER(c_uint8), c_size_t, c_uint8, c_uint32, c_void_p)
         self.audio_receive_frame_cb = c_callback(callback)
-        ToxAV.libtoxav.toxav_callback_audio_receive_frame(self._toxav_pointer, self.audio_receive_frame_cb, user_data)
+        self.libtoxav.toxav_callback_audio_receive_frame(self._toxav_pointer, self.audio_receive_frame_cb, user_data)
 
     def callback_video_receive_frame(self, callback, user_data):
         """
@@ -360,4 +359,4 @@ class ToxAV:
         c_callback = CFUNCTYPE(None, c_void_p, c_uint32, c_uint16, c_uint16, POINTER(c_uint8), POINTER(c_uint8),
                                POINTER(c_uint8), c_int32, c_int32, c_int32, c_void_p)
         self.video_receive_frame_cb = c_callback(callback)
-        ToxAV.libtoxav.toxav_callback_video_receive_frame(self._toxav_pointer, self.video_receive_frame_cb, user_data)
+        self.libtoxav.toxav_callback_video_receive_frame(self._toxav_pointer, self.video_receive_frame_cb, user_data)

toxygen/toxencryptsave.py

@@ -1,65 +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):
-
-    libtoxencryptsave = libtox.LibToxEncryptSave()
 
     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
         """
@@ -67,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
@@ -82,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
         """
@@ -92,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,109 @@
+import util
+import os
+import settings
+import platform
+import urllib
+try:
+    from PySide import QtNetwork, QtCore
+except ImportError:
+    from PyQt4 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,25 @@
+# -*- coding: utf-8 -*-
+
 import os
 import time
 import shutil
+import sys
+import re
 
-program_version = '0.2.3'
+program_version = '0.2.8'
+
+
+def cached(func):
+    saved_result = None
+
+    def wrapped_func():
+        nonlocal saved_result
+        if saved_result is None:
+            saved_result = func()
+
+        return saved_result
+
+    return wrapped_func
 
 
 def log(data):
@@ -10,6 +27,7 @@ def log(data):
         fl.write(str(data) + '\n')
 
 
+@cached
 def curr_directory():
     return os.path.dirname(os.path.realpath(__file__))
 
@@ -30,14 +48,51 @@ 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)
 
 
+@cached
+def time_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
+    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

@@ -9,12 +9,19 @@ class DataLabel(QtGui.QLabel):
     Label with elided text
     """
     def setText(self, text):
-        text = ''.join(c if c <= '\u10FFFF' 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 ComboBox(QtGui.QComboBox):
+
+    def __init__(self, *args):
+        super().__init__(*args)
+        self.view().setSizePolicy(QtGui.QSizePolicy.MinimumExpanding, QtGui.QSizePolicy.Expanding)
+
+
 class CenteredWidget(QtGui.QWidget):
 
     def __init__(self):
@@ -130,4 +137,3 @@ class MultilineEdit(CenteredWidget):
     def button_click(self):
         self.save(self.edit.toPlainText())
         self.close()
-