update big NGC

This reverts commit 47c115e699.

.gitignore

@@ -1,11 +1,11 @@
 *.pyc
 *.pyo
-*.ui
 toxygen/toxcore
 tests/tests
 tests/libs
 tests/.cache
 tests/__pycache__
+tests/avatars
 toxygen/libs
 .idea
 *~
@@ -15,9 +15,14 @@ toxygen/libs
 toxygen/build
 toxygen/dist
 *.spec
-dist/
+dist
 toxygen/avatars
 toxygen/__pycache__
 /*.egg-info
 /*.egg
+html
+Toxygen.egg-info
+*.tox
+.cache
+*.db
 

.travis.yml

@@ -1,14 +1,33 @@
 language: python
 python:
-  - "3.4"
+  - "3.5"
+  - "3.6"
+os:
+  - linux
+dist: trusty
+notifications:
+  email: false
 before_install:
+  - sudo apt-get update
   - sudo apt-get install -y checkinstall build-essential
   - sudo apt-get install portaudio19-dev
+  - sudo apt-get install libsecret-1-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/;
+  - pip install sip
-  - python ~/virtualenv/python${TRAVIS_PYTHON_VERSION}/bin/pyside_postinstall.py -install
+  - pip install pyqt5
   - pip install pyaudio
+  - pip install opencv-python
+  - pip install pydenticon
 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
@@ -19,13 +38,16 @@ before_script:
   - sudo ldconfig
   - cd ..
 # Toxcore
-  - git clone https://github.com/irungentoo/toxcore.git
+  - git clone https://github.com/ingvar1995/toxcore.git --branch=ngc_rebase
   - cd toxcore
-  - autoreconf -if
+  - mkdir _build && cd _build
-  - ./configure
+  - cmake ..
   - 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
+  - cd ..
+script:
+  - py.test tests/travis.py
+  - py.test tests/tests.py

MANIFEST.in

@@ -12,9 +12,8 @@ include toxygen/smileys/starwars/*.png
 include toxygen/smileys/starwars/config.json
 include toxygen/smileys/ksk/*.png
 include toxygen/smileys/ksk/config.json
-include toxygen/styles/style.qss
+include toxygen/styles/*.qss
 include toxygen/translations/*.qm
 include toxygen/libs/libtox.dll
 include toxygen/libs/libsodium.a
-include toxygen/libs/libtox64.dll
+include toxygen/bootstrap/nodes.json
-include toxygen/libs/libsodium64.a

README.md

@@ -1,51 +1,48 @@
 # Toxygen
 
-Toxygen is cross-platform [Tox](https://tox.chat/) client written in pure Python3
+Toxygen is powerful cross-platform [Tox](https://tox.chat/) client written in pure Python3.
 
-[![Release](https://img.shields.io/github/release/xveduk/toxygen.svg?style=flat)](https://github.com/toxygen-project/toxygen/releases/latest)
+[![Release](https://img.shields.io/github/release/toxygen-project/toxygen.svg?style=flat)](https://github.com/toxygen-project/toxygen/releases/latest)
-[![Stars](https://img.shields.io/github/stars/xveduk/toxygen.svg?style=flat)](https://github.com/toxygen-project/toxygen/stargazers)
+[![Stars](https://img.shields.io/github/stars/toxygen-project/toxygen.svg?style=flat)](https://github.com/toxygen-project/toxygen/stargazers)
-[![Open issues](https://img.shields.io/github/issues/xveduk/toxygen.svg?style=flat)](https://github.com/toxygen-project/toxygen/issues)
+[![Open issues](https://img.shields.io/github/issues/toxygen-project/toxygen.svg?style=flat)](https://github.com/toxygen-project/toxygen/issues)
 [![License](https://img.shields.io/badge/license-GPLv3-blue.svg?style=flat)](https://raw.githubusercontent.com/toxygen-project/toxygen/master/LICENSE.md)
+[![Build Status](https://travis-ci.org/toxygen-project/toxygen.svg?branch=master)](https://travis-ci.org/toxygen-project/toxygen)
 
-### [Install](/docs/install.md) - [Contribute](/docs/contributing.md) - [Plugins](/docs/plugins.md) - [Compile](/docs/compile.md) - [Contact](/docs/contact.md)
+### [Install](/docs/install.md) - [Contribute](/docs/contributing.md) - [Plugins](/docs/plugins.md) - [Compile](/docs/compile.md) - [Contact](/docs/contact.md) - [Updater](https://github.com/toxygen-project/toxygen_updater)
 
-### Supported OS:
+### Supported OS: Linux and Windows
 
-- Windows
+### Features:
-- Linux
-- OS X
 
-### Features
+- 1v1 messages
-
+- File transfers
-- [x] 1v1 messages
+- Audio calls
-- [x] File transfers
+- Video calls
-- [x] Audio
+- Group chats
-- [x] Plugins support
+- Plugins support
-- [x] Chat history
+- Desktop sharing
-- [x] Emoticons
+- Chat history
-- [x] Stickers
+- Emoticons
-- [x] Screenshots
+- Stickers
-- [x] Name lookups (toxme.io support)
+- Screenshots
-- [x] Save file encryption
+- Name lookups (toxme.io support)
-- [x] Profile import and export
+- Save file encryption
-- [x] Faux offline messaging
+- Profile import and export
-- [x] Faux offline file transfers
+- Faux offline messaging
-- [x] Inline images
+- Faux offline file transfers
-- [x] Message splitting
+- Inline images
-- [x] Proxy support
+- Message splitting
-- [x] Avatars
+- Proxy support
-- [x] Multiprofile
+- Avatars
-- [x] Multilingual
+- Multiprofile
-- [x] Sound notifications
+- Multilingual
-- [x] Contact aliases
+- Sound notifications
-- [x] Contact blocking
+- Contact aliases
-- [x] Typing notifications
+- Contact blocking
-- [x] Changing nospam
+- Typing notifications
-- [x] File resuming
+- Changing nospam
-- [x] Read receipts
+- File resuming
-- [ ] Video
+- Read receipts
-- [ ] Desktop sharing
-- [ ] Group chats
 
 ### Downloads
 [Releases](https://github.com/toxygen-project/toxygen/releases)
@@ -61,3 +58,7 @@ Toxygen is cross-platform [Tox](https://tox.chat/) client written in pure Python
 
 ### Docs
 [Check /docs/ for more info](/docs/)
+
+Also visit [pythonhosted.org/Toxygen/](http://pythonhosted.org/Toxygen/)
+
+[Wiki](https://wiki.tox.chat/clients/toxygen)

build/Dockerfile

@@ -0,0 +1,13 @@
+FROM ubuntu:16.04
+
+RUN apt-get update && \
+apt-get install build-essential libtool autotools-dev automake checkinstall cmake check git yasm libsodium-dev libopus-dev libvpx-dev pkg-config -y && \
+git clone https://github.com/ingvar1995/toxcore.git --branch=ngc_rebase && \
+cd toxcore && mkdir _build && cd _build && \
+cmake .. && make && make install
+
+RUN apt-get install portaudio19-dev python3-pyqt5 python3-pyaudio python3-pip -y && \
+pip3 install numpy pydenticon opencv-python pyinstaller
+
+RUN useradd -ms /bin/bash toxygen
+USER toxygen

build/build.sh

@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+
+cd ~
+git clone https://github.com/toxygen-project/toxygen.git --branch=next_gen
+cd toxygen/toxygen
+
+pyinstaller --windowed --icon=images/icon.ico main.py
+
+cp -r styles dist/main/
+find . -type f ! -name '*.qss' -delete
+cp -r plugins dist/main/
+mkdir -p dist/main/ui/views
+cp -r ui/views dist/main/ui/
+cp -r sounds dist/main/
+cp -r smileys dist/main/
+cp -r stickers dist/main/
+cp -r bootstrap dist/main/
+find . -type f ! -name '*.json' -delete
+cp -r images dist/main/
+cp -r translations dist/main/
+find . -name "*.ts" -type f -delete
+
+cd dist
+mv main toxygen
+cd toxygen
+mv main toxygen
+wget -O updater https://github.com/toxygen-project/toxygen_updater/releases/download/v0.1/toxygen_updater_linux_64
+echo "[Paths]" >> qt.conf
+echo "Prefix = PyQt5/Qt" >> qt.conf
+cd ..
+
+tar -zcvf toxygen_linux_64.tar.gz toxygen > /dev/null
+rm -rf toxygen

docs/compile.md

@@ -2,9 +2,18 @@
 
 You can compile Toxygen using [PyInstaller](http://www.pyinstaller.org/)
 
-Install PyInstaller: 
+Use Dockerfile and build script from `build` directory:
-``pip3 install pyinstaller``
 
-``pyinstaller --windowed --icon images/icon.ico main.py``
+1. Build image:
+```
+docker build -t toxygen .
+```
 
-Don't forget to copy /images/, /sounds/, /translations/, /styles/, /smileys/, /stickers/, /plugins/ (and /libs/libtox.dll, /libs/libsodium.a on Windows) to /dist/main/
+2. Run container:
+```
+docker run -it toxygen bash
+```
+
+3. Execute `build.sh` script:
+
+```./build.sh```

docs/contact.md

@@ -1,5 +1,6 @@
 # Contact us:
 
-1) Using GitHub - open issue
+1) https://git.plastiras.org/emdee/toxygen/issues
 
-2) Use Toxygen Tox Group - add bot kalina@toxme.io (or 12EDB939AA529641CE53830B518D6EB30241868EE0E5023C46A372363CAEC91C2C948AEFE4EB)
+2) Use Toxygen Tox Group (NGC) - 
+ID: 59D68B2709E81A679CF91416CB0E3692851C6CFCABEFF98B7131E3805A6D75FA

docs/contributing.md

@@ -4,17 +4,22 @@ Help us find all bugs in Toxygen! Please provide following info:
 
 - OS
 - Toxygen version
-- Toxygen executable info - .py or precompiled binary
+- Toxygen executable info - python executable (.py), precompiled binary, from package etc.
 - 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://git.plastiras.org/emdee/toxygen/issues)
 
 # 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://git.plastiras.org/emdee/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.
 
+Note that we have a lot of branches for different purposes. Master branch is for stable versions (releases) only, so I recommend to open PR's to develop branch. Development of next Toxygen version usually goes there. Other branches used for implementing different tasks such as file transfers improvements or audio calls implementation etc.
+
 # Translations
 
-Help us translate Toxygen! Translation can be created using pyside-lupdate (``pyside-lupdate toxygen.pro``) and QT Linguist.
+Help us translate Toxygen! Translation can be created using pylupdate (``pylupdate5 toxygen.pro``) and QT Linguist.

docs/install.md

@@ -1,86 +1,44 @@
 # How to install Toxygen
 
-## Use precompiled binary:
-[Check our releases page](https://github.com/xveduk/toxygen/releases)
-
-## Using pip3
-
-### Windows
-
-``pip3.4 install toxygen``
-
-Run app using ``toxygen`` command.
-
 ### Linux
 
-1. Install [toxcore](https://github.com/irungentoo/toxcore/blob/master/INSTALL.md) with toxav support in your system (install in /usr/lib/)
+1. Install [c-toxcore](https://github.com/TokTok/c-toxcore/)
 2. Install PortAudio: 
 ``sudo apt-get install portaudio19-dev``
-3. Install PySide: ``sudo apt-get install python3-pyside``
+3. For 32-bit Linux install PyQt5: ``sudo apt-get install python3-pyqt5``
-4. Install toxygen: 
+4. Install [OpenCV](http://docs.opencv.org/trunk/d7/d9f/tutorial_linux_install.html) or via ``sudo pip3 install opencv-python``
-``sudo pip3.4 install toxygen``
+5. Install [toxygen](https://git.plastiras.org/emdee/toxygen/)
-5. Run toxygen using ``toxygen`` command.
+6. 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 install toxygen``
-4. Run toxygen using ``toxygen`` command.
-
-## Packages
-
-Coming soon.
 
 ## From source code (recommended for developers)
 
 ### Windows
 
-1. [Download and install latest Python 3.4](https://www.python.org/downloads/windows/)
+Note: 32-bit Python isn't supported due to bug with videocalls. It is strictly recommended to use 64-bit Python.
-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 \toxygen\main.py.
 
-Optional: install toxygen using setup.py: ``python3.4 setup.py install``
+1. [Download and install latest Python 3 64-bit](https://www.python.org/downloads/windows/)
-
+2. Install PyQt5: ``pip install pyqt5``
-[libtox.dll for 32-bit Python](https://build.tox.chat/view/libtoxcore/job/libtoxcore_build_windows_x86_shared_release/lastSuccessfulBuild/artifact/libtoxcore_build_windows_x86_shared_release.zip)
+3. Install PyAudio: ``pip install pyaudio``
-
+4. Install numpy: ``pip install numpy``
-[libtox.dll for 64-bit Python](https://build.tox.chat/view/libtoxcore/job/libtoxcore_build_windows_x86-64_shared_release/lastSuccessfulBuild/artifact/libtoxcore_build_windows_x86-64_shared_release.zip)
+5. Install OpenCV: ``pip install opencv-python``
-
+6. [Download toxygen](https://github.com/toxygen-project/toxygen/archive/master.zip)
-[libsodium.a for 32-bit Python](https://build.tox.chat/view/libsodium/job/libsodium_build_windows_x86_static_release/lastSuccessfulBuild/artifact/libsodium_build_windows_x86_static_release.zip)
+7. Unpack archive
-
+8. Download latest libtox.dll build, download latest libsodium.a build, put it into \toxygen\libs\
-[libsodium.a for 64-bit Python](https://build.tox.chat/view/libsodium/job/libsodium_build_windows_x86-64_static_release/lastSuccessfulBuild/artifact/libsodium_build_windows_x86-64_static_release.zip)
+9. Run \toxygen\main.py.
 
 ### Linux
 
 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) (``sudo apt-get install python3-pyqt4``).
+2. Install PyQt5: ``sudo apt-get install python3-pyqt5`` or ``sudo pip3 install pyqt5``
-3. Install [toxcore](https://github.com/irungentoo/toxcore/blob/master/INSTALL.md) with toxav support in your system (install in /usr/lib/)
+3. Install [toxcore](https://github.com/TokTok/c-toxcore) with toxav support)
 4. Install PyAudio: 
-``sudo apt-get install portaudio19-dev`` and ``sudo apt-get install python3-pyaudio`` (or ``pip3 install pyaudio``)
+``sudo apt-get install portaudio19-dev`` and ``sudo apt-get install python3-pyaudio`` (or ``sudo pip3 install pyaudio``)
-5. [Download toxygen](https://github.com/xveduk/toxygen/archive/master.zip)
+5. Install NumPy: ``sudo pip3 install numpy``
-6. Unpack archive 
+6. Install [OpenCV](http://docs.opencv.org/trunk/d7/d9f/tutorial_linux_install.html) or via ``sudo pip3 install opencv-python``
-7. Run app:
+7. [Download toxygen](https://git.plastiras.org/emdee/toxygen/)
-``python3.4 main.py``
+8. Unpack archive
-
+9. Run app:
-Optional: install toxygen using setup.py: ``python3.4 setup.py install``
+``python3 main.py``
-
-### OS X
-
-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,6 +1,6 @@
 # Plugins API
 
-In Toxygen plugin is single python (supported Python 3.0 - 3.4) module (.py file) and directory with data associated with it. 
+In Toxygen plugin is single python 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. 
 
 Every plugin has its own full name and unique short name (1-5 symbols). Main app can get it using special methods. 
@@ -18,7 +18,7 @@ All plugin's data should be stored in following structure:
 ```
 
 Plugin MUST override:
--  __init__ with params: tox (Tox instance), profile (Profile instance), settings (Settings instance), encrypt_save (ToxEncryptSave instance). Call super().__init__ with params plugin_full_name, plugin_short_name, tox, profile, settings, encrypt_save.
+-  __init__ with params: tox (Tox instance), profile (Profile instance), settings (Settings instance), encrypt_save (ToxES instance). Call super().__init__ with params plugin_full_name, plugin_short_name, tox, profile, settings, encrypt_save.
 
 Plugin can override following methods:
 - get_description - this method should return plugin description. 
@@ -45,7 +45,7 @@ Import statement will not work in case you import module that wasn't previously
 
 About GUI:
 
-It's strictly recommended to support both PySide and PyQt4 in GUI. Plugin can have no GUI at all.
+GUI is available via PyQt5. Plugin can have no GUI at all.
 
 Exceptions:
 
@@ -53,5 +53,5 @@ Plugin's methods MUST NOT raise exceptions.
 
 # 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,6 +1,6 @@
 # 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. 
+Toxygen is the first [Tox](https://tox.chat/) client with plugins support. Plugin is Python 3.5 - 3.6 module (.py file) and directory with plugin's data which provide some additional functionality.
 
 # How to write plugin
 
@@ -10,8 +10,8 @@ Check [Plugin API](/docs/plugin_api.md) for more info
 
 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
 
@@ -19,4 +19,4 @@ Toxygen comes without preinstalled plugins.
 
 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

@@ -8,6 +8,6 @@ Animated smileys (.gif) are supported too.
 
 # Stickers
 
-Sticker is inline image. If you want to create your own smiley pack, create directory in src/stickers/ and place your stickers there.
+Sticker is inline image. If you want to create your own sticker 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

@@ -2,21 +2,48 @@ from setuptools import setup
 from setuptools.command.install import install
 from platform import system
 from subprocess import call
-from toxygen.util import program_version
+import main
 import sys
+import os
+from utils.util import curr_directory, join_path
 
 
-version = program_version + '.0'
+version = main.__version__ + '.0'
 
-MODULES = []
 
-if system() in ('Windows', 'Darwin'):
+if system() == 'Windows':
-    MODULES = ['PyAudio', 'PySide']
+    MODULES = ['PyQt5', 'PyAudio', 'numpy', 'opencv-python', 'pydenticon']
 else:
+    MODULES = []
     try:
         import pyaudio
     except ImportError:
-        MODULES = ['PyAudio']
+        MODULES.append('PyAudio')
+    try:
+        import PyQt5
+    except ImportError:
+        MODULES.append('PyQt5')
+    try:
+        import numpy
+    except ImportError:
+        MODULES.append('numpy')
+    try:
+        import cv2
+    except ImportError:
+        MODULES.append('opencv-python')
+    try:
+        import pydenticon
+    except ImportError:
+        MODULES.append('pydenticon')
+
+
+def get_packages():
+    directory = join_path(curr_directory(__file__), 'toxygen')
+    for root, dirs, files in os.walk(directory):
+        packages = map(lambda d: 'toxygen.' + d, dirs)
+        packages = ['toxygen'] + list(packages)
+
+        return packages
 
 
 class InstallScript(install):
@@ -25,9 +52,7 @@ class InstallScript(install):
     def run(self):
         install.run(self)
         try:
-            if system() == 'Windows':
+            if system() != 'Windows':
-                call(["toxygen", "--configure"])
-            else:
                 call(["toxygen", "--clean"])
         except:
             try:
@@ -37,35 +62,32 @@ class InstallScript(install):
                     if path[-1] not in ('/', '\\'):
                         path += '/'
                     path += 'bin/toxygen'
-                    if system() == 'Windows':
+                    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',
       license='GPL3',
-      packages=['toxygen', 'toxygen.plugins', 'toxygen.styles'],
+      packages=get_packages(),
       install_requires=MODULES,
       include_package_data=True,
       classifiers=[
           'Programming Language :: Python :: 3 :: Only',
-          'Programming Language :: Python :: 3.2',
+          'Programming Language :: Python :: 3.5',
-          'Programming Language :: Python :: 3.3',
+          'Programming Language :: Python :: 3.6',
-          'Programming Language :: Python :: 3.4',
       ],
       entry_points={
-          'console_scripts': ['toxygen=toxygen.main:main'],
+          'console_scripts': ['toxygen=toxygen.main:main']
       },
       cmdclass={
-          'install': InstallScript,
+          'install': InstallScript
-      },
+      })
-      )

tests/tests.py

@@ -1,70 +1,18 @@
-from toxygen.bootstrap import node_generator
+from toxygen.middleware.tox_factory import *
-from toxygen.profile import *
-from toxygen.settings import ProfileHelper
-from toxygen.tox_dns import tox_dns
-import toxygen.toxencryptsave as encr
 
 
-class TestProfile:
+# TODO: add new tests
-
-    def test_search(self):
-        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'
+        name = 'Toxygen User'
-        status_message = b'Toxing on Toxygen'
+        status_message = 'Toxing on Toxygen'
         tox = tox_factory()
         tox.self_set_name(name)
         tox.self_set_status_message(status_message)
         data = tox.get_savedata()
         del tox
         tox = tox_factory(data)
-        assert tox.self_get_name() == str(name, 'utf-8')
+        assert tox.self_get_name() == name
-        assert tox.self_get_status_message() == str(status_message, 'utf-8')
+        assert tox.self_get_status_message() == status_message
-
-    def test_friend_list(self):
-        data = ProfileHelper(Settings.get_default_path(), 'bob').open_profile()
-        settings = Settings.get_default_settings()
-        tox = tox_factory(data, settings)
-        s = tox.self_get_friend_list()
-        size = tox.self_get_friend_list_size()
-        assert size <= 2
-        assert len(s) <= 2
-        del tox
-
-
-class TestDNS:
-
-    def test_dns(self):
-        bot_id = '56A1ADE4B65B86BCD51CC73E2CD4E542179F47959FE3E0E21B4B0ACDADE51855D34D34D37CB5'
-        tox_id = tox_dns('groupbot@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:
-            data = fl.read()
-        lib = encr.ToxEncryptSave()
-        lib.set_password('easypassword')
-        copy_data = data[:]
-        data = lib.pass_encrypt(data)
-        data = lib.pass_decrypt(data)
-        assert copy_data == data

tests/travis.py

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

toxygen/app.py

@@ -0,0 +1,424 @@
+from middleware import threads
+import middleware.callbacks as callbacks
+from PyQt5 import QtWidgets, QtGui, QtCore
+import ui.password_screen as password_screen
+import updater.updater as updater
+import os
+from middleware.tox_factory import tox_factory
+import wrapper.toxencryptsave as tox_encrypt_save
+import user_data.toxes
+from user_data.settings import Settings
+from ui.login_screen import LoginScreen
+from user_data.profile_manager import ProfileManager
+from plugin_support.plugin_support import PluginLoader
+from ui.main_screen import MainWindow
+from ui import tray
+import utils.ui as util_ui
+import utils.util as util
+from contacts.profile import Profile
+from file_transfers.file_transfers_handler import FileTransfersHandler
+from contacts.contact_provider import ContactProvider
+from contacts.friend_factory import FriendFactory
+from contacts.group_factory import GroupFactory
+from contacts.contacts_manager import ContactsManager
+from av.calls_manager import CallsManager
+from history.database import Database
+from ui.widgets_factory import WidgetsFactory
+from smileys.smileys import SmileyLoader
+from ui.items_factories import MessagesItemsFactory, ContactItemsFactory
+from messenger.messenger import Messenger
+from network.tox_dns import ToxDns
+from history.history import History
+from file_transfers.file_transfers_messages_service import FileTransfersMessagesService
+from groups.groups_service import GroupsService
+from ui.create_profile_screen import CreateProfileScreen
+from common.provider import Provider
+from contacts.group_peer_factory import GroupPeerFactory
+from user_data.backup_service import BackupService
+import styles.style  # TODO: dynamic loading
+
+
+class App:
+
+    def __init__(self, version, path_to_profile=None, uri=None):
+        self._version = version
+        self._app = self._settings = self._profile_manager = self._plugin_loader = self._messenger = None
+        self._tox = self._ms = self._init = self._main_loop = self._av_loop = None
+        self._uri = self._toxes = self._tray = self._file_transfer_handler = self._contacts_provider = None
+        self._friend_factory = self._calls_manager = self._contacts_manager = self._smiley_loader = None
+        self._group_peer_factory = self._tox_dns = self._backup_service = None
+        self._group_factory = self._groups_service = self._profile = None
+        if uri is not None and uri.startswith('tox:'):
+            self._uri = uri[4:]
+        self._path = path_to_profile
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Public methods
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def main(self):
+        """
+        Main function of app. loads login screen if needed and starts main screen
+        """
+        self._app = QtWidgets.QApplication([])
+        self._load_icon()
+
+        if util.get_platform() == 'Linux':
+            QtCore.QCoreApplication.setAttribute(QtCore.Qt.AA_X11InitThreads)
+
+        self._load_base_style()
+
+        if not self._select_and_load_profile():
+            return
+
+        if self._try_to_update():
+            return
+
+        self._load_app_styles()
+        self._load_app_translations()
+
+        self._create_dependencies()
+        self._start_threads()
+
+        if self._uri is not None:
+            self._ms.add_contact(self._uri)
+
+        self._app.lastWindowClosed.connect(self._app.quit)
+
+        self._execute_app()
+
+        self._stop_app()
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # App executing
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def _execute_app(self):
+        while True:
+            try:
+                self._app.exec_()
+            except Exception as ex:
+                util.log('Unhandled exception: ' + str(ex))
+            else:
+                break
+
+    def _stop_app(self):
+        self._plugin_loader.stop()
+        self._stop_threads()
+        self._file_transfer_handler.stop()
+        self._tray.hide()
+        self._save_profile()
+        self._settings.close()
+        self._kill_toxav()
+        self._kill_tox()
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # App loading
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def _load_base_style(self):
+        with open(util.join_path(util.get_styles_directory(), 'dark_style.qss')) as fl:
+            style = fl.read()
+        self._app.setStyleSheet(style)
+
+    def _load_app_styles(self):
+        # application color scheme
+        if self._settings['theme'] == 'dark':
+            return
+        for theme in self._settings.built_in_themes().keys():
+            if self._settings['theme'] != theme:
+                continue
+            theme_path = self._settings.built_in_themes()[theme]
+            file_path = util.join_path(util.get_styles_directory(), theme_path)
+            with open(file_path) as fl:
+                style = fl.read()
+            self._app.setStyleSheet(style)
+            break
+
+    def _load_login_screen_translations(self):
+        current_language, supported_languages = self._get_languages()
+        if current_language not in supported_languages:
+            return
+        lang_path = supported_languages[current_language]
+        translator = QtCore.QTranslator()
+        translator.load(util.get_translations_directory() + lang_path)
+        self._app.installTranslator(translator)
+        self._app.translator = translator
+
+    def _load_icon(self):
+        icon_file = os.path.join(util.get_images_directory(), 'icon.png')
+        self._app.setWindowIcon(QtGui.QIcon(icon_file))
+
+    @staticmethod
+    def _get_languages():
+        current_locale = QtCore.QLocale()
+        curr_language = current_locale.languageToString(current_locale.language())
+        supported_languages = Settings.supported_languages()
+
+        return curr_language, supported_languages
+
+    def _load_app_translations(self):
+        lang = Settings.supported_languages()[self._settings['language']]
+        translator = QtCore.QTranslator()
+        translator.load(os.path.join(util.get_translations_directory(), lang))
+        self._app.installTranslator(translator)
+        self._app.translator = translator
+
+    def _select_and_load_profile(self):
+        encrypt_save = tox_encrypt_save.ToxEncryptSave()
+        self._toxes = user_data.toxes.ToxES(encrypt_save)
+
+        if self._path is not None:  # toxygen was started with path to profile
+            self._load_existing_profile(self._path)
+        else:
+            auto_profile = Settings.get_auto_profile()
+            if auto_profile is None:  # no default profile
+                result = self._select_profile()
+                if result is None:
+                    return False
+                if result.is_new_profile():  # create new profile
+                    if not self._create_new_profile(result.profile_path):
+                        return False
+                else:  # load existing profile
+                    self._load_existing_profile(result.profile_path)
+                self._path = result.profile_path
+            else:  # default profile
+                self._path = auto_profile
+                self._load_existing_profile(auto_profile)
+
+        if Settings.is_active_profile(self._path):  # profile is in use
+            profile_name = util.get_profile_name_from_path(self._path)
+            title = util_ui.tr('Profile {}').format(profile_name)
+            text = util_ui.tr(
+                'Other instance of Toxygen uses this profile or profile was not properly closed. Continue?')
+            reply = util_ui.question(text, title)
+            if not reply:
+                return False
+
+        self._settings.set_active_profile()
+
+        return True
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Threads
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def _start_threads(self, initial_start=True):
+        # init thread
+        self._init = threads.InitThread(self._tox, self._plugin_loader, self._settings, initial_start)
+        self._init.start()
+
+        # starting threads for tox iterate and toxav iterate
+        self._main_loop = threads.ToxIterateThread(self._tox)
+        self._main_loop.start()
+        self._av_loop = threads.ToxAVIterateThread(self._tox.AV)
+        self._av_loop.start()
+
+        if initial_start:
+            threads.start_file_transfer_thread()
+
+    def _stop_threads(self, is_app_closing=True):
+        self._init.stop_thread()
+
+        self._av_loop.stop_thread()
+        self._main_loop.stop_thread()
+
+        if is_app_closing:
+            threads.stop_file_transfer_thread()
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Profiles
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def _select_profile(self):
+        self._load_login_screen_translations()
+        ls = LoginScreen()
+        profiles = ProfileManager.find_profiles()
+        ls.update_select(profiles)
+        ls.show()
+        self._app.exec_()
+
+        return ls.result
+
+    def _load_existing_profile(self, profile_path):
+        self._profile_manager = ProfileManager(self._toxes, profile_path)
+        data = self._profile_manager.open_profile()
+        if self._toxes.is_data_encrypted(data):
+            data = self._enter_password(data)
+        self._settings = Settings(self._toxes, profile_path.replace('.tox', '.json'))
+        self._tox = self._create_tox(data)
+
+    def _create_new_profile(self, profile_name):
+        result = self._get_create_profile_screen_result()
+        if result is None:
+            return False
+        if result.save_into_default_folder:
+            profile_path = util.join_path(Settings.get_default_path(), profile_name + '.tox')
+        else:
+            profile_path = util.join_path(util.curr_directory(__file__), profile_name + '.tox')
+        if os.path.isfile(profile_path):
+            util_ui.message_box(util_ui.tr('Profile with this name already exists'),
+                                util_ui.tr('Error'))
+            return False
+        name = profile_name or 'toxygen_user'
+        self._tox = tox_factory()
+        self._tox.self_set_name(name if name else 'Toxygen User')
+        self._tox.self_set_status_message('Toxing on Toxygen')
+        self._path = profile_path
+        if result.password:
+            self._toxes.set_password(result.password)
+        self._settings = Settings(self._toxes, self._path.replace('.tox', '.json'))
+        self._profile_manager = ProfileManager(self._toxes, profile_path)
+        try:
+            self._save_profile()
+        except Exception as ex:
+            print(ex)
+            util.log('Profile creation exception: ' + str(ex))
+            text = util_ui.tr('Profile saving error! Does Toxygen have permission to write to this directory?')
+            util_ui.message_box(text, util_ui.tr('Error'))
+
+            return False
+        current_language, supported_languages = self._get_languages()
+        if current_language in supported_languages:
+            self._settings['language'] = current_language
+        self._settings.save()
+
+        return True
+
+    def _get_create_profile_screen_result(self):
+        cps = CreateProfileScreen()
+        cps.show()
+        self._app.exec_()
+
+        return cps.result
+
+    def _save_profile(self, data=None):
+        data = data or self._tox.get_savedata()
+        self._profile_manager.save_profile(data)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Other private methods
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def _enter_password(self, data):
+        """
+        Show password screen
+        """
+        p = password_screen.PasswordScreen(self._toxes, data)
+        p.show()
+        self._app.lastWindowClosed.connect(self._app.quit)
+        self._app.exec_()
+        if p.result is not None:
+            return p.result
+        self._force_exit()
+
+    def _reset(self):
+        """
+        Create new tox instance (new network settings)
+        :return: tox instance
+        """
+        self._contacts_manager.reset_contacts_statuses()
+        self._stop_threads(False)
+        data = self._tox.get_savedata()
+        self._save_profile(data)
+        self._kill_toxav()
+        self._kill_tox()
+        # create new tox instance
+        self._tox = self._create_tox(data)
+        self._start_threads(False)
+
+        tox_savers = [self._friend_factory, self._group_factory, self._plugin_loader, self._contacts_manager,
+                      self._contacts_provider, self._messenger, self._file_transfer_handler, self._groups_service,
+                      self._profile]
+        for tox_saver in tox_savers:
+            tox_saver.set_tox(self._tox)
+
+        self._calls_manager.set_toxav(self._tox.AV)
+        self._contacts_manager.update_friends_numbers()
+        self._contacts_manager.update_groups_lists()
+        self._contacts_manager.update_groups_numbers()
+
+        self._init_callbacks()
+
+    def _create_dependencies(self):
+        self._backup_service = BackupService(self._settings, self._profile_manager)
+        self._smiley_loader = SmileyLoader(self._settings)
+        self._tox_dns = ToxDns(self._settings)
+        self._ms = MainWindow(self._settings, self._tray)
+        db = Database(self._path.replace('.tox', '.db'), self._toxes)
+
+        contact_items_factory = ContactItemsFactory(self._settings, self._ms)
+        self._friend_factory = FriendFactory(self._profile_manager, self._settings,
+                                             self._tox, db, contact_items_factory)
+        self._group_factory = GroupFactory(self._profile_manager, self._settings, self._tox, db, contact_items_factory)
+        self._group_peer_factory = GroupPeerFactory(self._tox, self._profile_manager, db, contact_items_factory)
+        self._contacts_provider = ContactProvider(self._tox, self._friend_factory, self._group_factory,
+                                                  self._group_peer_factory)
+        self._profile = Profile(self._profile_manager, self._tox, self._ms, self._contacts_provider, self._reset)
+        self._init_profile()
+        self._plugin_loader = PluginLoader(self._settings, self)
+        history = None
+        messages_items_factory = MessagesItemsFactory(self._settings, self._plugin_loader, self._smiley_loader,
+                                                      self._ms, lambda m: history.delete_message(m))
+        history = History(self._contacts_provider, db, self._settings, self._ms, messages_items_factory)
+        self._contacts_manager = ContactsManager(self._tox, self._settings, self._ms, self._profile_manager,
+                                                 self._contacts_provider, history, self._tox_dns,
+                                                 messages_items_factory)
+        history.set_contacts_manager(self._contacts_manager)
+        self._calls_manager = CallsManager(self._tox.AV, self._settings, self._ms, self._contacts_manager)
+        self._messenger = Messenger(self._tox, self._plugin_loader, self._ms, self._contacts_manager,
+                                    self._contacts_provider, messages_items_factory, self._profile,
+                                    self._calls_manager)
+        file_transfers_message_service = FileTransfersMessagesService(self._contacts_manager, messages_items_factory,
+                                                                      self._profile, self._ms)
+        self._file_transfer_handler = FileTransfersHandler(self._tox, self._settings, self._contacts_provider,
+                                                           file_transfers_message_service, self._profile)
+        messages_items_factory.set_file_transfers_handler(self._file_transfer_handler)
+        widgets_factory = None
+        widgets_factory_provider = Provider(lambda: widgets_factory)
+        self._groups_service = GroupsService(self._tox, self._contacts_manager, self._contacts_provider, self._ms,
+                                             widgets_factory_provider)
+        widgets_factory = WidgetsFactory(self._settings, self._profile, self._profile_manager, self._contacts_manager,
+                                         self._file_transfer_handler, self._smiley_loader, self._plugin_loader,
+                                         self._toxes, self._version, self._groups_service, history,
+                                         self._contacts_provider)
+        self._tray = tray.init_tray(self._profile, self._settings, self._ms, self._toxes)
+        self._ms.set_dependencies(widgets_factory, self._tray, self._contacts_manager, self._messenger, self._profile,
+                                  self._plugin_loader, self._file_transfer_handler, history, self._calls_manager,
+                                  self._groups_service, self._toxes)
+
+        self._tray.show()
+        self._ms.show()
+
+        self._init_callbacks()
+
+    def _try_to_update(self):
+        updating = updater.start_update_if_needed(self._version, self._settings)
+        if updating:
+            self._save_profile()
+            self._settings.close()
+            self._kill_toxav()
+            self._kill_tox()
+        return updating
+
+    def _create_tox(self, data):
+        return tox_factory(data, self._settings)
+
+    def _force_exit(self):
+        raise SystemExit()
+
+    def _init_callbacks(self):
+        callbacks.init_callbacks(self._tox, self._profile, self._settings, self._plugin_loader, self._contacts_manager,
+                                 self._calls_manager, self._file_transfer_handler, self._ms, self._tray,
+                                 self._messenger, self._groups_service, self._contacts_provider)
+
+    def _init_profile(self):
+        if not self._profile.has_avatar():
+            self._profile.reset_avatar(self._settings['identicons'])
+
+    def _kill_toxav(self):
+        self._calls_manager.set_toxav(None)
+        self._tox.AV.kill()
+
+    def _kill_tox(self):
+        self._tox.kill()

toxygen/av/call.py

@@ -0,0 +1,58 @@
+
+
+class Call:
+
+    def __init__(self, out_audio, out_video, in_audio=False, in_video=False):
+        self._in_audio = in_audio
+        self._in_video = in_video
+        self._out_audio = out_audio
+        self._out_video = out_video
+        self._is_active = False
+
+    def get_is_active(self):
+        return self._is_active
+
+    def set_is_active(self, value):
+        self._is_active = value
+
+    is_active = property(get_is_active, set_is_active)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Audio
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def get_in_audio(self):
+        return self._in_audio
+
+    def set_in_audio(self, value):
+        self._in_audio = value
+
+    in_audio = property(get_in_audio, set_in_audio)
+
+    def get_out_audio(self):
+        return self._out_audio
+
+    def set_out_audio(self, value):
+        self._out_audio = value
+
+    out_audio = property(get_out_audio, set_out_audio)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Video
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def get_in_video(self):
+        return self._in_video
+
+    def set_in_video(self, value):
+        self._in_video = value
+
+    in_video = property(get_in_video, set_in_video)
+
+    def get_out_video(self):
+        return self._out_video
+
+    def set_out_video(self, value):
+        self._out_video = value
+
+    out_video = property(get_out_video, set_out_video)

toxygen/av/calls.py

@@ -0,0 +1,281 @@
+import pyaudio
+import time
+import threading
+from wrapper.toxav_enums import *
+import cv2
+import itertools
+import numpy as np
+from av import screen_sharing
+from av.call import Call
+import common.tox_save
+
+
+class AV(common.tox_save.ToxAvSave):
+
+    def __init__(self, toxav, settings):
+        super().__init__(toxav)
+        self._settings = settings
+        self._running = True
+
+        self._calls = {}  # dict: key - friend number, value - Call instance
+
+        self._audio = None
+        self._audio_stream = None
+        self._audio_thread = None
+        self._audio_running = False
+        self._out_stream = None
+
+        self._audio_rate = 8000
+        self._audio_channels = 1
+        self._audio_duration = 60
+        self._audio_sample_count = self._audio_rate * self._audio_channels * self._audio_duration // 1000
+
+        self._video = None
+        self._video_thread = None
+        self._video_running = False
+
+        self._video_width = 640
+        self._video_height = 480
+
+    def stop(self):
+        self._running = False
+        self.stop_audio_thread()
+        self.stop_video_thread()
+
+    def __contains__(self, friend_number):
+        return friend_number in self._calls
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Calls
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def __call__(self, friend_number, audio, video):
+        """Call friend with specified number"""
+        self._toxav.call(friend_number, 32 if audio else 0, 5000 if video else 0)
+        self._calls[friend_number] = Call(audio, video)
+        threading.Timer(30.0, lambda: self.finish_not_started_call(friend_number)).start()
+
+    def accept_call(self, friend_number, audio_enabled, video_enabled):
+        if self._running:
+            self._calls[friend_number] = Call(audio_enabled, video_enabled)
+            self._toxav.answer(friend_number, 32 if audio_enabled else 0, 5000 if video_enabled else 0)
+            if audio_enabled:
+                self.start_audio_thread()
+            if video_enabled:
+                self.start_video_thread()
+
+    def finish_call(self, friend_number, by_friend=False):
+        if not by_friend:
+            self._toxav.call_control(friend_number, TOXAV_CALL_CONTROL['CANCEL'])
+        if friend_number in self._calls:
+            del self._calls[friend_number]
+        if not len(list(filter(lambda c: c.out_audio, self._calls))):
+            self.stop_audio_thread()
+        if not len(list(filter(lambda c: c.out_video, self._calls))):
+            self.stop_video_thread()
+
+    def finish_not_started_call(self, friend_number):
+        if friend_number in self:
+            call = self._calls[friend_number]
+            if not call.is_active:
+                self.finish_call(friend_number)
+
+    def toxav_call_state_cb(self, friend_number, state):
+        """
+        New call state
+        """
+        call = self._calls[friend_number]
+        call.is_active = True
+
+        call.in_audio = state | TOXAV_FRIEND_CALL_STATE['SENDING_A'] > 0
+        call.in_video = state | TOXAV_FRIEND_CALL_STATE['SENDING_V'] > 0
+
+        if state | TOXAV_FRIEND_CALL_STATE['ACCEPTING_A'] and call.out_audio:
+            self.start_audio_thread()
+
+        if state | TOXAV_FRIEND_CALL_STATE['ACCEPTING_V'] and call.out_video:
+            self.start_video_thread()
+
+    def is_video_call(self, number):
+        return number in self and self._calls[number].in_video
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Threads
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def start_audio_thread(self):
+        """
+        Start audio sending
+        """
+        if self._audio_thread is not None:
+            return
+
+        self._audio_running = True
+
+        self._audio = pyaudio.PyAudio()
+        self._audio_stream = self._audio.open(format=pyaudio.paInt16,
+                                              rate=self._audio_rate,
+                                              channels=self._audio_channels,
+                                              input=True,
+                                              input_device_index=self._settings.audio['input'],
+                                              frames_per_buffer=self._audio_sample_count * 10)
+
+        self._audio_thread = threading.Thread(target=self.send_audio)
+        self._audio_thread.start()
+
+    def stop_audio_thread(self):
+
+        if self._audio_thread is None:
+            return
+
+        self._audio_running = False
+
+        self._audio_thread.join()
+
+        self._audio_thread = None
+        self._audio_stream = None
+        self._audio = None
+
+        if self._out_stream is not None:
+            self._out_stream.stop_stream()
+            self._out_stream.close()
+            self._out_stream = None
+
+    def start_video_thread(self):
+        if self._video_thread is not None:
+            return
+
+        self._video_running = True
+        self._video_width = s.video['width']
+        self._video_height = s.video['height']
+
+        if s.video['device'] == -1:
+            self._video = screen_sharing.DesktopGrabber(self._settings.video['x'], self._settings.video['y'],
+                                                        self._settings.video['width'], self._settings.video['height'])
+        else:
+            self._video = cv2.VideoCapture(self._settings.video['device'])
+            self._video.set(cv2.CAP_PROP_FPS, 25)
+            self._video.set(cv2.CAP_PROP_FRAME_WIDTH, self._video_width)
+            self._video.set(cv2.CAP_PROP_FRAME_HEIGHT, self._video_height)
+
+        self._video_thread = threading.Thread(target=self.send_video)
+        self._video_thread.start()
+
+    def stop_video_thread(self):
+        if self._video_thread is None:
+            return
+
+        self._video_running = False
+        self._video_thread.join()
+        self._video_thread = None
+        self._video = None
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Incoming chunks
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def audio_chunk(self, samples, channels_count, rate):
+        """
+        Incoming chunk
+        """
+
+        if self._out_stream is None:
+            self._out_stream = self._audio.open(format=pyaudio.paInt16,
+                                                channels=channels_count,
+                                                rate=rate,
+                                                output_device_index=self._settings.audio['output'],
+                                                output=True)
+        self._out_stream.write(samples)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # AV sending
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def send_audio(self):
+        """
+        This method sends audio to friends
+        """
+
+        while self._audio_running:
+            try:
+                pcm = self._audio_stream.read(self._audio_sample_count)
+                if pcm:
+                    for friend_num in self._calls:
+                        if self._calls[friend_num].out_audio:
+                            try:
+                                self._toxav.audio_send_frame(friend_num, pcm, self._audio_sample_count,
+                                                             self._audio_channels, self._audio_rate)
+                            except:
+                                pass
+            except:
+                pass
+
+            time.sleep(0.01)
+
+    def send_video(self):
+        """
+        This method sends video to friends
+        """
+        while self._video_running:
+            try:
+                result, frame = self._video.read()
+                if result:
+                    height, width, channels = frame.shape
+                    for friend_num in self._calls:
+                        if self._calls[friend_num].out_video:
+                            try:
+                                y, u, v = self.convert_bgr_to_yuv(frame)
+                                self._toxav.video_send_frame(friend_num, width, height, y, u, v)
+                            except:
+                                pass
+            except:
+                pass
+
+            time.sleep(0.01)
+
+    def convert_bgr_to_yuv(self, frame):
+        """
+        :param frame: input bgr frame
+        :return y, u, v: y, u, v values of frame
+
+        How this function works:
+        OpenCV creates YUV420 frame from BGR
+        This frame has following structure and size:
+        width, height - dim of input frame
+        width, height * 1.5 - dim of output frame
+
+                  width
+        -------------------------
+        |                       |
+        |          Y            |      height
+        |                       |
+        -------------------------
+        |           |           |
+        |  U even   |   U odd   |      height // 4
+        |           |           |
+        -------------------------
+        |           |           |
+        |  V even   |   V odd   |      height // 4
+        |           |           |
+        -------------------------
+
+         width // 2   width // 2
+
+        Y, U, V can be extracted using slices and joined in one list using itertools.chain.from_iterable()
+        Function returns bytes(y), bytes(u), bytes(v), because it is required for ctypes
+        """
+        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2YUV_I420)
+
+        y = frame[:self._video_height, :]
+        y = list(itertools.chain.from_iterable(y))
+
+        u = np.zeros((self._video_height // 2, self._video_width // 2), dtype=np.int)
+        u[::2, :] = frame[self._video_height:self._video_height * 5 // 4, :self._video_width // 2]
+        u[1::2, :] = frame[self._video_height:self._video_height * 5 // 4, self._video_width // 2:]
+        u = list(itertools.chain.from_iterable(u))
+        v = np.zeros((self._video_height // 2, self._video_width // 2), dtype=np.int)
+        v[::2, :] = frame[self._video_height * 5 // 4:, :self._video_width // 2]
+        v[1::2, :] = frame[self._video_height * 5 // 4:, self._video_width // 2:]
+        v = list(itertools.chain.from_iterable(v))
+
+        return bytes(y), bytes(u), bytes(v)

toxygen/av/calls_manager.py

@@ -0,0 +1,116 @@
+import threading
+import cv2
+import av.calls
+from messenger.messages import *
+from ui import av_widgets
+import common.event as event
+
+
+class CallsManager:
+
+    def __init__(self, toxav, settings, screen, contacts_manager):
+        self._call = av.calls.AV(toxav, settings)  # object with data about calls
+        self._call_widgets = {}  # dict of incoming call widgets
+        self._incoming_calls = set()
+        self._settings = settings
+        self._screen = screen
+        self._contacts_manager = contacts_manager
+        self._call_started_event = event.Event()  # friend_number, audio, video, is_outgoing
+        self._call_finished_event = event.Event()  # friend_number, is_declined
+
+    def set_toxav(self, toxav):
+        self._call.set_toxav(toxav)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Events
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def get_call_started_event(self):
+        return self._call_started_event
+
+    call_started_event = property(get_call_started_event)
+
+    def get_call_finished_event(self):
+        return self._call_finished_event
+
+    call_finished_event = property(get_call_finished_event)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # AV support
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def call_click(self, audio=True, video=False):
+        """User clicked audio button in main window"""
+        num = self._contacts_manager.get_active_number()
+        if not self._contacts_manager.is_active_a_friend():
+            return
+        if num not in self._call and self._contacts_manager.is_active_online():  # start call
+            if not self._settings.audio['enabled']:
+                return
+            self._call(num, audio, video)
+            self._screen.active_call()
+            self._call_started_event(num, audio, video, True)
+        elif num in self._call:  # finish or cancel call if you call with active friend
+            self.stop_call(num, False)
+
+    def incoming_call(self, audio, video, friend_number):
+        """
+        Incoming call from friend.
+        """
+        if not self._settings.audio['enabled']:
+            return
+        friend = self._contacts_manager.get_friend_by_number(friend_number)
+        self._call_started_event(friend_number, audio, video, False)
+        self._incoming_calls.add(friend_number)
+        if friend_number == self._contacts_manager.get_active_number():
+            self._screen.incoming_call()
+        else:
+            friend.actions = True
+        text = util_ui.tr("Incoming video call") if video else util_ui.tr("Incoming audio call")
+        self._call_widgets[friend_number] = self._get_incoming_call_widget(friend_number, text, friend.name)
+        self._call_widgets[friend_number].set_pixmap(friend.get_pixmap())
+        self._call_widgets[friend_number].show()
+
+    def accept_call(self, friend_number, audio, video):
+        """
+        Accept incoming call with audio or video
+        """
+        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)
+        del self._call_widgets[friend_number]
+
+    def stop_call(self, friend_number, by_friend):
+        """
+        Stop call with friend
+        """
+        if friend_number in self._incoming_calls:
+            self._incoming_calls.remove(friend_number)
+            is_declined = True
+        else:
+            is_declined = False
+        self._screen.call_finished()
+        is_video = self._call.is_video_call(friend_number)
+        self._call.finish_call(friend_number, by_friend)  # finish or decline call
+        if friend_number in self._call_widgets:
+            self._call_widgets[friend_number].close()
+            del self._call_widgets[friend_number]
+
+        def destroy_window():
+            if is_video:
+                cv2.destroyWindow(str(friend_number))
+
+        threading.Timer(2.0, destroy_window).start()
+        self._call_finished_event(friend_number, is_declined)
+
+    def friend_exit(self, friend_number):
+        if friend_number in self._call:
+            self._call.finish_call(friend_number, True)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Private methods
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def _get_incoming_call_widget(self, friend_number, text, friend_name):
+        return av_widgets.IncomingCallWidget(self._settings, self, friend_number, text, friend_name)

toxygen/av/screen_sharing.py

@@ -0,0 +1,22 @@
+import numpy as np
+from PyQt5 import QtWidgets
+
+
+class DesktopGrabber:
+
+    def __init__(self, x, y, width, height):
+        self._x = x
+        self._y = y
+        self._width = width
+        self._height = height
+        self._width -= width % 4
+        self._height -= height % 4
+        self._screen = QtWidgets.QApplication.primaryScreen()
+
+    def read(self):
+        pixmap = self._screen.grabWindow(0, self._x, self._y, self._width, self._height)
+        image = pixmap.toImage()
+        s = image.bits().asstring(self._width * self._height * 4)
+        arr = np.fromstring(s, dtype=np.uint8).reshape((self._height, self._width, 4))
+
+        return True, arr

toxygen/bootstrap.py

@@ -1,83 +0,0 @@
-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
-
-    def get_data(self):
-        return bytes(self._ip, 'utf-8'), self._port, self._tox_key
-
-
-def node_generator():
-    nodes = []
-    ips = [
-        "144.76.60.215", "23.226.230.47", "195.154.119.113", "biribiri.org",
-        "46.38.239.179", "178.62.250.138", "130.133.110.14", "104.167.101.29",
-        "205.185.116.116", "198.98.51.198", "80.232.246.79", "108.61.165.198",
-        "212.71.252.109", "194.249.212.109", "185.25.116.107", "192.99.168.140",
-        "46.101.197.175", "95.215.46.114", "5.189.176.217", "148.251.23.146",
-        "104.223.122.15", "78.47.114.252", "d4rk4.ru", "81.4.110.149",
-        "95.31.20.151", "104.233.104.126", "51.254.84.212", "home.vikingmakt.com.br",
-        "5.135.59.163", "185.58.206.164", "188.244.38.183", "mrflibble.c4.ee",
-        "82.211.31.116", "128.199.199.197", "103.230.156.174", "91.121.66.124",
-        "92.54.84.70", "tox1.privacydragon.me"
-    ]
-    ports = [
-        33445, 33445, 33445, 33445,
-        33445, 33445, 33445, 33445,
-        33445, 33445, 33445, 33445,
-        33445, 33445, 33445, 33445,
-        443, 33445, 5190, 2306,
-        33445, 33445, 1813, 33445,
-        33445, 33445, 33445, 33445,
-        33445, 33445, 33445, 33445,
-        33445, 33445, 33445, 33445,
-        33445, 33445
-    ]
-    ids = [
-        "04119E835DF3E78BACF0F84235B300546AF8B936F035185E2A8E9E0A67C8924F",
-        "A09162D68618E742FFBCA1C2C70385E6679604B2D80EA6E84AD0996A1AC8A074",
-        "E398A69646B8CEACA9F0B84F553726C1C49270558C57DF5F3C368F05A7D71354",
-        "F404ABAA1C99A9D37D61AB54898F56793E1DEF8BD46B1038B9D822E8460FAB67",
-        "F5A1A38EFB6BD3C2C8AF8B10D85F0F89E931704D349F1D0720C3C4059AF2440A",
-        "788236D34978D1D5BD822F0A5BEBD2C53C64CC31CD3149350EE27D4D9A2F9B6B",
-        "461FA3776EF0FA655F1A05477DF1B3B614F7D6B124F7DB1DD4FE3C08B03B640F",
-        "5918AC3C06955962A75AD7DF4F80A5D7C34F7DB9E1498D2E0495DE35B3FE8A57",
-        "A179B09749AC826FF01F37A9613F6B57118AE014D4196A0E1105A98F93A54702",
-        "1D5A5F2F5D6233058BF0259B09622FB40B482E4FA0931EB8FD3AB8E7BF7DAF6F",
-        "CF6CECA0A14A31717CC8501DA51BE27742B70746956E6676FF423A529F91ED5D",
-        "8E7D0B859922EF569298B4D261A8CCB5FEA14FB91ED412A7603A585A25698832",
-        "C4CEB8C7AC607C6B374E2E782B3C00EA3A63B80D4910B8649CCACDD19F260819",
-        "3CEE1F054081E7A011234883BC4FC39F661A55B73637A5AC293DDF1251D9432B",
-        "DA4E4ED4B697F2E9B000EEFE3A34B554ACD3F45F5C96EAEA2516DD7FF9AF7B43",
-        "6A4D0607A296838434A6A7DDF99F50EF9D60A2C510BBF31FE538A25CB6B4652F",
-        "CD133B521159541FB1D326DE9850F5E56A6C724B5B8E5EB5CD8D950408E95707",
-        "5823FB947FF24CF83DDFAC3F3BAA18F96EA2018B16CC08429CB97FA502F40C23",
-        "2B2137E094F743AC8BD44652C55F41DFACC502F125E99E4FE24D40537489E32F",
-        "7AED21F94D82B05774F697B209628CD5A9AD17E0C073D9329076A4C28ED28147",
-        "0FB96EEBFB1650DDB52E70CF773DDFCABE25A95CC3BB50FC251082E4B63EF82A",
-        "1C5293AEF2114717547B39DA8EA6F1E331E5E358B35F9B6B5F19317911C5F976",
-        "53737F6D47FA6BD2808F378E339AF45BF86F39B64E79D6D491C53A1D522E7039",
-        "9E7BD4793FFECA7F32238FA2361040C09025ED3333744483CA6F3039BFF0211E",
-        "9CA69BB74DE7C056D1CC6B16AB8A0A38725C0349D187D8996766958584D39340",
-        "EDEE8F2E839A57820DE3DA4156D88350E53D4161447068A3457EE8F59F362414",
-        "AEC204B9A4501412D5F0BB67D9C81B5DB3EE6ADA64122D32A3E9B093D544327D",
-        "188E072676404ED833A4E947DC1D223DF8EFEBE5F5258573A236573688FB9761",
-        "2D320F971EF2CA18004416C2AAE7BA52BF7949DB34EA8E2E21AF67BD367BE211",
-        "24156472041E5F220D1FA11D9DF32F7AD697D59845701CDD7BE7D1785EB9DB39",
-        "15A0F9684E2423F9F46CFA5A50B562AE42525580D840CC50E518192BF333EE38",
-        "FAAB17014F42F7F20949F61E55F66A73C230876812A9737F5F6D2DCE4D9E4207",
-        "AF97B76392A6474AF2FD269220FDCF4127D86A42EF3A242DF53A40A268A2CD7C",
-        "B05C8869DBB4EDDD308F43C1A974A20A725A36EACCA123862FDE9945BF9D3E09",
-        "5C4C7A60183D668E5BD8B3780D1288203E2F1BAE4EEF03278019E21F86174C1D",
-        "4E3F7D37295664BBD0741B6DBCB6431D6CD77FC4105338C2FC31567BF5C8224A",
-        "5625A62618CB4FCA70E147A71B29695F38CC65FF0CBD68AD46254585BE564802",
-        "31910C0497D347FF160D6F3A6C0E317BAFA71E8E03BC4CBB2A185C9D4FB8B31E"
-    ]
-    for i in range(len(ips)):
-        nodes.append(Node(ips[i], ports[i], ids[i], random.randint(0, 1000000)))
-    arr = sorted(nodes, key=lambda x: x.rand)[:4]
-    for elem in arr:
-        yield elem.get_data()
-

toxygen/bootstrap/bootstrap.py

@@ -0,0 +1,83 @@
+import random
+import urllib.request
+from utils.util import *
+from PyQt5 import QtNetwork, QtCore
+import json
+
+
+DEFAULT_NODES_COUNT = 4
+
+
+class Node:
+
+    def __init__(self, node):
+        self._ip, self._port, self._tox_key = node['ipv4'], node['port'], node['public_key']
+        self._priority = random.randint(1, 1000000) if node['status_tcp'] and node['status_udp'] else 0
+
+    def get_priority(self):
+        return self._priority
+
+    priority = property(get_priority)
+
+    def get_data(self):
+        return self._ip, self._port, self._tox_key
+
+
+def generate_nodes(nodes_count=DEFAULT_NODES_COUNT):
+    with open(_get_nodes_path(), 'rt') as fl:
+        json_nodes = json.loads(fl.read())['nodes']
+    nodes = map(lambda json_node: Node(json_node), json_nodes)
+    nodes = filter(lambda n: n.priority > 0, nodes)
+    sorted_nodes = sorted(nodes, key=lambda x: x.priority)
+    if nodes_count is not None:
+        sorted_nodes = sorted_nodes[-DEFAULT_NODES_COUNT:]
+    for node in sorted_nodes:
+        yield node.get_data()
+
+
+def download_nodes_list(settings):
+    url = 'https://nodes.tox.chat/json'
+    if not settings['download_nodes_list']:
+        return
+
+    if not settings['proxy_type']:  # no proxy
+        try:
+            req = urllib.request.Request(url)
+            req.add_header('Content-Type', 'application/json')
+            response = urllib.request.urlopen(req)
+            result = response.read()
+            _save_nodes(result)
+        except Exception as ex:
+            log('TOX nodes loading error: ' + str(ex))
+    else:  # proxy
+        netman = QtNetwork.QNetworkAccessManager()
+        proxy = QtNetwork.QNetworkProxy()
+        proxy.setType(
+            QtNetwork.QNetworkProxy.Socks5Proxy if settings['proxy_type'] == 2 else QtNetwork.QNetworkProxy.HttpProxy)
+        proxy.setHostName(settings['proxy_host'])
+        proxy.setPort(settings['proxy_port'])
+        netman.setProxy(proxy)
+        try:
+            request = QtNetwork.QNetworkRequest()
+            request.setUrl(QtCore.QUrl(url))
+            reply = netman.get(request)
+
+            while not reply.isFinished():
+                QtCore.QThread.msleep(1)
+                QtCore.QCoreApplication.processEvents()
+            data = bytes(reply.readAll().data())
+            _save_nodes(data)
+        except Exception as ex:
+            log('TOX nodes loading error: ' + str(ex))
+
+
+def _get_nodes_path():
+    return join_path(curr_directory(__file__), 'nodes.json')
+
+
+def _save_nodes(nodes):
+    if not nodes:
+        return
+    print('Saving nodes...')
+    with open(_get_nodes_path(), 'wb') as fl:
+        fl.write(nodes)

toxygen/bootstrap/nodes.json

@@ -0,0 +1 @@
+{"nodes":[{"ipv4":"80.211.19.83","ipv6":"-","port":33445,"public_key":"A2D7BF17C10A12C339B9F4E8DD77DEEE8457D580535A6F0D0F9AF04B8B4C4420","status_udp":true,"status_tcp":true}]}

toxygen/callbacks.py

@@ -1,357 +0,0 @@
-try:
-    from PySide import QtCore
-except ImportError:
-    from PyQt4 import QtCore
-from notifications import *
-from settings import Settings
-from profile import Profile
-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):
-    EVENT_TYPE = QtCore.QEvent.Type(QtCore.QEvent.registerEventType())
-
-    def __init__(self, fn, *args, **kwargs):
-        QtCore.QEvent.__init__(self, InvokeEvent.EVENT_TYPE)
-        self.fn = fn
-        self.args = args
-        self.kwargs = kwargs
-
-
-class Invoker(QtCore.QObject):
-
-    def event(self, event):
-        event.fn(*event.args, **event.kwargs)
-        return True
-
-_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
-# -----------------------------------------------------------------------------------------------------------------
-
-
-def self_connection_status(tox_link):
-    """
-    Current user changed connection status (offline, UDP, TCP)
-    """
-    def wrapped(tox, connection, user_data):
-        print('Connection status: ', str(connection))
-        profile = Profile.get_instance()
-        if profile.status is None:
-            status = tox_link.self_get_status()
-            invoke_in_main_thread(profile.set_status, status)
-        elif connection == TOX_CONNECTION['NONE']:
-            invoke_in_main_thread(profile.set_status, None)
-    return wrapped
-
-
-# -----------------------------------------------------------------------------------------------------------------
-# Callbacks - friends
-# -----------------------------------------------------------------------------------------------------------------
-
-
-def friend_status(tox, friend_num, new_status, user_data):
-    """
-    Check friend's status (none, busy, away)
-    """
-    print("Friend's #{} status changed!".format(friend_num))
-    profile = Profile.get_instance()
-    friend = profile.get_friend_by_number(friend_num)
-    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(QtCore.QTimer.singleShot, 5000, lambda: profile.send_files(friend_num))
-    invoke_in_main_thread(profile.update_filtration)
-
-
-def friend_connection_status(tox, friend_num, new_status, user_data):
-    """
-    Check friend's connection status (offline, udp, tcp)
-    """
-    print("Friend #{} connection status: {}".format(friend_num, new_status))
-    profile = Profile.get_instance()
-    friend = profile.get_friend_by_number(friend_num)
-    if new_status == TOX_CONNECTION['NONE']:
-        invoke_in_main_thread(profile.friend_exit, friend_num)
-        invoke_in_main_thread(profile.update_filtration)
-        if Settings.get_instance()['sound_notifications'] and profile.status != TOX_USER_STATUS['BUSY']:
-            sound_notification(SOUND_NOTIFICATION['FRIEND_CONNECTION_STATUS'])
-    elif friend.status is None:
-        invoke_in_main_thread(profile.send_avatar, friend_num)
-        invoke_in_main_thread(PluginLoader.get_instance().friend_online, friend_num)
-
-
-def friend_name(tox, friend_num, name, size, user_data):
-    """
-    Friend changed his name
-    """
-    profile = Profile.get_instance()
-    print('New name friend #' + str(friend_num))
-    invoke_in_main_thread(profile.new_name, friend_num, name)
-
-
-def friend_status_message(tox, friend_num, status_message, size, user_data):
-    """
-    :return: function for callback friend_status_message. It updates friend's status message
-    and calls window repaint
-    """
-    profile = Profile.get_instance()
-    friend = profile.get_friend_by_number(friend_num)
-    invoke_in_main_thread(friend.set_status_message, status_message)
-    print('User #{} has new status'.format(friend_num))
-    invoke_in_main_thread(profile.send_messages, friend_num)
-    if profile.get_active_number() == friend_num:
-        invoke_in_main_thread(profile.set_active)
-
-
-def friend_message(window, tray):
-    """
-    New message from friend
-    """
-    def wrapped(tox, friend_number, message_type, message, size, user_data):
-        profile = Profile.get_instance()
-        settings = Settings.get_instance()
-        message = str(message, 'utf-8')
-        invoke_in_main_thread(profile.new_message, friend_number, message_type, message)
-        if not window.isActiveWindow():
-            friend = profile.get_friend_by_number(friend_number)
-            if settings['notifications'] and profile.status != TOX_USER_STATUS['BUSY'] and not settings.locked:
-                invoke_in_main_thread(tray_notification, friend.name, message, tray, window)
-            if settings['sound_notifications'] and profile.status != TOX_USER_STATUS['BUSY']:
-                sound_notification(SOUND_NOTIFICATION['MESSAGE'])
-            invoke_in_main_thread(tray.setIcon, QtGui.QIcon(curr_directory() + '/images/icon_new_messages.png'))
-    return wrapped
-
-
-def friend_request(tox, public_key, message, message_size, user_data):
-    """
-    Called when user get new friend request
-    """
-    print('Friend request')
-    profile = Profile.get_instance()
-    key = ''.join(chr(x) for x in public_key[:TOX_PUBLIC_KEY_SIZE])
-    tox_id = bin_to_string(key, TOX_PUBLIC_KEY_SIZE)
-    if tox_id not in Settings.get_instance()['blocked']:
-        invoke_in_main_thread(profile.process_friend_request, tox_id, str(message, 'utf-8'))
-
-
-def friend_typing(tox, friend_number, typing, user_data):
-    invoke_in_main_thread(Profile.get_instance().friend_typing, friend_number, typing)
-
-
-def friend_read_receipt(tox, friend_number, message_id, user_data):
-    profile = Profile.get_instance()
-    profile.get_friend_by_number(friend_number).dec_receipt()
-    if friend_number == profile.get_active_number():
-        invoke_in_main_thread(profile.receipt)
-
-# -----------------------------------------------------------------------------------------------------------------
-# Callbacks - file transfers
-# -----------------------------------------------------------------------------------------------------------------
-
-
-def tox_file_recv(window, tray):
-    """
-    New incoming file
-    """
-    def wrapped(tox, friend_number, file_number, file_type, size, file_name, file_name_size, user_data):
-        profile = Profile.get_instance()
-        settings = Settings.get_instance()
-        if file_type == TOX_FILE_KIND['DATA']:
-            print('File')
-            try:
-                file_name = str(file_name[:file_name_size], 'utf-8')
-            except:
-                file_name = 'toxygen_file'
-            invoke_in_main_thread(profile.incoming_file_transfer,
-                                  friend_number,
-                                  file_number,
-                                  size,
-                                  file_name)
-            if not window.isActiveWindow():
-                friend = profile.get_friend_by_number(friend_number)
-                if settings['notifications'] and profile.status != TOX_USER_STATUS['BUSY'] and not settings.locked:
-                    file_from = QtGui.QApplication.translate("Callback", "File from", None, QtGui.QApplication.UnicodeUTF8)
-                    invoke_in_main_thread(tray_notification, file_from + ' ' + friend.name, file_name, tray, window)
-                if settings['sound_notifications'] and profile.status != TOX_USER_STATUS['BUSY']:
-                    sound_notification(SOUND_NOTIFICATION['FILE_TRANSFER'])
-                invoke_in_main_thread(tray.setIcon, QtGui.QIcon(curr_directory() + '/images/icon_new_messages.png'))
-        else:  # AVATAR
-            print('Avatar')
-            invoke_in_main_thread(profile.incoming_avatar,
-                                  friend_number,
-                                  file_number,
-                                  size)
-    return wrapped
-
-
-def file_recv_chunk(tox, friend_number, file_number, position, chunk, length, user_data):
-    """
-    Incoming chunk
-    """
-    _thread.execute(Profile.get_instance().incoming_chunk, friend_number, file_number, position,
-                    chunk[:length] if length else None)
-
-
-def file_chunk_request(tox, friend_number, file_number, position, size, user_data):
-    """
-    Outgoing chunk
-    """
-    Profile.get_instance().outgoing_chunk(friend_number, file_number, position, size)
-
-
-def file_recv_control(tox, friend_number, file_number, file_control, user_data):
-    """
-    Friend cancelled, paused or resumed file transfer
-    """
-    if file_control == TOX_FILE_CONTROL['CANCEL']:
-        invoke_in_main_thread(Profile.get_instance().cancel_transfer, friend_number, file_number, True)
-    elif file_control == TOX_FILE_CONTROL['PAUSE']:
-        invoke_in_main_thread(Profile.get_instance().pause_transfer, friend_number, file_number, True)
-    elif file_control == TOX_FILE_CONTROL['RESUME']:
-        invoke_in_main_thread(Profile.get_instance().resume_transfer, friend_number, file_number, True)
-
-# -----------------------------------------------------------------------------------------------------------------
-# Callbacks - custom packets
-# -----------------------------------------------------------------------------------------------------------------
-
-
-def lossless_packet(tox, friend_number, data, length, user_data):
-    """
-    Incoming lossless packet
-    """
-    plugin = PluginLoader.get_instance()
-    invoke_in_main_thread(plugin.callback_lossless, friend_number, data, length)
-
-
-def lossy_packet(tox, friend_number, data, length, user_data):
-    """
-    Incoming lossy packet
-    """
-    plugin = PluginLoader.get_instance()
-    invoke_in_main_thread(plugin.callback_lossy, friend_number, data, length)
-
-
-# -----------------------------------------------------------------------------------------------------------------
-# Callbacks - audio
-# -----------------------------------------------------------------------------------------------------------------
-
-def call_state(toxav, friend_number, mask, user_data):
-    """
-    New call state
-    """
-    print(friend_number, mask)
-    if mask == TOXAV_FRIEND_CALL_STATE['FINISHED'] or mask == TOXAV_FRIEND_CALL_STATE['ERROR']:
-        invoke_in_main_thread(Profile.get_instance().stop_call, friend_number, True)
-    else:
-        Profile.get_instance().call.toxav_call_state_cb(friend_number, mask)
-
-
-def call(toxav, friend_number, audio, video, user_data):
-    """
-    Incoming call from friend
-    """
-    print(friend_number, audio, video)
-    invoke_in_main_thread(Profile.get_instance().incoming_call, audio, video, friend_number)
-
-
-def callback_audio(toxav, friend_number, samples, audio_samples_per_channel, audio_channels_count, rate, user_data):
-    """
-    New audio chunk
-    """
-    Profile.get_instance().call.chunk(
-        bytes(samples[:audio_samples_per_channel * 2 * audio_channels_count]),
-        audio_channels_count,
-        rate)
-
-
-# -----------------------------------------------------------------------------------------------------------------
-# Callbacks - initialization
-# -----------------------------------------------------------------------------------------------------------------
-
-
-def init_callbacks(tox, window, tray):
-    """
-    Initialization of all callbacks.
-    :param tox: tox instance
-    :param window: main window
-    :param tray: tray (for notifications)
-    """
-    tox.callback_self_connection_status(self_connection_status(tox), 0)
-
-    tox.callback_friend_status(friend_status, 0)
-    tox.callback_friend_message(friend_message(window, tray), 0)
-    tox.callback_friend_connection_status(friend_connection_status, 0)
-    tox.callback_friend_name(friend_name, 0)
-    tox.callback_friend_status_message(friend_status_message, 0)
-    tox.callback_friend_request(friend_request, 0)
-    tox.callback_friend_typing(friend_typing, 0)
-    tox.callback_friend_read_receipt(friend_read_receipt, 0)
-
-    tox.callback_file_recv(tox_file_recv(window, tray), 0)
-    tox.callback_file_recv_chunk(file_recv_chunk, 0)
-    tox.callback_file_chunk_request(file_chunk_request, 0)
-    tox.callback_file_recv_control(file_recv_control, 0)
-
-    toxav = tox.AV
-    toxav.callback_call_state(call_state, 0)
-    toxav.callback_call(call, 0)
-    toxav.callback_audio_receive_frame(callback_audio, 0)
-
-    tox.callback_friend_lossless_packet(lossless_packet, 0)
-    tox.callback_friend_lossy_packet(lossy_packet, 0)
-

toxygen/calls.py

@@ -1,144 +0,0 @@
-import pyaudio
-import time
-import threading
-import settings
-from toxav_enums import *
-# TODO: play sound until outgoing call will be started or cancelled and add timeout
-# TODO: add widget for call
-
-CALL_TYPE = {
-    'NONE': 0,
-    'AUDIO': 1,
-    'VIDEO': 2
-}
-
-
-class AV:
-
-    def __init__(self, toxav):
-        self._toxav = toxav
-        self._running = True
-
-        self._calls = {}  # dict: key - friend number, value - call type
-
-        self._audio = None
-        self._audio_stream = None
-        self._audio_thread = None
-        self._audio_running = False
-        self._out_stream = None
-
-        self._audio_rate = 8000
-        self._audio_channels = 1
-        self._audio_duration = 60
-        self._audio_sample_count = self._audio_rate * self._audio_channels * self._audio_duration // 1000
-
-    def __contains__(self, friend_number):
-        return friend_number in self._calls
-
-    def __call__(self, friend_number, audio, video):
-        """Call friend with specified number"""
-        self._toxav.call(friend_number, 32 if audio else 0, 5000 if video else 0)
-        self._calls[friend_number] = CALL_TYPE['AUDIO']
-        self.start_audio_thread()
-
-    def finish_call(self, friend_number, by_friend=False):
-
-        if not by_friend:
-            self._toxav.call_control(friend_number, TOXAV_CALL_CONTROL['CANCEL'])
-        if friend_number in self._calls:
-            del self._calls[friend_number]
-        if not len(self._calls):
-            self.stop_audio_thread()
-
-    def stop(self):
-        self._running = False
-        self.stop_audio_thread()
-
-    def start_audio_thread(self):
-        """
-        Start audio sending
-        """
-        if self._audio_thread is not None:
-            return
-
-        self._audio_running = True
-
-        self._audio = pyaudio.PyAudio()
-        self._audio_stream = self._audio.open(format=pyaudio.paInt16,
-                                              rate=self._audio_rate,
-                                              channels=self._audio_channels,
-                                              input=True,
-                                              input_device_index=settings.Settings.get_instance().audio['input'],
-                                              frames_per_buffer=self._audio_sample_count * 10)
-
-        self._audio_thread = threading.Thread(target=self.send_audio)
-        self._audio_thread.start()
-
-    def stop_audio_thread(self):
-
-        if self._audio_thread is None:
-            return
-
-        self._audio_running = False
-
-        self._audio_thread.join()
-
-        self._audio_thread = None
-        self._audio_stream = None
-        self._audio = None
-
-        if self._out_stream is not None:
-            self._out_stream.stop_stream()
-            self._out_stream.close()
-            self._out_stream = None
-
-    def chunk(self, samples, channels_count, rate):
-        """
-        Incoming chunk
-        """
-
-        if self._out_stream is None:
-            self._out_stream = self._audio.open(format=pyaudio.paInt16,
-                                                channels=channels_count,
-                                                rate=rate,
-                                                output_device_index=settings.Settings.get_instance().audio['output'],
-                                                output=True)
-        self._out_stream.write(samples)
-
-    def send_audio(self):
-        """
-        This method sends audio to friends
-        """
-
-        while self._audio_running:
-            try:
-                pcm = self._audio_stream.read(self._audio_sample_count)
-                if pcm:
-                    for friend in self._calls:
-                        if self._calls[friend] & 1:
-                            try:
-                                self._toxav.audio_send_frame(friend, pcm, self._audio_sample_count,
-                                                             self._audio_channels, self._audio_rate)
-                            except:
-                                pass
-            except:
-                pass
-
-            time.sleep(0.01)
-
-    def accept_call(self, friend_number, audio_enabled, video_enabled):
-
-        if self._running:
-            self._calls[friend_number] = int(video_enabled) * 2 + int(audio_enabled)
-            self._toxav.answer(friend_number, 32 if audio_enabled else 0, 5000 if video_enabled else 0)
-            self.start_audio_thread()
-
-    def toxav_call_state_cb(self, friend_number, state):
-        """
-        New call state
-        """
-        if self._running:
-
-            if state & TOXAV_FRIEND_CALL_STATE['ACCEPTING_A']:
-                self._calls[friend_number] |= 1
-

toxygen/common/event.py

@@ -0,0 +1,26 @@
+
+
+class Event:
+
+    def __init__(self):
+        self._callbacks = set()
+
+    def __iadd__(self, callback):
+        self.add_callback(callback)
+
+        return self
+
+    def __isub__(self, callback):
+        self.remove_callback(callback)
+
+        return self
+
+    def __call__(self, *args, **kwargs):
+        for callback in self._callbacks:
+            callback(*args, **kwargs)
+
+    def add_callback(self, callback):
+        self._callbacks.add(callback)
+
+    def remove_callback(self, callback):
+        self._callbacks.discard(callback)

toxygen/common/provider.py

@@ -0,0 +1,13 @@
+
+
+class Provider:
+
+    def __init__(self, get_item_action):
+        self._get_item_action = get_item_action
+        self._item = None
+
+    def get_item(self):
+        if self._item is None:
+            self._item = self._get_item_action()
+
+        return self._item

toxygen/common/tox_save.py

@@ -0,0 +1,18 @@
+
+
+class ToxSave:
+
+    def __init__(self, tox):
+        self._tox = tox
+
+    def set_tox(self, tox):
+        self._tox = tox
+
+
+class ToxAvSave:
+
+    def __init__(self, toxav):
+        self._toxav = toxav
+
+    def set_toxav(self, toxav):
+        self._toxav = toxav

toxygen/contact.py

@@ -1,113 +0,0 @@
-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
-
-
-class Contact:
-    """
-    Class encapsulating TOX contact
-    Properties: name (alias of contact or name), status_message, status (connection status)
-    widget - widget for update
-    """
-
-    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._widget.name.setText(name)
-        self._widget.status_message.setText(status_message)
-        self._tox_id = tox_id
-        self.load_avatar()
-
-    # -----------------------------------------------------------------------------------------------------------------
-    # 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
-        """
-        avatar_path = '{}.png'.format(self._tox_id[:TOX_PUBLIC_KEY_SIZE * 2])
-        os.chdir(ProfileHelper.get_path() + 'avatars/')
-        if not os.path.isfile(avatar_path):  # load default image
-            avatar_path = 'avatar.png'
-            os.chdir(curr_directory() + '/images/')
-        width = self._widget.avatar_label.width()
-        pixmap = QtGui.QPixmap(avatar_path)
-        self._widget.avatar_label.setPixmap(pixmap.scaled(width, width, QtCore.Qt.KeepAspectRatio,
-                                                          QtCore.Qt.SmoothTransformation))
-        self._widget.avatar_label.repaint()
-
-    def reset_avatar(self):
-        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()

toxygen/contacts/basecontact.py

@@ -0,0 +1,180 @@
+from user_data.settings import *
+from PyQt5 import QtCore, QtGui
+from wrapper.toxcore_enums_and_consts import TOX_PUBLIC_KEY_SIZE
+import utils.util as util
+import common.event as event
+import contacts.common as common
+
+
+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, profile_manager, 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._profile_manager = profile_manager
+        self._name, self._status_message = name, status_message
+        self._status, self._widget = None, widget
+        self._tox_id = tox_id
+        self._name_changed_event = event.Event()
+        self._status_message_changed_event = event.Event()
+        self._status_changed_event = event.Event()
+        self._avatar_changed_event = event.Event()
+        self.init_widget()
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Name - current name or alias of user
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def get_name(self):
+        return self._name
+
+    def set_name(self, value):
+        if self._name == value:
+            return
+        self._name = value
+        self._widget.name.setText(self._name)
+        self._widget.name.repaint()
+        self._name_changed_event(self._name)
+
+    name = property(get_name, set_name)
+
+    def get_name_changed_event(self):
+        return self._name_changed_event
+
+    name_changed_event = property(get_name_changed_event)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Status message
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def get_status_message(self):
+        return self._status_message
+
+    def set_status_message(self, value):
+        if self._status_message == value:
+            return
+        self._status_message = value
+        self._widget.status_message.setText(self._status_message)
+        self._widget.status_message.repaint()
+        self._status_message_changed_event(self._status_message)
+
+    status_message = property(get_status_message, set_status_message)
+
+    def get_status_message_changed_event(self):
+        return self._status_message_changed_event
+
+    status_message_changed_event = property(get_status_message_changed_event)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Status
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def get_status(self):
+        return self._status
+
+    def set_status(self, value):
+        if self._status == value:
+            return
+        self._status = value
+        self._widget.connection_status.update(value)
+        self._status_changed_event(self._status)
+
+    status = property(get_status, set_status)
+
+    def get_status_changed_event(self):
+        return self._status_changed_event
+
+    status_changed_event = property(get_status_changed_event)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # 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
+        """
+        avatar_path = self.get_avatar_path()
+        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()
+        self._avatar_changed_event(avatar_path)
+
+    def reset_avatar(self, generate_new):
+        avatar_path = self.get_avatar_path()
+        if os.path.isfile(avatar_path) and not avatar_path == self._get_default_avatar_path():
+            os.remove(avatar_path)
+        if generate_new:
+            self.set_avatar(common.generate_avatar(self._tox_id[:TOX_PUBLIC_KEY_SIZE * 2]))
+        else:
+            self.load_avatar()
+
+    def set_avatar(self, avatar):
+        avatar_path = self.get_contact_avatar_path()
+        with open(avatar_path, 'wb') as f:
+            f.write(avatar)
+        self.load_avatar()
+
+    def get_pixmap(self):
+        return self._widget.avatar_label.pixmap()
+
+    def get_avatar_path(self):
+        avatar_path = self.get_contact_avatar_path()
+        if not os.path.isfile(avatar_path) or not os.path.getsize(avatar_path):  # load default image
+            avatar_path = self._get_default_avatar_path()
+
+        return avatar_path
+
+    def get_contact_avatar_path(self):
+        directory = util.join_path(self._profile_manager.get_dir(), 'avatars')
+
+        return util.join_path(directory, '{}.png'.format(self._tox_id[:TOX_PUBLIC_KEY_SIZE * 2]))
+
+    def has_avatar(self):
+        path = self.get_contact_avatar_path()
+
+        return util.file_exists(path)
+
+    def get_avatar_changed_event(self):
+        return self._avatar_changed_event
+
+    avatar_changed_event = property(get_avatar_changed_event)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Widgets
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def init_widget(self):
+        self._widget.name.setText(self._name)
+        self._widget.status_message.setText(self._status_message)
+        self._widget.connection_status.update(self._status)
+        self.load_avatar()
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Private methods
+    # -----------------------------------------------------------------------------------------------------------------
+
+    @staticmethod
+    def _get_default_avatar_path():
+        return util.join_path(util.get_images_directory(), 'avatar.png')

toxygen/contacts/common.py

@@ -0,0 +1,50 @@
+from pydenticon import Generator
+import hashlib
+
+
+# -----------------------------------------------------------------------------------------------------------------
+# Typing notifications
+# -----------------------------------------------------------------------------------------------------------------
+
+class BaseTypingNotificationHandler:
+
+    DEFAULT_HANDLER = None
+
+    def __init__(self):
+        pass
+
+    def send(self, tox, is_typing):
+        pass
+
+
+class FriendTypingNotificationHandler(BaseTypingNotificationHandler):
+
+    def __init__(self, friend_number):
+        super().__init__()
+        self._friend_number = friend_number
+
+    def send(self, tox, is_typing):
+        tox.self_set_typing(self._friend_number, is_typing)
+
+
+BaseTypingNotificationHandler.DEFAULT_HANDLER = BaseTypingNotificationHandler()
+
+
+# -----------------------------------------------------------------------------------------------------------------
+# Identicons support
+# -----------------------------------------------------------------------------------------------------------------
+
+
+def generate_avatar(public_key):
+    foreground = ['rgb(45,79,255)', 'rgb(185, 66, 244)', 'rgb(185, 66, 244)',
+                  'rgb(254,180,44)', 'rgb(252, 2, 2)', 'rgb(109, 198, 0)',
+                  'rgb(226,121,234)', 'rgb(130, 135, 124)',
+                  'rgb(30,179,253)', 'rgb(160, 157, 0)',
+                  'rgb(232,77,65)', 'rgb(102, 4, 4)',
+                  'rgb(49,203,115)',
+                  'rgb(141,69,170)']
+    generator = Generator(5, 5, foreground=foreground, background='rgba(42,42,42,0)')
+    digest = hashlib.sha256(public_key.encode('utf-8')).hexdigest()
+    identicon = generator.generate(digest, 220, 220, padding=(10, 10, 10, 10))
+
+    return identicon

toxygen/contacts/contact.py

@@ -0,0 +1,333 @@
+from history.database import *
+from contacts import basecontact, common
+from messenger.messages import *
+from contacts.contact_menu import *
+from file_transfers import file_transfers as ft
+import re
+
+
+class Contact(basecontact.BaseContact):
+    """
+    Class encapsulating TOX contact
+    Properties: number, message getter, history etc. Base class for friend and gc classes
+    """
+
+    def __init__(self, profile_manager, message_getter, number, name, status_message, widget, tox_id):
+        """
+        :param message_getter: gets messages from db
+        :param number: number of friend.
+        """
+        super().__init__(profile_manager, name, status_message, widget, tox_id)
+        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._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
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # History support
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def load_corr(self, first_time=True):
+        """
+        :param first_time: friend became active, load first part of messages
+        """
+        try:
+            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 p: self._get_text_message(p), data))
+            self._corr = data + self._corr
+        except:
+            pass
+        finally:
+            self._history_loaded = True
+
+    def load_all_corr(self):
+        """
+        Get all chat history from db for current friend
+        """
+        if self._message_getter is None:
+            return
+        data = list(self._message_getter.get_all())
+        if data is not None and len(data):
+            data.reverse()
+            data = list(map(lambda p: self._get_text_message(p), 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 m: m.type in (MESSAGE_TYPE['TEXT'], MESSAGE_TYPE['ACTION']), self._corr))
+        return 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.type in (MESSAGE_TYPE['TEXT'], MESSAGE_TYPE['ACTION']):
+            self._unsaved_messages += 1
+
+    def get_last_message_text(self):
+        messages = list(filter(lambda m: m.type in (MESSAGE_TYPE['TEXT'], MESSAGE_TYPE['ACTION'])
+                                         and m.author.type != MESSAGE_AUTHOR['FRIEND'], self._corr))
+        if messages:
+            return messages[-1].text
+        else:
+            return ''
+
+    def remove_messages_widgets(self):
+        for message in self._corr:
+            message.remove_widget()
+
+    def get_message(self, _filter):
+        return list(filter(lambda m: _filter(m), self._corr))[0]
+
+    @staticmethod
+    def _get_text_message(params):
+        (message, author_type, author_name, unix_time, message_type, unique_id) = params
+        author = MessageAuthor(author_name, author_type)
+
+        return TextMessage(message, author, unix_time, message_type, unique_id)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Unsent messages
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def get_unsent_messages(self):
+        """
+        :return list of unsent messages
+        """
+        messages = filter(lambda m: m.author is not None and m.author.type == MESSAGE_AUTHOR['NOT_SENT'], self._corr)
+        return list(messages)
+
+    def get_unsent_messages_for_saving(self):
+        """
+        :return list of unsent messages for saving
+        """
+        messages = filter(lambda m: m.type in (MESSAGE_TYPE['TEXT'], MESSAGE_TYPE['ACTION'])
+                                    and m.author.type == MESSAGE_AUTHOR['NOT_SENT'], self._corr)
+        return list(messages)
+
+    def mark_as_sent(self, tox_message_id):
+        try:
+            message = list(filter(lambda m: m.author is not None and m.author.type == MESSAGE_AUTHOR['NOT_SENT']
+                                            and m.tox_message_id == tox_message_id, 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, message_id):
+        elem = list(filter(lambda m: m.message_id == message_id, self._corr))[0]
+        tmp = list(filter(lambda m: m.type in (MESSAGE_TYPE['TEXT'], MESSAGE_TYPE['ACTION']), 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(m):
+            if m.type == MESSAGE_TYPE['FILE_TRANSFER'] and (m.state not in ACTIVE_FILE_TRANSFERS):
+                return True
+            return m.author is not None and m.author.type == MESSAGE_AUTHOR['NOT_SENT']
+
+        old = filter(save_message, self._corr[:-SAVE_MESSAGES])
+        self._corr = list(old) + self._corr[-SAVE_MESSAGES:]
+        text_messages = filter(lambda m: m.type in (MESSAGE_TYPE['TEXT'], MESSAGE_TYPE['ACTION']), 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 m: m.type == MESSAGE_TYPE['FILE_TRANSFER'] and
+                                               m.state in ft.ACTIVE_FILE_TRANSFERS, self._corr))
+            self._unsaved_messages = 0
+        else:
+            self._corr = list(filter(lambda m: (m.type == MESSAGE_TYPE['FILE_TRANSFER']
+                                                and m.state in ft.ACTIVE_FILE_TRANSFERS)
+                                               or (m.type in (MESSAGE_TYPE['TEXT'], MESSAGE_TYPE['ACTION'])
+                                                   and m.author.type == MESSAGE_AUTHOR['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].type not in (MESSAGE_TYPE['TEXT'], MESSAGE_TYPE['ACTION']):
+                    continue
+                message = self._corr[i].text
+                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].type not in (MESSAGE_TYPE['TEXT'], MESSAGE_TYPE['ACTION']):
+                continue
+            message = self._corr[i].text
+            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):
+        """
+        Set new name or ignore if alias exists
+        :param value: new name
+        """
+        if not self._alias:
+            super().set_name(value)
+
+    def set_alias(self, alias):
+        self._alias = bool(alias)
+
+    def has_alias(self):
+        return self._alias
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Visibility in friends' list
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def get_visibility(self):
+        return self._visible
+
+    def set_visibility(self, value):
+        self._visible = value
+
+    visibility = property(get_visibility, set_visibility)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Unread messages 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 or group'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)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Typing notifications
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def get_typing_notification_handler(self):
+        return common.BaseTypingNotificationHandler.DEFAULT_HANDLER
+
+    typing_notification_handler = property(get_typing_notification_handler)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Context menu support
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def get_context_menu_generator(self):
+        return BaseContactMenuGenerator(self)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Filtration support
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def set_widget(self, widget):
+        self._widget = widget
+        self.init_widget()

toxygen/contacts/contact_menu.py

@@ -0,0 +1,229 @@
+from PyQt5 import QtWidgets
+import utils.ui as util_ui
+
+
+# -----------------------------------------------------------------------------------------------------------------
+# Builder
+# -----------------------------------------------------------------------------------------------------------------
+
+def _create_menu(menu_name, parent):
+    menu_name = menu_name or ''
+
+    return QtWidgets.QMenu(menu_name) if parent is None else parent.addMenu(menu_name)
+
+
+class ContactMenuBuilder:
+
+    def __init__(self):
+        self._actions = {}
+        self._submenus = {}
+        self._name = None
+        self._index = 0
+
+    def with_name(self, name):
+        self._name = name
+
+        return self
+
+    def with_action(self, text, handler):
+        self._add_action(text, handler)
+
+        return self
+
+    def with_optional_action(self, text, handler, show_action):
+        if show_action:
+            self._add_action(text, handler)
+
+        return self
+
+    def with_actions(self, actions):
+        for action in actions:
+            (text, handler) = action
+            self._add_action(text, handler)
+
+        return self
+
+    def with_submenu(self, submenu_builder):
+        self._add_submenu(submenu_builder)
+
+        return self
+
+    def with_optional_submenu(self, submenu_builder):
+        if submenu_builder is not None:
+            self._add_submenu(submenu_builder)
+
+        return self
+
+    def build(self, parent=None):
+        menu = _create_menu(self._name, parent)
+
+        for i in range(self._index):
+            if i in self._actions:
+                text, handler = self._actions[i]
+                action = menu.addAction(text)
+                action.triggered.connect(handler)
+            else:
+                submenu_builder = self._submenus[i]
+                submenu = submenu_builder.build(menu)
+                menu.addMenu(submenu)
+
+        return menu
+
+    def _add_submenu(self, submenu):
+        self._submenus[self._index] = submenu
+        self._index += 1
+
+    def _add_action(self, text, handler):
+        self._actions[self._index] = (text, handler)
+        self._index += 1
+
+# -----------------------------------------------------------------------------------------------------------------
+# Generators
+# -----------------------------------------------------------------------------------------------------------------
+
+
+class BaseContactMenuGenerator:
+
+    def __init__(self, contact):
+        self._contact = contact
+
+    def generate(self, plugin_loader, contacts_manager, main_screen, settings, number, groups_service, history_loader):
+        return ContactMenuBuilder().build()
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Private methods
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def _generate_copy_menu_builder(self, main_screen):
+        copy_menu_builder = ContactMenuBuilder()
+        (copy_menu_builder
+         .with_name(util_ui.tr('Copy'))
+         .with_action(util_ui.tr('Name'), lambda: main_screen.copy_text(self._contact.name))
+         .with_action(util_ui.tr('Status message'), lambda: main_screen.copy_text(self._contact.status_message))
+         .with_action(util_ui.tr('Public key'), lambda: main_screen.copy_text(self._contact.tox_id))
+         )
+
+        return copy_menu_builder
+
+    def _generate_history_menu_builder(self, history_loader, main_screen):
+        history_menu_builder = ContactMenuBuilder()
+        (history_menu_builder
+         .with_name(util_ui.tr('Chat history'))
+         .with_action(util_ui.tr('Clear history'), lambda: history_loader.clear_history(self._contact)
+                                                           or main_screen.messages.clear())
+         .with_action(util_ui.tr('Export as text'), lambda: history_loader.export_history(self._contact))
+         .with_action(util_ui.tr('Export as HTML'), lambda: history_loader.export_history(self._contact, False))
+         )
+
+        return history_menu_builder
+
+
+class FriendMenuGenerator(BaseContactMenuGenerator):
+
+    def generate(self, plugin_loader, contacts_manager, main_screen, settings, number, groups_service, history_loader):
+        history_menu_builder = self._generate_history_menu_builder(history_loader, main_screen)
+        copy_menu_builder = self._generate_copy_menu_builder(main_screen)
+        plugins_menu_builder = self._generate_plugins_menu_builder(plugin_loader, number)
+        groups_menu_builder = self._generate_groups_menu(contacts_manager, groups_service)
+
+        allowed = self._contact.tox_id in settings['auto_accept_from_friends']
+        auto = util_ui.tr('Disallow auto accept') if allowed else util_ui.tr('Allow auto accept')
+
+        builder = ContactMenuBuilder()
+        menu = (builder
+                .with_action(util_ui.tr('Set alias'), lambda: main_screen.set_alias(number))
+                .with_submenu(history_menu_builder)
+                .with_submenu(copy_menu_builder)
+                .with_action(auto, lambda: main_screen.auto_accept(number, not allowed))
+                .with_action(util_ui.tr('Remove friend'), lambda: main_screen.remove_friend(number))
+                .with_action(util_ui.tr('Block friend'), lambda: main_screen.block_friend(number))
+                .with_action(util_ui.tr('Notes'), lambda: main_screen.show_note(self._contact))
+                .with_optional_submenu(plugins_menu_builder)
+                .with_optional_submenu(groups_menu_builder)
+                ).build()
+
+        return menu
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Private methods
+    # -----------------------------------------------------------------------------------------------------------------
+
+    @staticmethod
+    def _generate_plugins_menu_builder(plugin_loader, number):
+        if plugin_loader is None:
+            return None
+        plugins_actions = plugin_loader.get_menu(number)
+        if not len(plugins_actions):
+            return None
+        plugins_menu_builder = ContactMenuBuilder()
+        (plugins_menu_builder
+         .with_name(util_ui.tr('Plugins'))
+         .with_actions(plugins_actions)
+         )
+
+        return plugins_menu_builder
+
+    def _generate_groups_menu(self, contacts_manager, groups_service):
+        chats = contacts_manager.get_group_chats()
+        if not len(chats) or self._contact.status is None:
+            return None
+        groups_menu_builder = ContactMenuBuilder()
+        (groups_menu_builder
+         .with_name(util_ui.tr('Invite to group'))
+         .with_actions([(g.name, lambda: groups_service.invite_friend(self._contact.number, g.number)) for g in chats])
+         )
+
+        return groups_menu_builder
+
+
+class GroupMenuGenerator(BaseContactMenuGenerator):
+
+    def generate(self, plugin_loader, contacts_manager, main_screen, settings, number, groups_service, history_loader):
+        copy_menu_builder = self._generate_copy_menu_builder(main_screen)
+        history_menu_builder = self._generate_history_menu_builder(history_loader, main_screen)
+
+        builder = ContactMenuBuilder()
+        menu = (builder
+                .with_action(util_ui.tr('Set alias'), lambda: main_screen.set_alias(number))
+                .with_submenu(copy_menu_builder)
+                .with_submenu(history_menu_builder)
+                .with_optional_action(util_ui.tr('Manage group'),
+                                      lambda: groups_service.show_group_management_screen(self._contact),
+                                      self._contact.is_self_founder())
+                .with_optional_action(util_ui.tr('Group settings'),
+                                      lambda: groups_service.show_group_settings_screen(self._contact),
+                                      not self._contact.is_self_founder())
+                .with_optional_action(util_ui.tr('Set topic'),
+                                      lambda: groups_service.set_group_topic(self._contact),
+                                      self._contact.is_self_moderator_or_founder())
+                .with_action(util_ui.tr('Bans list'),
+                             lambda: groups_service.show_bans_list(self._contact))
+                .with_action(util_ui.tr('Reconnect to group'),
+                             lambda: groups_service.reconnect_to_group(self._contact.number))
+                .with_optional_action(util_ui.tr('Disconnect from group'),
+                                      lambda: groups_service.disconnect_from_group(self._contact.number),
+                                      self._contact.status is not None)
+                .with_action(util_ui.tr('Leave group'), lambda: groups_service.leave_group(self._contact.number))
+                .with_action(util_ui.tr('Notes'), lambda: main_screen.show_note(self._contact))
+                ).build()
+
+        return menu
+
+
+class GroupPeerMenuGenerator(BaseContactMenuGenerator):
+
+    def generate(self, plugin_loader, contacts_manager, main_screen, settings, number, groups_service, history_loader):
+        copy_menu_builder = self._generate_copy_menu_builder(main_screen)
+        history_menu_builder = self._generate_history_menu_builder(history_loader, main_screen)
+
+        builder = ContactMenuBuilder()
+        menu = (builder
+                .with_action(util_ui.tr('Set alias'), lambda: main_screen.set_alias(number))
+                .with_submenu(copy_menu_builder)
+                .with_submenu(history_menu_builder)
+                .with_action(util_ui.tr('Quit chat'),
+                             lambda: contacts_manager.remove_group_peer(self._contact))
+                .with_action(util_ui.tr('Notes'), lambda: main_screen.show_note(self._contact))
+                ).build()
+
+        return menu

toxygen/contacts/contact_provider.py

@@ -0,0 +1,107 @@
+import common.tox_save as tox_save
+
+
+class ContactProvider(tox_save.ToxSave):
+
+    def __init__(self, tox, friend_factory, group_factory, group_peer_factory):
+        super().__init__(tox)
+        self._friend_factory = friend_factory
+        self._group_factory = group_factory
+        self._group_peer_factory = group_peer_factory
+        self._cache = {}  # key - contact's public key, value - contact instance
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Friends
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def get_friend_by_number(self, friend_number):
+        public_key = self._tox.friend_get_public_key(friend_number)
+
+        return self.get_friend_by_public_key(public_key)
+
+    def get_friend_by_public_key(self, public_key):
+        friend = self._get_contact_from_cache(public_key)
+        if friend is not None:
+            return friend
+        friend = self._friend_factory.create_friend_by_public_key(public_key)
+        self._add_to_cache(public_key, friend)
+
+        return friend
+
+    def get_all_friends(self):
+        friend_numbers = self._tox.self_get_friend_list()
+        friends = map(lambda n: self.get_friend_by_number(n), friend_numbers)
+
+        return list(friends)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Groups
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def get_all_groups(self):
+        group_numbers = range(self._tox.group_get_number_groups())
+        groups = map(lambda n: self.get_group_by_number(n), group_numbers)
+
+        return list(groups)
+
+    def get_group_by_number(self, group_number):
+        public_key = self._tox.group_get_chat_id(group_number)
+
+        return self.get_group_by_public_key(public_key)
+
+    def get_group_by_public_key(self, public_key):
+        group = self._get_contact_from_cache(public_key)
+        if group is not None:
+            return group
+        group = self._group_factory.create_group_by_public_key(public_key)
+        self._add_to_cache(public_key, group)
+
+        return group
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Group peers
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def get_all_group_peers(self):
+        return list()
+
+    def get_group_peer_by_id(self, group, peer_id):
+        peer = group.get_peer_by_id(peer_id)
+
+        return self._get_group_peer(group, peer)
+
+    def get_group_peer_by_public_key(self, group, public_key):
+        peer = group.get_peer_by_public_key(public_key)
+
+        return self._get_group_peer(group, peer)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # All contacts
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def get_all(self):
+        return self.get_all_friends() + self.get_all_groups() + self.get_all_group_peers()
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Caching
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def clear_cache(self):
+        self._cache.clear()
+
+    def remove_contact_from_cache(self, contact_public_key):
+        if contact_public_key in self._cache:
+            del self._cache[contact_public_key]
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Private methods
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def _get_contact_from_cache(self, public_key):
+        return self._cache[public_key] if public_key in self._cache else None
+
+    def _add_to_cache(self, public_key, contact):
+        self._cache[public_key] = contact
+
+    def _get_group_peer(self, group, peer):
+        return self._group_peer_factory.create_group_peer(group, peer)

toxygen/contacts/contacts_manager.py

@@ -0,0 +1,575 @@
+from contacts.friend import Friend
+from contacts.group_chat import GroupChat
+from messenger.messages import *
+from common.tox_save import ToxSave
+from contacts.group_peer_contact import GroupPeerContact
+
+
+class ContactsManager(ToxSave):
+    """
+    Represents contacts list.
+    """
+
+    def __init__(self, tox, settings, screen, profile_manager, contact_provider, history, tox_dns,
+                 messages_items_factory):
+        super().__init__(tox)
+        self._settings = settings
+        self._screen = screen
+        self._profile_manager = profile_manager
+        self._contact_provider = contact_provider
+        self._tox_dns = tox_dns
+        self._messages_items_factory = messages_items_factory
+        self._messages = screen.messages
+        self._contacts, self._active_contact = [], -1
+        self._active_contact_changed = Event()
+        self._sorting = settings['sorting']
+        self._filter_string = ''
+        screen.contacts_filter.setCurrentIndex(int(self._sorting))
+        self._history = history
+        self._load_contacts()
+
+    def get_contact(self, num):
+        if num < 0 or num >= len(self._contacts):
+            return None
+        return self._contacts[num]
+
+    def get_curr_contact(self):
+        return self._contacts[self._active_contact] if self._active_contact + 1 else None
+
+    def save_profile(self):
+        data = self._tox.get_savedata()
+        self._profile_manager.save_profile(data)
+
+    def is_friend_active(self, friend_number):
+        if not self.is_active_a_friend():
+            return False
+
+        return self.get_curr_contact().number == friend_number
+
+    def is_group_active(self, group_number):
+        if self.is_active_a_friend():
+            return False
+
+        return self.get_curr_contact().number == group_number
+
+    def is_contact_active(self, contact):
+        return self._contacts[self._active_contact].tox_id == contact.tox_id
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Reconnection support
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def reset_contacts_statuses(self):
+        for contact in self._contacts:
+            contact.status = None
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Work with active friend
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def get_active(self):
+        return self._active_contact
+
+    def set_active(self, value):
+        """
+        Change current active friend or update info
+        :param value: number of new active friend in friend's list
+        """
+        if value is None and self._active_contact == -1:  # nothing to update
+            return
+        if value == -1:  # all friends were deleted
+            self._screen.account_name.setText('')
+            self._screen.account_status.setText('')
+            self._screen.account_status.setToolTip('')
+            self._active_contact = -1
+            self._screen.account_avatar.setHidden(True)
+            self._messages.clear()
+            self._screen.messageEdit.clear()
+            return
+        try:
+            self._screen.typing.setVisible(False)
+            current_contact = self.get_curr_contact()
+            if current_contact is not None:
+                # TODO: send when needed
+                current_contact.typing_notification_handler.send(self._tox, False)
+                current_contact.remove_messages_widgets()  # TODO: if required
+                self._unsubscribe_from_events(current_contact)
+
+            if self._active_contact + 1 and self._active_contact != value:
+                try:
+                    current_contact.curr_text = self._screen.messageEdit.toPlainText()
+                except:
+                    pass
+            contact = self._contacts[value]
+            self._subscribe_to_events(contact)
+            contact.remove_invalid_unsent_files()
+            if self._active_contact != value:
+                self._screen.messageEdit.setPlainText(contact.curr_text)
+            self._active_contact = value
+            contact.reset_messages()
+            if not self._settings['save_history']:
+                contact.delete_old_messages()
+            self._messages.clear()
+            contact.load_corr()
+            corr = contact.get_corr()[-PAGE_SIZE:]
+            for message in corr:
+                if message.type == MESSAGE_TYPE['FILE_TRANSFER']:
+                    self._messages_items_factory.create_file_transfer_item(message)
+                elif message.type == MESSAGE_TYPE['INLINE']:
+                    self._messages_items_factory.create_inline_item(message)
+                else:
+                    self._messages_items_factory.create_message_item(message)
+            self._messages.scrollToBottom()
+            # if value in self._call:
+            #     self._screen.active_call()
+            # elif value in self._incoming_calls:
+            #     self._screen.incoming_call()
+            # else:
+            #     self._screen.call_finished()
+            self._set_current_contact_data(contact)
+            self._active_contact_changed(contact)
+        except Exception as ex:  # no friend found. ignore
+            util.log('Friend value: ' + str(value))
+            util.log('Error in set active: ' + str(ex))
+            raise
+
+    active_contact = property(get_active, set_active)
+
+    def get_active_contact_changed(self):
+        return self._active_contact_changed
+
+    active_contact_changed = property(get_active_contact_changed)
+
+    def update(self):
+        if self._active_contact + 1:
+            self.set_active(self._active_contact)
+
+    def is_active_a_friend(self):
+        return type(self.get_curr_contact()) is Friend
+
+    def is_active_a_group(self):
+        return type(self.get_curr_contact()) is GroupChat
+
+    def is_active_a_group_chat_peer(self):
+        return type(self.get_curr_contact()) is GroupPeerContact
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Filtration
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def filtration_and_sorting(self, sorting=0, filter_str=''):
+        """
+        Filtration of friends list
+        :param sorting: 0 - no sorting, 1 - online only, 2 - online first, 3 - by name,
+        4 - online and by name, 5 - online first and by name
+        :param filter_str: show contacts which name contains this substring
+        """
+        filter_str = filter_str.lower()
+        current_contact = self.get_curr_contact()
+
+        if sorting > 5 or sorting < 0:
+            sorting = 0
+
+        if sorting in (1, 2, 4, 5):  # online first
+            self._contacts = sorted(self._contacts, key=lambda x: int(x.status is not None), reverse=True)
+            sort_by_name = sorting in (4, 5)
+            # save results of previous sorting
+            online_friends = filter(lambda x: x.status is not None, self._contacts)
+            online_friends_count = len(list(online_friends))
+            part1 = self._contacts[:online_friends_count]
+            part2 = self._contacts[online_friends_count:]
+            key_lambda = lambda x: x.name.lower() if sort_by_name else x.number
+            part1 = sorted(part1, key=key_lambda)
+            part2 = sorted(part2, key=key_lambda)
+            self._contacts = part1 + part2
+        elif sorting == 0:
+            contacts = sorted(self._contacts, key=lambda c: c.number)
+            friends = filter(lambda c: type(c) is Friend, contacts)
+            groups = filter(lambda c: type(c) is GroupChat, contacts)
+            group_peers = filter(lambda c: type(c) is GroupPeerContact, contacts)
+            self._contacts = list(friends) + list(groups) + list(group_peers)
+        else:
+            self._contacts = sorted(self._contacts, key=lambda x: x.name.lower())
+
+        # change item widgets
+        for index, contact in enumerate(self._contacts):
+            list_item = self._screen.friends_list.item(index)
+            item_widget = self._screen.friends_list.itemWidget(list_item)
+            contact.set_widget(item_widget)
+
+        for index, friend in enumerate(self._contacts):
+            filtered_by_name = filter_str in friend.name.lower()
+            friend.visibility = (friend.status is not None or sorting not in (1, 4)) and filtered_by_name
+            # show friend even if it's hidden when there any unread messages/actions
+            friend.visibility = friend.visibility or friend.messages or friend.actions
+            item = self._screen.friends_list.item(index)
+            item_widget = self._screen.friends_list.itemWidget(item)
+            item.setSizeHint(QtCore.QSize(250, item_widget.height() if friend.visibility else 0))
+
+        # save soring results
+        self._sorting, self._filter_string = sorting, filter_str
+        self._settings['sorting'] = self._sorting
+        self._settings.save()
+
+        # update active contact
+        if current_contact is not None:
+            index = self._contacts.index(current_contact)
+            self.set_active(index)
+
+    def update_filtration(self):
+        """
+        Update list of contacts when 1 of friends change connection status
+        """
+        self.filtration_and_sorting(self._sorting, self._filter_string)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Contact getters
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def get_friend_by_number(self, number):
+        return list(filter(lambda c: c.number == number and type(c) is Friend, self._contacts))[0]
+
+    def get_group_by_number(self, number):
+        return list(filter(lambda c: c.number == number and type(c) is GroupChat, self._contacts))[0]
+
+    def get_or_create_group_peer_contact(self, group_number, peer_id):
+        group = self.get_group_by_number(group_number)
+        peer = group.get_peer_by_id(peer_id)
+        if not self.check_if_contact_exists(peer.public_key):
+            self.add_group_peer(group, peer)
+
+        return self.get_contact_by_tox_id(peer.public_key)
+
+    def check_if_contact_exists(self, tox_id):
+        return any(filter(lambda c: c.tox_id == tox_id, self._contacts))
+
+    def get_contact_by_tox_id(self, tox_id):
+        return list(filter(lambda c: c.tox_id == tox_id, self._contacts))[0]
+
+    def get_active_number(self):
+        return self.get_curr_contact().number if self._active_contact + 1 else -1
+
+    def get_active_name(self):
+        return self.get_curr_contact().name if self._active_contact + 1 else ''
+
+    def is_active_online(self):
+        return self._active_contact + 1 and self.get_curr_contact().status is not None
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Work with friends (remove, block, set alias, get public key)
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def set_alias(self, num):
+        """
+        Set new alias for friend
+        """
+        friend = self._contacts[num]
+        name = friend.name
+        text = util_ui.tr("Enter new alias for friend {} or leave empty to use friend's name:").format(name)
+        title = util_ui.tr('Set alias')
+        text, ok = util_ui.text_dialog(text, title, name)
+        if not ok:
+            return
+        aliases = self._settings['friends_aliases']
+        if text:
+            friend.name = text
+            try:
+                index = list(map(lambda x: x[0], aliases)).index(friend.tox_id)
+                aliases[index] = (friend.tox_id, text)
+            except:
+                aliases.append((friend.tox_id, text))
+            friend.set_alias(text)
+        else:  # use default name
+            friend.name = self._tox.friend_get_name(friend.number)
+            friend.set_alias('')
+            try:
+                index = list(map(lambda x: x[0], aliases)).index(friend.tox_id)
+                del aliases[index]
+            except:
+                pass
+        self._settings.save()
+
+    def friend_public_key(self, num):
+        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._contacts[num]
+        self._cleanup_contact_data(friend)
+        self._tox.friend_delete(friend.number)
+        self._delete_contact(num)
+
+    def add_friend(self, tox_id):
+        """
+        Adds friend to list
+        """
+        self._tox.friend_add_norequest(tox_id)
+        self._add_friend(tox_id)
+        self.update_filtration()
+
+    def block_user(self, tox_id):
+        """
+        Block user with specified tox id (or public key) - delete from friends list and ignore friend requests
+        """
+        tox_id = tox_id[:TOX_PUBLIC_KEY_SIZE * 2]
+        if tox_id == self._tox.self_get_address[:TOX_PUBLIC_KEY_SIZE * 2]:
+            return
+        if tox_id not in self._settings['blocked']:
+            self._settings['blocked'].append(tox_id)
+            self._settings.save()
+        try:
+            num = self._tox.friend_by_public_key(tox_id)
+            self.delete_friend(num)
+            self.save_profile()
+        except:  # not in friend list
+            pass
+
+    def unblock_user(self, tox_id, add_to_friend_list):
+        """
+        Unblock user
+        :param tox_id: tox id of contact
+        :param add_to_friend_list: add this contact to friend list or not
+        """
+        self._settings['blocked'].remove(tox_id)
+        self._settings.save()
+        if add_to_friend_list:
+            self.add_friend(tox_id)
+            self.save_profile()
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Groups support
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def get_group_chats(self):
+        return list(filter(lambda c: type(c) is GroupChat, self._contacts))
+
+    def add_group(self, group_number):
+        group = self._contact_provider.get_group_by_number(group_number)
+        index = len(self._contacts)
+        self._contacts.append(group)
+        group.reset_avatar(self._settings['identicons'])
+        self._save_profile()
+        self.set_active(index)
+        self.update_filtration()
+
+    def delete_group(self, group_number):
+        group = self.get_group_by_number(group_number)
+        self._cleanup_contact_data(group)
+        num = self._contacts.index(group)
+        self._delete_contact(num)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Groups private messaging
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def add_group_peer(self, group, peer):
+        contact = self._contact_provider.get_group_peer_by_id(group, peer.id)
+        if self.check_if_contact_exists(contact.tox_id):
+            return
+        self._contacts.append(contact)
+        contact.reset_avatar(self._settings['identicons'])
+        self._save_profile()
+
+    def remove_group_peer_by_id(self, group, peer_id):
+        peer = group.get_peer_by_id(peer_id)
+        if not self.check_if_contact_exists(peer.public_key):
+            return
+        contact = self.get_contact_by_tox_id(peer.public_key)
+        self.remove_group_peer(contact)
+
+    def remove_group_peer(self, group_peer_contact):
+        contact = self.get_contact_by_tox_id(group_peer_contact.tox_id)
+        self._cleanup_contact_data(contact)
+        num = self._contacts.index(contact)
+        self._delete_contact(num)
+
+    def get_gc_peer_name(self, name):
+        group = self.get_curr_contact()
+
+        names = sorted(group.get_peers_names())
+        if name in names:  # return next nick
+            index = names.index(name)
+            index = (index + 1) % len(names)
+
+            return names[index]
+
+        suggested_names = list(filter(lambda x: x.startswith(name), names))
+        if not len(suggested_names):
+            return '\t'
+
+        return suggested_names[0]
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Friend requests
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def send_friend_request(self, tox_id, message):
+        """
+        Function tries to send request to contact with specified id
+        :param tox_id: id of new contact or tox dns 4 value
+        :param message: additional message
+        :return: True on success else error string
+        """
+        try:
+            message = message or 'Hello! Add me to your contact list please'
+            if '@' in tox_id:  # value like groupbot@toxme.io
+                tox_id = self._tox_dns.lookup(tox_id)
+                if tox_id is None:
+                    raise Exception('TOX DNS lookup failed')
+            if len(tox_id) == TOX_PUBLIC_KEY_SIZE * 2:  # public key
+                self.add_friend(tox_id)
+                title = util_ui.tr('Friend added')
+                text = util_ui.tr('Friend added without sending friend request')
+                util_ui.message_box(text, title)
+            else:
+                self._tox.friend_add(tox_id, message.encode('utf-8'))
+                tox_id = tox_id[:TOX_PUBLIC_KEY_SIZE * 2]
+                self._add_friend(tox_id)
+                self.update_filtration()
+            self.save_profile()
+            return True
+        except Exception as ex:  # wrong data
+            util.log('Friend request failed with ' + str(ex))
+            return str(ex)
+
+    def process_friend_request(self, tox_id, message):
+        """
+        Accept or ignore friend request
+        :param tox_id: tox id of contact
+        :param message: message
+        """
+        if tox_id in self._settings['blocked']:
+            return
+        try:
+            text = util_ui.tr('User {} wants to add you to contact list. Message:\n{}')
+            reply = util_ui.question(text.format(tox_id, message), util_ui.tr('Friend request'))
+            if reply:  # accepted
+                self.add_friend(tox_id)
+                data = self._tox.get_savedata()
+                self._profile_manager.save_profile(data)
+        except Exception as ex:  # something is wrong
+            util.log('Accept friend request failed! ' + str(ex))
+
+    def can_send_typing_notification(self):
+        return self._settings['typing_notifications'] and not self.is_active_a_group_chat_peer()
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Contacts numbers update
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def update_friends_numbers(self):
+        for friend in self._contact_provider.get_all_friends():
+            friend.number = self._tox.friend_by_public_key(friend.tox_id)
+        self.update_filtration()
+
+    def update_groups_numbers(self):
+        groups = self._contact_provider.get_all_groups()
+        for i in range(len(groups)):
+            chat_id = self._tox.group_get_chat_id(i)
+            group = self.get_contact_by_tox_id(chat_id)
+            group.number = i
+        self.update_filtration()
+
+    def update_groups_lists(self):
+        groups = self._contact_provider.get_all_groups()
+        for group in groups:
+            group.remove_all_peers_except_self()
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Private methods
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def _load_contacts(self):
+        self._load_friends()
+        self._load_groups()
+        if len(self._contacts):
+            self.set_active(0)
+        for contact in filter(lambda c: not c.has_avatar(), self._contacts):
+            contact.reset_avatar(self._settings['identicons'])
+        self.update_filtration()
+
+    def _load_friends(self):
+        self._contacts.extend(self._contact_provider.get_all_friends())
+
+    def _load_groups(self):
+        self._contacts.extend(self._contact_provider.get_all_groups())
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Current contact subscriptions
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def _subscribe_to_events(self, contact):
+        contact.name_changed_event.add_callback(self._current_contact_name_changed)
+        contact.status_changed_event.add_callback(self._current_contact_status_changed)
+        contact.status_message_changed_event.add_callback(self._current_contact_status_message_changed)
+        contact.avatar_changed_event.add_callback(self._current_contact_avatar_changed)
+
+    def _unsubscribe_from_events(self, contact):
+        contact.name_changed_event.remove_callback(self._current_contact_name_changed)
+        contact.status_changed_event.remove_callback(self._current_contact_status_changed)
+        contact.status_message_changed_event.remove_callback(self._current_contact_status_message_changed)
+        contact.avatar_changed_event.remove_callback(self._current_contact_avatar_changed)
+
+    def _current_contact_name_changed(self, name):
+        self._screen.account_name.setText(name)
+
+    def _current_contact_status_changed(self, status):
+        pass
+
+    def _current_contact_status_message_changed(self, status_message):
+        self._screen.account_status.setText(status_message)
+
+    def _current_contact_avatar_changed(self, avatar_path):
+        self._set_current_contact_avatar(avatar_path)
+
+    def _set_current_contact_data(self, contact):
+        self._screen.account_name.setText(contact.name)
+        self._screen.account_status.setText(contact.status_message)
+        self._set_current_contact_avatar(contact.get_avatar_path())
+
+    def _set_current_contact_avatar(self, avatar_path):
+        width = self._screen.account_avatar.width()
+        pixmap = QtGui.QPixmap(avatar_path)
+        self._screen.account_avatar.setPixmap(pixmap.scaled(width, width,
+                                                            QtCore.Qt.KeepAspectRatio, QtCore.Qt.SmoothTransformation))
+
+    def _add_friend(self, tox_id):
+        self._history.add_friend_to_db(tox_id)
+        friend = self._contact_provider.get_friend_by_public_key(tox_id)
+        index = len(self._contacts)
+        self._contacts.append(friend)
+        if not friend.has_avatar():
+            friend.reset_avatar(self._settings['identicons'])
+        self._save_profile()
+        self.set_active(index)
+
+    def _save_profile(self):
+        data = self._tox.get_savedata()
+        self._profile_manager.save_profile(data)
+
+    def _cleanup_contact_data(self, contact):
+        try:
+            index = list(map(lambda x: x[0], self._settings['friends_aliases'])).index(contact.tox_id)
+            del self._settings['friends_aliases'][index]
+        except:
+            pass
+        if contact.tox_id in self._settings['notes']:
+            del self._settings['notes'][contact.tox_id]
+        self._settings.save()
+        self._history.delete_history(contact)
+        if contact.has_avatar():
+            avatar_path = contact.get_contact_avatar_path()
+            remove(avatar_path)
+
+    def _delete_contact(self, num):
+        self.set_active(-1 if len(self._contacts) == 1 else 0)
+
+        self._contact_provider.remove_contact_from_cache(self._contacts[num].tox_id)
+        del self._contacts[num]
+        self._screen.friends_list.takeItem(num)
+        self._save_profile()
+
+        self.update_filtration()

toxygen/contacts/friend.py

@@ -0,0 +1,74 @@
+from contacts import contact, common
+from messenger.messages import *
+import os
+from contacts.contact_menu import *
+
+
+class Friend(contact.Contact):
+    """
+    Friend in list of friends.
+    """
+
+    def __init__(self, profile_manager, message_getter, number, name, status_message, widget, tox_id):
+        super().__init__(profile_manager, message_getter, number, name, status_message, widget, tox_id)
+        self._receipts = 0
+        self._typing_notification_handler = common.FriendTypingNotificationHandler(number)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # File transfers support
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def insert_inline(self, before_message_id, inline):
+        """
+        Update status of active transfer and load inline if needed
+        """
+        try:
+            tr = list(filter(lambda m: m.message_id == before_message_id, self._corr))[0]
+            i = self._corr.index(tr)
+            if inline:  # inline was loaded
+                self._corr.insert(i, inline)
+            return i - len(self._corr)
+        except:
+            pass
+
+    def get_unsent_files(self):
+        messages = filter(lambda m: type(m) is UnsentFileMessage, self._corr)
+        return list(messages)
+
+    def clear_unsent_files(self):
+        self._corr = list(filter(lambda m: type(m) is not UnsentFileMessage, self._corr))
+
+    def remove_invalid_unsent_files(self):
+        def is_valid(message):
+            if type(message) is not UnsentFileMessage:
+                return True
+            if message.data is not None:
+                return True
+            return os.path.exists(message.path)
+
+        self._corr = list(filter(is_valid, self._corr))
+
+    def delete_one_unsent_file(self, message_id):
+        self._corr = list(filter(lambda m: not (type(m) is UnsentFileMessage and m.message_id == message_id),
+                                 self._corr))
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Full status
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def get_full_status(self):
+        return self._status_message
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Typing notifications
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def get_typing_notification_handler(self):
+        return self._typing_notification_handler
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Context menu support
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def get_context_menu_generator(self):
+        return FriendMenuGenerator(self)

toxygen/contacts/friend_factory.py

@@ -0,0 +1,44 @@
+from contacts.friend import Friend
+from common.tox_save import ToxSave
+
+
+class FriendFactory(ToxSave):
+
+    def __init__(self, profile_manager, settings, tox, db, items_factory):
+        super().__init__(tox)
+        self._profile_manager = profile_manager
+        self._settings = settings
+        self._db = db
+        self._items_factory = items_factory
+
+    def create_friend_by_public_key(self, public_key):
+        friend_number = self._tox.friend_by_public_key(public_key)
+
+        return self.create_friend_by_number(friend_number)
+
+    def create_friend_by_number(self, friend_number):
+        aliases = self._settings['friends_aliases']
+        tox_id = self._tox.friend_get_public_key(friend_number)
+        try:
+            alias = list(filter(lambda x: x[0] == tox_id, aliases))[0][1]
+        except:
+            alias = ''
+        item = self._create_friend_item()
+        name = alias or self._tox.friend_get_name(friend_number) or tox_id
+        status_message = self._tox.friend_get_status_message(friend_number)
+        message_getter = self._db.messages_getter(tox_id)
+        friend = Friend(self._profile_manager, message_getter, friend_number, name, status_message, item, tox_id)
+        friend.set_alias(alias)
+
+        return friend
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Private methods
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def _create_friend_item(self):
+        """
+        Method-factory
+        :return: new widget for friend instance
+        """
+        return self._items_factory.create_contact_item()

toxygen/contacts/group_chat.py

@@ -0,0 +1,137 @@
+from contacts import contact
+from contacts.contact_menu import GroupMenuGenerator
+import utils.util as util
+from groups.group_peer import GroupChatPeer
+from wrapper import toxcore_enums_and_consts as constants
+from common.tox_save import ToxSave
+from groups.group_ban import GroupBan
+
+
+class GroupChat(contact.Contact, ToxSave):
+
+    def __init__(self, tox, profile_manager, message_getter, number, name, status_message, widget, tox_id, is_private):
+        super().__init__(profile_manager, message_getter, number, name, status_message, widget, tox_id)
+        ToxSave.__init__(self, tox)
+
+        self._is_private = is_private
+        self._password = str()
+        self._peers_limit = 512
+        self._peers = []
+        self._add_self_to_gc()
+
+    def remove_invalid_unsent_files(self):
+        pass
+
+    def get_context_menu_generator(self):
+        return GroupMenuGenerator(self)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Properties
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def get_is_private(self):
+        return self._is_private
+
+    def set_is_private(self, is_private):
+        self._is_private = is_private
+
+    is_private = property(get_is_private, set_is_private)
+
+    def get_password(self):
+        return self._password
+
+    def set_password(self, password):
+        self._password = password
+
+    password = property(get_password, set_password)
+
+    def get_peers_limit(self):
+        return self._peers_limit
+
+    def set_peers_limit(self, peers_limit):
+        self._peers_limit = peers_limit
+
+    peers_limit = property(get_peers_limit, set_peers_limit)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Peers methods
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def get_self_peer(self):
+        return self._peers[0]
+
+    def get_self_name(self):
+        return self._peers[0].name
+
+    def get_self_role(self):
+        return self._peers[0].role
+
+    def is_self_moderator_or_founder(self):
+        return self.get_self_role() <= constants.TOX_GROUP_ROLE['MODERATOR']
+
+    def is_self_founder(self):
+        return self.get_self_role() == constants.TOX_GROUP_ROLE['FOUNDER']
+
+    def add_peer(self, peer_id, is_current_user=False):
+        peer = GroupChatPeer(peer_id,
+                             self._tox.group_peer_get_name(self._number, peer_id),
+                             self._tox.group_peer_get_status(self._number, peer_id),
+                             self._tox.group_peer_get_role(self._number, peer_id),
+                             self._tox.group_peer_get_public_key(self._number, peer_id),
+                             is_current_user)
+        self._peers.append(peer)
+
+    def remove_peer(self, peer_id):
+        if peer_id == self.get_self_peer().id:  # we were kicked or banned
+            self.remove_all_peers_except_self()
+        else:
+            peer = self.get_peer_by_id(peer_id)
+            self._peers.remove(peer)
+
+    def get_peer_by_id(self, peer_id):
+        peers = list(filter(lambda p: p.id == peer_id, self._peers))
+
+        return peers[0]
+
+    def get_peer_by_public_key(self, public_key):
+        peers = list(filter(lambda p: p.public_key == public_key, self._peers))
+
+        return peers[0]
+
+    def remove_all_peers_except_self(self):
+        self._peers = self._peers[:1]
+
+    def get_peers_names(self):
+        peers_names = map(lambda p: p.name, self._peers)
+
+        return list(peers_names)
+
+    def get_peers(self):
+        return self._peers[:]
+
+    peers = property(get_peers)
+
+    def get_bans(self):
+        ban_ids = self._tox.group_ban_get_list(self._number)
+        bans = []
+        for ban_id in ban_ids:
+            ban = GroupBan(ban_id,
+                           self._tox.group_ban_get_target(self._number, ban_id),
+                           self._tox.group_ban_get_time_set(self._number, ban_id))
+            bans.append(ban)
+
+        return bans
+
+    bans = property(get_bans)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Private methods
+    # -----------------------------------------------------------------------------------------------------------------
+
+    @staticmethod
+    def _get_default_avatar_path():
+        return util.join_path(util.get_images_directory(), 'group.png')
+
+    def _add_self_to_gc(self):
+        peer_id = self._tox.group_self_get_peer_id(self._number)
+        self.add_peer(peer_id, True)

toxygen/contacts/group_factory.py

@@ -0,0 +1,53 @@
+from contacts.group_chat import GroupChat
+from common.tox_save import ToxSave
+import wrapper.toxcore_enums_and_consts as constants
+
+
+class GroupFactory(ToxSave):
+
+    def __init__(self, profile_manager, settings, tox, db, items_factory):
+        super().__init__(tox)
+        self._profile_manager = profile_manager
+        self._settings = settings
+        self._db = db
+        self._items_factory = items_factory
+
+    def create_group_by_public_key(self, public_key):
+        group_number = self._get_group_number_by_chat_id(public_key)
+
+        return self.create_group_by_number(group_number)
+
+    def create_group_by_number(self, group_number):
+        aliases = self._settings['friends_aliases']
+        tox_id = self._tox.group_get_chat_id(group_number)
+        try:
+            alias = list(filter(lambda x: x[0] == tox_id, aliases))[0][1]
+        except:
+            alias = ''
+        item = self._create_group_item()
+        name = alias or self._tox.group_get_name(group_number) or tox_id
+        status_message = self._tox.group_get_topic(group_number)
+        message_getter = self._db.messages_getter(tox_id)
+        is_private = self._tox.group_get_privacy_state(group_number) == constants.TOX_GROUP_PRIVACY_STATE['PRIVATE']
+        group = GroupChat(self._tox, self._profile_manager, message_getter, group_number, name, status_message,
+                          item, tox_id, is_private)
+        group.set_alias(alias)
+
+        return group
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Private methods
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def _create_group_item(self):
+        """
+        Method-factory
+        :return: new widget for group instance
+        """
+        return self._items_factory.create_contact_item()
+
+    def _get_group_number_by_chat_id(self, chat_id):
+        for i in range(self._tox.group_get_number_groups()):
+            if self._tox.group_get_chat_id(i) == chat_id:
+                return i
+        return -1

toxygen/contacts/group_peer_contact.py

@@ -0,0 +1,20 @@
+import contacts.contact
+from contacts.contact_menu import GroupPeerMenuGenerator
+
+
+class GroupPeerContact(contacts.contact.Contact):
+
+    def __init__(self, profile_manager, message_getter, peer_number, name, widget, tox_id, group_pk):
+        super().__init__(profile_manager, message_getter, peer_number, name, str(), widget, tox_id)
+        self._group_pk = group_pk
+
+    def get_group_pk(self):
+        return self._group_pk
+
+    group_pk = property(get_group_pk)
+
+    def remove_invalid_unsent_files(self):
+        pass
+
+    def get_context_menu_generator(self):
+        return GroupPeerMenuGenerator(self)

toxygen/contacts/group_peer_factory.py

@@ -0,0 +1,23 @@
+from common.tox_save import ToxSave
+from contacts.group_peer_contact import GroupPeerContact
+
+
+class GroupPeerFactory(ToxSave):
+
+    def __init__(self, tox, profile_manager, db, items_factory):
+        super().__init__(tox)
+        self._profile_manager = profile_manager
+        self._db = db
+        self._items_factory = items_factory
+
+    def create_group_peer(self, group, peer):
+        item = self._create_group_peer_item()
+        message_getter = self._db.messages_getter(peer.public_key)
+        group_peer_contact = GroupPeerContact(self._profile_manager, message_getter, peer.id, peer.name,
+                                              item, peer.public_key, group.tox_id)
+        group_peer_contact.status = peer.status
+
+        return group_peer_contact
+
+    def _create_group_peer_item(self):
+        return self._items_factory.create_contact_item()

toxygen/contacts/profile.py

@@ -0,0 +1,87 @@
+from contacts import basecontact
+import random
+import threading
+import common.tox_save as tox_save
+from middleware.threads import invoke_in_main_thread
+
+
+class Profile(basecontact.BaseContact, tox_save.ToxSave):
+    """
+    Profile of current toxygen user.
+    """
+    def __init__(self, profile_manager, tox, screen, contacts_provider, reset_action):
+        """
+        :param tox: tox instance
+        :param screen: ref to main screen
+        """
+        basecontact.BaseContact.__init__(self,
+                                         profile_manager,
+                                         tox.self_get_name(),
+                                         tox.self_get_status_message(),
+                                         screen,
+                                         tox.self_get_address())
+        tox_save.ToxSave.__init__(self, tox)
+        self._screen = screen
+        self._messages = screen.messages
+        self._contacts_provider = contacts_provider
+        self._reset_action = reset_action
+        self._waiting_for_reconnection = False
+        self._timer = None
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Edit current user's data
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def change_status(self):
+        """
+        Changes status of user (online, away, busy)
+        """
+        if self._status is not None:
+            self.set_status((self._status + 1) % 3)
+
+    def set_status(self, status):
+        super().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
+            self._timer = threading.Timer(50, self._reconnect)
+            self._timer.start()
+
+    def set_name(self, value):
+        if self.name == value:
+            return
+        super().set_name(value)
+        self._tox.self_set_name(self._name)
+
+    def set_status_message(self, value):
+        super().set_status_message(value)
+        self._tox.self_set_status_message(self._status_message)
+
+    def set_new_nospam(self):
+        """Sets new nospam part of tox id"""
+        self._tox.self_set_nospam(random.randint(0, 4294967295))  # no spam - uint32
+        self._tox_id = self._tox.self_get_address()
+
+        return self._tox_id
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Reset
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def restart(self):
+        """
+        Recreate tox instance
+        """
+        self.status = None
+        invoke_in_main_thread(self._reset_action)
+
+    def _reconnect(self):
+        self._waiting_for_reconnection = False
+        contacts = self._contacts_provider.get_all_friends()
+        all_friends_offline = all(list(map(lambda x: x.status is None, contacts)))
+        if self.status is None or (all_friends_offline and len(contacts)):
+            self._waiting_for_reconnection = True
+            self.restart()
+            self._timer = threading.Timer(50, self._reconnect)
+            self._timer.start()

toxygen/file_transfers/file_transfers.py

@@ -1,24 +1,21 @@
-from toxcore_enums_and_consts import TOX_FILE_KIND, TOX_FILE_CONTROL
+from wrapper.toxcore_enums_and_consts import TOX_FILE_KIND, TOX_FILE_CONTROL
 from os.path import basename, getsize, exists, dirname
 from os import remove, rename, chdir
-from time import time, sleep
+from time import time
-from tox import Tox
+from wrapper.tox import Tox
-import settings
+from common.event import Event
-try:
+from middleware.threads import invoke_in_main_thread
-    from PySide import QtCore
-except ImportError:
-    from PyQt4 import QtCore
-    QtCore.Signal = QtCore.pyqtSignal
 
 
-TOX_FILE_TRANSFER_STATE = {
+FILE_TRANSFER_STATE = {
     'RUNNING': 0,
     'PAUSED_BY_USER': 1,
     'CANCELLED': 2,
     'FINISHED': 3,
     'PAUSED_BY_FRIEND': 4,
     'INCOMING_NOT_STARTED': 5,
-    'OUTGOING_NOT_STARTED': 6
+    'OUTGOING_NOT_STARTED': 6,
+    'UNSENT': 7
 }
 
 ACTIVE_FILE_TRANSFERS = (0, 1, 4, 5, 6)
@@ -29,98 +26,106 @@ DO_NOT_SHOW_ACCEPT_BUTTON = (2, 3, 4, 6)
 
 SHOW_PROGRESS_BAR = (0, 1, 4)
 
-ALLOWED_FILES = ('toxygen_inline.png', 'utox-inline.png', 'sticker.png')
+
+def is_inline(file_name):
+    allowed_inlines = ('toxygen_inline.png', 'utox-inline.png', 'sticker.png')
+
+    return file_name in allowed_inlines or file_name.startswith('qTox_Image_')
 
 
-class StateSignal(QtCore.QObject):
+class FileTransfer:
-
-    signal = QtCore.Signal(int, float, int)  # state, progress, time in sec
-
-
-class TransferFinishedSignal(QtCore.QObject):
-
-    signal = QtCore.Signal(int, int)  # friend number, file number
-
-
-class FileTransfer(QtCore.QObject):
     """
     Superclass for file transfers
     """
 
     def __init__(self, path, tox, friend_number, size, file_number=None):
-        QtCore.QObject.__init__(self)
         self._path = path
         self._tox = tox
         self._friend_number = friend_number
-        self.state = TOX_FILE_TRANSFER_STATE['RUNNING']
+        self._state = FILE_TRANSFER_STATE['RUNNING']
         self._file_number = file_number
         self._creation_time = None
         self._size = float(size)
         self._done = 0
-        self._state_changed = StateSignal()
+        self._state_changed_event = Event()
-        self._finished = TransferFinishedSignal()
+        self._finished_event = Event()
-        self._file_id = None
+        self._file_id = self._file = None
-
-    def set_tox(self, tox):
-        self._tox = tox
 
     def set_state_changed_handler(self, handler):
-        self._state_changed.signal.connect(handler)
+        self._state_changed_event += lambda *args: invoke_in_main_thread(handler, *args)
 
     def set_transfer_finished_handler(self, handler):
-        self._finished.signal.connect(handler)
+        self._finished_event += lambda *args: invoke_in_main_thread(handler, *args)
-
-    def signal(self):
-        percentage = self._done / self._size if self._size else 0
-        if self._creation_time is None or not percentage:
-            t = -1
-        else:
-            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
 
+    file_number = property(get_file_number)
+
+    def get_state(self):
+        return self._state
+
+    def set_state(self, value):
+        self._state = value
+        self._signal()
+
+    state = property(get_state, set_state)
+
     def get_friend_number(self):
         return self._friend_number
 
-    def get_id(self):
+    friend_number = property(get_friend_number)
+
+    def get_file_id(self):
         return self._file_id
 
+    file_id = property(get_file_id)
+
     def get_path(self):
         return self._path
 
+    path = property(get_path)
+
+    def get_size(self):
+        return self._size
+
+    size = property(get_size)
+
     def cancel(self):
         self.send_control(TOX_FILE_CONTROL['CANCEL'])
-        if hasattr(self, '_file'):
+        if self._file is not None:
             self._file.close()
-        self.signal()
+        self._signal()
 
     def cancelled(self):
-        if hasattr(self, '_file'):
+        if self._file is not None:
-            sleep(0.1)
             self._file.close()
-        self.state = TOX_FILE_TRANSFER_STATE['CANCELLED']
+        self.set_state(FILE_TRANSFER_STATE['CANCELLED'])
-        self.signal()
 
     def pause(self, by_friend):
         if not by_friend:
             self.send_control(TOX_FILE_CONTROL['PAUSE'])
         else:
-            self.state = TOX_FILE_TRANSFER_STATE['PAUSED_BY_FRIEND']
+            self.set_state(FILE_TRANSFER_STATE['PAUSED_BY_FRIEND'])
-        self.signal()
 
     def send_control(self, control):
         if self._tox.file_control(self._friend_number, self._file_number, control):
-            self.state = control
+            self.set_state(control)
-            self.signal()
 
     def get_file_id(self):
         return self._tox.file_get_file_id(self._friend_number, self._file_number)
 
+    def _signal(self):
+        percentage = self._done / self._size if self._size else 0
+        if self._creation_time is None or not percentage:
+            t = -1
+        else:
+            t = ((time() - self._creation_time) / percentage) * (1 - percentage)
+        self._state_changed_event(self.state, percentage, int(t))
+
+    def _finished(self):
+        self._finished_event(self._friend_number, self._file_number)
+
 # -----------------------------------------------------------------------------------------------------------------
 # Send file
 # -----------------------------------------------------------------------------------------------------------------
@@ -130,12 +135,14 @@ class SendTransfer(FileTransfer):
 
     def __init__(self, path, tox, friend_number, kind=TOX_FILE_KIND['DATA'], file_id=None):
         if path is not None:
-            self._file = open(path, 'rb')
+            fl = open(path, 'rb')
             size = getsize(path)
         else:
+            fl = None
             size = 0
-        super(SendTransfer, self).__init__(path, tox, friend_number, size)
+        super().__init__(path, tox, friend_number, size)
-        self.state = TOX_FILE_TRANSFER_STATE['OUTGOING_NOT_STARTED']
+        self._file = fl
+        self.state = 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()
@@ -153,12 +160,12 @@ 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'):
+            if self._file is not None:
                 self._file.close()
-            self.state = TOX_FILE_TRANSFER_STATE['FINISHED']
+            self.state = FILE_TRANSFER_STATE['FINISHED']
-            self.finished()
+            self._finished()
-        self.signal()
 
 
 class SendAvatar(SendTransfer):
@@ -168,11 +175,11 @@ class SendAvatar(SendTransfer):
 
     def __init__(self, path, tox, friend_number):
         if path is None:
-            hash = None
+            avatar_hash = None
         else:
             with open(path, 'rb') as fl:
-                hash = Tox.hash(fl.read())
+                avatar_hash = Tox.hash(fl.read())
-        super(SendAvatar, self).__init__(path, tox, friend_number, TOX_FILE_KIND['AVATAR'], hash)
+        super().__init__(path, tox, friend_number, TOX_FILE_KIND['AVATAR'], avatar_hash)
 
 
 class SendFromBuffer(FileTransfer):
@@ -181,8 +188,8 @@ class SendFromBuffer(FileTransfer):
     """
 
     def __init__(self, tox, friend_number, data, file_name):
-        super(SendFromBuffer, self).__init__(None, tox, friend_number, len(data))
+        super().__init__(None, tox, friend_number, len(data))
-        self.state = TOX_FILE_TRANSFER_STATE['OUTGOING_NOT_STARTED']
+        self.state = FILE_TRANSFER_STATE['OUTGOING_NOT_STARTED']
         self._data = data
         self._file_number = tox.file_send(friend_number, TOX_FILE_KIND['DATA'],
                                           len(data), None, bytes(file_name, 'utf-8'))
@@ -190,6 +197,8 @@ class SendFromBuffer(FileTransfer):
     def get_data(self):
         return self._data
 
+    data = property(get_data)
+
     def send_chunk(self, position, size):
         if self._creation_time is None:
             self._creation_time = time()
@@ -198,18 +207,18 @@ class SendFromBuffer(FileTransfer):
             self._tox.file_send_chunk(self._friend_number, self._file_number, position, data)
             self._done += size
         else:
-            self.state = TOX_FILE_TRANSFER_STATE['FINISHED']
+            self.state = FILE_TRANSFER_STATE['FINISHED']
-            self.finished()
+            self._finished()
-        self.signal()
+        self._signal()
 
 
 class SendFromFileBuffer(SendTransfer):
 
     def __init__(self, *args):
-        super(SendFromFileBuffer, self).__init__(*args)
+        super().__init__(*args)
 
     def send_chunk(self, position, size):
-        super(SendFromFileBuffer, self).send_chunk(position, size)
+        super().send_chunk(position, size)
         if not size:
             chdir(dirname(self._path))
             remove(self._path)
@@ -222,7 +231,7 @@ class SendFromFileBuffer(SendTransfer):
 class ReceiveTransfer(FileTransfer):
 
     def __init__(self, path, tox, friend_number, size, file_number, position=0):
-        super(ReceiveTransfer, self).__init__(path, tox, friend_number, size, file_number)
+        super().__init__(path, tox, friend_number, size, file_number)
         self._file = open(self._path, 'wb')
         self._file_size = position
         self._file.truncate(position)
@@ -231,11 +240,12 @@ class ReceiveTransfer(FileTransfer):
         self._done = position
 
     def cancel(self):
-        super(ReceiveTransfer, self).cancel()
+        super().cancel()
         remove(self._path)
 
     def total_size(self):
         self._missed.add(self._file_size)
+
         return min(self._missed)
 
     def write_chunk(self, position, data):
@@ -248,8 +258,8 @@ class ReceiveTransfer(FileTransfer):
             self._creation_time = time()
         if data is None:
             self._file.close()
-            self.state = TOX_FILE_TRANSFER_STATE['FINISHED']
+            self.state = FILE_TRANSFER_STATE['FINISHED']
-            self.finished()
+            self._finished()
         else:
             data = bytearray(data)
             if self._file_size < position:
@@ -264,7 +274,7 @@ class ReceiveTransfer(FileTransfer):
             if position + l > self._file_size:
                 self._file_size = position + l
             self._done += l
-        self.signal()
+        self._signal()
 
 
 class ReceiveToBuffer(FileTransfer):
@@ -273,19 +283,21 @@ class ReceiveToBuffer(FileTransfer):
     """
 
     def __init__(self, tox, friend_number, size, file_number):
-        super(ReceiveToBuffer, self).__init__(None, tox, friend_number, size, file_number)
+        super().__init__(None, tox, friend_number, size, file_number)
         self._data = bytes()
         self._data_size = 0
 
     def get_data(self):
         return self._data
 
+    data = property(get_data)
+
     def write_chunk(self, position, data):
         if self._creation_time is None:
             self._creation_time = time()
         if data is None:
-            self.state = TOX_FILE_TRANSFER_STATE['FINISHED']
+            self.state = FILE_TRANSFER_STATE['FINISHED']
-            self.finished()
+            self._finished()
         else:
             data = bytes(data)
             l = len(data)
@@ -295,7 +307,7 @@ class ReceiveToBuffer(FileTransfer):
             if position + l > self._data_size:
                 self._data_size = position + l
             self._done += l
-        self.signal()
+        self._signal()
 
 
 class ReceiveAvatar(ReceiveTransfer):
@@ -304,20 +316,17 @@ class ReceiveAvatar(ReceiveTransfer):
     """
     MAX_AVATAR_SIZE = 512 * 1024
 
-    def __init__(self, tox, friend_number, size, file_number):
+    def __init__(self, path, tox, friend_number, size, file_number):
-        path = settings.ProfileHelper.get_path() + 'avatars/{}.png'.format(tox.friend_get_public_key(friend_number))
+        full_path = path + '.tmp'
-        super(ReceiveAvatar, self).__init__(path + '.tmp', tox, friend_number, size, file_number)
+        super().__init__(full_path, tox, friend_number, size, file_number)
         if size > self.MAX_AVATAR_SIZE:
             self.send_control(TOX_FILE_CONTROL['CANCEL'])
             self._file.close()
-            remove(path + '.tmp')
+            remove(full_path)
         elif not size:
             self.send_control(TOX_FILE_CONTROL['CANCEL'])
             self._file.close()
-            if exists(path):
+            remove(full_path)
-                remove(path)
-            self._file.close()
-            remove(path + '.tmp')
         elif exists(path):
             hash = self.get_file_id()
             with open(path, 'rb') as fl:
@@ -326,17 +335,17 @@ class ReceiveAvatar(ReceiveTransfer):
             if hash == existing_hash:
                 self.send_control(TOX_FILE_CONTROL['CANCEL'])
                 self._file.close()
-                remove(path + '.tmp')
+                remove(full_path)
             else:
                 self.send_control(TOX_FILE_CONTROL['RESUME'])
         else:
             self.send_control(TOX_FILE_CONTROL['RESUME'])
 
     def write_chunk(self, position, data):
-        super(ReceiveAvatar, self).write_chunk(position, data)
+        if data is None:
-        if self.state:
             avatar_path = self._path[:-4]
             if exists(avatar_path):
                 chdir(dirname(avatar_path))
                 remove(avatar_path)
             rename(self._path, avatar_path)
+        super().write_chunk(position, data)

toxygen/file_transfers/file_transfers_handler.py

@@ -0,0 +1,304 @@
+from messenger.messages import *
+from ui.contact_items import *
+import utils.util as util
+from common.tox_save import ToxSave
+
+
+class FileTransfersHandler(ToxSave):
+
+    def __init__(self, tox, settings, contact_provider, file_transfers_message_service, profile):
+        super().__init__(tox)
+        self._settings = settings
+        self._contact_provider = contact_provider
+        self._file_transfers_message_service = file_transfers_message_service
+        self._file_transfers = {}
+        # key = (friend number, file number), value - transfer instance
+        self._paused_file_transfers = dict(settings['paused_file_transfers'])
+        # key - file id, value: [path, friend number, is incoming, start position]
+        self._insert_inline_before = {}
+        # key = (friend number, file number), value - message id
+
+        profile.avatar_changed_event.add_callback(self._send_avatar_to_contacts)
+        
+    def stop(self):
+        self._settings['paused_file_transfers'] = self._paused_file_transfers if self._settings['resend_files'] else {}
+        self._settings.save()
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # File transfers support
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def incoming_file_transfer(self, friend_number, file_number, size, file_name):
+        """
+        New transfer
+        :param friend_number: number of friend who sent file
+        :param file_number: file number
+        :param size: file size in bytes
+        :param file_name: file name without path
+        """
+        friend = self._get_friend_by_number(friend_number)
+        auto = self._settings['allow_auto_accept'] and friend.tox_id in self._settings['auto_accept_from_friends']
+        inline = is_inline(file_name) and self._settings['allow_inline']
+        file_id = self._tox.file_get_file_id(friend_number, file_number)
+        accepted = True
+        if file_id in self._paused_file_transfers:
+            (path, ft_friend_number, is_incoming, start_position) = self._paused_file_transfers[file_id]
+            pos = start_position if os.path.exists(path) 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._file_transfers_message_service.add_incoming_transfer_message(
+                friend, accepted, size, file_name, file_number)
+            self.accept_transfer(path, friend_number, file_number, size, False, pos)
+        elif inline and size < 1024 * 1024:
+            self._file_transfers_message_service.add_incoming_transfer_message(
+                friend, accepted, size, file_name, file_number)
+            self.accept_transfer('', friend_number, file_number, size, True)
+        elif auto:
+            path = self._settings['auto_accept_path'] or util.curr_directory()
+            self._file_transfers_message_service.add_incoming_transfer_message(
+                friend, accepted, size, file_name, file_number)
+            self.accept_transfer(path + '/' + file_name, friend_number, file_number, size)
+        else:
+            accepted = False
+            self._file_transfers_message_service.add_incoming_transfer_message(
+                friend, accepted, size, file_name, file_number)
+
+    def cancel_transfer(self, friend_number, file_number, already_cancelled=False):
+        """
+        Stop transfer
+        :param friend_number: number of friend
+        :param file_number: file number
+        :param already_cancelled: was cancelled by friend
+        """
+        if (friend_number, file_number) in self._file_transfers:
+            tr = self._file_transfers[(friend_number, file_number)]
+            if not already_cancelled:
+                tr.cancel()
+            else:
+                tr.cancelled()
+            if (friend_number, file_number) in self._file_transfers:
+                del tr
+                del self._file_transfers[(friend_number, file_number)]
+        elif not already_cancelled:
+            self._tox.file_control(friend_number, file_number, TOX_FILE_CONTROL['CANCEL'])
+
+    def cancel_not_started_transfer(self, friend_number, message_id):
+        self._get_friend_by_number(friend_number).delete_one_unsent_file(message_id)
+
+    def pause_transfer(self, friend_number, file_number, by_friend=False):
+        """
+        Pause transfer with specified data
+        """
+        tr = self._file_transfers[(friend_number, file_number)]
+        tr.pause(by_friend)
+
+    def resume_transfer(self, friend_number, file_number, by_friend=False):
+        """
+        Resume transfer with specified data
+        """
+        tr = self._file_transfers[(friend_number, file_number)]
+        if by_friend:
+            tr.state = FILE_TRANSFER_STATE['RUNNING']
+        else:
+            tr.send_control(TOX_FILE_CONTROL['RESUME'])
+
+    def accept_transfer(self, path, friend_number, file_number, size, inline=False, from_position=0):
+        """
+        :param path: path for saving
+        :param friend_number: friend number
+        :param file_number: file number
+        :param size: file size
+        :param inline: is inline image
+        :param from_position: position for start
+        """
+        path = self._generate_valid_path(path, from_position)
+        friend = self._get_friend_by_number(friend_number)
+        if not inline:
+            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)
+        message = friend.get_message(lambda m: m.type == MESSAGE_TYPE['FILE_TRANSFER']
+                                               and m.state in (FILE_TRANSFER_STATE['INCOMING_NOT_STARTED'],
+                                                               FILE_TRANSFER_STATE['RUNNING'])
+                                               and m.file_number == file_number)
+        rt.set_state_changed_handler(message.transfer_updated)
+        self._file_transfers[(friend_number, file_number)] = rt
+        rt.send_control(TOX_FILE_CONTROL['RESUME'])
+        if inline:
+            self._insert_inline_before[(friend_number, file_number)] = message.message_id
+
+    def send_screenshot(self, data, friend_number):
+        """
+        Send screenshot
+        :param data: raw data - png format
+        :param friend_number: friend number
+        """
+        self.send_inline(data, 'toxygen_inline.png', friend_number)
+
+    def send_sticker(self, path, friend_number):
+        with open(path, 'rb') as fl:
+            data = fl.read()
+        self.send_inline(data, 'sticker.png', friend_number)
+
+    def send_inline(self, data, file_name, friend_number, is_resend=False):
+        friend = self._get_friend_by_number(friend_number)
+        if friend.status is None and not is_resend:
+            self._file_transfers_message_service.add_unsent_file_message(friend, file_name, data)
+            return
+        elif friend.status is None and is_resend:
+            raise RuntimeError()
+        st = SendFromBuffer(self._tox, friend.number, data, file_name)
+        self._send_file_add_set_handlers(st, friend, file_name, True)
+
+    def send_file(self, path, friend_number, is_resend=False, file_id=None):
+        """
+        Send file to current active friend
+        :param path: file path
+        :param friend_number: friend_number
+        :param is_resend: is 'offline' message
+        :param file_id: file id of transfer
+        """
+        friend = self._get_friend_by_number(friend_number)
+        if friend.status is None and not is_resend:
+            self._file_transfers_message_service.add_unsent_file_message(friend, path, None)
+            return
+        elif friend.status is None and is_resend:
+            print('Error in sending')
+            return
+        st = SendTransfer(path, self._tox, friend_number, TOX_FILE_KIND['DATA'], file_id)
+        file_name = os.path.basename(path)
+        self._send_file_add_set_handlers(st, friend, file_name)
+
+    def incoming_chunk(self, friend_number, file_number, position, data):
+        """
+        Incoming chunk
+        """
+        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)
+
+    def transfer_finished(self, friend_number, file_number):
+        transfer = self._file_transfers[(friend_number, file_number)]
+        t = type(transfer)
+        if t is ReceiveAvatar:
+            self._get_friend_by_number(friend_number).load_avatar()
+        elif t is ReceiveToBuffer or (t is SendFromBuffer and self._settings['allow_inline']):  # inline image
+            print('inline')
+            inline = InlineImageMessage(transfer.data)
+            message_id = self._insert_inline_before[(friend_number, file_number)]
+            del self._insert_inline_before[(friend_number, file_number)]
+            index = self._get_friend_by_number(friend_number).insert_inline(message_id, inline)
+            self._file_transfers_message_service.add_inline_message(transfer, index)
+        del self._file_transfers[(friend_number, file_number)]
+
+    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:
+                data, path = fl.data, fl.path
+                if data is not None:
+                    self.send_inline(data, path, friend_number, True)
+                else:
+                    self.send_file(path, friend_number, True)
+            friend.clear_unsent_files()
+            for key in self._paused_file_transfers.keys():
+                (path, ft_friend_number, is_incoming, start_position) = self._paused_file_transfers[key]
+                if not os.path.exists(path):
+                    del self._paused_file_transfers[key]
+                elif ft_friend_number == friend_number and not is_incoming:
+                    self.send_file(path, friend_number, True, key)
+                    del self._paused_file_transfers[key]
+        except Exception as ex:
+            print('Exception in file sending: ' + str(ex))
+
+    def friend_exit(self, friend_number):
+        for friend_num, file_num in self._file_transfers.keys():
+            if friend_num != friend_number:
+                continue
+            ft = self._file_transfers[(friend_num, file_num)]
+            if type(ft) is SendTransfer:
+                self._paused_file_transfers[ft.file_id] = [ft.path, friend_num, False, -1]
+            elif type(ft) is ReceiveTransfer and ft.state != FILE_TRANSFER_STATE['INCOMING_NOT_STARTED']:
+                self._paused_file_transfers[ft.file_id] = [ft.path, friend_num, True, ft.total_size()]
+            self.cancel_transfer(friend_num, file_num, True)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Avatars support
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def send_avatar(self, friend_number, avatar_path=None):
+        """
+        :param friend_number: number of friend who should get new avatar
+        :param avatar_path: path to avatar or None if reset
+        """
+        sa = SendAvatar(avatar_path, self._tox, friend_number)
+        self._file_transfers[(friend_number, sa.file_number)] = sa
+
+    def incoming_avatar(self, friend_number, file_number, size):
+        """
+        Friend changed avatar
+        :param friend_number: friend number
+        :param file_number: file number
+        :param size: size of avatar or 0 (default avatar)
+        """
+        friend = self._get_friend_by_number(friend_number)
+        ra = ReceiveAvatar(friend.get_contact_avatar_path(), self._tox, friend_number, size, file_number)
+        if ra.state != FILE_TRANSFER_STATE['CANCELLED']:
+            self._file_transfers[(friend_number, file_number)] = ra
+            ra.set_transfer_finished_handler(self.transfer_finished)
+        elif not size:
+            friend.reset_avatar(self._settings['identicons'])
+
+    def _send_avatar_to_contacts(self, _):
+        friends = self._get_all_friends()
+        for friend in filter(self._is_friend_online, friends):
+            self.send_avatar(friend.number)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Private methods
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def _is_friend_online(self, friend_number):
+        friend = self._get_friend_by_number(friend_number)
+
+        return friend.status is not None
+
+    def _get_friend_by_number(self, friend_number):
+        return self._contact_provider.get_friend_by_number(friend_number)
+
+    def _get_all_friends(self):
+        return self._contact_provider.get_all_friends()
+
+    def _send_file_add_set_handlers(self, st, friend, file_name, inline=False):
+        st.set_transfer_finished_handler(self.transfer_finished)
+        file_number = st.get_file_number()
+        self._file_transfers[(friend.number, file_number)] = st
+        tm = self._file_transfers_message_service.add_outgoing_transfer_message(friend, st.size, file_name, file_number)
+        st.set_state_changed_handler(tm.transfer_updated)
+        if inline:
+            self._insert_inline_before[(friend.number, file_number)] = tm.message_id
+
+    @staticmethod
+    def _generate_valid_path(path, from_position):
+        path, file_name = os.path.split(path)
+        new_file_name, i = file_name, 1
+        if not from_position:
+            while os.path.isfile(join_path(path, new_file_name)):  # file with same name already exists
+                if '.' in file_name:  # has extension
+                    d = file_name.rindex('.')
+                else:  # no extension
+                    d = len(file_name)
+                new_file_name = file_name[:d] + ' ({})'.format(i) + file_name[d:]
+                i += 1
+        path = join_path(path, new_file_name)
+
+        return path

toxygen/file_transfers/file_transfers_messages_service.py

@@ -0,0 +1,78 @@
+from messenger.messenger import *
+import utils.util as util
+from file_transfers.file_transfers import *
+
+
+class FileTransfersMessagesService:
+
+    def __init__(self, contacts_manager, messages_items_factory, profile, main_screen):
+        self._contacts_manager = contacts_manager
+        self._messages_items_factory = messages_items_factory
+        self._profile = profile
+        self._messages = main_screen.messages
+
+    def add_incoming_transfer_message(self, friend, accepted, size, file_name, file_number):
+        author = MessageAuthor(friend.name, MESSAGE_AUTHOR['FRIEND'])
+        status = FILE_TRANSFER_STATE['RUNNING'] if accepted else FILE_TRANSFER_STATE['INCOMING_NOT_STARTED']
+        tm = TransferMessage(author, util.get_unix_time(), status, size, file_name, friend.number, file_number)
+
+        if self._is_friend_active(friend.number):
+            self._create_file_transfer_item(tm)
+            self._messages.scrollToBottom()
+        else:
+            friend.actions = True
+
+        friend.append_message(tm)
+
+        return tm
+
+    def add_outgoing_transfer_message(self, friend, size, file_name, file_number):
+        author = MessageAuthor(self._profile.name, MESSAGE_AUTHOR['ME'])
+        status = FILE_TRANSFER_STATE['OUTGOING_NOT_STARTED']
+        tm = TransferMessage(author, util.get_unix_time(), status, size, file_name, friend.number, file_number)
+
+        if self._is_friend_active(friend.number):
+            self._create_file_transfer_item(tm)
+            self._messages.scrollToBottom()
+
+        friend.append_message(tm)
+
+        return tm
+
+    def add_inline_message(self, transfer, index):
+        if not self._is_friend_active(transfer.friend_number):
+            return
+        count = self._messages.count()
+        if count + index + 1 >= 0:
+            self._create_inline_item(transfer.data, count + index + 1)
+
+    def add_unsent_file_message(self, friend, file_path, data):
+        author = MessageAuthor(self._profile.name, MESSAGE_AUTHOR['ME'])
+        size = os.path.getsize(file_path) if data is None else len(data)
+        tm = UnsentFileMessage(file_path, data, util.get_unix_time(), author, size, friend.number)
+        friend.append_message(tm)
+
+        if self._is_friend_active(friend.number):
+            self._create_unsent_file_item(tm)
+            self._messages.scrollToBottom()
+
+        return tm
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Private methods
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def _is_friend_active(self, friend_number):
+        if not self._contacts_manager.is_active_a_friend():
+            return False
+
+        return friend_number == self._contacts_manager.get_active_number()
+
+    def _create_file_transfer_item(self, tm):
+        return self._messages_items_factory.create_file_transfer_item(tm)
+
+    def _create_inline_item(self, data, position):
+        return self._messages_items_factory.create_inline_item(data, False, position)
+
+    def _create_unsent_file_item(self, tm):
+        return self._messages_items_factory.create_unsent_file_item(tm)

toxygen/friend.py

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

toxygen/groups/group_ban.py

@@ -0,0 +1,23 @@
+
+
+class GroupBan:
+
+    def __init__(self, ban_id, ban_target, ban_time):
+        self._ban_id = ban_id
+        self._ban_target = ban_target
+        self._ban_time = ban_time
+
+    def get_ban_id(self):
+        return self._ban_id
+
+    ban_id = property(get_ban_id)
+
+    def get_ban_target(self):
+        return self._ban_target
+
+    ban_target = property(get_ban_target)
+
+    def get_ban_time(self):
+        return self._ban_time
+
+    ban_time = property(get_ban_time)

toxygen/groups/group_invite.py

@@ -0,0 +1,23 @@
+
+
+class GroupInvite:
+
+    def __init__(self, friend_public_key, chat_name, invite_data):
+        self._friend_public_key = friend_public_key
+        self._chat_name = chat_name
+        self._invite_data = invite_data[:]
+
+    def get_friend_public_key(self):
+        return self._friend_public_key
+
+    friend_public_key = property(get_friend_public_key)
+
+    def get_chat_name(self):
+        return self._chat_name
+
+    chat_name = property(get_chat_name)
+
+    def get_invite_data(self):
+        return self._invite_data[:]
+
+    invite_data = property(get_invite_data)

toxygen/groups/group_peer.py

@@ -0,0 +1,70 @@
+
+
+class GroupChatPeer:
+    """
+    Represents peer in group chat.
+    """
+
+    def __init__(self, peer_id, name, status, role, public_key, is_current_user=False, is_muted=False):
+        self._peer_id = peer_id
+        self._name = name
+        self._status = status
+        self._role = role
+        self._public_key = public_key
+        self._is_current_user = is_current_user
+        self._is_muted = is_muted
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Readonly properties
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def get_id(self):
+        return self._peer_id
+
+    id = property(get_id)
+
+    def get_public_key(self):
+        return self._public_key
+
+    public_key = property(get_public_key)
+
+    def get_is_current_user(self):
+        return self._is_current_user
+
+    is_current_user = property(get_is_current_user)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Read-write properties
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def get_name(self):
+        return self._name
+
+    def set_name(self, name):
+        self._name = name
+
+    name = property(get_name, set_name)
+
+    def get_status(self):
+        return self._status
+
+    def set_status(self, status):
+        self._status = status
+
+    status = property(get_status, set_status)
+
+    def get_role(self):
+        return self._role
+
+    def set_role(self, role):
+        self._role = role
+
+    role = property(get_role, set_role)
+
+    def get_is_muted(self):
+        return self._is_muted
+
+    def set_is_muted(self, is_muted):
+        self._is_muted = is_muted
+
+    is_muted = property(get_is_muted, set_is_muted)

toxygen/groups/groups_service.py

@@ -0,0 +1,242 @@
+import common.tox_save as tox_save
+import utils.ui as util_ui
+from groups.peers_list import PeersListGenerator
+from groups.group_invite import GroupInvite
+import wrapper.toxcore_enums_and_consts as constants
+
+
+class GroupsService(tox_save.ToxSave):
+
+    def __init__(self, tox, contacts_manager, contacts_provider, main_screen, widgets_factory_provider):
+        super().__init__(tox)
+        self._contacts_manager = contacts_manager
+        self._contacts_provider = contacts_provider
+        self._main_screen = main_screen
+        self._peers_list_widget = main_screen.peers_list
+        self._widgets_factory_provider = widgets_factory_provider
+        self._group_invites = []
+        self._screen = None
+
+    def set_tox(self, tox):
+        super().set_tox(tox)
+        for group in self._get_all_groups():
+            group.set_tox(tox)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Groups creation
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def create_new_gc(self, name, privacy_state, nick, status):
+        group_number = self._tox.group_new(privacy_state, name, nick, status)
+        if group_number == -1:
+            return
+
+        self._add_new_group_by_number(group_number)
+        group = self._get_group_by_number(group_number)
+        group.status = constants.TOX_USER_STATUS['NONE']
+        self._contacts_manager.update_filtration()
+
+    def join_gc_by_id(self, chat_id, password, nick, status):
+        group_number = self._tox.group_join(chat_id, password, nick, status)
+        self._add_new_group_by_number(group_number)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Groups reconnect and leaving
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def leave_group(self, group_number):
+        self._tox.group_leave(group_number)
+        self._contacts_manager.delete_group(group_number)
+
+    def disconnect_from_group(self, group_number):
+        self._tox.group_disconnect(group_number)
+        group = self._get_group_by_number(group_number)
+        group.status = None
+        self._clear_peers_list(group)
+
+    def reconnect_to_group(self, group_number):
+        self._tox.group_reconnect(group_number)
+        group = self._get_group_by_number(group_number)
+        group.status = constants.TOX_USER_STATUS['NONE']
+        self._clear_peers_list(group)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Group invites
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def invite_friend(self, friend_number, group_number):
+        self._tox.group_invite_friend(group_number, friend_number)
+
+    def process_group_invite(self, friend_number, group_name, invite_data):
+        friend = self._get_friend_by_number(friend_number)
+        invite = GroupInvite(friend.tox_id, group_name, invite_data)
+        self._group_invites.append(invite)
+        self._update_invites_button_state()
+
+    def accept_group_invite(self, invite, name, status, password):
+        pk = invite.friend_public_key
+        friend = self._get_friend_by_public_key(pk)
+        self._join_gc_via_invite(invite.invite_data, friend.number, name, status, password)
+        self._delete_group_invite(invite)
+        self._update_invites_button_state()
+
+    def decline_group_invite(self, invite):
+        self._delete_group_invite(invite)
+        self._main_screen.update_gc_invites_button_state()
+
+    def get_group_invites(self):
+        return self._group_invites[:]
+
+    group_invites = property(get_group_invites)
+
+    def get_group_invites_count(self):
+        return len(self._group_invites)
+
+    group_invites_count = property(get_group_invites_count)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Group info methods
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def update_group_info(self, group):
+        group.name = self._tox.group_get_name(group.number)
+        group.status_message = self._tox.group_get_topic(group.number)
+
+    def set_group_topic(self, group):
+        if not group.is_self_moderator_or_founder():
+            return
+        text = util_ui.tr('New topic for group "{}":'.format(group.name))
+        title = util_ui.tr('Set group topic')
+        topic, ok = util_ui.text_dialog(text, title, group.status_message)
+        if not ok or not topic:
+            return
+        self._tox.group_set_topic(group.number, topic)
+        group.status_message = topic
+
+    def show_group_management_screen(self, group):
+        widgets_factory = self._get_widgets_factory()
+        self._screen = widgets_factory.create_group_management_screen(group)
+        self._screen.show()
+
+    def show_group_settings_screen(self, group):
+        widgets_factory = self._get_widgets_factory()
+        self._screen = widgets_factory.create_group_settings_screen(group)
+        self._screen.show()
+
+    def set_group_password(self, group, password):
+        if group.password == password:
+            return
+        self._tox.group_founder_set_password(group.number, password)
+        group.password = password
+
+    def set_group_peers_limit(self, group, peers_limit):
+        if group.peers_limit == peers_limit:
+            return
+        self._tox.group_founder_set_peer_limit(group.number, peers_limit)
+        group.peers_limit = peers_limit
+
+    def set_group_privacy_state(self, group, privacy_state):
+        is_private = privacy_state == constants.TOX_GROUP_PRIVACY_STATE['PRIVATE']
+        if group.is_private == is_private:
+            return
+        self._tox.group_founder_set_privacy_state(group.number, privacy_state)
+        group.is_private = is_private
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Peers list
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def generate_peers_list(self):
+        if not self._contacts_manager.is_active_a_group():
+            return
+        group = self._contacts_manager.get_curr_contact()
+        PeersListGenerator().generate(group.peers, self, self._peers_list_widget, group.tox_id)
+
+    def peer_selected(self, chat_id, peer_id):
+        widgets_factory = self._get_widgets_factory()
+        group = self._get_group_by_public_key(chat_id)
+        self_peer = group.get_self_peer()
+        if self_peer.id != peer_id:
+            self._screen = widgets_factory.create_peer_screen_window(group, peer_id)
+        else:
+            self._screen = widgets_factory.create_self_peer_screen_window(group)
+        self._screen.show()
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Peers actions
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def set_new_peer_role(self, group, peer, role):
+        self._tox.group_mod_set_role(group.number, peer.id, role)
+        peer.role = role
+        self.generate_peers_list()
+
+    def toggle_ignore_peer(self, group, peer, ignore):
+        self._tox.group_toggle_ignore(group.number, peer.id, ignore)
+        peer.is_muted = ignore
+
+    def set_self_info(self, group, name, status):
+        self._tox.group_self_set_name(group.number, name)
+        self._tox.group_self_set_status(group.number, status)
+        self_peer = group.get_self_peer()
+        self_peer.name = name
+        self_peer.status = status
+        self.generate_peers_list()
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Bans support
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def show_bans_list(self, group):
+        widgets_factory = self._get_widgets_factory()
+        self._screen = widgets_factory.create_groups_bans_screen(group)
+        self._screen.show()
+
+    def ban_peer(self, group, peer_id, ban_type):
+        self._tox.group_mod_ban_peer(group.number, peer_id, ban_type)
+
+    def kick_peer(self, group, peer_id):
+        self._tox.group_mod_remove_peer(group.number, peer_id)
+
+    def cancel_ban(self, group_number, ban_id):
+        self._tox.group_mod_remove_ban(group_number, ban_id)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Private methods
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def _add_new_group_by_number(self, group_number):
+        self._contacts_manager.add_group(group_number)
+
+    def _get_group_by_number(self, group_number):
+        return self._contacts_provider.get_group_by_number(group_number)
+
+    def _get_group_by_public_key(self, public_key):
+        return self._contacts_provider.get_group_by_public_key(public_key)
+
+    def _get_all_groups(self):
+        return self._contacts_provider.get_all_groups()
+
+    def _get_friend_by_number(self, friend_number):
+        return self._contacts_provider.get_friend_by_number(friend_number)
+
+    def _get_friend_by_public_key(self, public_key):
+        return self._contacts_provider.get_friend_by_public_key(public_key)
+
+    def _clear_peers_list(self, group):
+        group.remove_all_peers_except_self()
+        self.generate_peers_list()
+
+    def _delete_group_invite(self, invite):
+        if invite in self._group_invites:
+            self._group_invites.remove(invite)
+
+    def _join_gc_via_invite(self, invite_data, friend_number, nick, status, password):
+        group_number = self._tox.group_invite_accept(invite_data, friend_number, nick, status, password)
+        self._add_new_group_by_number(group_number)
+
+    def _update_invites_button_state(self):
+        self._main_screen.update_gc_invites_button_state()
+
+    def _get_widgets_factory(self):
+        return self._widgets_factory_provider.get_item()

toxygen/groups/peers_list.py

@@ -0,0 +1,104 @@
+from ui.group_peers_list import PeerItem, PeerTypeItem
+from wrapper.toxcore_enums_and_consts import *
+from ui.widgets import *
+
+
+# -----------------------------------------------------------------------------------------------------------------
+# Builder
+# -----------------------------------------------------------------------------------------------------------------
+
+
+class PeerListBuilder:
+
+    def __init__(self):
+        self._peers = {}
+        self._titles = {}
+        self._index = 0
+        self._handler = None
+
+    def with_click_handler(self, handler):
+        self._handler = handler
+
+        return self
+
+    def with_title(self, title):
+        self._titles[self._index] = title
+        self._index += 1
+
+        return self
+
+    def with_peers(self, peers):
+        for peer in peers:
+            self._add_peer(peer)
+
+        return self
+
+    def build(self, list_widget):
+        list_widget.clear()
+
+        for i in range(self._index):
+            if i in self._peers:
+                peer = self._peers[i]
+                self._add_peer_item(peer, list_widget)
+            else:
+                title = self._titles[i]
+                self._add_peer_type_item(title, list_widget)
+
+    def _add_peer_item(self, peer, parent):
+        item = PeerItem(peer, self._handler, parent.width(), parent)
+        self._add_item(parent, item)
+
+    def _add_peer_type_item(self, text, parent):
+        item = PeerTypeItem(text, parent.width(), parent)
+        self._add_item(parent, item)
+
+    @staticmethod
+    def _add_item(parent, item):
+        elem = QtWidgets.QListWidgetItem(parent)
+        elem.setSizeHint(QtCore.QSize(parent.width(), item.height()))
+        parent.addItem(elem)
+        parent.setItemWidget(elem, item)
+
+    def _add_peer(self, peer):
+        self._peers[self._index] = peer
+        self._index += 1
+
+# -----------------------------------------------------------------------------------------------------------------
+# Generators
+# -----------------------------------------------------------------------------------------------------------------
+
+
+class PeersListGenerator:
+
+    @staticmethod
+    def generate(peers_list, groups_service, list_widget, chat_id):
+        admin_title = util_ui.tr('Administrator')
+        moderators_title = util_ui.tr('Moderators')
+        users_title = util_ui.tr('Users')
+        observers_title = util_ui.tr('Observers')
+
+        admins = list(filter(lambda p: p.role == TOX_GROUP_ROLE['FOUNDER'], peers_list))
+        moderators = list(filter(lambda p: p.role == TOX_GROUP_ROLE['MODERATOR'], peers_list))
+        users = list(filter(lambda p: p.role == TOX_GROUP_ROLE['USER'], peers_list))
+        observers = list(filter(lambda p: p.role == TOX_GROUP_ROLE['OBSERVER'], peers_list))
+
+        builder = (PeerListBuilder()
+                   .with_click_handler(lambda peer_id: groups_service.peer_selected(chat_id, peer_id)))
+        if len(admins):
+            (builder
+             .with_title(admin_title)
+             .with_peers(admins))
+        if len(moderators):
+            (builder
+             .with_title(moderators_title)
+             .with_peers(moderators))
+        if len(users):
+            (builder
+             .with_title(users_title)
+             .with_peers(users))
+        if len(observers):
+            (builder
+             .with_title(observers_title)
+             .with_peers(observers))
+
+        builder.build(list_widget)

toxygen/history.py

@@ -1,182 +0,0 @@
-# coding=utf-8
-from sqlite3 import connect
-import settings
-from os import chdir
-import os.path
-from toxencryptsave import ToxEncryptSave
-
-
-PAGE_SIZE = 42
-
-MESSAGE_OWNER = {
-    'ME': 0,
-    'FRIEND': 1,
-    'NOT_SENT': 2
-}
-
-
-class History:
-
-    def __init__(self, name):
-        self._name = name
-        chdir(settings.ProfileHelper.get_path())
-        path = settings.ProfileHelper.get_path() + self._name + '.hstr'
-        if os.path.exists(path):
-            decr = ToxEncryptSave.get_instance()
-            try:
-                with open(path, 'rb') as fin:
-                    data = fin.read()
-                if decr.is_data_encrypted(data):
-                    data = decr.pass_decrypt(data)
-                    with open(path, 'wb') as fout:
-                        fout.write(data)
-            except:
-                os.remove(path)
-        db = connect(name + '.hstr')
-        cursor = db.cursor()
-        cursor.execute('CREATE TABLE IF NOT EXISTS friends('
-                       '    tox_id TEXT PRIMARY KEY'
-                       ')')
-        db.close()
-
-    def save(self):
-        encr = ToxEncryptSave.get_instance()
-        if encr.has_password():
-            path = settings.ProfileHelper.get_path() + self._name + '.hstr'
-            with open(path, 'rb') as fin:
-                data = fin.read()
-            data = encr.pass_encrypt(bytes(data))
-            with open(path, 'wb') as fout:
-                fout.write(data)
-
-    def export(self, directory):
-        path = settings.ProfileHelper.get_path() + self._name + '.hstr'
-        new_path = directory + self._name + '.hstr'
-        with open(path, 'rb') as fin:
-            data = fin.read()
-        encr = ToxEncryptSave.get_instance()
-        if encr.has_password():
-            data = encr.pass_encrypt(data)
-        with open(new_path, 'wb') as fout:
-            fout.write(data)
-
-    def add_friend_to_db(self, tox_id):
-        chdir(settings.ProfileHelper.get_path())
-        db = connect(self._name + '.hstr')
-        try:
-            cursor = db.cursor()
-            cursor.execute('INSERT INTO friends VALUES (?);', (tox_id, ))
-            cursor.execute('CREATE TABLE id' + tox_id + '('
-                           '    id INTEGER PRIMARY KEY,'
-                           '    message TEXT,'
-                           '    owner INTEGER,'
-                           '    unix_time REAL,'
-                           '    message_type INTEGER'
-                           ')')
-            db.commit()
-        except:
-            db.rollback()
-            raise
-        finally:
-            db.close()
-
-    def delete_friend_from_db(self, tox_id):
-        chdir(settings.ProfileHelper.get_path())
-        db = connect(self._name + '.hstr')
-        try:
-            cursor = db.cursor()
-            cursor.execute('DELETE FROM friends WHERE tox_id=?;', (tox_id, ))
-            cursor.execute('DROP TABLE id' + tox_id + ';')
-            db.commit()
-        except:
-            db.rollback()
-            raise
-        finally:
-            db.close()
-
-    def friend_exists_in_db(self, tox_id):
-        chdir(settings.ProfileHelper.get_path())
-        db = connect(self._name + '.hstr')
-        cursor = db.cursor()
-        cursor.execute('SELECT 0 FROM friends WHERE tox_id=?', (tox_id, ))
-        result = cursor.fetchone()
-        db.close()
-        return result is not None
-
-    def save_messages_to_db(self, tox_id, messages_iter):
-        chdir(settings.ProfileHelper.get_path())
-        db = connect(self._name + '.hstr')
-        try:
-            cursor = db.cursor()
-            cursor.executemany('INSERT INTO id' + tox_id + '(message, owner, unix_time, message_type) '
-                               'VALUES (?, ?, ?, ?);', messages_iter)
-            db.commit()
-        except:
-            db.rollback()
-            raise
-        finally:
-            db.close()
-
-    def update_messages(self, tox_id, unsent_time):
-        chdir(settings.ProfileHelper.get_path())
-        db = connect(self._name + '.hstr')
-        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:
-            db.rollback()
-            raise
-        finally:
-            db.close()
-        pass
-
-    def delete_message(self, tox_id, time):
-        chdir(settings.ProfileHelper.get_path())
-        db = connect(self._name + '.hstr')
-        try:
-            cursor = db.cursor()
-            cursor.execute('DELETE FROM id' + tox_id + ' WHERE unix_time = ' + str(time) + ';')
-            db.commit()
-        except:
-            db.rollback()
-            raise
-        finally:
-            db.close()
-
-    def delete_messages(self, tox_id):
-        chdir(settings.ProfileHelper.get_path())
-        db = connect(self._name + '.hstr')
-        try:
-            cursor = db.cursor()
-            cursor.execute('DELETE FROM id' + tox_id + ';')
-            db.commit()
-        except:
-            db.rollback()
-            raise
-        finally:
-            db.close()
-
-    def messages_getter(self, tox_id):
-        return History.MessageGetter(self._name, tox_id)
-
-    class MessageGetter:
-        def __init__(self, name, tox_id):
-            chdir(settings.ProfileHelper.get_path())
-            self._db = connect(name + '.hstr')
-            self._cursor = self._db.cursor()
-            self._cursor.execute('SELECT message, owner, unix_time, message_type FROM id' + tox_id +
-                                 ' ORDER BY unix_time DESC;')
-
-        def get_one(self):
-            return self._cursor.fetchone()
-
-        def get_all(self):
-            return self._cursor.fetchall()
-
-        def get(self, count):
-            return self._cursor.fetchmany(count)
-
-        def __del__(self):
-            self._db.close()

toxygen/history/database.py

@@ -0,0 +1,201 @@
+from sqlite3 import connect
+import os.path
+import utils.util as util
+
+
+TIMEOUT = 11
+
+SAVE_MESSAGES = 500
+
+MESSAGE_AUTHOR = {
+    'ME': 0,
+    'FRIEND': 1,
+    'NOT_SENT': 2,
+    'GC_PEER': 3
+}
+
+CONTACT_TYPE = {
+    'FRIEND': 0,
+    'GC_PEER': 1,
+    'GC_PEER_PRIVATE': 2
+}
+
+
+class Database:
+
+    def __init__(self, path, toxes):
+        self._path, self._toxes = path, toxes
+        self._name = os.path.basename(path)
+        if os.path.exists(path):
+            try:
+                with open(path, 'rb') as fin:
+                    data = fin.read()
+                if toxes.is_data_encrypted(data):
+                    data = toxes.pass_decrypt(data)
+                    with open(path, 'wb') as fout:
+                        fout.write(data)
+            except Exception as ex:
+                util.log('Db reading error: ' + str(ex))
+                os.remove(path)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Public methods
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def save(self):
+        if self._toxes.has_password():
+            with open(self._path, 'rb') as fin:
+                data = fin.read()
+            data = self._toxes.pass_encrypt(bytes(data))
+            with open(self._path, 'wb') as fout:
+                fout.write(data)
+
+    def export(self, directory):
+        new_path = util.join_path(directory, self._name)
+        with open(self._path, 'rb') as fin:
+            data = fin.read()
+        if self._toxes.has_password():
+            data = self._toxes.pass_encrypt(data)
+        with open(new_path, 'wb') as fout:
+            fout.write(data)
+
+    def add_friend_to_db(self, tox_id):
+        db = self._connect()
+        try:
+            cursor = db.cursor()
+            cursor.execute('CREATE TABLE IF NOT EXISTS id' + tox_id + '('
+                           '    id INTEGER PRIMARY KEY,'
+                           '    author_name TEXT,'
+                           '    message TEXT,'
+                           '    author_type INTEGER,'
+                           '    unix_time REAL,'
+                           '    message_type INTEGER'
+                           ')')
+            db.commit()
+        except:
+            print('Database is locked!')
+            db.rollback()
+        finally:
+            db.close()
+
+    def delete_friend_from_db(self, tox_id):
+        db = self._connect()
+        try:
+            cursor = db.cursor()
+            cursor.execute('DROP TABLE id' + tox_id + ';')
+            db.commit()
+        except:
+            print('Database is locked!')
+            db.rollback()
+        finally:
+            db.close()
+
+    def save_messages_to_db(self, tox_id, messages_iter):
+        db = self._connect()
+        try:
+            cursor = db.cursor()
+            cursor.executemany('INSERT INTO id' + tox_id +
+                               '(message, author_name, author_type, unix_time, message_type) ' +
+                               'VALUES (?, ?, ?, ?, ?, ?);', messages_iter)
+            db.commit()
+        except:
+            print('Database is locked!')
+            db.rollback()
+        finally:
+            db.close()
+
+    def update_messages(self, tox_id, message_id):
+        db = self._connect()
+        try:
+            cursor = db.cursor()
+            cursor.execute('UPDATE id' + tox_id + ' SET author = 0 '
+                           'WHERE id = ' + str(message_id) + ' AND author = 2;')
+            db.commit()
+        except:
+            print('Database is locked!')
+            db.rollback()
+        finally:
+            db.close()
+
+    def delete_message(self, tox_id, unique_id):
+        db = self._connect()
+        try:
+            cursor = db.cursor()
+            cursor.execute('DELETE FROM id' + tox_id + ' WHERE id = ' + str(unique_id) + ';')
+            db.commit()
+        except:
+            print('Database is locked!')
+            db.rollback()
+        finally:
+            db.close()
+
+    def delete_messages(self, tox_id):
+        db = self._connect()
+        try:
+            cursor = db.cursor()
+            cursor.execute('DELETE FROM id' + tox_id + ';')
+            db.commit()
+        except:
+            print('Database is locked!')
+            db.rollback()
+        finally:
+            db.close()
+
+    def messages_getter(self, tox_id):
+        self.add_friend_to_db(tox_id)
+
+        return Database.MessageGetter(self._path, tox_id)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Messages loading
+    # -----------------------------------------------------------------------------------------------------------------
+
+    class MessageGetter:
+
+        def __init__(self, path, tox_id):
+            self._count = 0
+            self._path = path
+            self._tox_id = tox_id
+            self._db = self._cursor = None
+
+        def get_one(self):
+            return self.get(1)
+
+        def get_all(self):
+            self._connect()
+            data = self._cursor.fetchall()
+            self._disconnect()
+            self._count = len(data)
+            return data
+
+        def get(self, count):
+            self._connect()
+            self.skip()
+            data = self._cursor.fetchmany(count)
+            self._disconnect()
+            self._count += len(data)
+            return data
+
+        def skip(self):
+            if self._count:
+                self._cursor.fetchmany(self._count)
+
+        def delete_one(self):
+            if self._count:
+                self._count -= 1
+
+        def _connect(self):
+            self._db = connect(self._path, timeout=TIMEOUT)
+            self._cursor = self._db.cursor()
+            self._cursor.execute('SELECT message, author_type, author_name, unix_time, message_type, id FROM id' +
+                                 self._tox_id + ' ORDER BY unix_time DESC;')
+
+        def _disconnect(self):
+            self._db.close()
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Private methods
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def _connect(self):
+        return connect(self._path, timeout=TIMEOUT)

toxygen/history/history.py

@@ -0,0 +1,138 @@
+from history.history_logs_generators import *
+
+
+class History:
+
+    def __init__(self, contact_provider, db, settings, main_screen, messages_items_factory):
+        self._contact_provider = contact_provider
+        self._db = db
+        self._settings = settings
+        self._messages = main_screen.messages
+        self._messages_items_factory = messages_items_factory
+        self._is_loading = False
+        self._contacts_manager = None
+           
+    def __del__(self):
+        del self._db
+
+    def set_contacts_manager(self, contacts_manager):
+        self._contacts_manager = contacts_manager
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # History support
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def save_history(self):
+        """
+        Save history to db
+        """
+        if self._settings['save_db']:
+            for friend in self._contact_provider.get_all_friends():
+                self._db.add_friend_to_db(friend.tox_id)
+                if not self._settings['save_unsent_only']:
+                    messages = friend.get_corr_for_saving()
+                else:
+                    messages = friend.get_unsent_messages_for_saving()
+                    self._db.delete_messages(friend.tox_id)
+                messages = map(lambda m: (m.text, m.author.name, m.author.type, m.time, m.type), messages)
+                self._db.save_messages_to_db(friend.tox_id, messages)
+
+        self._db.save()
+
+    def clear_history(self, friend, save_unsent=False):
+        """
+        Clear chat history
+        """
+        friend.clear_corr(save_unsent)
+        self._db.delete_friend_from_db(friend.tox_id)
+
+    def export_history(self, contact, as_text=True):
+        extension = 'txt' if as_text else 'html'
+        file_name, _ = util_ui.save_file_dialog(util_ui.tr('Choose file name'), extension)
+
+        if not file_name:
+            return
+
+        if not file_name.endswith('.' + extension):
+            file_name += '.' + extension
+
+        history = self.generate_history(contact, as_text)
+        with open(file_name, 'wt') as fl:
+            fl.write(history)
+
+    def delete_message(self, message):
+        contact = self._contacts_manager.get_curr_contact()
+        if message.type in (MESSAGE_TYPE['TEXT'], MESSAGE_TYPE['ACTION']):
+            if message.is_saved():
+                self._db.delete_message(contact.tox_id, message.id)
+        contact.delete_message(message.message_id)
+
+    def load_history(self, friend):
+        """
+        Tries to load next part of messages
+        """
+        if self._is_loading:
+            return
+        self._is_loading = True
+        friend.load_corr(False)
+        messages = friend.get_corr()
+        if not messages:
+            self._is_loading = False
+            return
+        messages.reverse()
+        messages = messages[self._messages.count():self._messages.count() + PAGE_SIZE]
+        for message in messages:
+            message_type = message.get_type()
+            if message_type in (MESSAGE_TYPE['TEXT'], MESSAGE_TYPE['ACTION']):  # text message
+                self._create_message_item(message)
+            elif message_type == MESSAGE_TYPE['FILE_TRANSFER']:  # file transfer
+                if message.state == FILE_TRANSFER_STATE['UNSENT']:
+                    self._create_unsent_file_item(message)
+                else:
+                    self._create_file_transfer_item(message)
+            elif message_type == MESSAGE_TYPE['INLINE']:  # inline image
+                self._create_inline_item(message)
+            else:  # info message
+                self._create_message_item(message)
+        self._is_loading = False
+
+    def get_message_getter(self, friend_public_key):
+        self._db.add_friend_to_db(friend_public_key)
+
+        return self._db.messages_getter(friend_public_key)
+
+    def delete_history(self, friend):
+        self._db.delete_friend_from_db(friend.tox_id)
+
+    def add_friend_to_db(self, tox_id):
+        self._db.add_friend_to_db(tox_id)
+
+    @staticmethod
+    def generate_history(contact, as_text=True, _range=None):
+        if _range is None:
+            contact.load_all_corr()
+            corr = contact.get_corr()
+        elif _range[1] + 1:
+            corr = contact.get_corr()[_range[0]:_range[1] + 1]
+        else:
+            corr = contact.get_corr()[_range[0]:]
+
+        generator = TextHistoryGenerator(corr, contact.name) if as_text else HtmlHistoryGenerator(corr, contact.name)
+
+        return generator.generate()
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Items creation
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def _create_message_item(self, message):
+        return self._messages_items_factory.create_message_item(message, False)
+
+    def _create_unsent_file_item(self, message):
+        return self._messages_items_factory.create_unsent_file_item(message, False)
+
+    def _create_file_transfer_item(self, message):
+        return self._messages_items_factory.create_file_transfer_item(message, False)
+
+    def _create_inline_item(self, message):
+        return self._messages_items_factory.create_inline_item(message, False)

toxygen/history/history_logs_generators.py

@@ -0,0 +1,48 @@
+from messenger.messages import *
+import utils.util as util
+
+
+class HistoryLogsGenerator:
+
+    def __init__(self, history, contact_name):
+        self._history = history
+        self._contact_name = contact_name
+
+    def generate(self):
+        return str()
+
+    @staticmethod
+    def _get_message_time(message):
+        return util.convert_time(message.time) if message.author.type != MESSAGE_AUTHOR['NOT_SENT'] else 'Unsent'
+
+
+class HtmlHistoryGenerator(HistoryLogsGenerator):
+
+    def __init__(self, history, contact_name):
+        super().__init__(history, contact_name)
+
+    def generate(self):
+        arr = []
+        for message in self._history:
+            if type(message) is TextMessage:
+                x = '[{}] <b>{}:</b> {}<br>'
+                arr.append(x.format(self._get_message_time(message), message.author.name, message.text))
+        s = '<br>'.join(arr)
+        html = '<html><head><meta charset="UTF-8"><title>{}</title></head><body>{}</body></html>'
+
+        return html.format(self._contact_name, s)
+
+
+class TextHistoryGenerator(HistoryLogsGenerator):
+
+    def __init__(self, history, contact_name):
+        super().__init__(history, contact_name)
+
+    def generate(self):
+        arr = [self._contact_name]
+        for message in self._history:
+            if type(message) is TextMessage:
+                x = '[{}] {}: {}\n'
+                arr.append(x.format(self._get_message_time(message), message.author.name, message.text))
+
+        return '\n'.join(arr)

toxygen/libtox.py

@@ -1,53 +0,0 @@
-from platform import system
-from ctypes import CDLL
-import util
-
-
-class LibToxCore:
-
-    def __init__(self):
-        if system() == 'Windows':
-            self._libtoxcore = CDLL(util.curr_directory() + '/libs/libtox.dll')
-        else:
-            # 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)
-
-
-class LibToxAV:
-
-    def __init__(self):
-        if system() == 'Windows':
-            # on Windows av api is in libtox.dll
-            self._libtoxav = CDLL(util.curr_directory() + '/libs/libtox.dll')
-        else:
-            # /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)
-
-
-class LibToxEncryptSave:
-
-    def __init__(self):
-        if system() == 'Windows':
-            # on Windows profile encryption api is in libtox.dll
-            self._lib_tox_encrypt_save = CDLL(util.curr_directory() + '/libs/libtox.dll')
-        else:
-            # /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

@@ -1,529 +0,0 @@
-from toxcore_enums_and_consts import *
-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
-from widgets import DataLabel, create_menu
-import html as h
-import smileys
-import settings
-
-
-class MessageEdit(QtGui.QTextBrowser):
-
-    def __init__(self, text, width, message_type, parent=None):
-        super(MessageEdit, self).__init__(parent)
-        self.urls = {}
-        self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
-        self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
-        self.setWordWrapMode(QtGui.QTextOption.WrapAtWordBoundaryOrAnywhere)
-        self.document().setTextWidth(width)
-        self.setOpenExternalLinks(True)
-        self.setAcceptRichText(True)
-        self.setOpenLinks(False)
-        self.setSearchPaths([smileys.SmileyLoader.get_instance().get_smileys_path()])
-        self.document().setDefaultStyleSheet('a { color: #306EFF; }')
-        text = self.decoratedText(text)
-        if message_type != TOX_MESSAGE_TYPE['NORMAL']:
-            self.setHtml('<p style="color: #5CB3FF; font: italic; font-size: 20px;" >' + text + '</p>')
-        else:
-            self.setHtml(text)
-        font = QtGui.QFont()
-        font.setFamily(settings.Settings.get_instance()['font'])
-        font.setPixelSize(settings.Settings.get_instance()['message_font_size'])
-        font.setBold(False)
-        self.setFont(font)
-        self.resize(width, self.document().size().height())
-        self.setTextInteractionFlags(QtCore.Qt.TextSelectableByMouse | QtCore.Qt.LinksAccessibleByMouse)
-        self.anchorClicked.connect(self.on_anchor_clicked)
-
-    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:'):
-            import menu
-            self.add_contact = menu.AddContact(text[4:])
-            self.add_contact.show()
-        else:
-            QtGui.QDesktopServices.openUrl(url)
-        self.clearFocus()
-
-    def addAnimation(self, url, fileName):
-        movie = QtGui.QMovie(self)
-        movie.setFileName(fileName)
-        self.urls[movie] = url
-        movie.frameChanged[int].connect(lambda x: self.animate(movie))
-        movie.start()
-
-    def animate(self, movie):
-        self.document().addResource(QtGui.QTextDocument.ImageResource,
-                                    self.urls[movie],
-                                    movie.currentPixmap())
-        self.setLineWrapColumnOrWidth(self.lineWrapColumnOrWidth())
-
-    def decoratedText(self, text):
-        text = h.escape(text)  # replace < and >
-        exp = QtCore.QRegExp(
-            '('
-            '(?:\\b)((www\\.)|(http[s]?|ftp)://)'
-            '\\w+\\S+)'
-            '|(?:\\b)(file:///)([\\S| ]*)'
-            '|(?:\\b)(tox:[a-zA-Z\\d]{76}$)'
-            '|(?:\\b)(mailto:\\S+@\\S+\\.\\S+)'
-            '|(?:\\b)(tox:\\S+@\\S+)')
-        offset = exp.indexIn(text, 0)
-        while offset != -1:  # add links
-            url = exp.cap()
-            if exp.cap(2) == 'www.':
-                html = '<a href="http://{0}">{0}</a>'.format(url)
-            else:
-                html = '<a href="{0}">{0}</a>'.format(url)
-            text = text[:offset] + html + text[offset + len(exp.cap()):]
-            offset += len(html)
-            offset = exp.indexIn(text, offset)
-        arr = text.split('\n')
-        for i in range(len(arr)):  # quotes
-            if arr[i].startswith('&gt;'):
-                arr[i] = '<font color="green"><b>' + arr[i][4:] + '</b></font>'
-        text = '<br>'.join(arr)
-        text = smileys.SmileyLoader.get_instance().add_smileys_to_text(text, self)  # smileys
-        return text
-
-
-class MessageItem(QtGui.QWidget):
-    """
-    Message in messages list
-    """
-    def __init__(self, text, time, user='', sent=True, message_type=TOX_MESSAGE_TYPE['NORMAL'], parent=None):
-        QtGui.QWidget.__init__(self, parent)
-        self.name = DataLabel(self)
-        self.name.setGeometry(QtCore.QRect(2, 2, 95, 20))
-        self.name.setTextFormat(QtCore.Qt.PlainText)
-        font = QtGui.QFont()
-        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))
-        font.setPointSize(10)
-        font.setBold(False)
-        self.time.setFont(font)
-        self._time = time
-        if not sent:
-            movie = QtGui.QMovie(curr_directory() + '/images/spinner.gif')
-            self.time.setMovie(movie)
-            movie.start()
-            self.t = True
-        else:
-            self.time.setText(convert_time(time))
-            self.t = False
-
-        self.message = MessageEdit(text, parent.width() - 150, 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.setFixedHeight(self.message.height())
-
-    def mouseReleaseEvent(self, event):
-        if event.button() == QtCore.Qt.RightButton and event.x() > self.time.x():
-            self.listMenu = QtGui.QMenu()
-            delete_item = self.listMenu.addAction(QtGui.QApplication.translate("MainWindow", 'Delete message', None, QtGui.QApplication.UnicodeUTF8))
-            self.connect(delete_item, QtCore.SIGNAL("triggered()"), self.delete)
-            parent_position = self.time.mapToGlobal(QtCore.QPoint(0, 0))
-            self.listMenu.move(parent_position)
-            self.listMenu.show()
-
-    def delete(self):
-        pr = profile.Profile.get_instance()
-        pr.delete_message(self._time)
-
-    def mark_as_sent(self):
-        if self.t:
-            self.time.setText(convert_time(self._time))
-            self.t = False
-            return True
-        return False
-
-    def set_avatar(self, pixmap):
-        self.name.setAlignment(QtCore.Qt.AlignCenter)
-        self.message.setAlignment(QtCore.Qt.AlignVCenter)
-        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, QtCore.Qt.SmoothTransformation))
-
-
-class ContactItem(QtGui.QWidget):
-    """
-    Contact in friends list
-    """
-
-    def __init__(self, parent=None):
-        QtGui.QWidget.__init__(self, parent)
-        mode = settings.Settings.get_instance()['compact_mode']
-        self.setBaseSize(QtCore.QSize(250, 40 if mode else 70))
-        self.avatar_label = QtGui.QLabel(self)
-        size = 32 if mode else 64
-        self.avatar_label.setGeometry(QtCore.QRect(3, 4, size, size))
-        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(settings.Settings.get_instance()['font'])
-        font.setPointSize(10 if mode else 12)
-        font.setBold(True)
-        self.name.setFont(font)
-        self.status_message = DataLabel(self)
-        self.status_message.setGeometry(QtCore.QRect(50 if mode else 75, 20 if mode else 30, 170, 15 if mode else 20))
-        font.setPointSize(10)
-        font.setBold(False)
-        self.status_message.setFont(font)
-        self.connection_status = StatusCircle(self)
-        self.connection_status.setGeometry(QtCore.QRect(230, -2 if mode else 5, 32, 32))
-        self.messages = UnreadMessagesCount(self)
-        self.messages.setGeometry(QtCore.QRect(20 if mode else 52, 20 if mode else 50, 30, 20))
-
-
-class StatusCircle(QtGui.QWidget):
-    """
-    Connection status
-    """
-    def __init__(self, parent):
-        QtGui.QWidget.__init__(self, parent)
-        self.setGeometry(0, 0, 32, 32)
-        self.label = QtGui.QLabel(self)
-        self.label.setGeometry(QtCore.QRect(0, 0, 32, 32))
-        self.unread = False
-
-    def update(self, status, unread_messages=None):
-        if unread_messages is None:
-            unread_messages = self.unread
-        else:
-            self.unread = unread_messages
-        if status == TOX_USER_STATUS['NONE']:
-            name = 'online'
-        elif status == TOX_USER_STATUS['AWAY']:
-            name = 'idle'
-        elif status == TOX_USER_STATUS['BUSY']:
-            name = 'busy'
-        else:
-            name = 'offline'
-        if unread_messages:
-            name += '_notification'
-            self.label.setGeometry(QtCore.QRect(0, 0, 32, 32))
-        else:
-            self.label.setGeometry(QtCore.QRect(2, 0, 32, 32))
-        pixmap = QtGui.QPixmap(curr_directory() + '/images/{}.png'.format(name))
-        self.label.setPixmap(pixmap)
-
-
-class UnreadMessagesCount(QtGui.QWidget):
-
-    def __init__(self, parent=None):
-        super(UnreadMessagesCount, self).__init__(parent)
-        self.resize(30, 20)
-        self.label = QtGui.QLabel(self)
-        self.label.setGeometry(QtCore.QRect(0, 0, 30, 20))
-        self.label.setVisible(False)
-        font = QtGui.QFont()
-        font.setFamily(settings.Settings.get_instance()['font'])
-        font.setPointSize(12)
-        font.setBold(True)
-        self.label.setFont(font)
-        self.label.setAlignment(QtCore.Qt.AlignVCenter | QtCore.Qt.AlignCenter)
-        color = settings.Settings.get_instance()['unread_color']
-        self.label.setStyleSheet('QLabel { color: white; background-color: ' + color + '; border-radius: 10; }')
-
-    def update(self, messages_count):
-        color = settings.Settings.get_instance()['unread_color']
-        self.label.setStyleSheet('QLabel { color: white; background-color: ' + color + '; border-radius: 10; }')
-        if messages_count:
-            self.label.setVisible(True)
-            self.label.setText(str(messages_count))
-        else:
-            self.label.setVisible(False)
-
-
-class FileTransferItem(QtGui.QListWidget):
-
-    def __init__(self, file_name, size, time, user, friend_number, file_number, state, width, parent=None):
-
-        QtGui.QListWidget.__init__(self, parent)
-        self.resize(QtCore.QSize(width, 34))
-        if state == TOX_FILE_TRANSFER_STATE['CANCELLED']:
-            self.setStyleSheet('QListWidget { border: 1px solid #B40404; }')
-        elif state in PAUSED_FILE_TRANSFERS:
-            self.setStyleSheet('QListWidget { border: 1px solid #FF8000; }')
-        else:
-            self.setStyleSheet('QListWidget { border: 1px solid green; }')
-        self.state = state
-
-        self.name = DataLabel(self)
-        self.name.setGeometry(QtCore.QRect(3, 7, 95, 20))
-        self.name.setTextFormat(QtCore.Qt.PlainText)
-        font = QtGui.QFont()
-        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))
-        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))
-        pixmap = QtGui.QPixmap(curr_directory() + '/images/decline.png')
-        icon = QtGui.QIcon(pixmap)
-        self.cancel.setIcon(icon)
-        self.cancel.setIconSize(QtCore.QSize(30, 30))
-        self.cancel.setVisible(state in ACTIVE_FILE_TRANSFERS)
-        self.cancel.clicked.connect(lambda: self.cancel_transfer(friend_number, file_number))
-        self.cancel.setStyleSheet('QPushButton:hover { border: 1px solid #3A3939; background-color: none;}')
-
-        self.accept_or_pause = QtGui.QPushButton(self)
-        self.accept_or_pause.setGeometry(QtCore.QRect(width - 170, 2, 30, 30))
-        if state == TOX_FILE_TRANSFER_STATE['INCOMING_NOT_STARTED']:
-            self.accept_or_pause.setVisible(True)
-            self.button_update('accept')
-        elif state in DO_NOT_SHOW_ACCEPT_BUTTON:
-            self.accept_or_pause.setVisible(False)
-        elif state == TOX_FILE_TRANSFER_STATE['PAUSED_BY_USER']:  # setup for continue
-            self.accept_or_pause.setVisible(True)
-            self.button_update('resume')
-        else:  # pause
-            self.accept_or_pause.setVisible(True)
-            self.button_update('pause')
-        self.accept_or_pause.clicked.connect(lambda: self.accept_or_pause_transfer(friend_number, file_number, size))
-
-        self.accept_or_pause.setStyleSheet('QPushButton:hover { border: 1px solid #3A3939; background-color: none}')
-
-        self.pb = QtGui.QProgressBar(self)
-        self.pb.setGeometry(QtCore.QRect(100, 7, 100, 20))
-        self.pb.setValue(0)
-        self.pb.setStyleSheet('QProgressBar { background-color: #302F2F; }')
-        self.pb.setVisible(state in SHOW_PROGRESS_BAR)
-
-        self.file_name = DataLabel(self)
-        self.file_name.setGeometry(QtCore.QRect(210, 7, width - 420, 20))
-        font.setPointSize(12)
-        self.file_name.setFont(font)
-        file_size = size // 1024
-        if not file_size:
-            file_size = '{}B'.format(size)
-        elif file_size >= 1024:
-            file_size = '{}MB'.format(file_size // 1024)
-        else:
-            file_size = '{}KB'.format(file_size)
-        file_data = '{} {}'.format(file_size, file_name)
-        self.file_name.setText(file_data)
-        self.file_name.setToolTip(file_name)
-        self.saved_name = file_name
-        self.time_left = QtGui.QLabel(self)
-        self.time_left.setGeometry(QtCore.QRect(width - 87, 7, 30, 20))
-        font.setPointSize(10)
-        self.time_left.setFont(font)
-        self.time_left.setVisible(state == TOX_FILE_TRANSFER_STATE['RUNNING'])
-        self.setFocusPolicy(QtCore.Qt.NoFocus)
-        self.paused = False
-
-    def cancel_transfer(self, friend_number, file_number):
-        pr = profile.Profile.get_instance()
-        pr.cancel_transfer(friend_number, file_number)
-        self.setStyleSheet('QListWidget { border: 1px solid #B40404; }')
-        self.cancel.setVisible(False)
-        self.accept_or_pause.setVisible(False)
-        self.pb.setVisible(False)
-
-    def accept_or_pause_transfer(self, friend_number, file_number, size):
-        if self.state == TOX_FILE_TRANSFER_STATE['INCOMING_NOT_STARTED']:
-            directory = QtGui.QFileDialog.getExistingDirectory(self,
-                                                               QtGui.QApplication.translate("MainWindow", 'Choose folder', None, QtGui.QApplication.UnicodeUTF8),
-                                                               curr_directory(),
-                                                               QtGui.QFileDialog.ShowDirsOnly | QtGui.QFileDialog.DontUseNativeDialog)
-            self.pb.setVisible(True)
-            if directory:
-                pr = profile.Profile.get_instance()
-                pr.accept_transfer(self, directory + '/' + self.saved_name, friend_number, file_number, size)
-                self.button_update('pause')
-        elif self.state == TOX_FILE_TRANSFER_STATE['PAUSED_BY_USER']:  # resume
-            self.paused = False
-            profile.Profile.get_instance().resume_transfer(friend_number, file_number)
-            self.button_update('pause')
-            self.state = TOX_FILE_TRANSFER_STATE['RUNNING']
-        else:  # pause
-            self.paused = True
-            self.state = TOX_FILE_TRANSFER_STATE['PAUSED_BY_USER']
-            profile.Profile.get_instance().pause_transfer(friend_number, file_number)
-            self.button_update('resume')
-        self.accept_or_pause.clearFocus()
-
-    def button_update(self, path):
-        pixmap = QtGui.QPixmap(curr_directory() + '/images/{}.png'.format(path))
-        icon = QtGui.QIcon(pixmap)
-        self.accept_or_pause.setIcon(icon)
-        self.accept_or_pause.setIconSize(QtCore.QSize(30, 30))
-
-    @QtCore.Slot(int, float, int)
-    def update(self, state, progress, time):
-        self.pb.setValue(int(progress * 100))
-        if time + 1:
-            m, s = divmod(time, 60)
-            self.time_left.setText('{0:02d}:{1:02d}'.format(m, s))
-        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)
-                self.accept_or_pause.setVisible(False)
-                self.pb.setVisible(False)
-                self.state = state
-                self.time_left.setVisible(False)
-            elif state == TOX_FILE_TRANSFER_STATE['FINISHED']:
-                self.accept_or_pause.setVisible(False)
-                self.pb.setVisible(False)
-                self.cancel.setVisible(False)
-                self.setStyleSheet('QListWidget { border: 1px solid green; }')
-                self.state = state
-                self.time_left.setVisible(False)
-            elif state == TOX_FILE_TRANSFER_STATE['PAUSED_BY_FRIEND']:
-                self.accept_or_pause.setVisible(False)
-                self.setStyleSheet('QListWidget { border: 1px solid #FF8000; }')
-                self.state = state
-                self.time_left.setVisible(False)
-            elif state == TOX_FILE_TRANSFER_STATE['PAUSED_BY_USER']:
-                self.button_update('resume')  # setup button continue
-                self.setStyleSheet('QListWidget { border: 1px solid green; }')
-                self.state = state
-                self.time_left.setVisible(False)
-            elif state == TOX_FILE_TRANSFER_STATE['OUTGOING_NOT_STARTED']:
-                self.setStyleSheet('QListWidget { border: 1px solid #FF8000; }')
-                self.accept_or_pause.setVisible(False)
-                self.time_left.setVisible(False)
-                self.pb.setVisible(False)
-            elif not self.paused:  # active
-                self.pb.setVisible(True)
-                self.accept_or_pause.setVisible(True)  # setup to pause
-                self.button_update('pause')
-                self.setStyleSheet('QListWidget { border: 1px solid green; }')
-                self.state = state
-                self.time_left.setVisible(True)
-
-    def mark_as_sent(self):
-        return False
-
-
-class UnsentFileItem(FileTransferItem):
-
-    def __init__(self, file_name, size, user, time, width, parent=None):
-        super(UnsentFileItem, self).__init__(file_name, size, time, user, -1, -1,
-                                             TOX_FILE_TRANSFER_STATE['PAUSED_BY_FRIEND'], width, parent)
-        self._time = time
-        self.pb.setVisible(False)
-        movie = QtGui.QMovie(curr_directory() + '/images/spinner.gif')
-        self.time.setMovie(movie)
-        movie.start()
-
-    def cancel_transfer(self, *args):
-        pr = profile.Profile.get_instance()
-        pr.cancel_not_started_transfer(self._time)
-
-
-class InlineImageItem(QtGui.QScrollArea):
-
-    def __init__(self, data, width, elem):
-
-        QtGui.QScrollArea.__init__(self)
-        self.setFocusPolicy(QtCore.Qt.NoFocus)
-        self._elem = elem
-        self._image_label = QtGui.QLabel(self)
-        self._image_label.raise_()
-        self.setWidget(self._image_label)
-        self._image_label.setScaledContents(False)
-        self._pixmap = QtGui.QPixmap()
-        self._pixmap.loadFromData(data, 'PNG')
-        self._max_size = width - 30
-        self._resize_needed = not (self._pixmap.width() <= self._max_size)
-        self._full_size = not self._resize_needed
-        if not self._resize_needed:
-            self._image_label.setPixmap(self._pixmap)
-            self.resize(QtCore.QSize(self._max_size + 5, self._pixmap.height() + 5))
-            self._image_label.setGeometry(5, 0, self._pixmap.width(), self._pixmap.height())
-        else:
-            pixmap = self._pixmap.scaled(self._max_size, self._max_size, QtCore.Qt.KeepAspectRatio)
-            self._image_label.setPixmap(pixmap)
-            self.resize(QtCore.QSize(self._max_size + 5, pixmap.height()))
-            self._image_label.setGeometry(5, 0, self._max_size + 5, pixmap.height())
-        self._elem.setSizeHint(QtCore.QSize(self.width(), self.height()))
-
-    def mouseReleaseEvent(self, event):
-        if event.button() == QtCore.Qt.LeftButton and self._resize_needed:  # scale inline
-            if self._full_size:
-                pixmap = self._pixmap.scaled(self._max_size, self._max_size, QtCore.Qt.KeepAspectRatio)
-                self._image_label.setPixmap(pixmap)
-                self.resize(QtCore.QSize(self._max_size, pixmap.height()))
-                self._image_label.setGeometry(5, 0, pixmap.width(), pixmap.height())
-            else:
-                self._image_label.setPixmap(self._pixmap)
-                self.resize(QtCore.QSize(self._max_size, self._pixmap.height() + 17))
-                self._image_label.setGeometry(5, 0, self._pixmap.width(), self._pixmap.height())
-            self._full_size = not self._full_size
-            self._elem.setSizeHint(QtCore.QSize(self.width(), self.height()))
-        elif event.button() == QtCore.Qt.RightButton:  # save inline
-            directory = QtGui.QFileDialog.getExistingDirectory(self,
-                                                               QtGui.QApplication.translate("MainWindow",
-                                                                                            'Choose folder', None,
-                                                                                            QtGui.QApplication.UnicodeUTF8),
-                                                               curr_directory(),
-                                                               QtGui.QFileDialog.ShowDirsOnly | QtGui.QFileDialog.DontUseNativeDialog)
-            if directory:
-                fl = QtCore.QFile(directory + '/toxygen_inline_' + curr_time().replace(':', '_') + '.png')
-                self._pixmap.save(fl, 'PNG')
-
-        return False
-
-    def mark_as_sent(self):
-        return False
-
-
-
-

toxygen/loginscreen.py

@@ -1,108 +0,0 @@
-# -*- coding: utf-8 -*-
-
-try:
-    from PySide import QtCore, QtGui
-except ImportError:
-    from PyQt4 import QtCore, QtGui
-from widgets import *
-
-
-class NickEdit(LineEdit):
-
-    def __init__(self, parent):
-        super(NickEdit, self).__init__(parent)
-        self.parent = parent
-
-    def keyPressEvent(self, event):
-        if event.key() == QtCore.Qt.Key_Return:
-            self.parent.create_profile()
-        else:
-            super(NickEdit, self).keyPressEvent(event)
-
-
-class LoginScreen(CenteredWidget):
-
-    def __init__(self):
-        super(LoginScreen, self).__init__()
-        self.initUI()
-        self.center()
-
-    def initUI(self):
-        self.resize(400, 200)
-        self.setMinimumSize(QtCore.QSize(400, 200))
-        self.setMaximumSize(QtCore.QSize(400, 200))
-        self.new_profile = QtGui.QPushButton(self)
-        self.new_profile.setGeometry(QtCore.QRect(20, 150, 171, 27))
-        self.new_profile.clicked.connect(self.create_profile)
-        self.label = QtGui.QLabel(self)
-        self.label.setGeometry(QtCore.QRect(20, 70, 101, 17))
-        self.new_name = NickEdit(self)
-        self.new_name.setGeometry(QtCore.QRect(20, 100, 171, 31))
-        self.load_profile = QtGui.QPushButton(self)
-        self.load_profile.setGeometry(QtCore.QRect(220, 150, 161, 27))
-        self.load_profile.clicked.connect(self.load_ex_profile)
-        self.default = QtGui.QCheckBox(self)
-        self.default.setGeometry(QtCore.QRect(220, 110, 131, 22))
-        self.groupBox = QtGui.QGroupBox(self)
-        self.groupBox.setGeometry(QtCore.QRect(210, 40, 181, 151))
-        self.comboBox = QtGui.QComboBox(self.groupBox)
-        self.comboBox.setGeometry(QtCore.QRect(10, 30, 161, 27))
-        self.groupBox_2 = QtGui.QGroupBox(self)
-        self.groupBox_2.setGeometry(QtCore.QRect(10, 40, 191, 151))
-        self.toxygen = QtGui.QLabel(self)
-        self.groupBox.raise_()
-        self.groupBox_2.raise_()
-        self.comboBox.raise_()
-        self.default.raise_()
-        self.load_profile.raise_()
-        self.new_name.raise_()
-        self.new_profile.raise_()
-        self.toxygen.setGeometry(QtCore.QRect(160, 8, 90, 25))
-        font = QtGui.QFont()
-        font.setFamily("Impact")
-        font.setPointSize(16)
-        self.toxygen.setFont(font)
-        self.toxygen.setObjectName("toxygen")
-        self.type = 0
-        self.number = -1
-        self.load_as_default = False
-        self.name = None
-        self.retranslateUi()
-        QtCore.QMetaObject.connectSlotsByName(self)
-
-    def retranslateUi(self):
-        self.new_name.setPlaceholderText(QtGui.QApplication.translate("login", "Profile name", None, QtGui.QApplication.UnicodeUTF8))
-        self.setWindowTitle(QtGui.QApplication.translate("login", "Log in", None, QtGui.QApplication.UnicodeUTF8))
-        self.new_profile.setText(QtGui.QApplication.translate("login", "Create", None, QtGui.QApplication.UnicodeUTF8))
-        self.label.setText(QtGui.QApplication.translate("login", "Profile name:", None, QtGui.QApplication.UnicodeUTF8))
-        self.load_profile.setText(QtGui.QApplication.translate("login", "Load profile", None, QtGui.QApplication.UnicodeUTF8))
-        self.default.setText(QtGui.QApplication.translate("login", "Use as default", None, QtGui.QApplication.UnicodeUTF8))
-        self.groupBox.setTitle(QtGui.QApplication.translate("login", "Load existing profile", None, QtGui.QApplication.UnicodeUTF8))
-        self.groupBox_2.setTitle(QtGui.QApplication.translate("login", "Create new profile", None, QtGui.QApplication.UnicodeUTF8))
-        self.toxygen.setText(QtGui.QApplication.translate("login", "toxygen", None, QtGui.QApplication.UnicodeUTF8))
-
-    def create_profile(self):
-        self.type = 1
-        self.name = self.new_name.text()
-        self.close()
-
-    def load_ex_profile(self):
-        if not self.create_only:
-            self.type = 2
-            self.number = self.comboBox.currentIndex()
-            self.load_as_default = self.default.isChecked()
-            self.close()
-
-    def update_select(self, data):
-        list_of_profiles = []
-        for elem in data:
-            list_of_profiles.append(elem)
-        self.comboBox.addItems(list_of_profiles)
-        self.create_only = not list_of_profiles
-
-    def update_on_close(self, func):
-        self.onclose = func
-
-    def closeEvent(self, event):
-        self.onclose(self.type, self.number, self.load_as_default, self.name)
-        event.accept()

toxygen/main.py

@@ -1,460 +1,49 @@
-import sys
+import app
-from loginscreen import LoginScreen
+from user_data.settings import *
-import profile
+import utils.util as util
-from settings import *
+import argparse
-try:
-    from PySide import QtCore, QtGui
-except ImportError:
-    from PyQt4 import QtCore, QtGui
-from bootstrap import node_generator
-from mainscreen import MainWindow
-from callbacks import init_callbacks, stop, start
-from util import curr_directory, program_version
-import styles.style
-import platform
-import toxencryptsave
-from passwordscreen import PasswordScreen, UnlockAppScreen, SetProfilePasswordScreen
-from plugin_support import PluginLoader
 
 
-class Toxygen:
+__maintainer__ = 'Ingvar'
-
+__version__ = '0.5.0'
-    def __init__(self, path_or_uri=None):
-        super(Toxygen, self).__init__()
-        self.tox = self.ms = self.init = self.mainloop = self.avloop = None
-        if path_or_uri is None:
-            self.uri = self.path = None
-        elif path_or_uri.startswith('tox:'):
-            self.path = None
-            self.uri = path_or_uri[4:]
-        else:
-            self.path = path_or_uri
-            self.uri = None
-
-    def enter_pass(self, data):
-        """
-        Show password screen
-        """
-        tmp = [data]
-        p = PasswordScreen(toxencryptsave.ToxEncryptSave.get_instance(), tmp)
-        p.show()
-        self.app.connect(self.app, QtCore.SIGNAL("lastWindowClosed()"), self.app, QtCore.SLOT("quit()"))
-        self.app.exec_()
-        if tmp[0] == data:
-            raise SystemExit()
-        else:
-            return tmp[0]
-
-    def main(self):
-        """
-        Main function of app. loads login screen if needed and starts main screen
-        """
-        app = QtGui.QApplication(sys.argv)
-        app.setWindowIcon(QtGui.QIcon(curr_directory() + '/images/icon.png'))
-        self.app = app
-
-        if platform.system() == 'Linux':
-            QtCore.QCoreApplication.setAttribute(QtCore.Qt.AA_X11InitThreads)
-
-        # application color scheme
-        with open(curr_directory() + '/styles/style.qss') as fl:
-            dark_style = fl.read()
-        app.setStyleSheet(dark_style)
-
-        encrypt_save = toxencryptsave.ToxEncryptSave()
-
-        if self.path is not None:
-            path = os.path.dirname(self.path) + '/'
-            name = os.path.basename(self.path)[:-4]
-            data = ProfileHelper(path, name).open_profile()
-            if encrypt_save.is_data_encrypted(data):
-                data = self.enter_pass(data)
-            settings = Settings(name)
-            self.tox = profile.tox_factory(data, settings)
-        else:
-            auto_profile = Settings.get_auto_profile()
-            if not auto_profile[0]:
-                # show login screen if default profile not found
-                current_locale = QtCore.QLocale()
-                curr_lang = current_locale.languageToString(current_locale.language())
-                langs = Settings.supported_languages()
-                if curr_lang in langs:
-                    lang_path = langs[curr_lang]
-                    translator = QtCore.QTranslator()
-                    translator.load(curr_directory() + '/translations/' + lang_path)
-                    app.installTranslator(translator)
-                    app.translator = translator
-                ls = LoginScreen()
-                ls.setWindowIconText("Toxygen")
-                profiles = ProfileHelper.find_profiles()
-                ls.update_select(map(lambda x: x[1], profiles))
-                _login = self.Login(profiles)
-                ls.update_on_close(_login.login_screen_close)
-                ls.show()
-                app.connect(app, QtCore.SIGNAL("lastWindowClosed()"), app, QtCore.SLOT("quit()"))
-                app.exec_()
-                if not _login.t:
-                    return
-                elif _login.t == 1:  # create new profile
-                    _login.name = _login.name.strip()
-                    name = _login.name if _login.name else 'toxygen_user'
-                    pr = map(lambda x: x[1], ProfileHelper.find_profiles())
-                    if name in list(pr):
-                        msgBox = QtGui.QMessageBox()
-                        msgBox.setWindowTitle(
-                            QtGui.QApplication.translate("MainWindow", "Error", None, QtGui.QApplication.UnicodeUTF8))
-                        text = (QtGui.QApplication.translate("MainWindow",
-                                                             'Profile with this name already exists',
-                                                             None, QtGui.QApplication.UnicodeUTF8))
-                        msgBox.setText(text)
-                        msgBox.exec_()
-                        return
-                    self.tox = profile.tox_factory()
-                    self.tox.self_set_name(bytes(_login.name, 'utf-8') if _login.name else b'Toxygen User')
-                    self.tox.self_set_status_message(b'Toxing on Toxygen')
-                    reply = QtGui.QMessageBox.question(None,
-                                                       'Profile {}'.format(name),
-                                                       QtGui.QApplication.translate("login",
-                                                                                    'Do you want to set profile password?',
-                                                                                    None,
-                                                                                    QtGui.QApplication.UnicodeUTF8),
-                                                       QtGui.QMessageBox.Yes,
-                                                       QtGui.QMessageBox.No)
-                    if reply == QtGui.QMessageBox.Yes:
-                        set_pass = SetProfilePasswordScreen(encrypt_save)
-                        set_pass.show()
-                        self.app.connect(self.app, QtCore.SIGNAL("lastWindowClosed()"), self.app, QtCore.SLOT("quit()"))
-                        self.app.exec_()
-                    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()
-                    ProfileHelper(path, name).save_profile(self.tox.get_savedata())
-                    path = Settings.get_default_path()
-                    settings = Settings(name)
-                    if curr_lang in langs:
-                        settings['language'] = curr_lang
-                    settings.save()
-                else:  # load existing profile
-                    path, name = _login.get_data()
-                    if _login.default:
-                        Settings.set_auto_profile(path, name)
-                    data = ProfileHelper(path, name).open_profile()
-                    if encrypt_save.is_data_encrypted(data):
-                        data = self.enter_pass(data)
-                    settings = Settings(name)
-                    self.tox = profile.tox_factory(data, settings)
-            else:
-                path, name = auto_profile
-                data = ProfileHelper(path, name).open_profile()
-                if encrypt_save.is_data_encrypted(data):
-                    data = self.enter_pass(data)
-                settings = Settings(name)
-                self.tox = profile.tox_factory(data, settings)
-
-        if Settings.is_active_profile(path, name):  # profile is in use
-            reply = QtGui.QMessageBox.question(None,
-                                               'Profile {}'.format(name),
-                                               QtGui.QApplication.translate("login", 'Other instance of Toxygen uses this profile or profile was not properly closed. Continue?', None, QtGui.QApplication.UnicodeUTF8),
-                                               QtGui.QMessageBox.Yes,
-                                               QtGui.QMessageBox.No)
-            if reply != QtGui.QMessageBox.Yes:
-                return
-        else:
-            settings.set_active_profile()
-
-        lang = Settings.supported_languages()[settings['language']]
-        translator = QtCore.QTranslator()
-        translator.load(curr_directory() + '/translations/' + lang)
-        app.installTranslator(translator)
-        app.translator = translator
-
-        # tray icon
-        self.tray = QtGui.QSystemTrayIcon(QtGui.QIcon(curr_directory() + '/images/icon.png'))
-        self.tray.setObjectName('tray')
-
-        self.ms = MainWindow(self.tox, self.reset, self.tray)
-
-        class Menu(QtGui.QMenu):
-
-            def newStatus(self, status):
-                profile.Profile.get_instance().set_status(status)
-                self.aboutToShow()
-                self.hide()
-
-            def aboutToShow(self):
-                status = profile.Profile.get_instance().status
-                act = self.act
-                if status is None or Settings.get_instance().locked:
-                    self.actions()[1].setVisible(False)
-                else:
-                    self.actions()[1].setVisible(True)
-                    act.actions()[0].setChecked(False)
-                    act.actions()[1].setChecked(False)
-                    act.actions()[2].setChecked(False)
-                    act.actions()[status].setChecked(True)
-                self.actions()[2].setVisible(not Settings.get_instance().locked)
-
-            def languageChange(self, *args, **kwargs):
-                self.actions()[0].setText(QtGui.QApplication.translate('tray', 'Open Toxygen', None, QtGui.QApplication.UnicodeUTF8))
-                self.actions()[1].setText(QtGui.QApplication.translate('tray', 'Set status', None, QtGui.QApplication.UnicodeUTF8))
-                self.actions()[2].setText(QtGui.QApplication.translate('tray', 'Exit', None, QtGui.QApplication.UnicodeUTF8))
-                self.act.actions()[0].setText(QtGui.QApplication.translate('tray', 'Online', None, QtGui.QApplication.UnicodeUTF8))
-                self.act.actions()[1].setText(QtGui.QApplication.translate('tray', 'Away', None, QtGui.QApplication.UnicodeUTF8))
-                self.act.actions()[2].setText(QtGui.QApplication.translate('tray', 'Busy', None, QtGui.QApplication.UnicodeUTF8))
-
-        m = Menu()
-        show = m.addAction(QtGui.QApplication.translate('tray', 'Open Toxygen', None, QtGui.QApplication.UnicodeUTF8))
-        sub = m.addMenu(QtGui.QApplication.translate('tray', 'Set status', None, QtGui.QApplication.UnicodeUTF8))
-        onl = sub.addAction(QtGui.QApplication.translate('tray', 'Online', None, QtGui.QApplication.UnicodeUTF8))
-        away = sub.addAction(QtGui.QApplication.translate('tray', 'Away', None, QtGui.QApplication.UnicodeUTF8))
-        busy = sub.addAction(QtGui.QApplication.translate('tray', 'Busy', None, QtGui.QApplication.UnicodeUTF8))
-        onl.setCheckable(True)
-        away.setCheckable(True)
-        busy.setCheckable(True)
-        m.act = sub
-        exit = m.addAction(QtGui.QApplication.translate('tray', 'Exit', None, QtGui.QApplication.UnicodeUTF8))
-
-        def show_window():
-            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:
-                show()
-            else:
-                def correct_pass():
-                    show()
-                    Settings.get_instance().locked = False
-                self.p = UnlockAppScreen(toxencryptsave.ToxEncryptSave.get_instance(), correct_pass)
-                self.p.show()
-
-        def tray_activated(reason):
-            if reason == QtGui.QSystemTrayIcon.DoubleClick:
-                show_window()
-
-        def close_app():
-            settings.closing = True
-            self.ms.close()
-
-        m.connect(show, QtCore.SIGNAL("triggered()"), show_window)
-        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))
-        sub.connect(busy, QtCore.SIGNAL("triggered()"), lambda: m.newStatus(2))
-
-        self.tray.setContextMenu(m)
-        self.tray.show()
-        self.tray.activated.connect(tray_activated)
-
-        self.ms.show()
-
-        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()
-
-        # starting threads for tox iterate and toxav iterate
-        self.mainloop = self.ToxIterateThread(self.tox)
-        self.mainloop.start()
-        self.avloop = self.ToxAVIterateThread(self.tox.AV)
-        self.avloop.start()
-
-        if self.uri is not None:
-            self.ms.add_contact(self.uri)
-
-        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()
-        data = self.tox.get_savedata()
-        ProfileHelper.get_instance().save_profile(data)
-        settings.close()
-        del self.tox
-
-    def reset(self):
-        """
-        Create new tox instance (new network settings)
-        :return: tox instance
-        """
-        self.mainloop.stop = True
-        self.init.stop = True
-        self.avloop.stop = True
-        self.mainloop.wait()
-        self.init.wait()
-        self.avloop.wait()
-        data = self.tox.get_savedata()
-        ProfileHelper.get_instance().save_profile(data)
-        del self.tox
-        # create new tox instance
-        self.tox = profile.tox_factory(data, Settings.get_instance())
-        # init thread
-        self.init = self.InitThread(self.tox, self.ms, self.tray)
-        self.init.start()
-
-        # starting threads for tox iterate and toxav iterate
-        self.mainloop = self.ToxIterateThread(self.tox)
-        self.mainloop.start()
-
-        self.avloop = self.ToxAVIterateThread(self.tox.AV)
-        self.avloop.start()
-
-        plugin_helper = PluginLoader.get_instance()
-        plugin_helper.set_tox(self.tox)
-
-        return self.tox
-
-    # -----------------------------------------------------------------------------------------------------------------
-    # Inner classes
-    # -----------------------------------------------------------------------------------------------------------------
-
-    class InitThread(QtCore.QThread):
-
-        def __init__(self, tox, ms, tray):
-            QtCore.QThread.__init__(self)
-            self.tox, self.ms, self.tray = tox, ms, tray
-            self.stop = False
-
-        def run(self):
-            # initializing callbacks
-            init_callbacks(self.tox, self.ms, self.tray)
-            # bootstrap
-            try:
-                for data in node_generator():
-                    if self.stop:
-                        return
-                    self.tox.bootstrap(*data)
-                    self.tox.add_tcp_relay(*data)
-            except:
-                pass
-            for _ in range(10):
-                if self.stop:
-                    return
-                self.msleep(1000)
-            while not self.tox.self_get_connection_status():
-                try:
-                    for data in node_generator():
-                        if self.stop:
-                            return
-                        self.tox.bootstrap(*data)
-                        self.tox.add_tcp_relay(*data)
-                except:
-                    pass
-                finally:
-                    self.msleep(5000)
-
-    class ToxIterateThread(QtCore.QThread):
-
-        def __init__(self, tox):
-            QtCore.QThread.__init__(self)
-            self.tox = tox
-            self.stop = False
-
-        def run(self):
-            while not self.stop:
-                self.tox.iterate()
-                self.msleep(self.tox.iteration_interval())
-
-    class ToxAVIterateThread(QtCore.QThread):
-
-        def __init__(self, toxav):
-            QtCore.QThread.__init__(self)
-            self.toxav = toxav
-            self.stop = False
-
-        def run(self):
-            while not self.stop:
-                self.toxav.iterate()
-                self.msleep(self.toxav.iteration_interval())
-
-    class Login:
-
-        def __init__(self, arr):
-            self.arr = arr
-
-        def login_screen_close(self, t, number=-1, default=False, name=None):
-            """ Function which processes data from login screen
-            :param t: 0 - window was closed, 1 - new profile was created, 2 - profile loaded
-            :param number: num of chosen profile in list (-1 by default)
-            :param default: was or not chosen profile marked as default
-            :param name: name of new profile
-            """
-            self.t = t
-            self.num = number
-            self.default = default
-            self.name = name
-
-        def get_data(self):
-            return self.arr[self.num]
 
 
 def clean():
-    """Removes all windows libs from libs folder"""
+    """Removes libs folder"""
-    d = curr_directory() + '/libs/'
+    directory = util.get_libs_directory()
-    for fl in ('libtox64.dll', 'libtox.dll', 'libsodium64.a', 'libsodium.a'):
+    util.remove(directory)
-        if os.path.exists(d + fl):
-            os.remove(d + fl)
 
 
-def configure():
+def reset():
-    """Removes unused libs"""
+    Settings.reset_auto_profile()
-    d = curr_directory() + '/libs/'
+
-    is_64bits = sys.maxsize > 2 ** 32
+
-    if not is_64bits:
+def print_toxygen_version():
-        if os.path.exists(d + 'libtox64.dll'):
+    print('Toxygen v' + __version__)
-            os.remove(d + 'libtox64.dll')
-        if os.path.exists(d + 'libsodium64.a'):
-            os.remove(d + 'libsodium64.a')
-    else:
-        if os.path.exists(d + 'libtox.dll'):
-            os.remove(d + 'libtox.dll')
-        if os.path.exists(d + 'libsodium.a'):
-            os.remove(d + 'libsodium.a')
-        try:
-            os.rename(d + 'libtox64.dll', d + 'libtox.dll')
-            os.rename(d + 'libsodium64.a', d + 'libsodium.a')
-        except:
-            pass
 
 
 def main():
-    if len(sys.argv) == 1:
+    parser = argparse.ArgumentParser()
-        toxygen = Toxygen()
+    parser.add_argument('--version', action='store_true', help='Prints Toxygen version')
-    else:  # started with argument(s)
+    parser.add_argument('--clean', action='store_true', help='Delete toxcore libs from libs folder')
-        arg = sys.argv[1]
+    parser.add_argument('--reset', action='store_true', help='Reset default profile')
-        if arg == '--version':
+    parser.add_argument('--uri', help='Add specified Tox ID to friends')
-            print('Toxygen v' + program_version)
+    parser.add_argument('profile', nargs='?', default=None, help='Path to Tox profile')
+    args = parser.parse_args()
+
+    if args.version:
+        print_toxygen_version()
         return
-        elif arg == '--help':
+
-            print('Usage:\ntoxygen path_to_profile\ntoxygen tox_id\ntoxygen --version')
+    if args.clean:
-            return
-        elif arg == '--configure':
-            configure()
-            return
-        elif arg == '--clean':
         clean()
         return
-        else:
+
-            toxygen = Toxygen(arg)
+    if args.reset:
+        reset()
+        return
+
+    toxygen = app.App(__version__, args.profile, args.uri)
     toxygen.main()
 
 

toxygen/mainscreen.py

@@ -1,651 +0,0 @@
-# -*- coding: utf-8 -*-
-
-from menu import *
-from profile import *
-from list_items import *
-from widgets import MultilineEdit, LineEdit
-import plugin_support
-from mainscreen_widgets import *
-import settings
-
-
-class MainWindow(QtGui.QMainWindow, Singleton):
-
-    def __init__(self, tox, reset, tray):
-        super().__init__()
-        Singleton.__init__(self)
-        self.reset = reset
-        self.tray = tray
-        self.setAcceptDrops(True)
-        self.initUI(tox)
-        if settings.Settings.get_instance()['show_welcome_screen']:
-            self.ws = WelcomeScreen()
-
-    def setup_menu(self, MainWindow):
-        self.menubar = QtGui.QMenuBar(MainWindow)
-        self.menubar.setObjectName("menubar")
-        self.menubar.setNativeMenuBar(False)
-        self.menubar.setMinimumSize(self.width(), 25)
-        self.menubar.setMaximumSize(self.width(), 25)
-        self.menubar.setBaseSize(self.width(), 25)
-
-        self.menuProfile = QtGui.QMenu(self.menubar)
-        self.menuProfile.setObjectName("menuProfile")
-        self.menuSettings = QtGui.QMenu(self.menubar)
-        self.menuSettings.setObjectName("menuSettings")
-        self.menuPlugins = QtGui.QMenu(self.menubar)
-        self.menuPlugins.setObjectName("menuPlugins")
-        self.menuAbout = QtGui.QMenu(self.menubar)
-        self.menuAbout.setObjectName("menuAbout")
-
-        self.actionAdd_friend = QtGui.QAction(MainWindow)
-        self.actionAdd_friend.setObjectName("actionAdd_friend")
-        self.actionprofilesettings = QtGui.QAction(MainWindow)
-        self.actionprofilesettings.setObjectName("actionprofilesettings")
-        self.actionPrivacy_settings = QtGui.QAction(MainWindow)
-        self.actionPrivacy_settings.setObjectName("actionPrivacy_settings")
-        self.actionInterface_settings = QtGui.QAction(MainWindow)
-        self.actionInterface_settings.setObjectName("actionInterface_settings")
-        self.actionNotifications = QtGui.QAction(MainWindow)
-        self.actionNotifications.setObjectName("actionNotifications")
-        self.actionNetwork = QtGui.QAction(MainWindow)
-        self.actionNetwork.setObjectName("actionNetwork")
-        self.actionAbout_program = QtGui.QAction(MainWindow)
-        self.actionAbout_program.setObjectName("actionAbout_program")
-        self.actionSettings = QtGui.QAction(MainWindow)
-        self.actionSettings.setObjectName("actionSettings")
-        self.audioSettings = QtGui.QAction(MainWindow)
-        self.pluginData = QtGui.QAction(MainWindow)
-        self.importPlugin = QtGui.QAction(MainWindow)
-        self.lockApp = QtGui.QAction(MainWindow)
-        self.menuProfile.addAction(self.actionAdd_friend)
-        self.menuProfile.addAction(self.actionSettings)
-        self.menuProfile.addAction(self.lockApp)
-        self.menuSettings.addAction(self.actionPrivacy_settings)
-        self.menuSettings.addAction(self.actionInterface_settings)
-        self.menuSettings.addAction(self.actionNotifications)
-        self.menuSettings.addAction(self.actionNetwork)
-        self.menuSettings.addAction(self.audioSettings)
-        self.menuPlugins.addAction(self.pluginData)
-        self.menuPlugins.addAction(self.importPlugin)
-        self.menuAbout.addAction(self.actionAbout_program)
-        self.menubar.addAction(self.menuProfile.menuAction())
-        self.menubar.addAction(self.menuSettings.menuAction())
-        self.menubar.addAction(self.menuPlugins.menuAction())
-        self.menubar.addAction(self.menuAbout.menuAction())
-
-        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.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.pluginData.triggered.connect(self.plugins_menu)
-        self.lockApp.triggered.connect(self.lock_app)
-        self.importPlugin.triggered.connect(self.import_plugin)
-        QtCore.QMetaObject.connectSlotsByName(MainWindow)
-
-    def languageChange(self, *args, **kwargs):
-        self.retranslateUi()
-
-    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.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.menuSettings.setTitle(QtGui.QApplication.translate("MainWindow", "Settings", None, QtGui.QApplication.UnicodeUTF8))
-        self.menuAbout.setTitle(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))
-        self.actionInterface_settings.setText(QtGui.QApplication.translate("MainWindow", "Interface", None, QtGui.QApplication.UnicodeUTF8))
-        self.actionNotifications.setText(QtGui.QApplication.translate("MainWindow", "Notifications", None, QtGui.QApplication.UnicodeUTF8))
-        self.actionNetwork.setText(QtGui.QApplication.translate("MainWindow", "Network", None, QtGui.QApplication.UnicodeUTF8))
-        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.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.importPlugin.setText(QtGui.QApplication.translate("MainWindow", "Import plugin", None, QtGui.QApplication.UnicodeUTF8))
-
-    def setup_right_bottom(self, Form):
-        Form.resize(650, 60)
-        self.messageEdit = MessageArea(Form, self)
-        self.messageEdit.setGeometry(QtCore.QRect(0, 3, 450, 55))
-        self.messageEdit.setObjectName("messageEdit")
-        font = QtGui.QFont()
-        font.setPointSize(10)
-        font.setFamily(settings.Settings.get_instance()['font'])
-        self.messageEdit.setFont(font)
-
-        self.sendMessageButton = QtGui.QPushButton(Form)
-        self.sendMessageButton.setGeometry(QtCore.QRect(565, 3, 60, 55))
-        self.sendMessageButton.setObjectName("sendMessageButton")
-
-        self.menuButton = MenuButton(Form, self.show_menu)
-        self.menuButton.setGeometry(QtCore.QRect(QtCore.QRect(455, 3, 55, 55)))
-
-        pixmap = QtGui.QPixmap('send.png')
-        icon = QtGui.QIcon(pixmap)
-        self.sendMessageButton.setIcon(icon)
-        self.sendMessageButton.setIconSize(QtCore.QSize(45, 60))
-
-        pixmap = QtGui.QPixmap('menu.png')
-        icon = QtGui.QIcon(pixmap)
-        self.menuButton.setIcon(icon)
-        self.menuButton.setIconSize(QtCore.QSize(40, 40))
-
-        self.sendMessageButton.clicked.connect(self.send_message)
-
-        QtCore.QMetaObject.connectSlotsByName(Form)
-
-    def setup_left_center_menu(self, Form):
-        Form.resize(270, 25)
-        self.search_label = QtGui.QLabel(Form)
-        self.search_label.setGeometry(QtCore.QRect(3, 2, 20, 20))
-        pixmap = QtGui.QPixmap()
-        pixmap.load(curr_directory() + '/images/search.png')
-        self.search_label.setScaledContents(False)
-        self.search_label.setPixmap(pixmap)
-
-        self.contact_name = LineEdit(Form)
-        self.contact_name.setGeometry(QtCore.QRect(0, 0, 150, 25))
-        self.contact_name.setObjectName("contact_name")
-        self.contact_name.textChanged.connect(self.filtering)
-
-        self.online_contacts = QtGui.QComboBox(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_()
-
-        QtCore.QMetaObject.connectSlotsByName(Form)
-
-    def setup_left_top(self, Form):
-        Form.setCursor(QtCore.Qt.PointingHandCursor)
-        Form.setMinimumSize(QtCore.QSize(270, 100))
-        Form.setMaximumSize(QtCore.QSize(270, 100))
-        Form.setBaseSize(QtCore.QSize(270, 100))
-        self.avatar_label = Form.avatar_label = QtGui.QLabel(Form)
-        self.avatar_label.setGeometry(QtCore.QRect(5, 30, 64, 64))
-        self.avatar_label.setScaledContents(False)
-        self.avatar_label.setAlignment(QtCore.Qt.AlignCenter)
-        self.name = Form.name = DataLabel(Form)
-        Form.name.setGeometry(QtCore.QRect(75, 40, 150, 25))
-        font = QtGui.QFont()
-        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))
-        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))
-        self.avatar_label.mouseReleaseEvent = self.profile_settings
-        self.status_message.mouseReleaseEvent = self.profile_settings
-        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)
-        self.account_avatar = QtGui.QLabel(Form)
-        self.account_avatar.setGeometry(QtCore.QRect(10, 30, 64, 64))
-        self.account_avatar.setScaledContents(False)
-        self.account_name = DataLabel(Form)
-        self.account_name.setGeometry(QtCore.QRect(100, 25, 400, 25))
-        self.account_name.setTextInteractionFlags(QtCore.Qt.LinksAccessibleByMouse)
-        font = QtGui.QFont()
-        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.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.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.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))
-        pixmap = QtGui.QPixmap(QtCore.QSize(50, 30))
-        pixmap.load(curr_directory() + '/images/typing.png')
-        self.typing.setScaledContents(False)
-        self.typing.setPixmap(pixmap.scaled(50, 30, QtCore.Qt.KeepAspectRatio))
-        self.typing.setVisible(False)
-        QtCore.QMetaObject.connectSlotsByName(Form)
-
-    def setup_left_center(self, widget):
-        self.friends_list = QtGui.QListWidget(widget)
-        self.friends_list.setObjectName("friends_list")
-        self.friends_list.setGeometry(0, 0, 270, 310)
-        self.friends_list.clicked.connect(self.friend_click)
-        self.friends_list.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
-        self.friends_list.connect(self.friends_list, QtCore.SIGNAL("customContextMenuRequested(QPoint)"),
-                                  self.friend_right_click)
-        self.friends_list.setVerticalScrollMode(QtGui.QAbstractItemView.ScrollPerPixel)
-
-    def setup_right_center(self, widget):
-        self.messages = QtGui.QListWidget(widget)
-        self.messages.setGeometry(0, 0, 620, 310)
-        self.messages.setObjectName("messages")
-        self.messages.setSpacing(1)
-        self.messages.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOn)
-        self.messages.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
-        # self.messages.setFocusPolicy(QtCore.Qt.NoFocus)
-
-        def load(pos):
-            if not pos:
-                self.profile.load_history()
-                self.messages.verticalScrollBar().setValue(1)
-        self.messages.verticalScrollBar().valueChanged.connect(load)
-        self.messages.setVerticalScrollMode(QtGui.QAbstractItemView.ScrollPerPixel)
-        self.messages.setSelectionMode(QtGui.QAbstractItemView.ExtendedSelection)
-
-    def initUI(self, tox):
-        self.setMinimumSize(920, 500)
-        s = Settings.get_instance()
-        self.setGeometry(s['x'], s['y'], s['width'], s['height'])
-        self.setWindowTitle('Toxygen')
-        os.chdir(curr_directory() + '/images/')
-        main = QtGui.QWidget()
-        grid = QtGui.QGridLayout()
-        search = QtGui.QWidget()
-        name = QtGui.QWidget()
-        info = QtGui.QWidget()
-        main_list = QtGui.QWidget()
-        messages = QtGui.QWidget()
-        message_buttons = QtGui.QWidget()
-        self.setup_left_center_menu(search)
-        self.setup_left_top(name)
-        self.setup_right_center(messages)
-        self.setup_right_top(info)
-        self.setup_right_bottom(message_buttons)
-        self.setup_left_center(main_list)
-        if not Settings.get_instance()['mirror_mode']:
-            grid.addWidget(search, 1, 0)
-            grid.addWidget(name, 0, 0)
-            grid.addWidget(messages, 1, 1, 2, 1)
-            grid.addWidget(info, 0, 1)
-            grid.addWidget(message_buttons, 3, 1)
-            grid.addWidget(main_list, 2, 0, 2, 1)
-            grid.setColumnMinimumWidth(1, 500)
-            grid.setColumnMinimumWidth(0, 270)
-        else:
-            grid.addWidget(search, 1, 1)
-            grid.addWidget(name, 0, 1)
-            grid.addWidget(messages, 1, 0, 2, 1)
-            grid.addWidget(info, 0, 0)
-            grid.addWidget(message_buttons, 3, 0)
-            grid.addWidget(main_list, 2, 1, 2, 1)
-            grid.setColumnMinimumWidth(0, 500)
-            grid.setColumnMinimumWidth(1, 270)
-        grid.setSpacing(0)
-        grid.setContentsMargins(0, 0, 0, 0)
-        grid.setRowMinimumHeight(0, 100)
-        grid.setRowMinimumHeight(1, 25)
-        grid.setRowMinimumHeight(2, 320)
-        grid.setRowMinimumHeight(3, 55)
-        grid.setColumnStretch(1, 1)
-        grid.setRowStretch(2, 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, event):
-        self.profile.save_history()
-        self.profile.close()
-        s = Settings.get_instance()
-        if not s['close_to_tray'] or s.closing:
-            s['x'] = self.geometry().x()
-            s['y'] = self.geometry().y()
-            s['width'] = self.width()
-            s['height'] = self.height()
-            s.save()
-            QtGui.QApplication.closeAllWindows()
-            event.accept()
-        else:
-            event.ignore()
-            self.hide()
-
-    def resizeEvent(self, *args, **kwargs):
-        self.messages.setGeometry(0, 0, self.width() - 270, self.height() - 155)
-        self.friends_list.setGeometry(0, 0, 270, self.height() - 125)
-
-        self.videocallButton.setGeometry(QtCore.QRect(self.width() - 330, 40, 50, 50))
-        self.callButton.setGeometry(QtCore.QRect(self.width() - 390, 40, 50, 50))
-        self.typing.setGeometry(QtCore.QRect(self.width() - 450, 50, 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_status.setGeometry(QtCore.QRect(100, 60, self.width() - 560, 25))
-        self.messageEdit.setFocus()
-        self.profile.update()
-
-    def keyPressEvent(self, event):
-        if event.key() == QtCore.Qt.Key_Escape:
-            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()
-        else:
-            super(MainWindow, self).keyPressEvent(event)
-
-    # -----------------------------------------------------------------------------------------------------------------
-    # Functions which called when user click in menu
-    # -----------------------------------------------------------------------------------------------------------------
-
-    def about_program(self):
-        import util
-        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: https://github.com/toxygen-project/toxygen/')
-        msgBox.exec_()
-
-    def network_settings(self):
-        self.n_s = NetworkSettings(self.reset)
-        self.n_s.show()
-
-    def plugins_menu(self):
-        self.p_s = PluginsSettings()
-        self.p_s.show()
-
-    def add_contact(self, link=''):
-        self.a_c = AddContact(link or '')
-        self.a_c.show()
-
-    def profile_settings(self, *args):
-        self.p_s = ProfileSettings()
-        self.p_s.show()
-
-    def privacy_settings(self):
-        self.priv_s = PrivacySettings()
-        self.priv_s.show()
-
-    def notification_settings(self):
-        self.notif_s = NotificationsSettings()
-        self.notif_s.show()
-
-    def interface_settings(self):
-        self.int_s = InterfaceSettings()
-        self.int_s.show()
-
-    def audio_settings(self):
-        self.audio_s = AudioSettings()
-        self.audio_s.show()
-
-    def import_plugin(self):
-        import util
-        directory = QtGui.QFileDialog.getExistingDirectory(self,
-                                                           QtGui.QApplication.translate("MainWindow", 'Choose folder with plugin',
-                                                                                        None,
-                                                                                        QtGui.QApplication.UnicodeUTF8),
-                                                           util.curr_directory(),
-                                                           QtGui.QFileDialog.ShowDirsOnly | QtGui.QFileDialog.DontUseNativeDialog)
-        if directory:
-            src = directory + '/'
-            dest = curr_directory() + '/plugins/'
-            util.copy(src, dest)
-            msgBox = QtGui.QMessageBox()
-            msgBox.setWindowTitle(
-                QtGui.QApplication.translate("MainWindow", "Restart Toxygen", None, QtGui.QApplication.UnicodeUTF8))
-            msgBox.setText(
-                QtGui.QApplication.translate("MainWindow", 'Plugin will be loaded after restart', None,
-                                             QtGui.QApplication.UnicodeUTF8))
-            msgBox.exec_()
-
-    def lock_app(self):
-        if toxencryptsave.ToxEncryptSave.get_instance().has_password():
-            Settings.get_instance().locked = True
-            self.hide()
-        else:
-            msgBox = QtGui.QMessageBox()
-            msgBox.setWindowTitle(
-                QtGui.QApplication.translate("MainWindow", "Cannot lock app", None, QtGui.QApplication.UnicodeUTF8))
-            msgBox.setText(
-                QtGui.QApplication.translate("MainWindow", 'Error. Profile password is not set.', None,
-                                             QtGui.QApplication.UnicodeUTF8))
-            msgBox.exec_()
-
-    def show_menu(self):
-        if not hasattr(self, 'menu'):
-            self.menu = DropdownMenu(self)
-        self.menu.setGeometry(QtCore.QRect(0 if Settings.get_instance()['mirror_mode'] else 270,
-                                           self.height() - 120,
-                                           180,
-                                           120))
-        self.menu.show()
-
-    # -----------------------------------------------------------------------------------------------------------------
-    # Messages, calls and file transfers
-    # -----------------------------------------------------------------------------------------------------------------
-
-    def send_message(self):
-        text = self.messageEdit.toPlainText()
-        self.profile.send_message(text)
-
-    def send_file(self):
-        self.menu.hide()
-        if self.profile.active_friend + 1:
-            choose = QtGui.QApplication.translate("MainWindow", 'Choose file', None, QtGui.QApplication.UnicodeUTF8)
-            name = QtGui.QFileDialog.getOpenFileName(self, choose, options=QtGui.QFileDialog.DontUseNativeDialog)
-            if name[0]:
-                self.profile.send_file(name[0])
-
-    def send_screenshot(self, hide=False):
-        self.menu.hide()
-        if self.profile.active_friend + 1:
-            self.sw = ScreenShotWindow(self)
-            self.sw.show()
-            if hide:
-                self.hide()
-
-    def send_smiley(self):
-        self.menu.hide()
-        if self.profile.active_friend + 1:
-            self.smiley = SmileyWindow(self)
-            self.smiley.setGeometry(QtCore.QRect(self.x() if Settings.get_instance()['mirror_mode'] else 270 + self.x(),
-                                                 self.y() + self.height() - 200,
-                                                 self.smiley.width(),
-                                                 self.smiley.height()))
-            self.smiley.show()
-
-    def send_sticker(self):
-        self.menu.hide()
-        if self.profile.active_friend + 1:
-            self.sticker = StickerWindow(self)
-            self.sticker.setGeometry(QtCore.QRect(self.x() if Settings.get_instance()['mirror_mode'] else 270 + self.x(),
-                                                 self.y() + self.height() - 200,
-                                                 self.sticker.width(),
-                                                 self.sticker.height()))
-            self.sticker.show()
-
-    def active_call(self):
-        self.update_call_state('finish_call')
-
-    def incoming_call(self):
-        self.update_call_state('incoming_call')
-
-    def call_finished(self):
-        self.update_call_state('call')
-
-    def update_call_state(self, fl):
-        # TODO: do smth with video call button
-        os.chdir(curr_directory() + '/images/')
-        pixmap = QtGui.QPixmap(curr_directory() + '/images/{}.png'.format(fl))
-        icon = QtGui.QIcon(pixmap)
-        self.callButton.setIcon(icon)
-        self.callButton.setIconSize(QtCore.QSize(50, 50))
-        pixmap = QtGui.QPixmap(curr_directory() + '/images/videocall.png')
-        icon = QtGui.QIcon(pixmap)
-        self.videocallButton.setIcon(icon)
-        self.videocallButton.setIconSize(QtCore.QSize(35, 35))
-
-    # -----------------------------------------------------------------------------------------------------------------
-    # Functions which called when user open context menu in friends list
-    # -----------------------------------------------------------------------------------------------------------------
-
-    def friend_right_click(self, pos):
-        item = self.friends_list.itemAt(pos)
-        num = self.friends_list.indexFromItem(item).row()
-        friend = Profile.get_instance().get_friend(num)
-        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))
-
-            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))
-            copy_key_item = copy_menu.addAction(QtGui.QApplication.translate("MainWindow", 'Public key', None, QtGui.QApplication.UnicodeUTF8))
-
-            auto_accept_item = self.listMenu.addAction(auto)
-            remove_item = self.listMenu.addAction(QtGui.QApplication.translate("MainWindow", 'Remove 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)
-            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(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()
-
-    def show_note(self, friend):
-        s = Settings.get_instance()
-        note = s['notes'][friend.tox_id] if friend.tox_id in s['notes'] else ''
-        user = QtGui.QApplication.translate("MainWindow", 'Notes about user', None, QtGui.QApplication.UnicodeUTF8)
-        user = '{} {}'.format(user, friend.name)
-
-        def save_note(text):
-            if friend.tox_id in s['notes']:
-                del s['notes'][friend.tox_id]
-            if text:
-                s['notes'][friend.tox_id] = text
-            s.save()
-        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 copy_friend_key(self, num):
-        tox_id = self.profile.friend_public_key(num)
-        clipboard = QtGui.QApplication.clipboard()
-        clipboard.setText(tox_id)
-
-    def copy_name(self, friend):
-        clipboard = QtGui.QApplication.clipboard()
-        clipboard.setText(friend.name)
-
-    def copy_status(self, friend):
-        clipboard = QtGui.QApplication.clipboard()
-        clipboard.setText(friend.status_message)
-
-    def clear_history(self, num):
-        self.profile.clear_history(num)
-
-    def auto_accept(self, num, value):
-        settings = Settings.get_instance()
-        tox_id = self.profile.friend_public_key(num)
-        if value:
-            settings['auto_accept_from_friends'].append(tox_id)
-        else:
-            settings['auto_accept_from_friends'].remove(tox_id)
-        settings.save()
-
-    # -----------------------------------------------------------------------------------------------------------------
-    # Functions which called when user click somewhere else
-    # -----------------------------------------------------------------------------------------------------------------
-
-    def friend_click(self, index):
-        num = index.row()
-        self.profile.set_active(num)
-
-    def mouseReleaseEvent(self, event):
-        pos = self.connection_status.pos()
-        x, y = pos.x() + self.user_info.pos().x(), pos.y() + self.user_info.pos().y()
-        if (x < event.x() < x + 32) and (y < event.y() < y + 32):
-            self.profile.change_status()
-        else:
-            super(MainWindow, self).mouseReleaseEvent(event)
-
-    def filtering(self):
-        self.profile.filtration(self.online_contacts.currentIndex() == 1, self.contact_name.text())

toxygen/mainscreen_widgets.py

@@ -1,394 +0,0 @@
-try:
-    from PySide import QtCore, QtGui
-except ImportError:
-    from PyQt4 import QtCore, QtGui
-from widgets import RubberBand, create_menu, QRightClickButton, CenteredWidget
-from profile import Profile
-import smileys
-import util
-
-
-class MessageArea(QtGui.QPlainTextEdit):
-    """User types messages here"""
-
-    def __init__(self, parent, form):
-        super(MessageArea, self).__init__(parent)
-        self.parent = form
-        self.setAcceptDrops(True)
-        self.timer = QtCore.QTimer(self)
-        self.timer.timeout.connect(lambda: self.parent.profile.send_typing(False))
-
-    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()
-            if modifiers & QtCore.Qt.ControlModifier or modifiers & QtCore.Qt.ShiftModifier:
-                self.insertPlainText('\n')
-            else:
-                if self.timer.isActive():
-                    self.timer.stop()
-                self.parent.profile.send_typing(False)
-                self.parent.send_message()
-        elif event.key() == QtCore.Qt.Key_Up and not self.toPlainText():
-            self.appendPlainText(Profile.get_instance().get_last_message())
-        else:
-            self.parent.profile.send_typing(True)
-            if self.timer.isActive():
-                self.timer.stop()
-            self.timer.start(5000)
-            super(MessageArea, self).keyPressEvent(event)
-
-    def contextMenuEvent(self, event):
-        menu = create_menu(self.createStandardContextMenu())
-        menu.exec_(event.globalPos())
-        del menu
-
-    def dragEnterEvent(self, e):
-        e.accept()
-
-    def dragMoveEvent(self, e):
-        e.accept()
-
-    def dropEvent(self, e):
-        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()
-
-    def pasteEvent(self, text=None):
-        text = text or QtGui.QApplication.clipboard().text()
-        if text.startswith('file://'):
-            self.parent.profile.send_file(text[7:])
-        else:
-            self.insertPlainText(text)
-
-
-class ScreenShotWindow(QtGui.QWidget):
-
-    def __init__(self, parent):
-        super(ScreenShotWindow, self).__init__()
-        self.parent = parent
-        self.setMouseTracking(True)
-        self.setWindowFlags(self.windowFlags() | QtCore.Qt.FramelessWindowHint | QtCore.Qt.WindowStaysOnTopHint)
-        self.showFullScreen()
-        self.setWindowOpacity(0.5)
-        self.rubberband = RubberBand()
-
-    def closeEvent(self, *args):
-        if self.parent.isHidden():
-            self.parent.show()
-
-    def mousePressEvent(self, event):
-        self.origin = event.pos()
-        self.rubberband.setGeometry(QtCore.QRect(self.origin, QtCore.QSize()))
-        self.rubberband.show()
-        QtGui.QWidget.mousePressEvent(self, event)
-
-    def mouseMoveEvent(self, event):
-        if self.rubberband.isVisible():
-            self.rubberband.setGeometry(QtCore.QRect(self.origin, event.pos()).normalized())
-            left = QtGui.QRegion(QtCore.QRect(0, 0, self.rubberband.x(), self.height()))
-            right = QtGui.QRegion(QtCore.QRect(self.rubberband.x() + self.rubberband.width(), 0, self.width(), self.height()))
-            top = QtGui.QRegion(0, 0, self.width(), self.rubberband.y())
-            bottom = QtGui.QRegion(0, self.rubberband.y() + self.rubberband.height(), self.width(), self.height())
-            self.setMask(left + right + top + bottom)
-
-    def mouseReleaseEvent(self, event):
-        if self.rubberband.isVisible():
-            self.rubberband.hide()
-            rect = self.rubberband.geometry()
-            if rect.width() and rect.height():
-                p = QtGui.QPixmap.grabWindow(QtGui.QApplication.desktop().winId(),
-                                             rect.x() + 4,
-                                             rect.y() + 4,
-                                             rect.width() - 8,
-                                             rect.height() - 8)
-                byte_array = QtCore.QByteArray()
-                buffer = QtCore.QBuffer(byte_array)
-                buffer.open(QtCore.QIODevice.WriteOnly)
-                p.save(buffer, 'PNG')
-                Profile.get_instance().send_screenshot(bytes(byte_array.data()))
-            self.close()
-
-    def keyPressEvent(self, event):
-        if event.key() == QtCore.Qt.Key_Escape:
-            self.rubberband.setHidden(True)
-            self.close()
-        else:
-            super(ScreenShotWindow, self).keyPressEvent(event)
-
-
-class SmileyWindow(QtGui.QWidget):
-    """
-    Smiley selection window
-    """
-
-    def __init__(self, parent):
-        super(SmileyWindow, self).__init__()
-        self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
-        inst = smileys.SmileyLoader.get_instance()
-        self.data = inst.get_smileys()
-        count = len(self.data)
-        if not count:
-            self.close()
-        self.page_size = int(pow(count / 8, 0.5) + 1) * 8  # smileys per page
-        if count % self.page_size == 0:
-            self.page_count = count // self.page_size
-        else:
-            self.page_count = round(count / self.page_size + 0.5)
-        self.page = -1
-        self.radio = []
-        self.parent = parent
-        for i in range(self.page_count):  # buttons with smileys
-            elem = QtGui.QRadioButton(self)
-            elem.setGeometry(QtCore.QRect(i * 20 + 5, 180, 20, 20))
-            elem.clicked.connect(lambda i=i: self.checked(i))
-            self.radio.append(elem)
-        width = max(self.page_count * 20 + 30, (self.page_size + 5) * 8 // 10)
-        self.setMaximumSize(width, 200)
-        self.setMinimumSize(width, 200)
-        self.buttons = []
-        for i in range(self.page_size):  # pages - radio buttons
-            b = QtGui.QPushButton(self)
-            b.setGeometry(QtCore.QRect((i // 8) * 20 + 5, (i % 8) * 20, 20, 20))
-            b.clicked.connect(lambda i=i: self.clicked(i))
-            self.buttons.append(b)
-        self.checked(0)
-
-    def checked(self, pos):  # new page opened
-        self.radio[self.page].setChecked(False)
-        self.radio[pos].setChecked(True)
-        self.page = pos
-        start = self.page * self.page_size
-        for i in range(self.page_size):
-            try:
-                self.buttons[i].setVisible(True)
-                pixmap = QtGui.QPixmap(self.data[start + i][1])
-                icon = QtGui.QIcon(pixmap)
-                self.buttons[i].setIcon(icon)
-            except:
-                self.buttons[i].setVisible(False)
-
-    def clicked(self, pos):  # smiley selected
-        pos += self.page * self.page_size
-        smiley = self.data[pos][0]
-        self.parent.messageEdit.insertPlainText(smiley)
-        self.close()
-
-    def leaveEvent(self, event):
-        self.close()
-
-
-class MenuButton(QtGui.QPushButton):
-
-    def __init__(self, parent, enter):
-        super(MenuButton, self).__init__(parent)
-        self.enter = enter
-
-    def enterEvent(self, event):
-        self.enter()
-        super(MenuButton, self).enterEvent(event)
-
-
-class DropdownMenu(QtGui.QWidget):
-
-    def __init__(self, parent):
-        super(DropdownMenu, self).__init__(parent)
-        self.installEventFilter(self)
-        self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
-        self.setMaximumSize(180, 120)
-        self.setMinimumSize(180, 120)
-        self.screenshotButton = QRightClickButton(self)
-        self.screenshotButton.setGeometry(QtCore.QRect(0, 60, 60, 60))
-        self.screenshotButton.setObjectName("screenshotButton")
-
-        self.fileTransferButton = QtGui.QPushButton(self)
-        self.fileTransferButton.setGeometry(QtCore.QRect(60, 60, 60, 60))
-        self.fileTransferButton.setObjectName("fileTransferButton")
-
-        self.audioMessageButton = QtGui.QPushButton(self)
-        self.audioMessageButton.setGeometry(QtCore.QRect(120, 60, 60, 60))
-
-        self.smileyButton = QtGui.QPushButton(self)
-        self.smileyButton.setGeometry(QtCore.QRect(0, 0, 60, 60))
-
-        self.videoMessageButton = QtGui.QPushButton(self)
-        self.videoMessageButton.setGeometry(QtCore.QRect(120, 0, 60, 60))
-
-        self.stickerButton = QtGui.QPushButton(self)
-        self.stickerButton.setGeometry(QtCore.QRect(60, 0, 60, 60))
-
-        pixmap = QtGui.QPixmap(util.curr_directory() + '/images/file.png')
-        icon = QtGui.QIcon(pixmap)
-        self.fileTransferButton.setIcon(icon)
-        self.fileTransferButton.setIconSize(QtCore.QSize(50, 50))
-        pixmap = QtGui.QPixmap(util.curr_directory() + '/images/screenshot.png')
-        icon = QtGui.QIcon(pixmap)
-        self.screenshotButton.setIcon(icon)
-        self.screenshotButton.setIconSize(QtCore.QSize(50, 60))
-        pixmap = QtGui.QPixmap(util.curr_directory() + '/images/audio_message.png')
-        icon = QtGui.QIcon(pixmap)
-        self.audioMessageButton.setIcon(icon)
-        self.audioMessageButton.setIconSize(QtCore.QSize(50, 50))
-        pixmap = QtGui.QPixmap(util.curr_directory() + '/images/smiley.png')
-        icon = QtGui.QIcon(pixmap)
-        self.smileyButton.setIcon(icon)
-        self.smileyButton.setIconSize(QtCore.QSize(50, 50))
-        pixmap = QtGui.QPixmap(util.curr_directory() + '/images/video_message.png')
-        icon = QtGui.QIcon(pixmap)
-        self.videoMessageButton.setIcon(icon)
-        self.videoMessageButton.setIconSize(QtCore.QSize(55, 55))
-        pixmap = QtGui.QPixmap(util.curr_directory() + '/images/sticker.png')
-        icon = QtGui.QIcon(pixmap)
-        self.stickerButton.setIcon(icon)
-        self.stickerButton.setIconSize(QtCore.QSize(55, 55))
-
-        self.screenshotButton.setToolTip(QtGui.QApplication.translate("MenuWindow", "Send screenshot", None, QtGui.QApplication.UnicodeUTF8))
-        self.fileTransferButton.setToolTip(QtGui.QApplication.translate("MenuWindow", "Send file", None, QtGui.QApplication.UnicodeUTF8))
-        self.audioMessageButton.setToolTip(QtGui.QApplication.translate("MenuWindow", "Send audio message", None, QtGui.QApplication.UnicodeUTF8))
-        self.videoMessageButton.setToolTip(QtGui.QApplication.translate("MenuWindow", "Send video message", None, QtGui.QApplication.UnicodeUTF8))
-        self.smileyButton.setToolTip(QtGui.QApplication.translate("MenuWindow", "Add smiley", None, QtGui.QApplication.UnicodeUTF8))
-        self.stickerButton.setToolTip(QtGui.QApplication.translate("MenuWindow", "Send sticker", None, QtGui.QApplication.UnicodeUTF8))
-
-        self.fileTransferButton.clicked.connect(parent.send_file)
-        self.screenshotButton.clicked.connect(parent.send_screenshot)
-        self.connect(self.screenshotButton, QtCore.SIGNAL("rightClicked()"), lambda: parent.send_screenshot(True))
-        self.smileyButton.clicked.connect(parent.send_smiley)
-        self.stickerButton.clicked.connect(parent.send_sticker)
-
-    def leaveEvent(self, event):
-        self.close()
-
-    def eventFilter(self, object, event):
-        if event.type() == QtCore.QEvent.WindowDeactivate:
-            self.close()
-        return False
-
-
-class StickerItem(QtGui.QWidget):
-
-    def __init__(self, fl):
-        super(StickerItem, self).__init__()
-        self._image_label = QtGui.QLabel(self)
-        self.path = fl
-        self.pixmap = QtGui.QPixmap()
-        self.pixmap.load(fl)
-        if self.pixmap.width() > 150:
-            self.pixmap = self.pixmap.scaled(150, 200, QtCore.Qt.KeepAspectRatio)
-        self.setFixedSize(150, self.pixmap.height())
-        self._image_label.setPixmap(self.pixmap)
-
-
-class StickerWindow(QtGui.QWidget):
-    """Sticker selection window"""
-
-    def __init__(self, parent):
-        super(StickerWindow, self).__init__()
-        self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
-        self.setMaximumSize(250, 200)
-        self.setMinimumSize(250, 200)
-        self.list = QtGui.QListWidget(self)
-        self.list.setGeometry(QtCore.QRect(0, 0, 250, 200))
-        self.arr = smileys.sticker_loader()
-        for sticker in self.arr:
-            item = StickerItem(sticker)
-            elem = QtGui.QListWidgetItem()
-            elem.setSizeHint(QtCore.QSize(250, item.height()))
-            self.list.addItem(elem)
-            self.list.setItemWidget(elem, item)
-        self.list.setVerticalScrollMode(QtGui.QAbstractItemView.ScrollPerPixel)
-        self.list.setSpacing(3)
-        self.list.clicked.connect(self.click)
-        self.parent = parent
-
-    def click(self, index):
-        num = index.row()
-        self.parent.profile.send_sticker(self.arr[num])
-        self.close()
-
-    def leaveEvent(self, event):
-        self.close()
-
-
-class WelcomeScreen(CenteredWidget):
-
-    def __init__(self):
-        super().__init__()
-        self.setMaximumSize(250, 200)
-        self.setMinimumSize(250, 200)
-        self.center()
-        self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
-        self.text = QtGui.QTextBrowser(self)
-        self.text.setGeometry(QtCore.QRect(0, 0, 250, 170))
-        self.text.setOpenExternalLinks(True)
-        self.checkbox = QtGui.QCheckBox(self)
-        self.checkbox.setGeometry(QtCore.QRect(5, 170, 240, 30))
-        self.checkbox.setText(QtGui.QApplication.translate('WelcomeScreen', "Don't show again",
-                                                           None, QtGui.QApplication.UnicodeUTF8))
-        self.setWindowTitle(QtGui.QApplication.translate('WelcomeScreen', 'Tip of the day',
-                                                         None, QtGui.QApplication.UnicodeUTF8))
-        import random
-        num = random.randint(0, 10)
-        if num == 0:
-            text = QtGui.QApplication.translate('WelcomeScreen', 'Press Esc if you want hide app to tray.',
-                                                None, QtGui.QApplication.UnicodeUTF8)
-        elif num == 1:
-            text = QtGui.QApplication.translate('WelcomeScreen',
-                                                'Right click on screenshot button hides app to tray during screenshot.',
-                                                None, QtGui.QApplication.UnicodeUTF8)
-        elif num == 2:
-            text = QtGui.QApplication.translate('WelcomeScreen',
-                                                'You can use Tox over Tor. For more info read <a href="https://wiki.tox.chat/users/tox_over_tor_tot">this post</a>',
-                                                None, QtGui.QApplication.UnicodeUTF8)
-        elif num == 3:
-            text = QtGui.QApplication.translate('WelcomeScreen',
-                                                'Use Settings -> Interface to customize interface.',
-                                                None, QtGui.QApplication.UnicodeUTF8)
-        elif num == 4:
-            text = QtGui.QApplication.translate('WelcomeScreen',
-                                                'Set profile password via Profile -> Settings. Password allows Toxygen encrypt your history and settings.',
-                                                None, QtGui.QApplication.UnicodeUTF8)
-        elif num == 5:
-            text = QtGui.QApplication.translate('WelcomeScreen',
-                                                '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:
-            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)
-        elif num == 8:
-            text = QtGui.QApplication.translate('WelcomeScreen',
-                                                'Delete single message in chat: make right click on spinner or message time and choose "Delete" in menu',
-                                                None, QtGui.QApplication.UnicodeUTF8)
-        elif num == 9:
-            text = QtGui.QApplication.translate('WelcomeScreen',
-                                                'Use right click on inline image to save it',
-                                                None, QtGui.QApplication.UnicodeUTF8)
-        else:
-            text = QtGui.QApplication.translate('WelcomeScreen',
-                                                'Set new NoSpam to avoid spam friend requests: Profile -> Settings -> Set new NoSpam.',
-                                                None, QtGui.QApplication.UnicodeUTF8)
-        self.text.setHtml(text)
-        self.checkbox.stateChanged.connect(self.not_show)
-        QtCore.QTimer.singleShot(1000, self.show)
-
-    def not_show(self):
-        import settings
-        s = settings.Settings.get_instance()
-        s['show_welcome_screen'] = False
-        s.save()

toxygen/menu.py

@@ -1,901 +0,0 @@
-try:
-    from PySide import QtCore, QtGui
-except ImportError:
-    from PyQt4 import QtCore, QtGui
-from settings import *
-from profile import Profile
-from util import curr_directory, copy
-from widgets import CenteredWidget, DataLabel, LineEdit
-import pyaudio
-import toxencryptsave
-import plugin_support
-
-
-class AddContact(CenteredWidget):
-    """Add contact form"""
-
-    def __init__(self, tox_id=''):
-        super(AddContact, self).__init__()
-        self.initUI(tox_id)
-        self._adding = False
-
-    def initUI(self, tox_id):
-        self.setObjectName('AddContact')
-        self.resize(568, 306)
-        self.sendRequestButton = QtGui.QPushButton(self)
-        self.sendRequestButton.setGeometry(QtCore.QRect(50, 270, 471, 31))
-        self.sendRequestButton.setMinimumSize(QtCore.QSize(0, 0))
-        self.sendRequestButton.setBaseSize(QtCore.QSize(0, 0))
-        self.sendRequestButton.setObjectName("sendRequestButton")
-        self.sendRequestButton.clicked.connect(self.add_friend)
-        self.tox_id = LineEdit(self)
-        self.tox_id.setGeometry(QtCore.QRect(50, 40, 471, 27))
-        self.tox_id.setObjectName("lineEdit")
-        self.tox_id.setText(tox_id)
-        self.label = QtGui.QLabel(self)
-        self.label.setGeometry(QtCore.QRect(50, 10, 80, 20))
-        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)
-        self.error_label.setStyleSheet("QLabel { color: #BC1C1C; }")
-        self.label.setObjectName("label")
-        self.message_edit = QtGui.QTextEdit(self)
-        self.message_edit.setGeometry(QtCore.QRect(50, 110, 471, 151))
-        self.message_edit.setObjectName("textEdit")
-        self.message = QtGui.QLabel(self)
-        self.message.setGeometry(QtCore.QRect(50, 70, 101, 31))
-        self.message.setFont(font)
-        self.message.setObjectName("label_2")
-        self.retranslateUi()
-        self.message_edit.setText('Hello! Add me to your contact list please')
-        font.setPointSize(12)
-        font.setBold(True)
-        self.label.setFont(font)
-        self.message.setFont(font)
-        QtCore.QMetaObject.connectSlotsByName(self)
-
-    def add_friend(self):
-        if self._adding:
-            return
-        self._adding = True
-        profile = Profile.get_instance()
-        send = profile.send_friend_request(self.tox_id.text().strip(), self.message_edit.toPlainText())
-        self._adding = False
-        if send is True:
-            # request was successful
-            self.close()
-        else:  # print error data
-            self.error_label.setText(send)
-
-    def retranslateUi(self):
-        self.setWindowTitle(QtGui.QApplication.translate('AddContact', "Add contact", None, QtGui.QApplication.UnicodeUTF8))
-        self.sendRequestButton.setText(QtGui.QApplication.translate("Form", "Send request", None, QtGui.QApplication.UnicodeUTF8))
-        self.label.setText(QtGui.QApplication.translate('AddContact', "TOX ID:", None, QtGui.QApplication.UnicodeUTF8))
-        self.message.setText(QtGui.QApplication.translate('AddContact', "Message:", None, QtGui.QApplication.UnicodeUTF8))
-        self.tox_id.setPlaceholderText(QtGui.QApplication.translate('AddContact', "TOX ID or public key of contact", None, QtGui.QApplication.UnicodeUTF8))
-
-
-class ProfileSettings(CenteredWidget):
-    """Form with profile settings such as name, status, TOX ID"""
-    def __init__(self):
-        super(ProfileSettings, self).__init__()
-        self.initUI()
-        self.center()
-
-    def initUI(self):
-        self.setObjectName("ProfileSettingsForm")
-        self.setMinimumSize(QtCore.QSize(700, 600))
-        self.setMaximumSize(QtCore.QSize(700, 600))
-        self.nick = LineEdit(self)
-        self.nick.setGeometry(QtCore.QRect(30, 60, 350, 27))
-        profile = Profile.get_instance()
-        self.nick.setText(profile.name)
-        self.status = QtGui.QComboBox(self)
-        self.status.setGeometry(QtCore.QRect(400, 60, 200, 27))
-        self.status_message = LineEdit(self)
-        self.status_message.setGeometry(QtCore.QRect(30, 130, 350, 27))
-        self.status_message.setText(profile.status_message)
-        self.label = QtGui.QLabel(self)
-        self.label.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)
-        self.label.setFont(font)
-        self.label_2 = QtGui.QLabel(self)
-        self.label_2.setGeometry(QtCore.QRect(40, 100, 100, 25))
-        self.label_2.setFont(font)
-        self.label_3 = QtGui.QLabel(self)
-        self.label_3.setGeometry(QtCore.QRect(40, 180, 100, 25))
-        self.label_3.setFont(font)
-        self.tox_id = QtGui.QLabel(self)
-        self.tox_id.setGeometry(QtCore.QRect(15, 210, 685, 21))
-        font.setPointSize(10)
-        self.tox_id.setFont(font)
-        s = profile.tox_id
-        self.tox_id.setText(s)
-        self.copyId = QtGui.QPushButton(self)
-        self.copyId.setGeometry(QtCore.QRect(40, 250, 180, 30))
-        self.copyId.clicked.connect(self.copy)
-        self.export = QtGui.QPushButton(self)
-        self.export.setGeometry(QtCore.QRect(230, 250, 180, 30))
-        self.export.clicked.connect(self.export_profile)
-        self.new_nospam = QtGui.QPushButton(self)
-        self.new_nospam.setGeometry(QtCore.QRect(420, 250, 180, 30))
-        self.new_nospam.clicked.connect(self.new_no_spam)
-        self.copy_pk = QtGui.QPushButton(self)
-        self.copy_pk.setGeometry(QtCore.QRect(40, 300, 180, 30))
-        self.copy_pk.clicked.connect(self.copy_public_key)
-        self.new_avatar = QtGui.QPushButton(self)
-        self.new_avatar.setGeometry(QtCore.QRect(230, 300, 180, 30))
-        self.delete_avatar = QtGui.QPushButton(self)
-        self.delete_avatar.setGeometry(QtCore.QRect(420, 300, 180, 30))
-        self.delete_avatar.clicked.connect(self.reset_avatar)
-        self.new_avatar.clicked.connect(self.set_avatar)
-        self.profilepass = QtGui.QLabel(self)
-        self.profilepass.setGeometry(QtCore.QRect(40, 340, 300, 30))
-        font.setPointSize(18)
-        self.profilepass.setFont(font)
-        self.password = LineEdit(self)
-        self.password.setGeometry(QtCore.QRect(40, 380, 300, 30))
-        self.password.setEchoMode(QtGui.QLineEdit.EchoMode.Password)
-        self.leave_blank = QtGui.QLabel(self)
-        self.leave_blank.setGeometry(QtCore.QRect(350, 380, 300, 30))
-        self.confirm_password = LineEdit(self)
-        self.confirm_password.setGeometry(QtCore.QRect(40, 420, 300, 30))
-        self.confirm_password.setEchoMode(QtGui.QLineEdit.EchoMode.Password)
-        self.set_password = QtGui.QPushButton(self)
-        self.set_password.setGeometry(QtCore.QRect(40, 470, 300, 30))
-        self.set_password.clicked.connect(self.new_password)
-        self.not_match = QtGui.QLabel(self)
-        self.not_match.setGeometry(QtCore.QRect(350, 420, 300, 30))
-        self.not_match.setVisible(False)
-        self.not_match.setStyleSheet('QLabel { color: #BC1C1C; }')
-        self.warning = QtGui.QLabel(self)
-        self.warning.setGeometry(QtCore.QRect(40, 510, 500, 30))
-        self.warning.setStyleSheet('QLabel { color: #BC1C1C; }')
-        self.default = QtGui.QPushButton(self)
-        self.default.setGeometry(QtCore.QRect(40, 550, 620, 30))
-        path, name = Settings.get_auto_profile()
-        self.auto = path + name == ProfileHelper.get_path() + Settings.get_instance().name
-        self.default.clicked.connect(self.auto_profile)
-        self.retranslateUi()
-        if profile.status is not None:
-            self.status.setCurrentIndex(profile.status)
-        else:
-            self.status.setVisible(False)
-        QtCore.QMetaObject.connectSlotsByName(self)
-
-    def retranslateUi(self):
-        self.export.setText(QtGui.QApplication.translate("ProfileSettingsForm", "Export profile", None, QtGui.QApplication.UnicodeUTF8))
-        self.setWindowTitle(QtGui.QApplication.translate("ProfileSettingsForm", "Profile settings", None, QtGui.QApplication.UnicodeUTF8))
-        self.label.setText(QtGui.QApplication.translate("ProfileSettingsForm", "Name:", None, QtGui.QApplication.UnicodeUTF8))
-        self.label_2.setText(QtGui.QApplication.translate("ProfileSettingsForm", "Status:", None, QtGui.QApplication.UnicodeUTF8))
-        self.label_3.setText(QtGui.QApplication.translate("ProfileSettingsForm", "TOX ID:", None, QtGui.QApplication.UnicodeUTF8))
-        self.copyId.setText(QtGui.QApplication.translate("ProfileSettingsForm", "Copy TOX ID", None, QtGui.QApplication.UnicodeUTF8))
-        self.new_avatar.setText(QtGui.QApplication.translate("ProfileSettingsForm", "New avatar", None, QtGui.QApplication.UnicodeUTF8))
-        self.delete_avatar.setText(QtGui.QApplication.translate("ProfileSettingsForm", "Reset avatar", None, QtGui.QApplication.UnicodeUTF8))
-        self.new_nospam.setText(QtGui.QApplication.translate("ProfileSettingsForm", "New NoSpam", None, QtGui.QApplication.UnicodeUTF8))
-        self.profilepass.setText(QtGui.QApplication.translate("ProfileSettingsForm", "Profile password", None, QtGui.QApplication.UnicodeUTF8))
-        self.password.setPlaceholderText(QtGui.QApplication.translate("ProfileSettingsForm", "Password (at least 8 symbols)", None, QtGui.QApplication.UnicodeUTF8))
-        self.confirm_password.setPlaceholderText(QtGui.QApplication.translate("ProfileSettingsForm", "Confirm password", None, QtGui.QApplication.UnicodeUTF8))
-        self.set_password.setText(QtGui.QApplication.translate("ProfileSettingsForm", "Set password", None, QtGui.QApplication.UnicodeUTF8))
-        self.not_match.setText(QtGui.QApplication.translate("ProfileSettingsForm", "Passwords do not match", None, QtGui.QApplication.UnicodeUTF8))
-        self.leave_blank.setText(QtGui.QApplication.translate("ProfileSettingsForm", "Leaving blank will reset current password", None, QtGui.QApplication.UnicodeUTF8))
-        self.warning.setText(QtGui.QApplication.translate("ProfileSettingsForm", "There is no way to recover lost passwords", None, QtGui.QApplication.UnicodeUTF8))
-        self.status.addItem(QtGui.QApplication.translate("ProfileSettingsForm", "Online", None, QtGui.QApplication.UnicodeUTF8))
-        self.status.addItem(QtGui.QApplication.translate("ProfileSettingsForm", "Away", None, QtGui.QApplication.UnicodeUTF8))
-        self.status.addItem(QtGui.QApplication.translate("ProfileSettingsForm", "Busy", None, QtGui.QApplication.UnicodeUTF8))
-        self.copy_pk.setText(QtGui.QApplication.translate("ProfileSettingsForm", "Copy public key", None, QtGui.QApplication.UnicodeUTF8))
-        if self.auto:
-            self.default.setText(QtGui.QApplication.translate("ProfileSettingsForm", "Mark as not default profile", None, QtGui.QApplication.UnicodeUTF8))
-        else:
-            self.default.setText(QtGui.QApplication.translate("ProfileSettingsForm", "Mark as default profile", None, QtGui.QApplication.UnicodeUTF8))
-
-    def auto_profile(self):
-        if self.auto:
-            Settings.reset_auto_profile()
-        else:
-            Settings.set_auto_profile(ProfileHelper.get_path(), Settings.get_instance().name)
-        self.auto = not self.auto
-        if self.auto:
-            self.default.setText(QtGui.QApplication.translate("ProfileSettingsForm", "Mark as not default profile", None,
-                                                              QtGui.QApplication.UnicodeUTF8))
-        else:
-            self.default.setText(
-                QtGui.QApplication.translate("ProfileSettingsForm", "Mark as default profile", None,
-                                             QtGui.QApplication.UnicodeUTF8))
-
-    def new_password(self):
-        if self.password.text() == self.confirm_password.text():
-            if not len(self.password.text()) or len(self.password.text()) >= 8:
-                e = toxencryptsave.ToxEncryptSave.get_instance()
-                e.set_password(self.password.text())
-                self.close()
-            else:
-                self.not_match.setText(
-                    QtGui.QApplication.translate("ProfileSettingsForm", "Password must be at least 8 symbols", None,
-                                                 QtGui.QApplication.UnicodeUTF8))
-            self.not_match.setVisible(True)
-        else:
-            self.not_match.setText(QtGui.QApplication.translate("ProfileSettingsForm", "Passwords do not match", None,
-                                                                QtGui.QApplication.UnicodeUTF8))
-            self.not_match.setVisible(True)
-
-    def copy(self):
-        clipboard = QtGui.QApplication.clipboard()
-        profile = Profile.get_instance()
-        clipboard.setText(profile.tox_id)
-        pixmap = QtGui.QPixmap(curr_directory() + '/images/accept.png')
-        icon = QtGui.QIcon(pixmap)
-        self.copyId.setIcon(icon)
-        self.copyId.setIconSize(QtCore.QSize(10, 10))
-
-    def copy_public_key(self):
-        clipboard = QtGui.QApplication.clipboard()
-        profile = Profile.get_instance()
-        clipboard.setText(profile.tox_id[:64])
-        pixmap = QtGui.QPixmap(curr_directory() + '/images/accept.png')
-        icon = QtGui.QIcon(pixmap)
-        self.copy_pk.setIcon(icon)
-        self.copy_pk.setIconSize(QtCore.QSize(10, 10))
-
-    def new_no_spam(self):
-        self.tox_id.setText(Profile.get_instance().new_nospam())
-
-    def reset_avatar(self):
-        Profile.get_instance().reset_avatar()
-
-    def set_avatar(self):
-        choose = QtGui.QApplication.translate("ProfileSettingsForm", "Choose avatar", None, QtGui.QApplication.UnicodeUTF8)
-        name = QtGui.QFileDialog.getOpenFileName(self, choose, None, 'Images (*.png)',
-                                                 options=QtGui.QFileDialog.DontUseNativeDialog)
-        if name[0]:
-            bitmap = QtGui.QPixmap(name[0])
-            bitmap.scaled(QtCore.QSize(128, 128), aspectMode=QtCore.Qt.KeepAspectRatio,
-                          mode=QtCore.Qt.SmoothTransformation)
-
-            byte_array = QtCore.QByteArray()
-            buffer = QtCore.QBuffer(byte_array)
-            buffer.open(QtCore.QIODevice.WriteOnly)
-            bitmap.save(buffer, 'PNG')
-            Profile.get_instance().set_avatar(bytes(byte_array.data()))
-
-    def export_profile(self):
-        directory = QtGui.QFileDialog.getExistingDirectory(options=QtGui.QFileDialog.DontUseNativeDialog,
-                                                           dir=curr_directory()) + '/'
-        if 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_db(directory)
-            ProfileHelper.get_instance().export_profile(directory, reply == QtGui.QMessageBox.Yes)
-
-    def closeEvent(self, event):
-        profile = Profile.get_instance()
-        profile.set_name(self.nick.text())
-        profile.set_status_message(self.status_message.text().encode('utf-8'))
-        profile.set_status(self.status.currentIndex())
-
-
-class NetworkSettings(CenteredWidget):
-    """Network settings form: UDP, Ipv6 and proxy"""
-    def __init__(self, reset):
-        super(NetworkSettings, self).__init__()
-        self.reset = reset
-        self.initUI()
-        self.center()
-
-    def initUI(self):
-        self.setObjectName("NetworkSettings")
-        self.resize(300, 330)
-        self.setMinimumSize(QtCore.QSize(300, 330))
-        self.setMaximumSize(QtCore.QSize(300, 330))
-        self.setBaseSize(QtCore.QSize(300, 330))
-        self.ipv = QtGui.QCheckBox(self)
-        self.ipv.setGeometry(QtCore.QRect(20, 10, 97, 22))
-        self.ipv.setObjectName("ipv")
-        self.udp = QtGui.QCheckBox(self)
-        self.udp.setGeometry(QtCore.QRect(150, 10, 97, 22))
-        self.udp.setObjectName("udp")
-        self.proxy = QtGui.QCheckBox(self)
-        self.proxy.setGeometry(QtCore.QRect(20, 40, 97, 22))
-        self.http = QtGui.QCheckBox(self)
-        self.http.setGeometry(QtCore.QRect(20, 70, 97, 22))
-        self.proxy.setObjectName("proxy")
-        self.proxyip = LineEdit(self)
-        self.proxyip.setGeometry(QtCore.QRect(40, 130, 231, 27))
-        self.proxyip.setObjectName("proxyip")
-        self.proxyport = LineEdit(self)
-        self.proxyport.setGeometry(QtCore.QRect(40, 190, 231, 27))
-        self.proxyport.setObjectName("proxyport")
-        self.label = QtGui.QLabel(self)
-        self.label.setGeometry(QtCore.QRect(40, 100, 66, 17))
-        self.label_2 = QtGui.QLabel(self)
-        self.label_2.setGeometry(QtCore.QRect(40, 165, 66, 17))
-        self.reconnect = QtGui.QPushButton(self)
-        self.reconnect.setGeometry(QtCore.QRect(40, 230, 231, 30))
-        self.reconnect.clicked.connect(self.restart_core)
-        settings = Settings.get_instance()
-        self.ipv.setChecked(settings['ipv6_enabled'])
-        self.udp.setChecked(settings['udp_enabled'])
-        self.proxy.setChecked(settings['proxy_type'])
-        self.proxyip.setText(settings['proxy_host'])
-        self.proxyport.setText(str(settings['proxy_port']))
-        self.http.setChecked(settings['proxy_type'] == 1)
-        self.warning = QtGui.QLabel(self)
-        self.warning.setGeometry(QtCore.QRect(5, 270, 290, 60))
-        self.warning.setStyleSheet('QLabel { color: #BC1C1C; }')
-        self.retranslateUi()
-        self.proxy.stateChanged.connect(lambda x: self.activate())
-        self.activate()
-        QtCore.QMetaObject.connectSlotsByName(self)
-
-    def retranslateUi(self):
-        self.setWindowTitle(QtGui.QApplication.translate("NetworkSettings", "Network settings", None, QtGui.QApplication.UnicodeUTF8))
-        self.ipv.setText(QtGui.QApplication.translate("Form", "IPv6", None, QtGui.QApplication.UnicodeUTF8))
-        self.udp.setText(QtGui.QApplication.translate("Form", "UDP", None, QtGui.QApplication.UnicodeUTF8))
-        self.proxy.setText(QtGui.QApplication.translate("Form", "Proxy", None, QtGui.QApplication.UnicodeUTF8))
-        self.label.setText(QtGui.QApplication.translate("Form", "IP:", None, QtGui.QApplication.UnicodeUTF8))
-        self.label_2.setText(QtGui.QApplication.translate("Form", "Port:", None, QtGui.QApplication.UnicodeUTF8))
-        self.reconnect.setText(QtGui.QApplication.translate("NetworkSettings", "Restart TOX core", None, QtGui.QApplication.UnicodeUTF8))
-        self.http.setText(QtGui.QApplication.translate("Form", "HTTP", None, QtGui.QApplication.UnicodeUTF8))
-        self.warning.setText(QtGui.QApplication.translate("Form", "WARNING:\nusing proxy with enabled UDP\ncan produce IP leak",
-                                                          None, QtGui.QApplication.UnicodeUTF8))
-
-    def activate(self):
-        bl = self.proxy.isChecked()
-        self.proxyip.setEnabled(bl)
-        self.http.setEnabled(bl)
-        self.proxyport.setEnabled(bl)
-
-    def restart_core(self):
-        try:
-            settings = Settings.get_instance()
-            settings['ipv6_enabled'] = self.ipv.isChecked()
-            settings['udp_enabled'] = self.udp.isChecked()
-            settings['proxy_type'] = 2 - int(self.http.isChecked()) if self.proxy.isChecked() else 0
-            settings['proxy_host'] = str(self.proxyip.text())
-            settings['proxy_port'] = int(self.proxyport.text())
-            settings.save()
-            # recreate tox instance
-            Profile.get_instance().reset(self.reset)
-            self.close()
-        except Exception as ex:
-            log('Exception in restart: ' + str(ex))
-
-
-class PrivacySettings(CenteredWidget):
-    """Privacy settings form: history, typing notifications"""
-
-    def __init__(self):
-        super(PrivacySettings, self).__init__()
-        self.initUI()
-        self.center()
-
-    def initUI(self):
-        self.setObjectName("privacySettings")
-        self.resize(370, 600)
-        self.setMinimumSize(QtCore.QSize(370, 600))
-        self.setMaximumSize(QtCore.QSize(370, 600))
-        self.saveHistory = QtGui.QCheckBox(self)
-        self.saveHistory.setGeometry(QtCore.QRect(10, 20, 350, 22))
-        self.saveUnsentOnly = QtGui.QCheckBox(self)
-        self.saveUnsentOnly.setGeometry(QtCore.QRect(10, 60, 350, 22))
-
-        self.fileautoaccept = QtGui.QCheckBox(self)
-        self.fileautoaccept.setGeometry(QtCore.QRect(10, 100, 350, 22))
-
-        self.typingNotifications = QtGui.QCheckBox(self)
-        self.typingNotifications.setGeometry(QtCore.QRect(10, 140, 350, 30))
-        self.inlines = QtGui.QCheckBox(self)
-        self.inlines.setGeometry(QtCore.QRect(10, 180, 350, 30))
-        self.auto_path = QtGui.QLabel(self)
-        self.auto_path.setGeometry(QtCore.QRect(10, 230, 350, 30))
-        self.path = QtGui.QPlainTextEdit(self)
-        self.path.setGeometry(QtCore.QRect(10, 265, 350, 45))
-        self.change_path = QtGui.QPushButton(self)
-        self.change_path.setGeometry(QtCore.QRect(10, 320, 350, 30))
-        settings = Settings.get_instance()
-        self.typingNotifications.setChecked(settings['typing_notifications'])
-        self.fileautoaccept.setChecked(settings['allow_auto_accept'])
-        self.saveHistory.setChecked(settings['save_history'])
-        self.inlines.setChecked(settings['allow_inline'])
-        self.saveUnsentOnly.setChecked(settings['save_unsent_only'])
-        self.saveUnsentOnly.setEnabled(settings['save_history'])
-        self.saveHistory.stateChanged.connect(self.update)
-        self.path.setPlainText(settings['auto_accept_path'] or curr_directory())
-        self.change_path.clicked.connect(self.new_path)
-        self.block_user_label = QtGui.QLabel(self)
-        self.block_user_label.setGeometry(QtCore.QRect(10, 360, 350, 30))
-        self.block_id = QtGui.QPlainTextEdit(self)
-        self.block_id.setGeometry(QtCore.QRect(10, 390, 350, 30))
-        self.block = QtGui.QPushButton(self)
-        self.block.setGeometry(QtCore.QRect(10, 430, 350, 30))
-        self.block.clicked.connect(lambda: Profile.get_instance().block_user(self.block_id.toPlainText()) or self.close())
-        self.blocked_users_label = QtGui.QLabel(self)
-        self.blocked_users_label.setGeometry(QtCore.QRect(10, 470, 350, 30))
-        self.comboBox = QtGui.QComboBox(self)
-        self.comboBox.setGeometry(QtCore.QRect(10, 500, 350, 30))
-        self.comboBox.addItems(settings['blocked'])
-        self.unblock = QtGui.QPushButton(self)
-        self.unblock.setGeometry(QtCore.QRect(10, 540, 350, 30))
-        self.unblock.clicked.connect(lambda: self.unblock_user())
-        self.retranslateUi()
-        QtCore.QMetaObject.connectSlotsByName(self)
-
-    def retranslateUi(self):
-        self.setWindowTitle(QtGui.QApplication.translate("privacySettings", "Privacy settings", None, QtGui.QApplication.UnicodeUTF8))
-        self.saveHistory.setText(QtGui.QApplication.translate("privacySettings", "Save chat history", None, QtGui.QApplication.UnicodeUTF8))
-        self.fileautoaccept.setText(QtGui.QApplication.translate("privacySettings", "Allow file auto accept", None, QtGui.QApplication.UnicodeUTF8))
-        self.typingNotifications.setText(QtGui.QApplication.translate("privacySettings", "Send typing notifications", None, QtGui.QApplication.UnicodeUTF8))
-        self.auto_path.setText(QtGui.QApplication.translate("privacySettings", "Auto accept default path:", None, QtGui.QApplication.UnicodeUTF8))
-        self.change_path.setText(QtGui.QApplication.translate("privacySettings", "Change", None, QtGui.QApplication.UnicodeUTF8))
-        self.inlines.setText(QtGui.QApplication.translate("privacySettings", "Allow inlines", None, QtGui.QApplication.UnicodeUTF8))
-        self.block_user_label.setText(QtGui.QApplication.translate("privacySettings", "Block by public key:", None, QtGui.QApplication.UnicodeUTF8))
-        self.blocked_users_label.setText(QtGui.QApplication.translate("privacySettings", "Blocked users:", None, QtGui.QApplication.UnicodeUTF8))
-        self.unblock.setText(QtGui.QApplication.translate("privacySettings", "Unblock", None, QtGui.QApplication.UnicodeUTF8))
-        self.block.setText(QtGui.QApplication.translate("privacySettings", "Block user", None, QtGui.QApplication.UnicodeUTF8))
-        self.saveUnsentOnly.setText(QtGui.QApplication.translate("privacySettings", "Save unsent messages only", None, QtGui.QApplication.UnicodeUTF8))
-
-    def update(self, new_state):
-        self.saveUnsentOnly.setEnabled(new_state)
-        if not new_state:
-            self.saveUnsentOnly.setChecked(False)
-
-    def unblock_user(self):
-        if not self.comboBox.count():
-            return
-        title = QtGui.QApplication.translate("privacySettings", "Add to friend list", None, QtGui.QApplication.UnicodeUTF8)
-        info = QtGui.QApplication.translate("privacySettings", "Do you want to add this user to friend list?", None, QtGui.QApplication.UnicodeUTF8)
-        reply = QtGui.QMessageBox.question(None, title, info, QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)
-        Profile.get_instance().unblock_user(self.comboBox.currentText(), reply == QtGui.QMessageBox.Yes)
-        self.close()
-
-    def closeEvent(self, event):
-        settings = Settings.get_instance()
-        settings['typing_notifications'] = self.typingNotifications.isChecked()
-        settings['allow_auto_accept'] = self.fileautoaccept.isChecked()
-
-        if settings['save_history'] and not self.saveHistory.isChecked():  # clear history
-            reply = QtGui.QMessageBox.question(None,
-                                               QtGui.QApplication.translate("privacySettings",
-                                                                            'Chat history',
-                                                                            None, QtGui.QApplication.UnicodeUTF8),
-                                               QtGui.QApplication.translate("privacySettings",
-                                                                            'History will be cleaned! Continue?',
-                                                                            None, QtGui.QApplication.UnicodeUTF8),
-                                               QtGui.QMessageBox.Yes,
-                                               QtGui.QMessageBox.No)
-            if reply == QtGui.QMessageBox.Yes:
-                Profile.get_instance().clear_history()
-                settings['save_history'] = self.saveHistory.isChecked()
-        else:
-            settings['save_history'] = self.saveHistory.isChecked()
-        if self.saveUnsentOnly.isChecked() and not settings['save_unsent_only']:
-            reply = QtGui.QMessageBox.question(None,
-                                               QtGui.QApplication.translate("privacySettings",
-                                                                            'Chat history',
-                                                                            None, QtGui.QApplication.UnicodeUTF8),
-                                               QtGui.QApplication.translate("privacySettings",
-                                                                            'History will be cleaned! Continue?',
-                                                                            None, QtGui.QApplication.UnicodeUTF8),
-                                               QtGui.QMessageBox.Yes,
-                                               QtGui.QMessageBox.No)
-            if reply == QtGui.QMessageBox.Yes:
-                Profile.get_instance().clear_history(None, True)
-                settings['save_unsent_only'] = self.saveUnsentOnly.isChecked()
-        else:
-            settings['save_unsent_only'] = self.saveUnsentOnly.isChecked()
-        settings['auto_accept_path'] = self.path.toPlainText()
-        settings['allow_inline'] = self.inlines.isChecked()
-        settings.save()
-
-    def new_path(self):
-        directory = QtGui.QFileDialog.getExistingDirectory(options=QtGui.QFileDialog.DontUseNativeDialog) + '/'
-        if directory != '/':
-            self.path.setPlainText(directory)
-
-
-class NotificationsSettings(CenteredWidget):
-    """Notifications settings form"""
-
-    def __init__(self):
-        super(NotificationsSettings, self).__init__()
-        self.initUI()
-        self.center()
-
-    def initUI(self):
-        self.setObjectName("notificationsForm")
-        self.resize(350, 180)
-        self.setMinimumSize(QtCore.QSize(350, 180))
-        self.setMaximumSize(QtCore.QSize(350, 180))
-        self.enableNotifications = QtGui.QCheckBox(self)
-        self.enableNotifications.setGeometry(QtCore.QRect(10, 20, 340, 18))
-        self.callsSound = QtGui.QCheckBox(self)
-        self.callsSound.setGeometry(QtCore.QRect(10, 120, 340, 18))
-        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)
-        self.enableNotifications.setChecked(s['notifications'])
-        self.soundNotifications.setChecked(s['sound_notifications'])
-        self.callsSound.setChecked(s['calls_sound'])
-        self.retranslateUi()
-        QtCore.QMetaObject.connectSlotsByName(self)
-
-    def retranslateUi(self):
-        self.setWindowTitle(QtGui.QApplication.translate("notificationsForm", "Notification settings", None, QtGui.QApplication.UnicodeUTF8))
-        self.enableNotifications.setText(QtGui.QApplication.translate("notificationsForm", "Enable notifications", None, QtGui.QApplication.UnicodeUTF8))
-        self.callsSound.setText(QtGui.QApplication.translate("notificationsForm", "Enable call\'s sound", None, QtGui.QApplication.UnicodeUTF8))
-        self.soundNotifications.setText(QtGui.QApplication.translate("notificationsForm", "Enable sound notifications", None, QtGui.QApplication.UnicodeUTF8))
-
-    def closeEvent(self, *args, **kwargs):
-        settings = Settings.get_instance()
-        settings['notifications'] = self.enableNotifications.isChecked()
-        settings['sound_notifications'] = self.soundNotifications.isChecked()
-        settings['calls_sound'] = self.callsSound.isChecked()
-        settings.save()
-
-
-class InterfaceSettings(CenteredWidget):
-    """Interface settings form"""
-    def __init__(self):
-        super(InterfaceSettings, self).__init__()
-        self.initUI()
-        self.center()
-
-    def initUI(self):
-        self.setObjectName("interfaceForm")
-        self.setMinimumSize(QtCore.QSize(400, 650))
-        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)
-        theme = settings['theme']
-        if theme in list_of_themes:
-            index = list_of_themes.index(theme)
-        else:
-            index = 0
-        self.themeSelect.setCurrentIndex(index)
-        self.lang_choose = QtGui.QComboBox(self)
-        self.lang_choose.setGeometry(QtCore.QRect(30, 110, 120, 30))
-        supported = sorted(Settings.supported_languages().keys(), reverse=True)
-        for key in supported:
-            self.lang_choose.insertItem(0, key)
-            if settings['language'] == key:
-                self.lang_choose.setCurrentIndex(0)
-        self.lang = QtGui.QLabel(self)
-        self.lang.setGeometry(QtCore.QRect(30, 80, 370, 20))
-        self.lang.setFont(font)
-        self.mirror_mode = QtGui.QCheckBox(self)
-        self.mirror_mode.setGeometry(QtCore.QRect(30, 160, 370, 20))
-        self.mirror_mode.setChecked(settings['mirror_mode'])
-        self.smileys = QtGui.QCheckBox(self)
-        self.smileys.setGeometry(QtCore.QRect(30, 190, 120, 20))
-        self.smileys.setChecked(settings['smileys'])
-        self.smiley_pack_label = QtGui.QLabel(self)
-        self.smiley_pack_label.setGeometry(QtCore.QRect(30, 230, 370, 20))
-        self.smiley_pack_label.setFont(font)
-        self.smiley_pack = QtGui.QComboBox(self)
-        self.smiley_pack.setGeometry(QtCore.QRect(30, 260, 160, 30))
-        sm = smileys.SmileyLoader.get_instance()
-        self.smiley_pack.addItems(sm.get_packs_list())
-        try:
-            ind = sm.get_packs_list().index(settings['smiley_pack'])
-        except:
-            ind = sm.get_packs_list().index('default')
-        self.smiley_pack.setCurrentIndex(ind)
-        self.messages_font_size_label = QtGui.QLabel(self)
-        self.messages_font_size_label.setGeometry(QtCore.QRect(30, 300, 370, 20))
-        self.messages_font_size_label.setFont(font)
-        self.messages_font_size = QtGui.QComboBox(self)
-        self.messages_font_size.setGeometry(QtCore.QRect(30, 330, 160, 30))
-        self.messages_font_size.addItems([str(x) for x in range(10, 19)])
-        self.messages_font_size.setCurrentIndex(settings['message_font_size'] - 10)
-
-        self.unread = QtGui.QPushButton(self)
-        self.unread.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, 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, 550, 340, 30))
-        self.import_smileys.clicked.connect(self.import_sm)
-
-        self.import_stickers = QtGui.QPushButton(self)
-        self.import_stickers.setGeometry(QtCore.QRect(30, 590, 340, 30))
-        self.import_stickers.clicked.connect(self.import_st)
-
-        self.retranslateUi()
-        QtCore.QMetaObject.connectSlotsByName(self)
-
-    def retranslateUi(self):
-        self.show_avatars.setText(QtGui.QApplication.translate("interfaceForm", "Show avatars in chat", None, QtGui.QApplication.UnicodeUTF8))
-        self.setWindowTitle(QtGui.QApplication.translate("interfaceForm", "Interface settings", None, QtGui.QApplication.UnicodeUTF8))
-        self.label.setText(QtGui.QApplication.translate("interfaceForm", "Theme:", None, QtGui.QApplication.UnicodeUTF8))
-        self.lang.setText(QtGui.QApplication.translate("interfaceForm", "Language:", None, QtGui.QApplication.UnicodeUTF8))
-        self.smileys.setText(QtGui.QApplication.translate("interfaceForm", "Smileys", None, QtGui.QApplication.UnicodeUTF8))
-        self.smiley_pack_label.setText(QtGui.QApplication.translate("interfaceForm", "Smiley pack:", None, QtGui.QApplication.UnicodeUTF8))
-        self.mirror_mode.setText(QtGui.QApplication.translate("interfaceForm", "Mirror mode", None, QtGui.QApplication.UnicodeUTF8))
-        self.messages_font_size_label.setText(QtGui.QApplication.translate("interfaceForm", "Messages font size:", None, QtGui.QApplication.UnicodeUTF8))
-        self.unread.setText(QtGui.QApplication.translate("interfaceForm", "Select unread messages notification color", None, QtGui.QApplication.UnicodeUTF8))
-        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,
-                                                           QtGui.QApplication.translate("MainWindow",
-                                                                                        'Choose folder with sticker pack',
-                                                                                        None,
-                                                                                        QtGui.QApplication.UnicodeUTF8),
-                                                           curr_directory(),
-                                                           QtGui.QFileDialog.ShowDirsOnly | QtGui.QFileDialog.DontUseNativeDialog)
-
-        if directory:
-            src = directory + '/'
-            dest = curr_directory() + '/stickers/' + os.path.basename(directory) + '/'
-            copy(src, dest)
-
-    def import_sm(self):
-        directory = QtGui.QFileDialog.getExistingDirectory(self,
-                                                           QtGui.QApplication.translate("MainWindow",
-                                                                                        'Choose folder with smiley pack',
-                                                                                        None,
-                                                                                        QtGui.QApplication.UnicodeUTF8),
-                                                           curr_directory(),
-                                                           QtGui.QFileDialog.ShowDirsOnly | QtGui.QFileDialog.DontUseNativeDialog)
-
-        if directory:
-            src = directory + '/'
-            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()
-
-        if col.isValid():
-            settings = Settings.get_instance()
-            name = col.name()
-            settings['unread_color'] = name
-            settings.save()
-
-    def closeEvent(self, event):
-        settings = Settings.get_instance()
-        settings['theme'] = str(self.themeSelect.currentText())
-        settings['smileys'] = self.smileys.isChecked()
-        restart = False
-        if settings['mirror_mode'] != self.mirror_mode.isChecked():
-            settings['mirror_mode'] = self.mirror_mode.isChecked()
-            restart = True
-        if settings['compact_mode'] != self.compact_mode.isChecked():
-            settings['compact_mode'] = self.compact_mode.isChecked()
-            restart = True
-        if settings['show_avatars'] != self.show_avatars.isChecked():
-            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:
-            settings['language'] = language
-            text = self.lang_choose.currentText()
-            path = Settings.supported_languages()[text]
-            app = QtGui.QApplication.instance()
-            app.removeTranslator(app.translator)
-            app.translator.load(curr_directory() + '/translations/' + path)
-            app.installTranslator(app.translator)
-        settings['message_font_size'] = self.messages_font_size.currentIndex() + 10
-        Profile.get_instance().update()
-        settings.save()
-        if restart:
-            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_()
-
-
-class AudioSettings(CenteredWidget):
-    """
-    Audio calls settings form
-    """
-
-    def __init__(self):
-        super(AudioSettings, self).__init__()
-        self.initUI()
-        self.retranslateUi()
-        self.center()
-
-    def initUI(self):
-        self.setObjectName("audioSettingsForm")
-        self.resize(400, 150)
-        self.setMinimumSize(QtCore.QSize(400, 150))
-        self.setMaximumSize(QtCore.QSize(400, 150))
-        self.in_label = QtGui.QLabel(self)
-        self.in_label.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)
-        self.input.setGeometry(QtCore.QRect(25, 30, 350, 30))
-        self.output = QtGui.QComboBox(self)
-        self.output.setGeometry(QtCore.QRect(25, 90, 350, 30))
-        p = pyaudio.PyAudio()
-        self.in_indexes, self.out_indexes = [], []
-        for i in range(p.get_device_count()):
-            device = p.get_device_info_by_index(i)
-            if device["maxInputChannels"]:
-                self.input.addItem(str(device["name"]))
-                self.in_indexes.append(i)
-            if device["maxOutputChannels"]:
-                self.output.addItem(str(device["name"]))
-                self.out_indexes.append(i)
-        self.input.setCurrentIndex(self.in_indexes.index(settings.audio['input']))
-        self.output.setCurrentIndex(self.out_indexes.index(settings.audio['output']))
-        QtCore.QMetaObject.connectSlotsByName(self)
-
-    def retranslateUi(self):
-        self.setWindowTitle(QtGui.QApplication.translate("audioSettingsForm", "Audio settings", None, QtGui.QApplication.UnicodeUTF8))
-        self.in_label.setText(QtGui.QApplication.translate("audioSettingsForm", "Input device:", None, QtGui.QApplication.UnicodeUTF8))
-        self.out_label.setText(QtGui.QApplication.translate("audioSettingsForm", "Output device:", None, QtGui.QApplication.UnicodeUTF8))
-
-    def closeEvent(self, event):
-        settings = Settings.get_instance()
-        settings.audio['input'] = self.in_indexes[self.input.currentIndex()]
-        settings.audio['output'] = self.out_indexes[self.output.currentIndex()]
-        settings.save()
-
-
-class PluginsSettings(CenteredWidget):
-    """
-    Plugins settings form
-    """
-
-    def __init__(self):
-        super(PluginsSettings, self).__init__()
-        self.initUI()
-        self.center()
-        self.retranslateUi()
-
-    def initUI(self):
-        self.resize(400, 210)
-        self.setMinimumSize(QtCore.QSize(400, 210))
-        self.setMaximumSize(QtCore.QSize(400, 210))
-        self.comboBox = QtGui.QComboBox(self)
-        self.comboBox.setGeometry(QtCore.QRect(30, 10, 340, 30))
-        self.label = QtGui.QLabel(self)
-        self.label.setGeometry(QtCore.QRect(30, 40, 340, 90))
-        self.label.setWordWrap(True)
-        self.button = QtGui.QPushButton(self)
-        self.button.setGeometry(QtCore.QRect(30, 130, 340, 30))
-        self.button.clicked.connect(self.button_click)
-        self.open = QtGui.QPushButton(self)
-        self.open.setGeometry(QtCore.QRect(30, 170, 340, 30))
-        self.open.clicked.connect(self.open_plugin)
-        self.pl_loader = plugin_support.PluginLoader.get_instance()
-        self.update_list()
-        self.comboBox.currentIndexChanged.connect(self.show_data)
-        self.show_data()
-
-    def retranslateUi(self):
-        self.setWindowTitle(QtGui.QApplication.translate('PluginsForm', "Plugins", None, QtGui.QApplication.UnicodeUTF8))
-        self.open.setText(QtGui.QApplication.translate('PluginsForm', "Open selected plugin", None, QtGui.QApplication.UnicodeUTF8))
-
-    def open_plugin(self):
-        ind = self.comboBox.currentIndex()
-        plugin = self.data[ind]
-        window = self.pl_loader.plugin_window(plugin[-1])
-        if window is not None:
-            self.window = window
-            self.window.show()
-        else:
-            msgBox = QtGui.QMessageBox()
-            text = QtGui.QApplication.translate("PluginsForm", 'No GUI found for this plugin', None,
-                                                QtGui.QApplication.UnicodeUTF8)
-            msgBox.setWindowTitle(QtGui.QApplication.translate("PluginsForm", 'Error', None,
-                                                               QtGui.QApplication.UnicodeUTF8))
-            msgBox.setText(text)
-            msgBox.exec_()
-
-    def update_list(self):
-        self.comboBox.clear()
-        data = self.pl_loader.get_plugins_list()
-        self.comboBox.addItems(list(map(lambda x: x[0], data)))
-        self.data = data
-
-    def show_data(self):
-        ind = self.comboBox.currentIndex()
-        if len(self.data):
-            plugin = self.data[ind]
-            descr = plugin[2] or QtGui.QApplication.translate("PluginsForm", "No description available", None, QtGui.QApplication.UnicodeUTF8)
-            self.label.setText(descr)
-            if plugin[1]:
-                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))
-        else:
-            self.open.setVisible(False)
-            self.button.setVisible(False)
-            self.label.setText(QtGui.QApplication.translate("PluginsForm", "No plugins found", None, QtGui.QApplication.UnicodeUTF8))
-
-    def button_click(self):
-        ind = self.comboBox.currentIndex()
-        plugin = self.data[ind]
-        self.pl_loader.toggle_plugin(plugin[-1])
-        plugin[1] = not plugin[1]
-        if plugin[1]:
-            self.button.setText(QtGui.QApplication.translate("PluginsForm", "Disable plugin", None, QtGui.QApplication.UnicodeUTF8))
-        else:
-            self.button.setText(QtGui.QApplication.translate("PluginsForm", "Enable plugin", None, QtGui.QApplication.UnicodeUTF8))

toxygen/messages.py

@@ -1,101 +0,0 @@
-
-
-MESSAGE_TYPE = {
-    'TEXT': 0,
-    'ACTION': 1,
-    'FILE_TRANSFER': 2,
-    'INLINE': 3,
-    'INFO_MESSAGE': 4
-}
-
-
-class Message:
-
-    def __init__(self, message_type, owner, time):
-        self._time = time
-        self._type = message_type
-        self._owner = owner
-
-    def get_type(self):
-        return self._type
-
-    def get_owner(self):
-        return self._owner
-
-    def mark_as_sent(self):
-        self._owner = 0
-
-
-class TextMessage(Message):
-    """
-    Plain text or action message
-    """
-
-    def __init__(self, message, owner, time, message_type):
-        super(TextMessage, self).__init__(message_type, owner, time)
-        self._message = message
-
-    def get_data(self):
-        return self._message, self._owner, self._time, self._type
-
-
-class TransferMessage(Message):
-    """
-    Message with info about file transfer
-    """
-
-    def __init__(self, owner, time, status, size, name, friend_number, file_number):
-        super(TransferMessage, self).__init__(MESSAGE_TYPE['FILE_TRANSFER'], owner, time)
-        self._status = status
-        self._size = size
-        self._file_name = name
-        self._friend_number, self._file_number = friend_number, file_number
-
-    def is_active(self, file_number):
-        return self._file_number == file_number and self._status not in (2, 3)
-
-    def get_friend_number(self):
-        return self._friend_number
-
-    def get_file_number(self):
-        return self._file_number
-
-    def get_status(self):
-        return self._status
-
-    def set_status(self, value):
-        self._status = value
-
-    def get_data(self):
-        return self._file_name, self._size, self._time, self._owner, self._friend_number, self._file_number, self._status
-
-
-class UnsentFile(Message):
-    def __init__(self, path, data, time):
-        super(UnsentFile, self).__init__(MESSAGE_TYPE['FILE_TRANSFER'], 0, time)
-        self._data, self._path = data, path
-
-    def get_data(self):
-        return self._path, self._data, self._time
-
-    def get_status(self):
-        return None
-
-
-class InlineImage(Message):
-    """
-    Inline image
-    """
-
-    def __init__(self, data):
-        super(InlineImage, self).__init__(MESSAGE_TYPE['INLINE'], None, None)
-        self._data = data
-
-    def get_data(self):
-        return self._data
-
-
-class InfoMessage(TextMessage):
-
-    def __init__(self, message, time):
-        super(InfoMessage, self).__init__(message, None, time, MESSAGE_TYPE['INFO_MESSAGE'])

toxygen/messenger/messages.py

@@ -0,0 +1,239 @@
+from history.database import MESSAGE_AUTHOR
+import os.path
+from ui.messages_widgets import *
+
+
+MESSAGE_TYPE = {
+    'TEXT': 0,
+    'ACTION': 1,
+    'FILE_TRANSFER': 2,
+    'INLINE': 3,
+    'INFO_MESSAGE': 4
+}
+
+PAGE_SIZE = 42
+
+
+class MessageAuthor:
+
+    def __init__(self, author_name, author_type):
+        self._name = author_name
+        self._type = author_type
+
+    def get_name(self):
+        return self._name
+
+    name = property(get_name)
+
+    def get_type(self):
+        return self._type
+
+    def set_type(self, value):
+        self._type = value
+
+    type = property(get_type, set_type)
+
+
+class Message:
+
+    MESSAGE_ID = 0
+
+    def __init__(self, message_type, author, time):
+        self._time = time
+        self._type = message_type
+        self._author = author
+        self._widget = None
+        self._message_id = self._get_id()
+
+    def get_type(self):
+        return self._type
+
+    type = property(get_type)
+
+    def get_author(self):
+        return self._author
+
+    author = property(get_author)
+
+    def get_time(self):
+        return self._time
+
+    time = property(get_time)
+
+    def get_message_id(self):
+        return self._message_id
+
+    message_id = property(get_message_id)
+
+    def get_widget(self, *args):
+        self._widget = self._create_widget(*args)
+
+        return self._widget
+
+    widget = property(get_widget)
+
+    def remove_widget(self):
+        self._widget = None
+
+    def mark_as_sent(self):
+        self._author.type = MESSAGE_AUTHOR['ME']
+        if self._widget is not None:
+            self._widget.mark_as_sent()
+
+    def _create_widget(self, *args):
+        pass
+
+    @staticmethod
+    def _get_id():
+        Message.MESSAGE_ID += 1
+
+        return int(Message.MESSAGE_ID)
+
+
+class TextMessage(Message):
+    """
+    Plain text or action message
+    """
+
+    def __init__(self, message, owner, time, message_type, message_id=0):
+        super().__init__(message_type, owner, time)
+        self._message = message
+        self._id = message_id
+
+    def get_text(self):
+        return self._message
+
+    text = property(get_text)
+
+    def get_id(self):
+        return self._id
+
+    id = property(get_id)
+
+    def is_saved(self):
+        return self._id > 0
+
+    def _create_widget(self, *args):
+        return MessageItem(self, *args)
+
+
+class OutgoingTextMessage(TextMessage):
+
+    def __init__(self, message, owner, time, message_type, tox_message_id=0):
+        super().__init__(message, owner, time, message_type)
+        self._tox_message_id = tox_message_id
+
+    def get_tox_message_id(self):
+        return self._tox_message_id
+
+    def set_tox_message_id(self, tox_message_id):
+        self._tox_message_id = tox_message_id
+
+    tox_message_id = property(get_tox_message_id, set_tox_message_id)
+
+
+class GroupChatMessage(TextMessage):
+
+    def __init__(self, id, message, owner, time, message_type, name):
+        super().__init__(id, message, owner, time, message_type)
+        self._user_name = name
+
+
+class TransferMessage(Message):
+    """
+    Message with info about file transfer
+    """
+
+    def __init__(self, author, time, state, size, file_name, friend_number, file_number):
+        super().__init__(MESSAGE_TYPE['FILE_TRANSFER'], author, time)
+        self._state = state
+        self._size = size
+        self._file_name = file_name
+        self._friend_number, self._file_number = friend_number, file_number
+
+    def is_active(self, file_number):
+        if self._file_number != file_number:
+            return False
+
+        return self._state not in (FILE_TRANSFER_STATE['FINISHED'], FILE_TRANSFER_STATE['CANCELLED'])
+
+    def get_friend_number(self):
+        return self._friend_number
+
+    friend_number = property(get_friend_number)
+
+    def get_file_number(self):
+        return self._file_number
+
+    file_number = property(get_file_number)
+
+    def get_state(self):
+        return self._state
+
+    def set_state(self, value):
+        self._state = value
+
+    state = property(get_state, set_state)
+
+    def get_size(self):
+        return self._size
+
+    size = property(get_size)
+
+    def get_file_name(self):
+        return self._file_name
+
+    file_name = property(get_file_name)
+
+    def transfer_updated(self, state, percentage, time):
+        self._state = state
+        if self._widget is not None:
+            self._widget.update_transfer_state(state, percentage, time)
+
+    def _create_widget(self, *args):
+        return FileTransferItem(self, *args)
+
+
+class UnsentFileMessage(TransferMessage):
+
+    def __init__(self, path, data, time, author, size, friend_number):
+        file_name = os.path.basename(path)
+        super().__init__(author, time, FILE_TRANSFER_STATE['UNSENT'], size, file_name, friend_number, -1)
+        self._data, self._path = data, path
+
+    def get_data(self):
+        return self._data
+
+    data = property(get_data)
+
+    def get_path(self):
+        return self._path
+
+    path = property(get_path)
+
+    def _create_widget(self, *args):
+        return UnsentFileItem(self, *args)
+
+
+class InlineImageMessage(Message):
+    """
+    Inline image
+    """
+
+    def __init__(self, data):
+        super().__init__(MESSAGE_TYPE['INLINE'], None, None)
+        self._data = data
+
+    def get_data(self):
+        return self._data
+
+    data = property(get_data)
+
+    def _create_widget(self, *args):
+        return InlineImageItem(self, *args)
+
+
+class InfoMessage(TextMessage):
+
+    def __init__(self, message, time):
+        super().__init__(message, None, time, MESSAGE_TYPE['INFO_MESSAGE'])

toxygen/messenger/messenger.py

@@ -0,0 +1,310 @@
+import common.tox_save as tox_save
+from messenger.messages import *
+
+
+class Messenger(tox_save.ToxSave):
+
+    def __init__(self, tox, plugin_loader, screen, contacts_manager, contacts_provider, items_factory, profile,
+                 calls_manager):
+        super().__init__(tox)
+        self._plugin_loader = plugin_loader
+        self._screen = screen
+        self._contacts_manager = contacts_manager
+        self._contacts_provider = contacts_provider
+        self._items_factory = items_factory
+        self._profile = profile
+        self._profile_name = profile.name
+
+        profile.name_changed_event.add_callback(self._on_profile_name_changed)
+        calls_manager.call_started_event.add_callback(self._on_call_started)
+        calls_manager.call_finished_event.add_callback(self._on_call_finished)
+
+    def get_last_message(self):
+        contact = self._contacts_manager.get_curr_contact()
+        if contact is None:
+            return str()
+
+        return contact.get_last_message_text()
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Messaging - friends
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def new_message(self, friend_number, message_type, message):
+        """
+        Current user gets new message
+        :param friend_number: friend_num of friend who sent message
+        :param message_type: message type - plain text or action message (/me)
+        :param message: text of message
+        """
+        t = util.get_unix_time()
+        friend = self._get_friend_by_number(friend_number)
+        text_message = TextMessage(message, MessageAuthor(friend.name, MESSAGE_AUTHOR['FRIEND']), t, message_type)
+        self._add_message(text_message, friend)
+
+    def send_message(self):
+        text = self._screen.messageEdit.toPlainText()
+
+        plugin_command_prefix = '/plugin '
+        if text.startswith(plugin_command_prefix):
+            self._plugin_loader.command(text[len(plugin_command_prefix):])
+            self._screen.messageEdit.clear()
+            return
+
+        action_message_prefix = '/me '
+        if text.startswith(action_message_prefix):
+            message_type = TOX_MESSAGE_TYPE['ACTION']
+            text = text[len(action_message_prefix):]
+        else:
+            message_type = TOX_MESSAGE_TYPE['NORMAL']
+
+        if self._contacts_manager.is_active_a_friend():
+            self.send_message_to_friend(text, message_type)
+        elif self._contacts_manager.is_active_a_group():
+            self.send_message_to_group(text, message_type)
+        elif self._contacts_manager.is_active_a_group_chat_peer():
+            self.send_message_to_group_peer(text, message_type)
+
+    def send_message_to_friend(self, text, message_type, friend_number=None):
+        """
+        Send message
+        :param text: message text
+        :param friend_number: number of friend
+        """
+        if friend_number is None:
+            friend_number = self._contacts_manager.get_active_number()
+
+        if not text or friend_number < 0:
+            return
+
+        friend = self._get_friend_by_number(friend_number)
+        messages = self._split_message(text.encode('utf-8'))
+        t = util.get_unix_time()
+        for message in messages:
+            if friend.status is not None:
+                message_id = self._tox.friend_send_message(friend_number, message_type, message)
+            else:
+                message_id = 0
+            message_author = MessageAuthor(self._profile.name, MESSAGE_AUTHOR['NOT_SENT'])
+            message = OutgoingTextMessage(text, message_author, t, message_type, message_id)
+            friend.append_message(message)
+            if not self._contacts_manager.is_friend_active(friend_number):
+                return
+            self._create_message_item(message)
+            self._screen.messageEdit.clear()
+            self._screen.messages.scrollToBottom()
+
+    def send_messages(self, friend_number):
+        """
+        Send 'offline' messages to friend
+        """
+        friend = self._get_friend_by_number(friend_number)
+        friend.load_corr()
+        messages = friend.get_unsent_messages()
+        try:
+            for message in messages:
+                message_id = self._tox.friend_send_message(friend_number, message.type, message.text.encode('utf-8'))
+                message.tox_message_id = message_id
+        except Exception as ex:
+            util.log('Sending pending messages failed with ' + str(ex))
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Messaging - groups
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def send_message_to_group(self, text, message_type, group_number=None):
+        if group_number is None:
+            group_number = self._contacts_manager.get_active_number()
+
+        if not text or group_number < 0:
+            return
+
+        group = self._get_group_by_number(group_number)
+        messages = self._split_message(text.encode('utf-8'))
+        t = util.get_unix_time()
+        for message in messages:
+            self._tox.group_send_message(group_number, message_type, message)
+            message_author = MessageAuthor(group.get_self_name(), MESSAGE_AUTHOR['GC_PEER'])
+            message = OutgoingTextMessage(text, message_author, t, message_type)
+            group.append_message(message)
+            if not self._contacts_manager.is_group_active(group_number):
+                return
+            self._create_message_item(message)
+            self._screen.messageEdit.clear()
+            self._screen.messages.scrollToBottom()
+
+    def new_group_message(self, group_number, message_type, message, peer_id):
+        """
+        Current user gets new message
+        :param message_type: message type - plain text or action message (/me)
+        :param message: text of message
+        """
+        t = util.get_unix_time()
+        group = self._get_group_by_number(group_number)
+        peer = group.get_peer_by_id(peer_id)
+        text_message = TextMessage(message, MessageAuthor(peer.name, MESSAGE_AUTHOR['GC_PEER']), t, message_type)
+        self._add_message(text_message, group)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Messaging - group peers
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def send_message_to_group_peer(self, text, message_type, group_number=None, peer_id=None):
+        if group_number is None or peer_id is None:
+            group_peer_contact = self._contacts_manager.get_curr_contact()
+            peer_id = group_peer_contact.number
+            group = self._get_group_by_public_key(group_peer_contact.group_pk)
+            group_number = group.number
+
+        if not text or group_number < 0 or peer_id < 0:
+            return
+
+        group_peer_contact = self._contacts_manager.get_or_create_group_peer_contact(group_number, peer_id)
+        group = self._get_group_by_number(group_number)
+        messages = self._split_message(text.encode('utf-8'))
+        t = util.get_unix_time()
+        for message in messages:
+            self._tox.group_send_private_message(group_number, peer_id, message_type, message)
+            message_author = MessageAuthor(group.get_self_name(), MESSAGE_AUTHOR['GC_PEER'])
+            message = OutgoingTextMessage(text, message_author, t, message_type)
+            group_peer_contact.append_message(message)
+            if not self._contacts_manager.is_contact_active(group_peer_contact):
+                return
+            self._create_message_item(message)
+            self._screen.messageEdit.clear()
+            self._screen.messages.scrollToBottom()
+
+    def new_group_private_message(self, group_number, message_type, message, peer_id):
+        """
+        Current user gets new message
+        :param message: text of message
+        """
+        t = util.get_unix_time()
+        group = self._get_group_by_number(group_number)
+        peer = group.get_peer_by_id(peer_id)
+        text_message = TextMessage(message, MessageAuthor(peer.name, MESSAGE_AUTHOR['GC_PEER']),
+                                   t, message_type)
+        group_peer_contact = self._contacts_manager.get_or_create_group_peer_contact(group_number, peer_id)
+        self._add_message(text_message, group_peer_contact)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Message receipts
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def receipt(self, friend_number, message_id):
+        friend = self._get_friend_by_number(friend_number)
+        friend.mark_as_sent(message_id)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Typing notifications
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def send_typing(self, typing):
+        """
+        Send typing notification to a friend
+        """
+        if not self._contacts_manager.can_send_typing_notification():
+            return
+        contact = self._contacts_manager.get_curr_contact()
+        contact.typing_notification_handler.send(self._tox, typing)
+
+    def friend_typing(self, friend_number, typing):
+        """
+        Display incoming typing notification
+        """
+        if self._contacts_manager.is_friend_active(friend_number):
+            self._screen.typing.setVisible(typing)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Contact info updated
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def new_friend_name(self, friend, old_name, new_name):
+        if old_name == new_name or friend.has_alias():
+            return
+        message = util_ui.tr('User {} is now known as {}')
+        message = message.format(old_name, new_name)
+        if not self._contacts_manager.is_friend_active(friend.number):
+            friend.actions = True
+        self._add_info_message(friend.number, message)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Private methods
+    # -----------------------------------------------------------------------------------------------------------------
+
+    @staticmethod
+    def _split_message(message):
+        messages = []
+        while len(message) > TOX_MAX_MESSAGE_LENGTH:
+            size = TOX_MAX_MESSAGE_LENGTH * 4 // 5
+            last_part = message[size:TOX_MAX_MESSAGE_LENGTH]
+            if b' ' in last_part:
+                index = last_part.index(b' ')
+            elif b',' in last_part:
+                index = last_part.index(b',')
+            elif b'.' in last_part:
+                index = last_part.index(b'.')
+            else:
+                index = TOX_MAX_MESSAGE_LENGTH - size - 1
+            index += size + 1
+            messages.append(message[:index])
+            message = message[index:]
+        if message:
+            messages.append(message)
+
+        return messages
+
+    def _get_friend_by_number(self, friend_number):
+        return self._contacts_provider.get_friend_by_number(friend_number)
+
+    def _get_group_by_number(self, group_number):
+        return self._contacts_provider.get_group_by_number(group_number)
+
+    def _get_group_by_public_key(self, public_key):
+        return self._contacts_provider.get_group_by_public_key( public_key)
+
+    def _on_profile_name_changed(self, new_name):
+        if self._profile_name == new_name:
+            return
+        message = util_ui.tr('User {} is now known as {}')
+        message = message.format(self._profile_name, new_name)
+        for friend in self._contacts_provider.get_all_friends():
+            self._add_info_message(friend.number, message)
+        self._profile_name = new_name
+
+    def _on_call_started(self, friend_number, audio, video, is_outgoing):
+        if is_outgoing:
+            text = util_ui.tr("Outgoing video call") if video else util_ui.tr("Outgoing audio call")
+        else:
+            text = util_ui.tr("Incoming video call") if video else util_ui.tr("Incoming audio call")
+        self._add_info_message(friend_number, text)
+
+    def _on_call_finished(self, friend_number, is_declined):
+        text = util_ui.tr("Call declined") if is_declined else util_ui.tr("Call finished")
+        self._add_info_message(friend_number, text)
+
+    def _add_info_message(self, friend_number, text):
+        friend = self._get_friend_by_number(friend_number)
+        message = InfoMessage(text, util.get_unix_time())
+        friend.append_message(message)
+        if self._contacts_manager.is_friend_active(friend_number):
+            self._create_info_message_item(message)
+
+    def _create_info_message_item(self, message):
+        self._items_factory.create_message_item(message)
+        self._screen.messages.scrollToBottom()
+
+    def _add_message(self, text_message, contact):
+        if self._contacts_manager.is_contact_active(contact):  # add message to list
+            self._create_message_item(text_message)
+            self._screen.messages.scrollToBottom()
+            self._contacts_manager.get_curr_contact().append_message(text_message)
+        else:
+            contact.inc_messages()
+            contact.append_message(text_message)
+            if not contact.visibility:
+                self._contacts_manager.update_filtration()
+
+    def _create_message_item(self, text_message):
+        # pixmap = self._contacts_manager.get_curr_contact().get_pixmap()
+        self._items_factory.create_message_item(text_message)

toxygen/middleware/callbacks.py

@@ -0,0 +1,605 @@
+from PyQt5 import QtGui
+from wrapper.toxcore_enums_and_consts import *
+from wrapper.toxav_enums import *
+from wrapper.tox import bin_to_string
+import utils.ui as util_ui
+import utils.util as util
+import cv2
+import numpy as np
+from middleware.threads import invoke_in_main_thread, execute
+from notifications.tray import tray_notification
+from notifications.sound import *
+import threading
+
+# TODO: refactoring. Use contact provider instead of manager
+
+# -----------------------------------------------------------------------------------------------------------------
+# Callbacks - current user
+# -----------------------------------------------------------------------------------------------------------------
+
+
+def self_connection_status(tox, profile):
+    """
+    Current user changed connection status (offline, TCP, UDP)
+    """
+    def wrapped(tox_link, connection, user_data):
+        print('Connection status: ', str(connection))
+        status = tox.self_get_status() if connection != TOX_CONNECTION['NONE'] else None
+        invoke_in_main_thread(profile.set_status, status)
+
+    return wrapped
+
+
+# -----------------------------------------------------------------------------------------------------------------
+# Callbacks - friends
+# -----------------------------------------------------------------------------------------------------------------
+
+
+def friend_status(contacts_manager, file_transfer_handler, profile, settings):
+    def wrapped(tox, friend_number, new_status, user_data):
+        """
+        Check friend's status (none, busy, away)
+        """
+        print("Friend's #{} status changed!".format(friend_number))
+        friend = contacts_manager.get_friend_by_number(friend_number)
+        if friend.status is None and settings['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)
+
+        def set_timer():
+            t = threading.Timer(5, lambda: file_transfer_handler.send_files(friend_number))
+            t.start()
+        invoke_in_main_thread(set_timer)
+        invoke_in_main_thread(contacts_manager.update_filtration)
+
+    return wrapped
+
+
+def friend_connection_status(contacts_manager, profile, settings, plugin_loader, file_transfer_handler,
+                             messenger, calls_manager):
+    def wrapped(tox, friend_number, new_status, user_data):
+        """
+        Check friend's connection status (offline, udp, tcp)
+        """
+        print("Friend #{} connection status: {}".format(friend_number, new_status))
+        friend = contacts_manager.get_friend_by_number(friend_number)
+        if new_status == TOX_CONNECTION['NONE']:
+            invoke_in_main_thread(friend.set_status, None)
+            invoke_in_main_thread(file_transfer_handler.friend_exit, friend_number)
+            invoke_in_main_thread(contacts_manager.update_filtration)
+            invoke_in_main_thread(messenger.friend_typing, friend_number, False)
+            invoke_in_main_thread(calls_manager.friend_exit, friend_number)
+            if settings['sound_notifications'] and profile.status != TOX_USER_STATUS['BUSY']:
+                sound_notification(SOUND_NOTIFICATION['FRIEND_CONNECTION_STATUS'])
+        elif friend.status is None:
+            invoke_in_main_thread(file_transfer_handler.send_avatar, friend_number)
+            invoke_in_main_thread(plugin_loader.friend_online, friend_number)
+
+    return wrapped
+
+
+def friend_name(contacts_provider, messenger):
+    def wrapped(tox, friend_number, name, size, user_data):
+        """
+        Friend changed his name
+        """
+        print('New name friend #' + str(friend_number))
+        friend = contacts_provider.get_friend_by_number(friend_number)
+        old_name = friend.name
+        new_name = str(name, 'utf-8')
+        invoke_in_main_thread(friend.set_name, new_name)
+        invoke_in_main_thread(messenger.new_friend_name, friend, old_name, new_name)
+
+    return wrapped
+
+
+def friend_status_message(contacts_manager, messenger):
+    def wrapped(tox, friend_number, status_message, size, user_data):
+        """
+        :return: function for callback friend_status_message. It updates friend's status message
+        and calls window repaint
+        """
+        friend = contacts_manager.get_friend_by_number(friend_number)
+        invoke_in_main_thread(friend.set_status_message, str(status_message, 'utf-8'))
+        print('User #{} has new status message'.format(friend_number))
+        invoke_in_main_thread(messenger.send_messages, friend_number)
+
+    return wrapped
+
+
+def friend_message(messenger, contacts_manager, profile, settings, window, tray):
+    def wrapped(tox, friend_number, message_type, message, size, user_data):
+        """
+        New message from friend
+        """
+        message = str(message, 'utf-8')
+        invoke_in_main_thread(messenger.new_message, friend_number, message_type, message)
+        if not window.isActiveWindow():
+            friend = contacts_manager.get_friend_by_number(friend_number)
+            if settings['notifications'] and profile.status != TOX_USER_STATUS['BUSY'] and not settings.locked:
+                invoke_in_main_thread(tray_notification, friend.name, message, tray, window)
+            if settings['sound_notifications'] and profile.status != TOX_USER_STATUS['BUSY']:
+                sound_notification(SOUND_NOTIFICATION['MESSAGE'])
+            icon = os.path.join(util.get_images_directory(), 'icon_new_messages.png')
+            invoke_in_main_thread(tray.setIcon, QtGui.QIcon(icon))
+
+    return wrapped
+
+
+def friend_request(contacts_manager):
+    def wrapped(tox, public_key, message, message_size, user_data):
+        """
+        Called when user get new friend request
+        """
+        print('Friend request')
+        key = ''.join(chr(x) for x in public_key[:TOX_PUBLIC_KEY_SIZE])
+        tox_id = bin_to_string(key, TOX_PUBLIC_KEY_SIZE)
+        invoke_in_main_thread(contacts_manager.process_friend_request, tox_id, str(message, 'utf-8'))
+
+    return wrapped
+
+
+def friend_typing(messenger):
+    def wrapped(tox, friend_number, typing, user_data):
+        invoke_in_main_thread(messenger.friend_typing, friend_number, typing)
+
+    return wrapped
+
+
+def friend_read_receipt(messenger):
+    def wrapped(tox, friend_number, message_id, user_data):
+        invoke_in_main_thread(messenger.receipt, friend_number, message_id)
+
+    return wrapped
+
+
+# -----------------------------------------------------------------------------------------------------------------
+# Callbacks - file transfers
+# -----------------------------------------------------------------------------------------------------------------
+
+
+def tox_file_recv(window, tray, profile, file_transfer_handler, contacts_manager, settings):
+    """
+    New incoming file
+    """
+    def wrapped(tox, friend_number, file_number, file_type, size, file_name, file_name_size, user_data):
+        if file_type == TOX_FILE_KIND['DATA']:
+            print('File')
+            try:
+                file_name = str(file_name[:file_name_size], 'utf-8')
+            except:
+                file_name = 'toxygen_file'
+            invoke_in_main_thread(file_transfer_handler.incoming_file_transfer,
+                                  friend_number,
+                                  file_number,
+                                  size,
+                                  file_name)
+            if not window.isActiveWindow():
+                friend = contacts_manager.get_friend_by_number(friend_number)
+                if settings['notifications'] and profile.status != TOX_USER_STATUS['BUSY'] and not settings.locked:
+                    file_from = util_ui.tr("File from")
+                    invoke_in_main_thread(tray_notification, file_from + ' ' + friend.name, file_name, tray, window)
+                if settings['sound_notifications'] and profile.status != TOX_USER_STATUS['BUSY']:
+                    sound_notification(SOUND_NOTIFICATION['FILE_TRANSFER'])
+                icon = util.join_path(util.get_images_directory(), 'icon_new_messages.png')
+                invoke_in_main_thread(tray.setIcon, QtGui.QIcon(icon))
+        else:  # avatar
+            print('Avatar')
+            invoke_in_main_thread(file_transfer_handler.incoming_avatar,
+                                  friend_number,
+                                  file_number,
+                                  size)
+    return wrapped
+
+
+def file_recv_chunk(file_transfer_handler):
+    """
+    Incoming chunk
+    """
+    def wrapped(tox, friend_number, file_number, position, chunk, length, user_data):
+        chunk = chunk[:length] if length else None
+        execute(file_transfer_handler.incoming_chunk, friend_number, file_number, position, chunk)
+
+    return wrapped
+
+
+def file_chunk_request(file_transfer_handler):
+    """
+    Outgoing chunk
+    """
+    def wrapped(tox, friend_number, file_number, position, size, user_data):
+        execute(file_transfer_handler.outgoing_chunk, friend_number, file_number, position, size)
+
+    return wrapped
+
+
+def file_recv_control(file_transfer_handler):
+    """
+    Friend cancelled, paused or resumed file transfer
+    """
+    def wrapped(tox, friend_number, file_number, file_control, user_data):
+        if file_control == TOX_FILE_CONTROL['CANCEL']:
+            file_transfer_handler.cancel_transfer(friend_number, file_number, True)
+        elif file_control == TOX_FILE_CONTROL['PAUSE']:
+            file_transfer_handler.pause_transfer(friend_number, file_number, True)
+        elif file_control == TOX_FILE_CONTROL['RESUME']:
+            file_transfer_handler.resume_transfer(friend_number, file_number, True)
+
+    return wrapped
+
+# -----------------------------------------------------------------------------------------------------------------
+# Callbacks - custom packets
+# -----------------------------------------------------------------------------------------------------------------
+
+
+def lossless_packet(plugin_loader):
+    def wrapped(tox, friend_number, data, length, user_data):
+        """
+        Incoming lossless packet
+        """
+        data = data[:length]
+        invoke_in_main_thread(plugin_loader.callback_lossless, friend_number, data)
+
+    return wrapped
+
+
+def lossy_packet(plugin_loader):
+    def wrapped(tox, friend_number, data, length, user_data):
+        """
+        Incoming lossy packet
+        """
+        data = data[:length]
+        invoke_in_main_thread(plugin_loader.callback_lossy, friend_number, data)
+
+    return wrapped
+
+
+# -----------------------------------------------------------------------------------------------------------------
+# Callbacks - audio
+# -----------------------------------------------------------------------------------------------------------------
+
+def call_state(calls_manager):
+    def wrapped(toxav, friend_number, mask, user_data):
+        """
+        New call state
+        """
+        print(friend_number, mask)
+        if mask == TOXAV_FRIEND_CALL_STATE['FINISHED'] or mask == TOXAV_FRIEND_CALL_STATE['ERROR']:
+            invoke_in_main_thread(calls_manager.stop_call, friend_number, True)
+        else:
+            calls_manager.toxav_call_state_cb(friend_number, mask)
+
+    return wrapped
+
+
+def call(calls_manager):
+    def wrapped(toxav, friend_number, audio, video, user_data):
+        """
+        Incoming call from friend
+        """
+        print(friend_number, audio, video)
+        invoke_in_main_thread(calls_manager.incoming_call, audio, video, friend_number)
+
+    return wrapped
+
+
+def callback_audio(calls_manager):
+    def wrapped(toxav, friend_number, samples, audio_samples_per_channel, audio_channels_count, rate, user_data):
+        """
+        New audio chunk
+        """
+        calls_manager.call.audio_chunk(
+            bytes(samples[:audio_samples_per_channel * 2 * audio_channels_count]),
+            audio_channels_count,
+            rate)
+
+    return wrapped
+
+# -----------------------------------------------------------------------------------------------------------------
+# Callbacks - video
+# -----------------------------------------------------------------------------------------------------------------
+
+
+def video_receive_frame(toxav, friend_number, width, height, y, u, v, ystride, ustride, vstride, user_data):
+    """
+    Creates yuv frame from y, u, v and shows it using OpenCV
+    For yuv => bgr we need this YUV420 frame:
+
+              width
+    -------------------------
+    |                       |
+    |          Y            |      height
+    |                       |
+    -------------------------
+    |           |           |
+    |  U even   |   U odd   |      height // 4
+    |           |           |
+    -------------------------
+    |           |           |
+    |  V even   |   V odd   |      height // 4
+    |           |           |
+    -------------------------
+
+     width // 2   width // 2
+
+    It can be created from initial y, u, v using slices
+    """
+    try:
+        y_size = abs(max(width, abs(ystride)))
+        u_size = abs(max(width // 2, abs(ustride)))
+        v_size = abs(max(width // 2, abs(vstride)))
+
+        y = np.asarray(y[:y_size * height], dtype=np.uint8).reshape(height, y_size)
+        u = np.asarray(u[:u_size * height // 2], dtype=np.uint8).reshape(height // 2, u_size)
+        v = np.asarray(v[:v_size * height // 2], dtype=np.uint8).reshape(height // 2, v_size)
+
+        width -= width % 4
+        height -= height % 4
+
+        frame = np.zeros((int(height * 1.5), width), dtype=np.uint8)
+
+        frame[:height, :] = y[:height, :width]
+        frame[height:height * 5 // 4, :width // 2] = u[:height // 2:2, :width // 2]
+        frame[height:height * 5 // 4, width // 2:] = u[1:height // 2:2, :width // 2]
+
+        frame[height * 5 // 4:, :width // 2] = v[:height // 2:2, :width // 2]
+        frame[height * 5 // 4:, width // 2:] = v[1:height // 2:2, :width // 2]
+
+        frame = cv2.cvtColor(frame, cv2.COLOR_YUV2BGR_I420)
+
+        invoke_in_main_thread(cv2.imshow, str(friend_number), frame)
+    except Exception as ex:
+        print(ex)
+
+# -----------------------------------------------------------------------------------------------------------------
+# Callbacks - groups
+# -----------------------------------------------------------------------------------------------------------------
+
+
+def group_message(window, tray, tox, messenger, settings, profile):
+    """
+    New message in group chat
+    """
+    def wrapped(tox_link, group_number, peer_id, message_type, message, length, user_data):
+        message = str(message[:length], 'utf-8')
+        invoke_in_main_thread(messenger.new_group_message, group_number, message_type, message, peer_id)
+        if window.isActiveWindow():
+            return
+        bl = settings['notify_all_gc'] or profile.name in message
+        name = tox.group_peer_get_name(group_number, peer_id)
+        if settings['notifications'] and profile.status != TOX_USER_STATUS['BUSY'] and (not settings.locked) and bl:
+            invoke_in_main_thread(tray_notification, name, message, tray, window)
+        if settings['sound_notifications'] and bl and profile.status != TOX_USER_STATUS['BUSY']:
+            sound_notification(SOUND_NOTIFICATION['MESSAGE'])
+        icon = util.join_path(util.get_images_directory(), 'icon_new_messages.png')
+        invoke_in_main_thread(tray.setIcon, QtGui.QIcon(icon))
+
+    return wrapped
+
+
+def group_private_message(window, tray, tox, messenger, settings, profile):
+    """
+    New private message in group chat
+    """
+    def wrapped(tox_link, group_number, peer_id, message_type, message, length, user_data):
+        message = str(message[:length], 'utf-8')
+        invoke_in_main_thread(messenger.new_group_private_message, group_number, message_type, message, peer_id)
+        if window.isActiveWindow():
+            return
+        bl = settings['notify_all_gc'] or profile.name in message
+        name = tox.group_peer_get_name(group_number, peer_id)
+        if settings['notifications'] and profile.status != TOX_USER_STATUS['BUSY'] and (not settings.locked) and bl:
+            invoke_in_main_thread(tray_notification, name, message, tray, window)
+        if settings['sound_notifications'] and bl and profile.status != TOX_USER_STATUS['BUSY']:
+            sound_notification(SOUND_NOTIFICATION['MESSAGE'])
+        icon = util.join_path(util.get_images_directory(), 'icon_new_messages.png')
+        invoke_in_main_thread(tray.setIcon, QtGui.QIcon(icon))
+
+    return wrapped
+
+
+def group_invite(window, settings, tray, profile, groups_service, contacts_provider):
+    def wrapped(tox, friend_number, invite_data, length, group_name, group_name_length, user_data):
+        group_name = str(bytes(group_name[:group_name_length]), 'utf-8')
+        invoke_in_main_thread(groups_service.process_group_invite,
+                              friend_number, group_name,
+                              bytes(invite_data[:length]))
+        if window.isActiveWindow():
+            return
+        if settings['notifications'] and profile.status != TOX_USER_STATUS['BUSY'] and not settings.locked:
+            friend = contacts_provider.get_friend_by_number(friend_number)
+            title = util_ui.tr('New invite to group chat')
+            text = util_ui.tr('{} invites you to group "{}"').format(friend.name, group_name)
+            invoke_in_main_thread(tray_notification, title, text, tray, window)
+        icon = util.join_path(util.get_images_directory(), 'icon_new_messages.png')
+        invoke_in_main_thread(tray.setIcon, QtGui.QIcon(icon))
+
+    return wrapped
+
+
+def group_self_join(contacts_provider, contacts_manager, groups_service):
+    def wrapped(tox, group_number, user_data):
+        group = contacts_provider.get_group_by_number(group_number)
+        invoke_in_main_thread(group.set_status, TOX_USER_STATUS['NONE'])
+        invoke_in_main_thread(groups_service.update_group_info, group)
+        invoke_in_main_thread(contacts_manager.update_filtration)
+
+    return wrapped
+
+
+def group_peer_join(contacts_provider, groups_service):
+    def wrapped(tox, group_number, peer_id, user_data):
+        group = contacts_provider.get_group_by_number(group_number)
+        group.add_peer(peer_id)
+        invoke_in_main_thread(groups_service.generate_peers_list)
+        invoke_in_main_thread(groups_service.update_group_info, group)
+
+    return wrapped
+
+
+def group_peer_exit(contacts_provider, groups_service, contacts_manager):
+    def wrapped(tox, group_number, peer_id, message, length, user_data):
+        group = contacts_provider.get_group_by_number(group_number)
+        group.remove_peer(peer_id)
+        invoke_in_main_thread(groups_service.generate_peers_list)
+
+    return wrapped
+
+
+def group_peer_name(contacts_provider, groups_service):
+    def wrapped(tox, group_number, peer_id, name, length, user_data):
+        group = contacts_provider.get_group_by_number(group_number)
+        peer = group.get_peer_by_id(peer_id)
+        peer.name = str(name[:length], 'utf-8')
+        invoke_in_main_thread(groups_service.generate_peers_list)
+
+    return wrapped
+
+
+def group_peer_status(contacts_provider, groups_service):
+    def wrapped(tox, group_number, peer_id, peer_status, user_data):
+        group = contacts_provider.get_group_by_number(group_number)
+        peer = group.get_peer_by_id(peer_id)
+        peer.status = peer_status
+        invoke_in_main_thread(groups_service.generate_peers_list)
+
+    return wrapped
+
+
+def group_topic(contacts_provider):
+    def wrapped(tox, group_number, peer_id, topic, length, user_data):
+        group = contacts_provider.get_group_by_number(group_number)
+        topic = str(topic[:length], 'utf-8')
+        invoke_in_main_thread(group.set_status_message, topic)
+
+    return wrapped
+
+
+def group_moderation(groups_service, contacts_provider, contacts_manager, messenger):
+
+    def update_peer_role(group, mod_peer_id, peer_id, new_role):
+        peer = group.get_peer_by_id(peer_id)
+        peer.role = new_role
+        # TODO: add info message
+
+    def remove_peer(group, mod_peer_id, peer_id, is_ban):
+        contacts_manager.remove_group_peer_by_id(group, peer_id)
+        group.remove_peer(peer_id)
+        # TODO: add info message
+
+    def wrapped(tox, group_number, mod_peer_id, peer_id, event_type, user_data):
+        group = contacts_provider.get_group_by_number(group_number)
+
+        if event_type == TOX_GROUP_MOD_EVENT['KICK']:
+            remove_peer(group, mod_peer_id, peer_id, False)
+        elif event_type == TOX_GROUP_MOD_EVENT['BAN']:
+            remove_peer(group, mod_peer_id, peer_id, True)
+        elif event_type == TOX_GROUP_MOD_EVENT['OBSERVER']:
+            update_peer_role(group, mod_peer_id, peer_id, TOX_GROUP_ROLE['OBSERVER'])
+        elif event_type == TOX_GROUP_MOD_EVENT['USER']:
+            update_peer_role(group, mod_peer_id, peer_id, TOX_GROUP_ROLE['USER'])
+        elif event_type == TOX_GROUP_MOD_EVENT['MODERATOR']:
+            update_peer_role(group, mod_peer_id, peer_id, TOX_GROUP_ROLE['MODERATOR'])
+
+        invoke_in_main_thread(groups_service.generate_peers_list)
+
+    return wrapped
+
+
+def group_password(contacts_provider):
+
+    def wrapped(tox_link, group_number, password, length, user_data):
+        password = str(password[:length], 'utf-8')
+        group = contacts_provider.get_group_by_number(group_number)
+        group.password = password
+
+    return wrapped
+
+
+def group_peer_limit(contacts_provider):
+
+    def wrapped(tox_link, group_number, peer_limit, user_data):
+        group = contacts_provider.get_group_by_number(group_number)
+        group.peer_limit = peer_limit
+
+    return wrapped
+
+
+def group_privacy_state(contacts_provider):
+
+    def wrapped(tox_link, group_number, privacy_state, user_data):
+        group = contacts_provider.get_group_by_number(group_number)
+        group.is_private = privacy_state == TOX_GROUP_PRIVACY_STATE['PRIVATE']
+
+    return wrapped
+
+# -----------------------------------------------------------------------------------------------------------------
+# Callbacks - initialization
+# -----------------------------------------------------------------------------------------------------------------
+
+
+def init_callbacks(tox, profile, settings, plugin_loader, contacts_manager,
+                   calls_manager, file_transfer_handler, main_window, tray, messenger, groups_service,
+                   contacts_provider):
+    """
+    Initialization of all callbacks.
+    :param tox: Tox instance
+    :param profile: Profile instance
+    :param settings: Settings instance
+    :param contacts_manager: ContactsManager instance
+    :param contacts_manager: ContactsManager instance
+    :param calls_manager: CallsManager instance
+    :param file_transfer_handler: FileTransferHandler instance
+    :param plugin_loader: PluginLoader instance
+    :param main_window: MainWindow instance
+    :param tray: tray (for notifications)
+    :param messenger: Messenger instance
+    :param groups_service: GroupsService instance
+    :param contacts_provider: ContactsProvider instance
+    """
+    # self callbacks
+    tox.callback_self_connection_status(self_connection_status(tox, profile))
+
+    # friend callbacks
+    tox.callback_friend_status(friend_status(contacts_manager, file_transfer_handler, profile, settings))
+    tox.callback_friend_message(friend_message(messenger, contacts_manager, profile, settings, main_window, tray))
+    tox.callback_friend_connection_status(friend_connection_status(contacts_manager, profile, settings, plugin_loader,
+                                                                   file_transfer_handler, messenger, calls_manager))
+    tox.callback_friend_name(friend_name(contacts_provider, messenger))
+    tox.callback_friend_status_message(friend_status_message(contacts_manager, messenger))
+    tox.callback_friend_request(friend_request(contacts_manager))
+    tox.callback_friend_typing(friend_typing(messenger))
+    tox.callback_friend_read_receipt(friend_read_receipt(messenger))
+
+    # file transfer
+    tox.callback_file_recv(tox_file_recv(main_window, tray, profile, file_transfer_handler,
+                                         contacts_manager, settings))
+    tox.callback_file_recv_chunk(file_recv_chunk(file_transfer_handler))
+    tox.callback_file_chunk_request(file_chunk_request(file_transfer_handler))
+    tox.callback_file_recv_control(file_recv_control(file_transfer_handler))
+
+    # av
+    toxav = tox.AV
+    toxav.callback_call_state(call_state(calls_manager), 0)
+    toxav.callback_call(call(calls_manager), 0)
+    toxav.callback_audio_receive_frame(callback_audio(calls_manager), 0)
+    toxav.callback_video_receive_frame(video_receive_frame, 0)
+
+    # custom packets
+    tox.callback_friend_lossless_packet(lossless_packet(plugin_loader))
+    tox.callback_friend_lossy_packet(lossy_packet(plugin_loader))
+
+    # gc callbacks
+    tox.callback_group_message(group_message(main_window, tray, tox, messenger, settings, profile), 0)
+    tox.callback_group_private_message(group_private_message(main_window, tray, tox, messenger, settings, profile), 0)
+    tox.callback_group_invite(group_invite(main_window, settings, tray, profile, groups_service, contacts_provider), 0)
+    tox.callback_group_self_join(group_self_join(contacts_provider, contacts_manager, groups_service), 0)
+    tox.callback_group_peer_join(group_peer_join(contacts_provider, groups_service), 0)
+    tox.callback_group_peer_exit(group_peer_exit(contacts_provider, groups_service, contacts_manager), 0)
+    tox.callback_group_peer_name(group_peer_name(contacts_provider, groups_service), 0)
+    tox.callback_group_peer_status(group_peer_status(contacts_provider, groups_service), 0)
+    tox.callback_group_topic(group_topic(contacts_provider), 0)
+    tox.callback_group_moderation(group_moderation(groups_service, contacts_provider, contacts_manager, messenger), 0)
+    tox.callback_group_password(group_password(contacts_provider), 0)
+    tox.callback_group_peer_limit(group_peer_limit(contacts_provider), 0)
+    tox.callback_group_privacy_state(group_privacy_state(contacts_provider), 0)

toxygen/middleware/threads.py

@@ -0,0 +1,172 @@
+from bootstrap.bootstrap import *
+import threading
+import queue
+from utils import util
+import time
+from PyQt5 import QtCore
+
+
+# -----------------------------------------------------------------------------------------------------------------
+# Base threads
+# -----------------------------------------------------------------------------------------------------------------
+
+class BaseThread(threading.Thread):
+
+    def __init__(self):
+        super().__init__()
+        self._stop_thread = False
+
+    def stop_thread(self):
+        self._stop_thread = True
+        self.join()
+
+
+class BaseQThread(QtCore.QThread):
+
+    def __init__(self):
+        super().__init__()
+        self._stop_thread = False
+
+    def stop_thread(self):
+        self._stop_thread = True
+        self.wait()
+
+
+# -----------------------------------------------------------------------------------------------------------------
+# Toxcore threads
+# -----------------------------------------------------------------------------------------------------------------
+
+class InitThread(BaseThread):
+
+    def __init__(self, tox, plugin_loader, settings, is_first_start):
+        super().__init__()
+        self._tox, self._plugin_loader, self._settings = tox, plugin_loader, settings
+        self._is_first_start = is_first_start
+
+    def run(self):
+        if self._is_first_start:
+            # download list of nodes if needed
+            download_nodes_list(self._settings)
+            # start plugins
+            self._plugin_loader.load()
+
+        # bootstrap
+        try:
+            for data in generate_nodes():
+                if self._stop_thread:
+                    return
+                self._tox.bootstrap(*data)
+                self._tox.add_tcp_relay(*data)
+        except:
+            pass
+
+        for _ in range(10):
+            if self._stop_thread:
+                return
+            time.sleep(1)
+
+        while not self._tox.self_get_connection_status():
+            try:
+                for data in generate_nodes(None):
+                    if self._stop_thread:
+                        return
+                    self._tox.bootstrap(*data)
+                    self._tox.add_tcp_relay(*data)
+            except:
+                pass
+            finally:
+                time.sleep(5)
+
+
+class ToxIterateThread(BaseQThread):
+
+    def __init__(self, tox):
+        super().__init__()
+        self._tox = tox
+
+    def run(self):
+        while not self._stop_thread:
+            self._tox.iterate()
+            time.sleep(self._tox.iteration_interval() / 1000)
+
+
+class ToxAVIterateThread(BaseQThread):
+
+    def __init__(self, toxav):
+        super().__init__()
+        self._toxav = toxav
+
+    def run(self):
+        while not self._stop_thread:
+            self._toxav.iterate()
+            time.sleep(self._toxav.iteration_interval() / 1000)
+
+
+# -----------------------------------------------------------------------------------------------------------------
+# File transfers thread
+# -----------------------------------------------------------------------------------------------------------------
+
+class FileTransfersThread(BaseQThread):
+
+    def __init__(self):
+        super().__init__()
+        self._queue = queue.Queue()
+        self._timeout = 0.01
+
+    def execute(self, func, *args, **kwargs):
+        self._queue.put((func, args, kwargs))
+
+    def run(self):
+        while not self._stop_thread:
+            try:
+                func, args, kwargs = self._queue.get(timeout=self._timeout)
+                func(*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_file_transfer_thread():
+    _thread.start()
+
+
+def stop_file_transfer_thread():
+    _thread.stop_thread()
+
+
+def execute(func, *args, **kwargs):
+    _thread.execute(func, *args, **kwargs)
+
+
+# -----------------------------------------------------------------------------------------------------------------
+# Invoking in main thread
+# -----------------------------------------------------------------------------------------------------------------
+
+class InvokeEvent(QtCore.QEvent):
+    EVENT_TYPE = QtCore.QEvent.Type(QtCore.QEvent.registerEventType())
+
+    def __init__(self, fn, *args, **kwargs):
+        QtCore.QEvent.__init__(self, InvokeEvent.EVENT_TYPE)
+        self.fn = fn
+        self.args = args
+        self.kwargs = kwargs
+
+
+class Invoker(QtCore.QObject):
+
+    def event(self, event):
+        event.fn(*event.args, **event.kwargs)
+        return True
+
+
+_invoker = Invoker()
+
+
+def invoke_in_main_thread(fn, *args, **kwargs):
+    QtCore.QCoreApplication.postEvent(_invoker, InvokeEvent(fn, *args, **kwargs))

toxygen/middleware/tox_factory.py

@@ -0,0 +1,34 @@
+import user_data.settings
+import wrapper.tox
+import wrapper.toxcore_enums_and_consts as enums
+import ctypes
+
+
+def tox_factory(data=None, settings=None):
+    """
+    :param data: user data from .tox file. None = no saved data, create new profile
+    :param settings: current profile settings. None = default settings will be used
+    :return: new tox instance
+    """
+    if settings is None:
+        settings = user_data.settings.Settings.get_default_settings()
+
+    tox_options = wrapper.tox.Tox.options_new()
+    tox_options.contents.udp_enabled = settings['udp_enabled']
+    tox_options.contents.proxy_type = settings['proxy_type']
+    tox_options.contents.proxy_host = bytes(settings['proxy_host'], 'UTF-8')
+    tox_options.contents.proxy_port = settings['proxy_port']
+    tox_options.contents.start_port = settings['start_port']
+    tox_options.contents.end_port = settings['end_port']
+    tox_options.contents.tcp_port = settings['tcp_port']
+    tox_options.contents.local_discovery_enabled = settings['lan_discovery']
+    if data:  # load existing profile
+        tox_options.contents.savedata_type = enums.TOX_SAVEDATA_TYPE['TOX_SAVE']
+        tox_options.contents.savedata_data = ctypes.c_char_p(data)
+        tox_options.contents.savedata_length = len(data)
+    else:  # create new profile
+        tox_options.contents.savedata_type = enums.TOX_SAVEDATA_TYPE['NONE']
+        tox_options.contents.savedata_data = None
+        tox_options.contents.savedata_length = 0
+
+    return wrapper.tox.Tox(tox_options)

toxygen/network/tox_dns.py

@@ -0,0 +1,65 @@
+import json
+import urllib.request
+import utils.util as util
+from PyQt5 import QtNetwork, QtCore
+
+
+class ToxDns:
+
+    def __init__(self, settings):
+        self._settings = settings
+
+    @staticmethod
+    def _send_request(url, data):
+        req = urllib.request.Request(url)
+        req.add_header('Content-Type', 'application/json')
+        response = urllib.request.urlopen(req, bytes(json.dumps(data), 'utf-8'))
+        res = json.loads(str(response.read(), 'utf-8'))
+        if not res['c']:
+            return res['tox_id']
+        else:
+            raise LookupError()
+
+    def lookup(self, email):
+        """
+        TOX DNS 4
+        :param email: data like 'groupbot@toxme.io'
+        :return: tox id on success else None
+        """
+        site = email.split('@')[1]
+        data = {"action": 3, "name": "{}".format(email)}
+        urls = ('https://{}/api'.format(site), 'http://{}/api'.format(site))
+        if not self._settings['proxy_type']:  # no proxy
+            for url in urls:
+                try:
+                    return self._send_request(url, data)
+                except Exception as ex:
+                    util.log('TOX DNS ERROR: ' + str(ex))
+        else:  # proxy
+            netman = QtNetwork.QNetworkAccessManager()
+            proxy = QtNetwork.QNetworkProxy()
+            if self._settings['proxy_type'] == 2:
+                proxy.setType(QtNetwork.QNetworkProxy.Socks5Proxy)
+            else:
+                proxy.setType(QtNetwork.QNetworkProxy.HttpProxy)
+            proxy.setHostName(self._settings['proxy_host'])
+            proxy.setPort(self._settings['proxy_port'])
+            netman.setProxy(proxy)
+            for url in urls:
+                try:
+                    request = QtNetwork.QNetworkRequest()
+                    request.setUrl(QtCore.QUrl(url))
+                    request.setHeader(QtNetwork.QNetworkRequest.ContentTypeHeader, "application/json")
+                    reply = netman.post(request, bytes(json.dumps(data), 'utf-8'))
+
+                    while not reply.isFinished():
+                        QtCore.QThread.msleep(1)
+                        QtCore.QCoreApplication.processEvents()
+                    data = bytes(reply.readAll().data())
+                    result = json.loads(str(data, 'utf-8'))
+                    if not result['c']:
+                        return result['tox_id']
+                except Exception as ex:
+                    util.log('TOX DNS ERROR: ' + str(ex))
+
+        return None  # error

toxygen/notifications.py

@@ -1,75 +0,0 @@
-try:
-    from PySide import QtCore, QtGui
-except ImportError:
-    from PyQt4 import QtCore, QtGui
-from util import curr_directory
-import wave
-import pyaudio
-
-
-SOUND_NOTIFICATION = {
-    'MESSAGE': 0,
-    'FRIEND_CONNECTION_STATUS': 1,
-    'FILE_TRANSFER': 2
-}
-
-
-def tray_notification(title, text, tray, window):
-    """
-    Show tray notification and activate window icon
-    NOTE: different behaviour on different OS
-    :param title: Name of user who sent message or file
-    :param text: text of message or file info
-    :param tray: ref to tray icon
-    :param window: main window
-    """
-    if QtGui.QSystemTrayIcon.isSystemTrayAvailable():
-        if len(text) > 30:
-            text = text[:27] + '...'
-        tray.showMessage(title, text, QtGui.QSystemTrayIcon.NoIcon, 3000)
-        QtGui.QApplication.alert(window, 0)
-
-        def message_clicked():
-            window.setWindowState(window.windowState() & ~QtCore.Qt.WindowMinimized | QtCore.Qt.WindowActive)
-            window.activateWindow()
-        tray.connect(tray, QtCore.SIGNAL("messageClicked()"), message_clicked)
-
-
-class AudioFile:
-    chunk = 1024
-
-    def __init__(self, fl):
-        self.wf = wave.open(fl, 'rb')
-        self.p = pyaudio.PyAudio()
-        self.stream = self.p.open(
-            format=self.p.get_format_from_width(self.wf.getsampwidth()),
-            channels=self.wf.getnchannels(),
-            rate=self.wf.getframerate(),
-            output=True
-        )
-
-    def play(self):
-        data = self.wf.readframes(self.chunk)
-        while data:
-            self.stream.write(data)
-            data = self.wf.readframes(self.chunk)
-
-    def close(self):
-        self.stream.close()
-        self.p.terminate()
-
-
-def sound_notification(t):
-    """
-    Plays sound notification
-    :param t: type of notification
-    """
-    if t == SOUND_NOTIFICATION['MESSAGE']:
-        f = curr_directory() + '/sounds/message.wav'
-    elif t == SOUND_NOTIFICATION['FILE_TRANSFER']:
-        f = curr_directory() + '/sounds/file.wav'
-    else:
-        f = curr_directory() + '/sounds/contact.wav'
-    a = AudioFile(f)
-    a.play()
-    a.close()

toxygen/notifications/sound.py

@@ -0,0 +1,54 @@
+import utils.util
+import wave
+import pyaudio
+import os.path
+
+
+SOUND_NOTIFICATION = {
+    'MESSAGE': 0,
+    'FRIEND_CONNECTION_STATUS': 1,
+    'FILE_TRANSFER': 2
+}
+
+
+class AudioFile:
+    chunk = 1024
+
+    def __init__(self, fl):
+        self.wf = wave.open(fl, 'rb')
+        self.p = pyaudio.PyAudio()
+        self.stream = self.p.open(
+            format=self.p.get_format_from_width(self.wf.getsampwidth()),
+            channels=self.wf.getnchannels(),
+            rate=self.wf.getframerate(),
+            output=True)
+
+    def play(self):
+        data = self.wf.readframes(self.chunk)
+        while data:
+            self.stream.write(data)
+            data = self.wf.readframes(self.chunk)
+
+    def close(self):
+        self.stream.close()
+        self.p.terminate()
+
+
+def sound_notification(t):
+    """
+    Plays sound notification
+    :param t: type of notification
+    """
+    if t == SOUND_NOTIFICATION['MESSAGE']:
+        f = get_file_path('message.wav')
+    elif t == SOUND_NOTIFICATION['FILE_TRANSFER']:
+        f = get_file_path('file.wav')
+    else:
+        f = get_file_path('contact.wav')
+    a = AudioFile(f)
+    a.play()
+    a.close()
+
+
+def get_file_path(file_name):
+    return os.path.join(utils.util.get_sounds_directory(), file_name)

toxygen/notifications/tray.py

@@ -0,0 +1,22 @@
+from PyQt5 import QtCore, QtWidgets
+
+
+def tray_notification(title, text, tray, window):
+    """
+    Show tray notification and activate window icon
+    NOTE: different behaviour on different OS
+    :param title: Name of user who sent message or file
+    :param text: text of message or file info
+    :param tray: ref to tray icon
+    :param window: main window
+    """
+    if QtWidgets.QSystemTrayIcon.isSystemTrayAvailable():
+        if len(text) > 30:
+            text = text[:27] + '...'
+        tray.showMessage(title, text, QtWidgets.QSystemTrayIcon.NoIcon, 3000)
+        QtWidgets.QApplication.alert(window, 0)
+
+        def message_clicked():
+            window.setWindowState(window.windowState() & ~QtCore.Qt.WindowMinimized | QtCore.Qt.WindowActive)
+            window.activateWindow()
+        tray.messageClicked.connect(message_clicked)

toxygen/plugin_support.py

@@ -1,167 +0,0 @@
-import util
-import profile
-import os
-import importlib
-import inspect
-import plugins.plugin_super_class as pl
-import toxencryptsave
-import sys
-
-
-class PluginLoader(util.Singleton):
-
-    def __init__(self, tox, settings):
-        super().__init__()
-        self._profile = profile.Profile.get_instance()
-        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()
-
-    def set_tox(self, tox):
-        """
-        New tox instance
-        """
-        self._tox = tox
-        for value in self._plugins.values():
-            value[0].set_tox(tox)
-
-    def load(self):
-        """
-        Load all plugins in plugins folder
-        """
-        path = util.curr_directory() + '/plugins/'
-        if not os.path.exists(path):
-            util.log('Plugin dir not found')
-            return
-        else:
-            sys.path.append(path)
-        files = [f for f in os.listdir(path) if os.path.isfile(os.path.join(path, f))]
-        for fl in files:
-            if fl in ('plugin_super_class.py', '__init__.py') or not fl.endswith('.py'):
-                continue
-            name = fl[:-3]  # module name without .py
-            try:
-                module = importlib.import_module(name)  # import plugin
-            except ImportError:
-                util.log('Import error in module ' + name)
-                continue
-            except Exception as ex:
-                util.log('Exception in module ' + name + ' Exception: ' + str(ex))
-                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
-                    print('Plugin', elem)
-                    try:  # create instance of plugin class
-                        inst = obj(self._tox, self._profile, self._settings, self._encr)
-                        autostart = inst.get_short_name() in self._settings['plugins']
-                        if autostart:
-                            inst.start()
-                    except Exception as ex:
-                        util.log('Exception in module ' + name + ' Exception: ' + str(ex))
-                        continue
-                    self._plugins[inst.get_short_name()] = [inst, autostart]  # (inst, is active)
-                    break
-
-    def callback_lossless(self, friend_number, data, length):
-        """
-        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)
-
-    def callback_lossy(self, friend_number, data, length):
-        """
-        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)
-
-    def friend_online(self, friend_number):
-        """
-        Friend with specified number is online
-        """
-        for elem in self._plugins.values():
-            if elem[1]:
-                elem[0].friend_connected(friend_number)
-
-    def get_plugins_list(self):
-        """
-        Returns list of all plugins
-        """
-        result = []
-        for data in self._plugins.values():
-            result.append([data[0].get_name(),  # plugin full name
-                           data[1],  # is enabled
-                           data[0].get_description(),  # plugin description
-                           data[0].get_short_name()])  # key - short unique name
-        return result
-
-    def plugin_window(self, key):
-        """
-        Return window or None for specified plugin
-        """
-        return self._plugins[key][0].get_window()
-
-    def toggle_plugin(self, key):
-        """
-        Enable/disable plugin
-        :param key: plugin short name
-        """
-        plugin = self._plugins[key]
-        if plugin[1]:
-            plugin[0].stop()
-        else:
-            plugin[0].start()
-        plugin[1] = not plugin[1]
-        if plugin[1]:
-            self._settings['plugins'].append(key)
-        else:
-            self._settings['plugins'].remove(key)
-        self._settings.save()
-
-    def command(self, text):
-        """
-        New command for plugin
-        """
-        text = text.strip()
-        name = text.split()[0]
-        if name in self._plugins and self._plugins[name][1]:
-            self._plugins[name][0].command(text[len(name) + 1:])
-
-    def get_menu(self, menu, num):
-        """
-        Return list of items for menu
-        """
-        result = []
-        for elem in self._plugins.values():
-            if elem[1]:
-                try:
-                    result.extend(elem[0].get_menu(menu, num))
-                except:
-                    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
-        """
-        for key in list(self._plugins.keys()):
-            if self._plugins[key][1]:
-                self._plugins[key][0].close()
-            del self._plugins[key]

toxygen/plugin_support/plugin_support.py

@@ -0,0 +1,194 @@
+import utils.util as util
+import os
+import importlib
+import inspect
+import plugins.plugin_super_class as pl
+import sys
+
+
+class Plugin:
+
+    def __init__(self, plugin, is_active):
+        self._instance = plugin
+        self._is_active = is_active
+
+    def get_instance(self):
+        return self._instance
+
+    instance = property(get_instance)
+
+    def get_is_active(self):
+        return self._is_active
+
+    def set_is_active(self, is_active):
+        self._is_active = is_active
+
+    is_active = property(get_is_active, set_is_active)
+
+
+class PluginLoader:
+
+    def __init__(self, settings, app):
+        self._settings = settings
+        self._app = app
+        self._plugins = {}  # dict. key - plugin unique short name, value - Plugin instance
+
+    def set_tox(self, tox):
+        """
+        New tox instance
+        """
+        for plugin in self._plugins.values():
+            plugin.instance.set_tox(tox)
+
+    def load(self):
+        """
+        Load all plugins in plugins folder
+        """
+        path = util.get_plugins_directory()
+        if not os.path.exists(path):
+            util.log('Plugin dir not found')
+            return
+        else:
+            sys.path.append(path)
+        files = [f for f in os.listdir(path) if os.path.isfile(os.path.join(path, f))]
+        for fl in files:
+            if fl in ('plugin_super_class.py', '__init__.py') or not fl.endswith('.py'):
+                continue
+            name = fl[:-3]  # module name without .py
+            try:
+                module = importlib.import_module(name)  # import plugin
+            except ImportError:
+                util.log('Import error in module ' + name)
+                continue
+            except Exception as ex:
+                util.log('Exception in module ' + name + ' Exception: ' + str(ex))
+                continue
+            for elem in dir(module):
+                obj = getattr(module, elem)
+                # looking for plugin class in module
+                if not inspect.isclass(obj) or not hasattr(obj, 'is_plugin') or not obj.is_plugin:
+                    continue
+                print('Plugin', elem)
+                try:  # create instance of plugin class
+                    instance = obj(self._app)
+                    is_active = instance.get_short_name() in self._settings['plugins']
+                    if is_active:
+                        instance.start()
+                except Exception as ex:
+                    util.log('Exception in module ' + name + ' Exception: ' + str(ex))
+                    continue
+                self._plugins[instance.get_short_name()] = Plugin(instance, is_active)
+                break
+
+    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].is_active:
+            self._plugins[name].instance.lossless_packet(''.join(chr(x) for x in data[l + 1:]), friend_number)
+
+    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].is_active:
+            self._plugins[name].instance.lossy_packet(''.join(chr(x) for x in data[l + 1:]), friend_number)
+
+    def friend_online(self, friend_number):
+        """
+        Friend with specified number is online
+        """
+        for plugin in self._plugins.values():
+            if plugin.is_active:
+                plugin.instance.friend_connected(friend_number)
+
+    def get_plugins_list(self):
+        """
+        Returns list of all plugins
+        """
+        result = []
+        for plugin in self._plugins.values():
+            try:
+                result.append([plugin.instance.get_name(),  # plugin full name
+                               plugin.is_active,  # is enabled
+                               plugin.instance.get_description(),  # plugin description
+                               plugin.instance.get_short_name()])  # key - short unique name
+            except:
+                continue
+
+        return result
+
+    def plugin_window(self, key):
+        """
+        Return window or None for specified plugin
+        """
+        return self._plugins[key].instance.get_window()
+
+    def toggle_plugin(self, key):
+        """
+        Enable/disable plugin
+        :param key: plugin short name
+        """
+        plugin = self._plugins[key]
+        if plugin.is_active:
+            plugin.instance.stop()
+        else:
+            plugin.instance.start()
+        plugin.is_active = not plugin.is_active
+        if plugin.is_active:
+            self._settings['plugins'].append(key)
+        else:
+            self._settings['plugins'].remove(key)
+        self._settings.save()
+
+    def command(self, text):
+        """
+        New command for plugin
+        """
+        text = text.strip()
+        name = text.split()[0]
+        if name in self._plugins and self._plugins[name].is_active:
+            self._plugins[name].instance.command(text[len(name) + 1:])
+
+    def get_menu(self, num):
+        """
+        Return list of items for menu
+        """
+        result = []
+        for plugin in self._plugins.values():
+            if not plugin.is_active:
+                continue
+            try:
+                result.extend(plugin.instance.get_menu(num))
+            except:
+                continue
+        return result
+
+    def get_message_menu(self, menu, selected_text):
+        result = []
+        for plugin in self._plugins.values():
+            if not plugin.is_active:
+                continue
+            try:
+                result.extend(plugin.instance.get_message_menu(menu, selected_text))
+            except:
+                pass
+        return result
+
+    def stop(self):
+        """
+        App is closing, stop all plugins
+        """
+        for key in list(self._plugins.keys()):
+            if self._plugins[key].is_active:
+                self._plugins[key].instance.close()
+            del self._plugins[key]
+
+    def reload(self):
+        print('Reloading plugins')
+        self.stop()
+        self.load()

toxygen/plugins/plugin_super_class.py

@@ -1,8 +1,7 @@
 import os
-try:
+from PyQt5 import QtCore, QtWidgets
-    from PySide import QtCore, QtGui
+import utils.ui as util_ui
-except ImportError:
+import common.tox_save as tox_save
-    from PyQt4 import QtCore, QtGui
 
 
 MAX_SHORT_NAME_LENGTH = 5
@@ -26,28 +25,25 @@ 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:
+class PluginSuperClass(tox_save.ToxSave):
     """
-    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
 
-    def __init__(self, name, short_name, tox=None, profile=None, settings=None, encrypt_save=None):
+    def __init__(self, name, short_name, app):
         """
-        Constructor. In plugin __init__ should take only 4 last arguments
+        Constructor. In plugin __init__ should take only 1 last argument
         :param name: plugin full name
         :param short_name: plugin unique short name (length of short name should not exceed MAX_SHORT_NAME_LENGTH)
-        :param tox: tox instance
+        :param app: App instance
-        :param profile: profile instance
-        :param settings: profile settings
-        :param encrypt_save: LibToxEncryptSave instance.
         """
-        self._settings = settings
+        tox = getattr(app, '_tox')
-        self._profile = profile
+        super().__init__(tox)
-        self._tox = tox
+        self._settings = getattr(app, '_settings')
         name = name.strip()
         short_name = short_name.strip()
         if not name or not short_name:
@@ -55,7 +51,6 @@ class PluginSuperClass:
         self._name = name
         self._short_name = short_name[:MAX_SHORT_NAME_LENGTH]
         self._translator = None  # translator for plugin's GUI
-        self._encrypt_save = encrypt_save
 
     # -----------------------------------------------------------------------------------------------------------------
     # Get methods
@@ -79,12 +74,11 @@ class PluginSuperClass:
         """
         return self.__doc__
 
-    def get_menu(self, menu, row_number):
+    def get_menu(self, row_number):
         """
         This method creates items for menu which called on right click in list of friends
-        :param menu: menu instance
         :param row_number: number of selected row in list of contacts
-        :return list of QAction's
+        :return list of tuples (text, handler)
         """
         return []
 
@@ -103,12 +97,6 @@ class PluginSuperClass:
         """
         return None
 
-    def set_tox(self, tox):
-        """
-        New tox instance
-        """
-        self._tox = tox
-
     # -----------------------------------------------------------------------------------------------------------------
     # Plugin was stopped, started or new command received
     # -----------------------------------------------------------------------------------------------------------------
@@ -129,7 +117,7 @@ class PluginSuperClass:
         """
         App is closing
         """
-        pass
+        self.stop()
 
     def command(self, command):
         """
@@ -137,11 +125,9 @@ class PluginSuperClass:
         :param command: string with command
         """
         if command == 'help':
-            msgbox = QtGui.QMessageBox()
+            text = util_ui.tr('No commands available')
-            title = QtGui.QApplication.translate("PluginWindow", "List of commands for plugin {}", None, QtGui.QApplication.UnicodeUTF8)
+            title = util_ui.tr('List of commands for plugin {}').format(self._name)
-            msgbox.setWindowTitle(title.format(self._name))
+            util_ui.message_box(text, title)
-            msgbox.setText(QtGui.QApplication.translate("PluginWindow", "No commands available", None, QtGui.QApplication.UnicodeUTF8))
-            msgbox.exec_()
 
     # -----------------------------------------------------------------------------------------------------------------
     # Translations support
@@ -151,7 +137,7 @@ class PluginSuperClass:
         """
         This method loads translations for GUI
         """
-        app = QtGui.QApplication.instance()
+        app = QtWidgets.QApplication.instance()
         langs = self._settings.supported_languages()
         curr_lang = self._settings['language']
         if curr_lang in langs:
@@ -169,6 +155,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/settings.py

@@ -1,291 +0,0 @@
-from platform import system
-import json
-import os
-from util import Singleton, curr_directory, log, copy
-import pyaudio
-from toxencryptsave import ToxEncryptSave
-import smileys
-
-
-class Settings(dict, Singleton):
-    """
-    Settings of current profile + global app settings
-    """
-
-    def __init__(self, name):
-        Singleton.__init__(self)
-        self.path = ProfileHelper.get_path() + str(name) + '.json'
-        self.name = name
-        if os.path.isfile(self.path):
-            with open(self.path, 'rb') as fl:
-                data = fl.read()
-            inst = ToxEncryptSave.get_instance()
-            try:
-                if inst.is_data_encrypted(data):
-                    data = inst.pass_decrypt(data)
-                info = json.loads(str(data, 'utf-8'))
-            except Exception as ex:
-                info = Settings.get_default_settings()
-                log('Parsing settings error: ' + str(ex))
-            super(Settings, self).__init__(info)
-            self.upgrade()
-        else:
-            super(Settings, self).__init__(Settings.get_default_settings())
-            self.save()
-        smileys.SmileyLoader(self)
-        self.locked = False
-        self.closing = 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'
-        if os.path.isfile(path):
-            with open(path) as fl:
-                data = fl.read()
-            auto = json.loads(data)
-            if 'path' in auto and 'name' in auto:
-                return str(auto['path']), str(auto['name'])
-        return '', ''
-
-    @staticmethod
-    def set_auto_profile(path, name):
-        p = Settings.get_default_path() + 'toxygen.json'
-        with open(p) as fl:
-            data = fl.read()
-        data = json.loads(data)
-        data['path'] = str(path)
-        data['name'] = str(name)
-        with open(p, 'w') as fl:
-            fl.write(json.dumps(data))
-
-    @staticmethod
-    def reset_auto_profile():
-        p = Settings.get_default_path() + 'toxygen.json'
-        with open(p) as fl:
-            data = fl.read()
-        data = json.loads(data)
-        if 'path' in data:
-            del data['path']
-            del data['name']
-        with open(p, 'w') as fl:
-            fl.write(json.dumps(data))
-
-    @staticmethod
-    def is_active_profile(path, name):
-        path = path + name + '.tox'
-        settings = Settings.get_default_path() + 'toxygen.json'
-        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():
-        """
-        Default profile settings
-        """
-        return {
-            'theme': 'default',
-            'ipv6_enabled': True,
-            'udp_enabled': True,
-            'proxy_type': 0,
-            'proxy_host': '127.0.0.1',
-            'proxy_port': 9050,
-            'start_port': 0,
-            'end_port': 0,
-            'tcp_port': 0,
-            'notifications': True,
-            'sound_notifications': False,
-            'language': 'English',
-            'save_history': False,
-            'allow_inline': True,
-            'allow_auto_accept': True,
-            'auto_accept_path': None,
-            'show_online_friends': False,
-            'auto_accept_from_friends': [],
-            'paused_file_transfers': {},
-            'resend_files': True,
-            'friends_aliases': [],
-            'show_avatars': False,
-            'typing_notifications': False,
-            'calls_sound': True,
-            'blocked': [],
-            'plugins': [],
-            'notes': {},
-            'smileys': True,
-            'smiley_pack': 'default',
-            'mirror_mode': False,
-            'width': 920,
-            'height': 500,
-            'x': 400,
-            'y': 400,
-            'message_font_size': 14,
-            'unread_color': 'red',
-            'save_unsent_only': False,
-            'compact_mode': False,
-            'show_welcome_screen': True,
-            'close_to_tray': False,
-            'font': 'Times New Roman'
-        }
-
-    @staticmethod
-    def supported_languages():
-        return {
-            'English': 'en_EN',
-            'Russian': 'ru_RU',
-            'French': 'fr_FR'
-        }
-
-    def upgrade(self):
-        default = Settings.get_default_settings()
-        for key in default:
-            if key not in self:
-                print(key)
-                self[key] = default[key]
-        self.save()
-
-    def save(self):
-        text = json.dumps(self)
-        inst = ToxEncryptSave.get_instance()
-        if inst.has_password():
-            text = bytes(inst.pass_encrypt(bytes(text, 'utf-8')))
-        else:
-            text = bytes(text, 'utf-8')
-        with open(self.path, 'wb') as fl:
-            fl.write(text)
-
-    def close(self):
-        path = Settings.get_default_path() + 'toxygen.json'
-        if os.path.isfile(path):
-            with open(path) as fl:
-                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'
-        if os.path.isfile(path):
-            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)
-
-    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_default_path():
-        if 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):
-    """
-    Class with methods for search, load and save profiles
-    """
-    def __init__(self, path, name):
-        Singleton.__init__(self)
-        self._path = path + name + '.tox'
-        self._directory = path
-        # create /avatars if not exists:
-        directory = path + 'avatars'
-        if not os.path.exists(directory):
-            os.makedirs(directory)
-
-    def open_profile(self):
-        with open(self._path, 'rb') as fl:
-            data = fl.read()
-        if data:
-            return data
-        else:
-            raise IOError('Save file has zero size!')
-
-    def get_dir(self):
-        return self._directory
-
-    def save_profile(self, data):
-        inst = ToxEncryptSave.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, use_new_path):
-        path = new_path + os.path.basename(self._path)
-        with open(self._path, 'rb') as fin:
-            data = fin.read()
-        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():
-        """
-        Find available tox profiles
-        """
-        path = Settings.get_default_path()
-        result = []
-        # check default path
-        if not os.path.exists(path):
-            os.makedirs(path)
-        for fl in os.listdir(path):
-            if fl.endswith('.tox'):
-                name = fl[:-4]
-                result.append((path, name))
-        path = curr_directory()
-        # check current directory
-        for fl in os.listdir(path):
-            if fl.endswith('.tox'):
-                name = fl[:-4]
-                result.append((path + '/', name))
-        return result
-
-    @staticmethod
-    def get_path():
-        return ProfileHelper.get_instance().get_dir()

toxygen/smileys/smileys.py

@@ -1,14 +1,11 @@
-import util
+from utils import util
 import json
 import os
 from collections import OrderedDict
-try:
+from PyQt5 import QtCore
-    from PySide import QtCore
-except ImportError:
-    from PyQt4 import QtCore
 
 
-class SmileyLoader(util.Singleton):
+class SmileyLoader:
     """
     Class which loads smileys packs and insert smileys into messages
     """
@@ -28,7 +25,7 @@ class SmileyLoader(util.Singleton):
         pack_name = self._settings['smiley_pack']
         if self._settings['smileys'] and self._curr_pack != pack_name:
             self._curr_pack = pack_name
-            path = self.get_smileys_path() + 'config.json'
+            path = util.join_path(self.get_smileys_path(), 'config.json')
             try:
                 with open(path, encoding='utf8') as fl:
                     self._smileys = json.loads(fl.read())
@@ -37,7 +34,7 @@ class SmileyLoader(util.Singleton):
                 print('Smiley pack {} loaded'.format(pack_name))
                 keys, values, self._list = [], [], []
                 for key, value in tmp.items():
-                    value = self.get_smileys_path() + value
+                    value = util.join_path(self.get_smileys_path(), value)
                     if value not in values:
                         keys.append(key)
                         values.append(value)
@@ -48,10 +45,11 @@ 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.join_path(util.get_smileys_directory(), self._curr_pack) if self._curr_pack is not None else None
 
-    def get_packs_list(self):
+    @staticmethod
-        d = util.curr_directory() + '/smileys/'
+    def get_packs_list():
+        d = util.get_smileys_directory()
         return [x[1] for x in os.walk(d)][0]
 
     def get_smileys(self):
@@ -74,18 +72,3 @@ class SmileyLoader(util.Singleton):
                 if file_name.endswith('.gif'):  # animated smiley
                     edit.addAnimation(QtCore.QUrl(file_name), self.get_smileys_path() + file_name)
         return ' '.join(arr)
-
-
-def sticker_loader():
-    """
-    :return list of stickers
-    """
-    result = []
-    d = util.curr_directory() + '/stickers/'
-    keys = [x[1] for x in os.walk(d)][0]
-    for key in keys:
-        path = d + key + '/'
-        files = filter(lambda f: f.endswith('.png'), os.listdir(path))
-        files = map(lambda f: str(path + f), files)
-        result.extend(files)
-    return result