updates

French translation up to v0.3.0

.github/workflows/ci.yml

@@ -0,0 +1,43 @@
+name: CI
+
+on:
+  - push
+  - pull_request
+
+jobs:
+
+  build:
+
+    strategy:
+      matrix:
+        python-version:
+          - "3.7"
+          - "3.8"
+          - "3.9"
+          - "3.10"
+
+    name: Python ${{ matrix.python-version }}
+    runs-on: ubuntu-20.04
+
+    steps:
+
+      - uses: actions/checkout@v2
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v2
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          pip install -r requirements.txt
+          pip install bandit flake8 pylint
+
+      - name: Lint with flake8
+        run: make flake8
+
+      # - name: Lint with pylint
+      #   run: make pylint
+
+      - name: Lint with bandit
+        run: make bandit

.gitignore

@@ -1,17 +1,41 @@
+.pylint.err
+.pylint.out
 *.pyc
 *.pyo
-*.ui
-src/toxcore
+
+*.zip
+*.bak
+*.lis
+*.dst
+*.so
+
+toxygen/toxcore
 tests/tests
-tests/libs
+toxygen/libs
 tests/.cache
 tests/__pycache__
-src/libs
+tests/avatars
+toxygen/libs
 .idea
 *~
+#*
 *.iml
+*.junk
+
 *.so
 *.log
-src/build
-src/dist
+toxygen/build
+toxygen/dist
 *.spec
+dist
+toxygen/avatars
+toxygen/__pycache__
+/*.egg-info
+/*.egg
+html
+Toxygen.egg-info
+*.tox
+.cache
+*.db
+*~
+Makefile

.pre-commit-config.yaml

@@ -0,0 +1,23 @@
+# -*- mode: yaml; indent-tabs-mode: nil; tab-width: 2; coding: utf-8-unix -*-
+---
+
+default_language_version:
+    python: python3.11
+default_stages: [pre-commit]
+fail_fast: true
+repos:
+- repo: local
+  hooks:
+    - id: pylint
+      name: pylint
+      entry: env PYTHONPATH=/mnt/o/var/local/src/toxygen.git/toxygen toxcore_pylint.bash
+      language: system
+      types: [python]
+      args:
+        [
+          "--source-roots=/mnt/o/var/local/src/toxygen.git/toxygen",
+          "-rn", # Only display messages
+          "-sn", # Don't display the score
+          "--rcfile=/usr/local/etc/testforge/pylint.rc", # Link to your config file
+          "-E"
+        ]

.pylintrc

@@ -0,0 +1,4 @@
+[pre-commit-hook]
+command=env PYTHONPATH=/mnt/o/var/local/src/toxygen.git/toxygen /usr/local/bin/toxcore_pylint.bash
+params= -E --exit-zero
+limit=8

.rsync.sh

@@ -0,0 +1,8 @@
+#!/bin/sh
+
+#find * -name \*.py | xargs grep -l '[ 	]*$' | xargs sed -i -e 's/[	 ]*$//'
+rsync "$@" -vaxL  --include \*.py \
+	--exclude Toxygen.egg-info --exclude build \
+	--exclude \*.pyc --exclude .pyl\* --exclude \*.so  --exclude \*~ \
+	--exclude __pycache__ --exclude \*.egg-info --exclude \*.new \
+	./ ../toxygen.git/|grep -v /$

.travis.yml

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

MANIFEST.in

@@ -0,0 +1,19 @@
+include toxygen/images/*.png
+include toxygen/images/*.ico
+include toxygen/images/*.gif
+include toxygen/sounds/*.wav
+include toxygen/stickers/tox/*.png
+include toxygen/smileys/default/*.png
+include toxygen/smileys/default/config.json
+include toxygen/smileys/animated/*.gif
+include toxygen/smileys/animated/config.json
+include toxygen/smileys/starwars/*.gif
+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/*.qss
+include toxygen/translations/*.qm
+include toxygen/libs/libtox.dll
+include toxygen/libs/libsodium.a
+include toxygen/bootstrap/nodes.json

README.md

@@ -1,60 +1,147 @@
-# Toxygen 
-Toxygen is cross-platform [Tox](https://tox.chat/) client written in Python3
+# Toxygen
 
-[![Release](https://img.shields.io/github/release/xveduk/toxygen.svg?style=flat)](https://github.com/xveduk/toxygen/releases/latest)
-[![Open issues](https://img.shields.io/github/issues/xveduk/toxygen.svg?style=flat)](https://github.com/xveduk/toxygen/issues)
-[![License](https://img.shields.io/badge/license-GPLv3-blue.svg?style=flat)](https://raw.githubusercontent.com/xveduk/toxygen/master/LICENSE.md)
+Toxygen is powerful cross-platform [Tox](https://tox.chat/) client
+for Tox and IRC/weechat written in pure Python3.
 
-### [Install](/docs/install.md) - [Contribute](/docs/contributing.md) - [Plugins](/docs/plugins.md)
+### [Install](/docs/install.md) - [Contribute](/docs/contributing.md) - [Plugins](/docs/plugins.md) - [Compile](/docs/compile.md) - [Contact](/docs/contact.md)
 
-### Supported OS:
-- Windows
-- Linux
+### Supported OS: Linux and Windows (only Linux is tested at the moment)
 
-###Features
-- [x] 1v1 messages
-- [x] File transfers
-- [x] Audio
-- [x] Plugins support
-- [x] Chat history
-- [x] Emoticons
-- [x] Stickers
-- [x] Screenshots
-- [x] Name lookups (toxme.io support)
-- [x] Save file encryption
-- [x] Profile import and export
-- [x] Faux offline messaging
-- [x] Faux offline file transfers
-- [x] Inline images
-- [x] Message splitting
-- [x] Proxy support
-- [x] Avatars
-- [x] Multiprofile
-- [x] Multilingual
-- [x] Sound notifications
-- [x] Contact aliases
-- [x] Contact blocking
-- [x] Typing notifications
-- [x] Changing nospam
-- [x] File resuming
-- [x] Read receipts
-- [ ] Video
-- [ ] Desktop sharing
-- [ ] Group chats
+### Features:
 
-###Downloads
-[Releases](https://github.com/xveduk/toxygen/releases)
+- PyQt5, PyQt6, and maybe PySide2, PySide6 via qtpy
+- IRC via weechat /relay
+- NGC groups
+- 1v1 messages
+- File transfers
+- Audio calls
+- Video calls
+- Group chats
+- Plugins support
+- Desktop sharing
+- Chat history
+- Emoticons
+- Stickers
+- Screenshots
+- Save file encryption
+- Profile import and export
+- Faux offline messaging
+- Faux offline file transfers
+- Inline images
+- Message splitting
+- Proxy support - runs over tor, without DNS leaks
+- Avatars
+- Multiprofile
+- Multilingual
+- Sound notifications
+- Contact aliases
+- Contact blocking
+- Typing notifications
+- Changing nospam
+- File resuming
+- Read receipts
+- uses gevent
 
-[Download last stable version](https://github.com/xveduk/toxygen/archive/master.zip)
-
-[Download develop version](https://github.com/xveduk/toxygen/archive/develop.zip)
-
-###Screenshots
+### Screenshots
 *Toxygen on Ubuntu and Windows*
 ![Ubuntu](/docs/ubuntu.png)
 ![Windows](/docs/windows.png)
 
+Windows was working but is not currently being tested. AV is working
+but the video is garbled: we're unsure of naming the AV devices
+from the commandline. We need to get a working echobot that supports SOCKS5;
+we were working on one in https://git.plastiras.org/emdee/toxygen_wrapper
 
-###Docs
-[Check /docs/ for more info](/docs/)
+## Forked
 
+This hard-forked from the dead https://github.com/toxygen-project/toxygen
+```next_gen``` branch.
+ 
+See ToDo.md to the current ToDo list.
+
+## IRC Weechat
+
+You can have a [weechat](https://github.com/weechat/qweechat)
+console so that you can have IRC and jabber in a window as well as Tox.
+There's a copy of qweechat in https://git.plastiras.org/emdee/qweechat
+that you must install first, which was backported to PyQt5 now to qtpy
+(PyQt5 PyQt6 and PySide2 and PySide6) and integrated into toxygen.
+Follow the normal instructions for adding a ```relay``` to
+[weechat](https://github.com/weechat/weechat)
+```
+/relay add weechat 9000
+/relay start weechat
+```
+or
+```
+weechat -r '/relay add weechat 9000;/relay start weechat'
+```
+and use the Plugins -> Weechat Console to start weechat under Toxygen.
+Then use the File/Connect menu item of the Console to connect to weechat.
+
+Weechat has a Jabber plugin to enable XMPP:
+```
+/python load jabber.el
+/help jabber
+```
+so you can have Tox, IRC and XMPP in the same application! See docs/ToxygenWeechat.md
+
+## Install
+
+To install read the requirements.txt and look at the comments; there
+are things that need installing by hand or decisions to be made
+on supported alternatives.
+
+https://git.plastiras.org/emdee/toxygen_wrapper needs installing as it is a
+dependency. Just download and install it from
+https://git.plastiras.org/emdee/toxygen_wrapper The same with
+https://git.plastiras.org/emdee/qweechat
+
+This is being ported to Qt6 using qtpy https://github.com/spyder-ide/qtpy
+It now runs on PyQt5 and PyQt6, and may run on PySide2 and PySide6 - YMMV.
+You will be able to choose between them by setting the environment variable
+```QT_API``` to one of: ```pyqt5 pyqt6 pyside2 pyside6```.
+It's currently tested mainly on PyQt5.
+
+To install it,  look in the Makefile for the install target and type
+```
+make install
+```
+You should set the PIP_EXE_MSYS and PYTHON_EXE_MSYS variables and it does
+```
+	${PIP_EXE_MSYS} --python ${PYTHON_EXE_MSYS} install \
+		--no-deps \
+		--target ${PREFIX}/lib/python${PYTHON_MINOR}/site-packages/ \
+		--upgrade .
+```
+and installs into PREFIX which is usually /usr/local
+
+## Updates
+
+Up-to-date code is on https://git.plastiras.org/emdee/toxygen
+
+Tox works over Tor, and the c-toxcore library can leak DNS requests
+due to a 6-year old known security issue:
+https://github.com/TokTok/c-toxcore/issues/469 but toxygen looksup
+addresses before calling c-toxcore. This also allows us to use onion
+addresses in the DHTnodes.json file. Still for anonymous communication
+we recommend having a TCP and UDP firewall in place.
+
+Although Tox works with multi-user group chat, there are no checks
+against impersonation of a screen nickname, so you may not be chatting
+with the person you think. For the Toxic client, the (closed) issue is:
+https://github.com/JFreegman/toxic/issues/622#issuecomment-1922116065
+Solving this might best be done with a solution to MultiDevice q.v.
+
+The Tox project does not follow semantic versioning of its main structures
+in C so the project may break the underlying ctypes wrapper at any time;
+it's not possible to use Tox version numbers to tell what the API will be.
+The last git version this code was tested with is
+``1623e3ee5c3a5837a92f959f289fcef18bfa9c959``` of Feb 12 10:06:37 2024.
+In which case you may need to go into the tox.py file in
+https://git.plastiras.org/emdee/toxygen_wrapper to fix it yourself.
+
+## MultiDevice
+
+Work on this project is suspended until the
+[MultiDevice](https://git.plastiras.org/emdee/tox_profile/wiki/MultiDevice-Announcements-POC) problem is solved. Fork me!

ToDo.md

@@ -0,0 +1,70 @@
+# Toxygen ToDo List
+
+## Bugs
+
+1. There is an agravating bug  where new messages are not put in the
+   current window, and a messages waiting indicator appears. You have
+   to focus out of the window and then back in the window. this may be
+   fixed already
+
+2. The tray icon is flaky and has been disabled - look in app.py
+   for bSHOW_TRAY
+
+## Fix history
+
+## Fix Audio
+
+The code is in there but it's not working. It looks like audio input
+is working but not output. The code is all in there; I may have broken
+it trying to wire up the ability to set the audio device from the
+command line.
+
+## Fix Video
+
+The code is in there but it's not working.  I may have broken it
+trying to wire up the ability to set the video device from the command
+line.
+
+## NGC Groups
+
+1. peer_id There has been a change of API on a field named
+   ```group.peer_id``` The code is broken in places because I have not
+   seen the path to change from the old API ro the new one.
+
+
+## Plugin system
+
+1. Needs better documentation and checking.
+
+2. There's something broken in the way some of them plug into Qt menus.
+
+3. Should the plugins be in toxygen or a separate repo?
+
+4. There needs to be a uniform way for plugins to wire into callbacks.
+
+## check toxygen_wrapper
+
+1. I've broken out toxygen_wrapper to be standalone,
+   https://git.plastiras.org/emdee/toxygen_wrapper but the tox.py
+   needs each call double checking.
+
+2. https://git.plastiras.org/emdee/toxygen_wrapper needs packaging
+   and making a dependency.
+
+## Migration
+
+Migrate PyQt5 to qtpy - done, but I'm not sure qtpy supports PyQt6.
+https://github.com/spyder-ide/qtpy/
+
+Maybe migrate gevent to asyncio, and migrate to
+[qasync](https://github.com/CabbageDevelopment/qasync)
+(see https://git.plastiras.org/emdee/phantompy ).
+
+(Also look at https://pypi.org/project/asyncio-gevent/ but it's dead).
+
+## Standards
+
+There's a standard for Tox clients that this has not been tested against:
+https://tox.gitbooks.io/tox-client-standard/content/general_requirements/general_requirements.html
+https://github.com/Tox/Tox-Client-Standard
+

_Bugs/segv.err

@@ -0,0 +1,130 @@
+0
+TRAC> network.c#1748:net_connect connecting socket 58 to 127.0.0.1:9050
+TRAC> Messenger.c#2709:do_messenger Friend num in DHT 2 != friend num in msger 14
+TRAC> Messenger.c#2723:do_messenger F[--: 0] D3385007C28852C5398393E3338E6AABE5F86EF249BF724E7404233207D4D927
+TRAC> Messenger.c#2723:do_messenger F[--: 1] 98984E104B8A97CC43AF03A27BE159AC1F4CF35FADCC03D6CD5F8D67B5942A56
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] =>T   2= 185.87.49.189:3389 (0: OK) | 0000000000000000...00
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>  10= 185.87.49.189:3389 (0: OK) | 010001b95731bd0d...3d
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] =>T   2= 37.221.66.161:443 (0: OK) | 0000000000000000...00
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>  10= 37.221.66.161:443 (0: OK) | 01000125dd42a101...bb
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>   3= 172.93.52.70:33445 (0: OK) | 0000000000000000...00
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 2 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>   3= 139.162.110.188:33445 (0: OK) | 0000000000000000...00
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 2 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>   3= 37.59.63.150:33445 (0: OK) | 0000000000000000...00
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 2 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>   3= 130.133.110.14:33445 (0: OK) | 0000000000000000...00
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 2 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>   3= 37.97.185.116:33445 (0: OK) | 0000000000000000...00
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 2 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>   3= 85.143.221.42:33445 (0: OK) | 0000000000000000...00
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 2 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>   3= 104.244.74.69:38445 (0: OK) | 0000000000000000...00
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 2 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>   3= 49.12.229.145:3389 (0: OK) | 0000000000000000...00
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 2 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>   3= 168.119.209.10:33445 (0: OK) | 0000000000000000...00
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 2 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>   3= 81.169.136.229:33445 (0: OK) | 0000000000000000...00
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 2 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>   3= 91.219.59.156:33445 (0: OK) | 0000000000000000...00
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 2 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>   3= 46.101.197.175:3389 (0: OK) | 0000000000000000...00
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 2 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>   3= 198.199.98.108:33445 (0: OK) | 0000000000000000...00
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 2 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>   3= 130.133.110.14:33445 (0: OK) | 0000000000000000...00
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 2 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>   3= 49.12.229.145:3389 (0: OK) | 0000000000000000...00
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 2 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>   3= 188.225.9.167:33445 (0: OK) | 0000000000000000...00
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 2 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>   3= 5.19.249.240:38296 (0: OK) | 0000000000000000...00
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 2 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>   3= 94.156.35.247:3389 (0: OK) | 0000000000000000...00
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 2 bytes
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] =>T   2= 172.93.52.70:33445 (0: OK) | 0000000000000000...00
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>  10= 172.93.52.70:33445 (0: OK) | 010001ac5d344682...a5
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] =>T   2= 139.162.110.188:33445 (0: OK) | 0000000000000000...00
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>  10= 139.162.110.188:33445 (0: OK) | 0100018ba26ebc82...a5
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] =>T   2= 37.59.63.150:33445 (0: OK) | 0000000000000000...00
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>  10= 37.59.63.150:33445 (0: OK) | 010001253b3f9682...a5
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] =>T   2= 130.133.110.14:33445 (0: OK) | 0000000000000000...00
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>  10= 130.133.110.14:33445 (0: OK) | 01000182856e0e82...a5
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] =>T   2= 37.97.185.116:33445 (0: OK) | 0000000000000000...00
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>  10= 37.97.185.116:33445 (0: OK) | 0100012561b97482...a5
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] =>T   2= 85.143.221.42:33445 (0: OK) | 0000000000000000...00
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>  10= 85.143.221.42:33445 (0: OK) | 010001558fdd2a82...a5
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] =>T   2= 104.244.74.69:38445 (0: OK) | 0000000000000000...00
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>  10= 104.244.74.69:38445 (0: OK) | 01000168f44a4596...2d
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] =>T   2= 49.12.229.145:3389 (0: OK) | 0000000000000000...00
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>  10= 49.12.229.145:3389 (0: OK) | 010001310ce5910d...3d
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] =>T   2= 168.119.209.10:33445 (0: OK) | 0000000000000000...00
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>  10= 168.119.209.10:33445 (0: OK) | 010001a877d10a82...a5
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] =>T   2= 81.169.136.229:33445 (0: OK) | 0000000000000000...00
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>  10= 81.169.136.229:33445 (0: OK) | 01000151a988e582...a5
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] =>T   2= 91.219.59.156:33445 (0: OK) | 0000000000000000...00
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>  10= 91.219.59.156:33445 (0: OK) | 0100015bdb3b9c82...a5
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] =>T   2= 46.101.197.175:3389 (0: OK) | 0000000000000000...00
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>  10= 46.101.197.175:3389 (0: OK) | 0100012e65c5af0d...3d
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] =>T   2= 198.199.98.108:33445 (0: OK) | 0000000000000000...00
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>  10= 198.199.98.108:33445 (0: OK) | 010001c6c7626c82...a5
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] =>T   2= 130.133.110.14:33445 (0: OK) | 0000000000000000...00
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>  10= 130.133.110.14:33445 (0: OK) | 01000182856e0e82...a5
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] =>T   2= 49.12.229.145:3389 (0: OK) | 0000000000000000...00
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>  10= 49.12.229.145:3389 (0: OK) | 010001310ce5910d...3d
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] =>T   2= 188.225.9.167:33445 (0: OK) | 0000000000000000...00
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>  10= 188.225.9.167:33445 (0: OK) | 010001bce109a782...a5
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] =>T   2= 5.19.249.240:38296 (0: OK) | 0000000000000000...00
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>  10= 5.19.249.240:38296 (0: OK) | 0100010513f9f095...98
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] =>T   2= 94.156.35.247:3389 (0: OK) | 0000000000000000...00
+TRAC> network.c#789:loglogdata [05 = <unknown>           ] T=>  10= 94.156.35.247:3389 (0: OK) | 0100015e9c23f70d...3d
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+TRAC> TCP_common.c#203:read_TCP_packet recv buffer has 0 bytes, but requested 10 bytes
+app.contacts.contacts_manager INFO update_groups_numbers len(groups)={len(groups)}
+
+Thread 76 "ToxIterateThrea" received signal SIGSEGV, Segmentation fault.
+[Switching to Thread 0x7ffedcb6b640 (LWP 2950427)]

_Bugs/tox.abilinski.com.ping

@@ -0,0 +1,11 @@
+ ping tox.abilinski.com
+ping: socket: Address family not supported by protocol
+PING tox.abilinski.com (172.103.226.229) 56(84) bytes of data.
+64 bytes from 172.103.226.229.cable.tpia.cipherkey.com (172.103.226.229): icmp_seq=1 ttl=48 time=86.6 ms
+64 bytes from 172.103.226.229.cable.tpia.cipherkey.com (172.103.226.229): icmp_seq=2 ttl=48 time=83.1 ms
+64 bytes from 172.103.226.229.cable.tpia.cipherkey.com (172.103.226.229): icmp_seq=3 ttl=48 time=82.9 ms
+64 bytes from 172.103.226.229.cable.tpia.cipherkey.com (172.103.226.229): icmp_seq=4 ttl=48 time=83.4 ms
+64 bytes from 172.103.226.229.cable.tpia.cipherkey.com (172.103.226.229): icmp_seq=5 ttl=48 time=102 ms
+64 bytes from 172.103.226.229.cable.tpia.cipherkey.com (172.103.226.229): icmp_seq=6 ttl=48 time=87.4 ms
+64 bytes from 172.103.226.229.cable.tpia.cipherkey.com (172.103.226.229): icmp_seq=7 ttl=48 time=84.9 ms
+^C

docs/ToxygenWeechat.md

@@ -0,0 +1,171 @@
+## Toxygen Weechat
+
+You can have a [weechat](https://github.com/weechat/qweechat)
+console so that you can have IRC and jabber in a window as well as Tox.
+There's a copy of qweechat in ```thirdparty/qweechat``` backported to
+PyQt5 and integrated into toxygen. Follow the normal instructions for
+adding a ```relay``` to [weechat](https://github.com/weechat/weechat)
+```
+/relay add ipv4.ssl.weechat 9000
+/relay start ipv4.ssl.weechat
+```
+or
+```
+/set relay.network.ipv6 off
+/set relay.network.password password
+/relay add weechat 9000
+/relay start weechat
+```
+and use the Plugins/Weechat Console to start weechat under Toxygen.
+Then use the File/Connect menu item of the Console to connect to weechat.
+
+Weechat has a Jabber plugin to enable XMPP:
+```
+/python load jabber.el
+/help jabber
+```
+so you can have Tox, IRC and XMPP in the same application!
+
+### Creating servers for IRC over Tor
+
+Create a proxy called tor
+```
+/proxy add tor socks5 127.0.0.1 9050
+```
+
+It should now show up in the list of proxies.
+```
+/proxy list
+```
+
+```
+/nick NickName
+```
+
+## TLS certificates
+
+[Create a Self-signed Certificate](https://www.oftc.net/NickServ/CertFP/)
+
+Choose a NickName you will identify as.
+
+Create a directory for your certificates ~/.config/weechat/ssl/ 
+and make a subdirectory for each server ~/.config/weechat/ssl/irc.oftc.net/ 
+
+Change to the server directory and use openssl to make a keypair and answer the questions:
+```
+openssl req -nodes -newkey rsa:2048 -keyout NickName.key -x509 -days 3650 -out NickName.cer
+chmod 400 NickName.key
+```
+We now combine certificate and key to a single file NickName.pem 
+```
+cat NickName.cer NickName.key > NickName.pem
+chmod 400 NickName.pem
+```
+
+Do this for each server you want to connect to, or just use one for all of them.
+
+### Libera TokTok channel
+
+The main discussion forum for Tox is the #TokTok channel on libera.
+
+https://mox.sh/sysadmin/secure-irc-connection-to-freenode-with-tor-and-weechat/
+We have to create an account without Tor, this is a requirement to use TOR:
+Connect to irc.libera.chat without Tor and register 
+```
+/msg NickServ identify NickName password
+/msg NickServ REGISTER mypassword mycoolemail@example.com
+/msg NickServ SET PRIVATE ON
+```
+You'll get an email with a registration code.
+Confirm registration after getting the mail with the code:
+```
+/msg NickServ VERIFY REGISTER NickName code1235678
+```
+
+Libera has an onion server so we can map an address in tor. Add this
+to your /etc/tor/torrc
+```
+MapAddress palladium.libera.chat libera75jm6of4wxpxt4aynol3xjmbtxgfyjpu34ss4d7r7q2v5zrpyd.onion
+```
+Or without the MapAddress just use
+libera75jm6of4wxpxt4aynol3xjmbtxgfyjpu34ss4d7r7q2v5zrpyd.onion
+as the server address below, but set tls_verify to off.
+
+Define the server in weechat
+https://www.weechat.org/files/doc/stable/weechat_user.en.html#irc_sasl_authentication
+```
+/server remove libera
+/server add libera palladium.libera.chat/6697 -tls -tls_verify
+/set irc.server.libera.ipv6 off
+/set irc.server.libera.proxy tor
+/set irc.server.libera.username NickName
+/set irc.server.libera.password password
+/set irc.server.libera.nicks NickName
+/set irc.server.libera.tls on
+/set irc.server.libera.tls_cert "${weechat_config_dir}/ssl/libera.chat/NickName.pem"
+```
+
+```
+/set irc.server.libera.sasl_mechanism ecdsa-nist256p-challenge
+/set irc.server.libera.sasl_username "NickName"
+/set irc.server.libera.sasl_key "${weechat_config_dir}/ssl/libera.chat/NickName.pem"
+```
+
+Disconnect and connect back to the server. 
+```
+/disconnect libera
+/connect libera
+```
+
+/msg nickserv identify password NickName
+
+
+### oftc.net
+
+To use oftc.net over tor, you need to authenticate by SSL certificates.
+
+
+Define the server in weechat
+```
+/server remove irc.oftc.net
+/server add OFTC irc.oftc.net/6697  -tls -tls_verify
+/set irc.server.OFTC.ipv6 off
+/set irc.server.OFTC.proxy tor
+/set irc.server.OFTC.username NickName
+/set irc.server.OFTC.nicks NickName
+/set irc.server.OFTC.tls on
+/set irc.server.OFTC.tls_cert "${weechat_config_dir}/ssl/irc.oftc.chat/NickName.pem"
+
+# Disconnect and connect back to the server. 
+/disconnect OFTC
+/connect OFTC
+``` 
+You must be identified in order to validate using certs
+```
+/msg nickserv identify password NickName
+```
+To allow NickServ to identify you based on this certificate you need
+to associate the certificate fingerprint with your nick. To do this
+issue the command cert add to Nickserv (try /msg nickserv helpcert).
+```
+/msg nickserv cert add
+```
+
+### Privacy
+
+[Add somes settings bellow to weechat](https://szorfein.github.io/weechat/tor/configure-weechat/).
+Detail from [faq](https://weechat.org/files/doc/weechat_faq.en.html#security).
+
+```
+/set irc.server_default.msg_part ""
+/set irc.server_default.msg_quit ""
+/set irc.ctcp.clientinfo ""
+/set irc.ctcp.finger ""
+/set irc.ctcp.source ""
+/set irc.ctcp.time ""
+/set irc.ctcp.userinfo ""
+/set irc.ctcp.version ""
+/set irc.ctcp.ping ""
+/plugin unload xfer
+/set weechat.plugin.autoload "*,!xfer"
+```

docs/compile.md

@@ -1,10 +1,19 @@
-#Compile Toxygen
+# Compile Toxygen
 
 You can compile Toxygen using [PyInstaller](http://www.pyinstaller.org/)
 
-Install PyInstaller: 
-``pip3 install pyinstaller``
+Use Dockerfile and build script from `build` directory:
 
-``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/ (and /libs/libtox.dll on Windows) to /dist/main/
+2. Run container:
+```
+docker run -it toxygen bash
+```
+
+3. Execute `build.sh` script:
+
+```./build.sh```

docs/contact.md

@@ -0,0 +1,6 @@
+# Contact us:
+
+1) https://git.plastiras.org/emdee/toxygen/issues
+
+2) Use Toxygen Tox Group (NGC) - 
+ID: 59D68B2709E81A679CF91416CB0E3692851C6CFCABEFF98B7131E3805A6D75FA

docs/contributing.md

@@ -1,20 +1,25 @@
-#Issues
+# Issues
 
 Help us find all bugs in Toxygen! Please provide following info:
 
 - OS
 - Toxygen version
-- Toxygen executable info - .py or precompiled binary
+- Toxygen executable info - 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
+# 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.
+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://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.
 
-#Translations
+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.
 
-Help us translate Toxygen! Translation can be created using pyside-lupdate (``pyside-lupdate toxygen.pro``) and QT Linguist.
+# Translations
+
+Help us translate Toxygen! Translation can be created using pylupdate (``pylupdate5 toxygen.pro``) and QT Linguist.

docs/install.md

@@ -1,48 +1,51 @@
 # How to install Toxygen
 
-## Use precompiled binary:
-[Check our releases page](https://github.com/xveduk/toxygen/releases)
+### Linux
+
+1. Install [c-toxcore](https://github.com/TokTok/c-toxcore/)
+2. Install PortAudio: 
+``sudo apt-get install portaudio19-dev``
+3. For 32-bit Linux install PyQt5: ``sudo apt-get install python3-pyqt5``
+4. Install [OpenCV](http://docs.opencv.org/trunk/d7/d9f/tutorial_linux_install.html) or via ``sudo pip3 install opencv-python``
+5. Install [toxygen](https://git.plastiras.org/emdee/toxygen/)
+6. Run toxygen using ``toxygen`` command.
 
 ## From source code (recommended for developers)
 
 ### Windows
 
-1. [Download and install latest Python 3.4](https://www.python.org/downloads/windows/)
-2. [Install PySide](https://pypi.python.org/pypi/PySide/1.2.4) (recommended) or [PyQt4](https://riverbankcomputing.com/software/pyqt/download)
-3. Install PyAudio: ``pip3 install pyaudio``
-4. [Download toxygen](https://github.com/xveduk/toxygen/archive/master.zip)
-5. Unpack archive  
-6. Download latest libtox.dll build, download latest libsodium.a build, put it into \src\libs\
-7. Run \src\main.py
-
-[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)
-
-[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)
-
-[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)
-
-[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)
+Note: 32-bit Python isn't supported due to bug with videocalls. It is strictly recommended to use 64-bit Python.
 
+1. [Download and install latest Python 3 64-bit](https://www.python.org/downloads/windows/)
+2. Install PyQt5: ``pip install pyqt5``
+3. Install PyAudio: ``pip install pyaudio``
+4. Install numpy: ``pip install numpy``
+5. Install OpenCV: ``pip install opencv-python``
+6. git clone --depth=1 https://git.plastiras.org/emdee/toxygen/
+7. I don't know
+8. Download latest libtox.dll build, download latest libsodium.a build, put it into \toxygen\libs\
+9. Run \toxygen\main.py.
 
 ### Linux
 
-Dependencies:
-
-1. Install latest Python3.4: 
+1. Install latest Python3: 
 ``sudo apt-get install python3``
-2. [Install PySide](https://wiki.qt.io/PySide_Binaries_Linux) (recommended) or [PyQt4](https://riverbankcomputing.com/software/pyqt/download)
-3. Install [toxcore](https://github.com/irungentoo/toxcore/blob/master/INSTALL.md) with toxav support in your system (install in /usr/lib/)
-4. Install PyAudio: 
-```bash
-sudo apt-get install portaudio19-dev
-sudo apt-get install python3-pyaudio
-```
-Toxygen:
+2. Install PyQt5: ``sudo apt-get install python3-pyqt5``
+3. Install [toxcore](https://github.com/TokTok/c-toxcore) with toxav support)
+4. Install PyAudio: ``sudo apt-get install portaudio19-dev python3-pyaudio`` (or ``sudo pip3 install pyaudio``)
+5. Install toxygen_wrapper https://git.plastiras.org/emdee/toxygen_wrapper
+6. Install the rest of the requirements: ``sudo pip3 install -m requirements.txt``
+7. git clone --depth=1 [toxygen](https://git.plastiras.org/emdee/toxygen/)
+8. Look in the Makefile for the install target and type
+``
+make install
+``
+You should set the PIP_EXE_MSYS and PYTHON_EXE_MSYS variables and it does
+``
+	${PIP_EXE_MSYS} --python ${PYTHON_EXE_MSYS} install \
+		--target ${PREFIX}/lib/python${PYTHON_MINOR}/site-packages/ \
+		--upgrade .
+``
+9. Run app:
+``python3 ${PREFIX}/lib/python${PYTHON_MINOR}/site-packages/bin/toxygen``
 
-1. [Download toxygen](https://github.com/xveduk/toxygen/archive/master.zip)
-2. Unpack archive 
-3. Run app:
-``python3 main.py``
-
-## Compile Toxygen
-Check [compile.md](/docs/compile.md) for more info

docs/plugin_api.md

@@ -1,9 +1,9 @@
-#Plugins API
+# Plugins API
 
-In Toxygen plugin is single python (supported Python 3.0 - 3.4) module (.py file) and directory with data associated with it. 
+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 it's own full name and unique short name (1-5 symbols). Main app can get it using special methods. 
+Every plugin has its own full name and unique short name (1-5 symbols). Main app can get it using special methods. 
 
 All plugin's data should be stored in following structure:
 
@@ -12,42 +12,46 @@ All plugin's data should be stored in following structure:
 |---plugin_short_name.py
 |---/plugin_short_name/
 	|---settings.json
+	|---readme.txt
 	|---logs.txt
 	|---other_files
 ```
 
+Plugin MUST override:
+-  __init__ with params: tox (Tox instance), profile (Profile instance), settings (Settings instance), encrypt_save (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. 
-- get_menu - plugins allowed to add items in friend menu. You can open this menu making right click on friend in friends list. This method should return list of QAction's. Plugin must connect to QAction's triggered() signal. 
+- get_menu - plugins allowed to add items in friend menu. User can open this menu making right click on friend in friends list. This method should return list of QAction's. Plugin must connect to QAction's triggered() signal. 
 - get_window - plugins can have GUI, this method should return window instance or None for plugins without GUI.
 - start - plugin was started.
 - stop - plugin was stopped.
 - close - app is closing, stop plugin.
-- command - new command to plugin. Command can be entered in message field in format '/plugin <plugin_short_name> <command>'. Command 'help' should show user list of supported commands.
+- command - new command to plugin. Command can be entered in message field in format '/plugin <plugin_short_name> <command>'. Command 'help' should show list of supported commands.
 - lossless_packet - callback - incoming lossless packet from friend.
 - lossy_packet - callback - incoming lossy packet from friend.
-- friend_connected - callback - friend became online.
+- friend_connected - callback - friend became online. Note that it called from friend_connection_status callback so friend is not really connected and ready for sending packets.
 
 Other methods:
-- send_lossless - this method send custom lossless packet. Plugins MUST send lossless packets using this method.
-- send_lossy - this method send custom lossy packet. Plugins MUST send lossy packets using this method.
+- send_lossless - this method sends custom lossless packet. Plugins MUST send lossless packets using this method.
+- send_lossy - this method sends custom lossy packet. Plugins MUST send lossy packets using this method.
 - load_settings - loads settings stored in default location.
 - save_settings - saves settings to default location.
-- load_translator - loads translations. Translations must be stored in directory with plugin's data. Files with translations must have the same name as in main app.
+- load_translator - loads translations. Translations must be stored in directory with plugin's data. Files with translations must have the same name as in main app (example: ru_RU.qm).
 
 About import:
 
-import statement will not work in case you import module that wasn't previously imported by main program and user use precompiled binary. It's recommended to use dynamic import instead.
+Import statement will not work in case you import module that wasn't previously imported by main program and user uses precompiled binary. It's recommended to use importlib module instead: importlib.import_module(module_name)
 
 About GUI:
 
-It's strictly recommended to support both PySide and PyQt4 in GUI. Plugin can not have GUI at all.
+GUI is available via PyQt5. Plugin can have no GUI at all.
 
 Exceptions:
 
-Plugin's methods should not raise exceptions.
+Plugin's methods MUST NOT raise exceptions.
 
-#Examples
+# Examples
 
-You can find examples in [official repo](https://github.com/ingvar1995/toxygen_plugins)
+You can find examples in [official repo](https://git.plastiras.org/emdee/toxygen_plugins)
 

docs/plugins.md

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

docs/smileys_and_stickers.md

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

docs/todo.md

@@ -0,0 +1,70 @@
+# Toxygen ToDo List
+
+## Bugs
+
+1. There is an agravating bug  where new messages are not put in the
+   current window, and a messages waiting indicator appears. You have
+   to focus out of the window and then back in the window. this may be
+   fixed already
+
+2. The tray icon is flaky and has been disabled - look in app.py
+   for bSHOW_TRAY
+
+## Fix history
+
+## Fix Audio
+
+The code is in there but it's not working. It looks like audio input
+is working but not output. The code is all in there; I may have broken
+it trying to wire up the ability to set the audio device from the
+command line.
+
+## Fix Video
+
+The code is in there but it's not working.  I may have broken it
+trying to wire up the ability to set the video device from the command
+line.
+
+## NGC Groups
+
+1. peer_id There has been a change of API on a field named
+   ```group.peer_id``` The code is broken in places because I have not
+   seen the path to change from the old API ro the new one.
+
+
+## Plugin system
+
+1. Needs better documentation and checking.
+
+2. There's something broken in the way some of them plug into Qt menus.
+
+3. Should the plugins be in toxygen or a separate repo?
+
+4. There needs to be a uniform way for plugins to wire into callbacks.
+
+## check toxygen_wrapper
+
+1. I've broken out toxygen_wrapper to be standalone,
+   https://git.plastiras.org/emdee/toxygen_wrapper but the tox.py
+   needs each call double checking.
+
+2. https://git.plastiras.org/emdee/toxygen_wrapper needs packaging
+   and making a dependency.
+
+## Migration
+
+Migrate PyQt5 to qtpy - done, but I'm not sure qtpy supports PyQt6.
+https://github.com/spyder-ide/qtpy/
+
+Maybe migrate gevent to asyncio, and migrate to
+[qasync](https://github.com/CabbageDevelopment/qasync)
+(see https://git.plastiras.org/emdee/phantompy ).
+
+(Also look at https://pypi.org/project/asyncio-gevent/ but it's dead).
+
+## Standards
+
+There's a standard for Tox clients that this has not been tested against:
+https://tox.gitbooks.io/tox-client-standard/content/general_requirements/general_requirements.html
+https://github.com/Tox/Tox-Client-Standard
+

pyproject.toml

@@ -0,0 +1,56 @@
+[project]
+name = "toxygen"
+description = "examples of using stem"
+authors = [{ name = "emdee", email = "emdee@spm.plastiras.org" } ]
+requires-python = ">=3.7"
+keywords = ["stem", "python3", "tox"]
+classifiers = [
+  # How mature is this project? Common values are
+  #   3 - Alpha
+  #   4 - Beta
+  #   5 - Production/Stable
+  "Development Status :: 4 - Beta",
+
+  # Indicate who your project is intended for
+  "Intended Audience :: Developers",
+
+  # Specify the Python versions you support here.
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved",
+  "Operating System :: POSIX :: BSD :: FreeBSD",
+  "Operating System :: POSIX :: Linux",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.6",
+  "Programming Language :: Python :: 3.7",
+  "Programming Language :: Python :: 3.8",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: Implementation :: CPython",
+]
+#
+dynamic = ["version", "readme", "dependencies"] # cannot be dynamic ['license']
+
+[project.gui-scripts]
+toxygen = "toxygen.__main__:main"
+
+[project.optional-dependencies]
+weechat = ["weechat"]
+
+#[project.license]
+#file = "LICENSE.md"
+
+[project.urls]
+repository = "https://git.plastiras.org/emdee/toxygen"
+
+[build-system]
+requires = ["setuptools >= 61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.dynamic]
+version = {attr = "toxygen.app.__version__"} 
+readme = {file = ["README.md", "ToDo.txt"]}
+dependencies = {file = ["requirements.txt"]}
+
+[tool.setuptools]
+packages = ["toxygen"]

requirements.txt

@@ -0,0 +1,26 @@
+# the versions are the current ones tested - may work with earlier versions
+# choose one of PyQt5 PyQt6 PySide2 PySide6
+# for now PyQt5 and PyQt6 is working, and most of the testing is PyQt5
+# usually this is installed by your OS package manager and pip may not
+# detect the right version, so we leave these commented
+# PyQt5 >= 5.15.10
+# this is not on pypi yet but is required - get it from
+# https://git.plastiras.org/emdee/toxygen_wrapper
+# toxygen_wrapper == 1.0.0
+QtPy >= 2.4.1
+PyAudio >= 0.2.13
+numpy >= 1.26.1
+opencv_python >= 4.8.0
+pillow >= 10.2.0
+gevent >= 23.9.1
+pydenticon >= 0.3.1
+greenlet >= 2.0.2
+sounddevice >= 0.3.15
+# this is optional
+coloredlogs >= 15.0.1
+# this is optional
+# qtconsole >= 5.4.3
+# this is not on pypi yet but is optional for qweechat - get it from
+# https://git.plastiras.org/emdee/qweechat
+# qweechat_wrapper == 0.0.1
+

setup.cfg

@@ -0,0 +1,54 @@
+[metadata]
+classifiers =
+    License :: OSI Approved
+    License :: OSI Approved :: BSD 1-clause
+    Intended Audience :: Web Developers
+    Operating System :: Microsoft :: Windows
+    Operating System :: POSIX :: BSD :: FreeBSD
+    Operating System :: POSIX :: Linux
+    Programming Language :: Python :: 3 :: Only
+    Programming Language :: Python :: 3.6
+    Programming Language :: Python :: 3.7
+    Programming Language :: Python :: 3.8
+    Programming Language :: Python :: 3.9
+    Programming Language :: Python :: 3.10
+    Programming Language :: Python :: 3.11
+    Programming Language :: Python :: Implementation :: CPython
+
+[options]
+zip_safe = false
+python_requires = ~=3.7
+include_package_data =
+    "*" = ["*.ui", "*.txt", "*.png", "*.ico", "*.gif", "*.wav"]
+
+[options.entry_points]
+console_scripts =
+    toxygen = toxygen.__main__:iMain
+
+[easy_install]
+zip_ok = false
+
+[flake8]
+jobs = 1
+max-line-length = 88
+ignore =
+    E111
+    E114
+    E128
+    E225
+    E261
+    E302
+    E305
+    E402
+    E501
+    E502
+    E541
+    E701
+    E702
+    E704
+    E722
+    E741
+    F508
+    F541
+    W503
+    W601

setup.py.dst

@@ -0,0 +1,53 @@
+import sys
+import os
+from setuptools import setup
+from setuptools.command.install import install
+
+version = '1.0.0'
+
+MODULES = open('requirements.txt', 'rt').readlines()
+
+def get_packages():
+    directory = os.path.join(os.path.dirname(__file__), 'tox_wrapper')
+    for root, dirs, files in os.walk(directory):
+        packages = map(lambda d: 'toxygen.' + d, dirs)
+        packages = ['toxygen'] + list(packages)
+        return packages
+
+class InstallScript(install):
+    """This class configures Toxygen after installation"""
+
+    def run(self):
+        install.run(self)
+
+setup(name='Toxygen',
+      version=version,
+      description='Toxygen - Tox client',
+      long_description='Toxygen is powerful Tox client written in Python3',
+      url='https://git.plastiras.org/emdee/toxygen/',
+      keywords='toxygen Tox messenger',
+      author='Ingvar',
+      maintainer='',
+      license='GPL3',
+      packages=get_packages(),
+      install_requires=MODULES,
+      include_package_data=True,
+      classifiers=[
+          'Programming Language :: Python :: 3 :: Only',
+    "Programming Language :: Python :: 3.6",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+          'Programming Language :: Python :: 3.11',
+      ],
+      entry_points={
+          'console_scripts': ['toxygen=toxygen.main:main']
+      },
+      package_data={"": ["*.ui"],},
+      cmdclass={
+          'install': InstallScript,
+      },
+      zip_safe=False
+      )

src/avwidgets.py

@@ -1,139 +0,0 @@
-try:
-    from PySide import QtCore, QtGui
-except ImportError:
-    from PyQt4 import QtCore, QtGui
-import widgets
-import profile
-import util
-import pyaudio
-import wave
-import settings
-from util import curr_directory
-
-
-class IncomingCallWidget(widgets.CenteredWidget):
-
-    def __init__(self, friend_number, text, name):
-        super(IncomingCallWidget, self).__init__()
-        self.setWindowFlags(QtCore.Qt.CustomizeWindowHint | QtCore.Qt.WindowTitleHint | QtCore.Qt.WindowStaysOnTopHint)
-        self.resize(QtCore.QSize(500, 270))
-        self.avatar_label = QtGui.QLabel(self)
-        self.avatar_label.setGeometry(QtCore.QRect(10, 20, 64, 64))
-        self.avatar_label.setScaledContents(False)
-        self.name = widgets.DataLabel(self)
-        self.name.setGeometry(QtCore.QRect(90, 20, 300, 25))
-        font = QtGui.QFont()
-        font.setFamily("Times New Roman")
-        font.setPointSize(16)
-        font.setBold(True)
-        self.name.setFont(font)
-        self.call_type = widgets.DataLabel(self)
-        self.call_type.setGeometry(QtCore.QRect(90, 55, 300, 25))
-        self.call_type.setFont(font)
-        self.accept_audio = QtGui.QPushButton(self)
-        self.accept_audio.setGeometry(QtCore.QRect(20, 100, 150, 150))
-        self.accept_video = QtGui.QPushButton(self)
-        self.accept_video.setGeometry(QtCore.QRect(170, 100, 150, 150))
-        self.decline = QtGui.QPushButton(self)
-        self.decline.setGeometry(QtCore.QRect(320, 100, 150, 150))
-        pixmap = QtGui.QPixmap(util.curr_directory() + '/images/accept_audio.png')
-        icon = QtGui.QIcon(pixmap)
-        self.accept_audio.setIcon(icon)
-        pixmap = QtGui.QPixmap(util.curr_directory() + '/images/accept_video.png')
-        icon = QtGui.QIcon(pixmap)
-        self.accept_video.setIcon(icon)
-        pixmap = QtGui.QPixmap(util.curr_directory() + '/images/decline_call.png')
-        icon = QtGui.QIcon(pixmap)
-        self.decline.setIcon(icon)
-        self.accept_audio.setIconSize(QtCore.QSize(150, 150))
-        self.accept_video.setIconSize(QtCore.QSize(140, 140))
-        self.decline.setIconSize(QtCore.QSize(140, 140))
-        self.accept_audio.setStyleSheet("QPushButton { border: none }")
-        self.accept_video.setStyleSheet("QPushButton { border: none }")
-        self.decline.setStyleSheet("QPushButton { border: none }")
-        self.setWindowTitle(text)
-        self.name.setText(name)
-        self.call_type.setText(text)
-        pr = profile.Profile.get_instance()
-        self.accept_audio.clicked.connect(lambda: pr.accept_call(friend_number, True, False) or self.stop())
-        # self.accept_video.clicked.connect(lambda: pr.start_call(friend_number, True, True))
-        self.decline.clicked.connect(lambda: pr.stop_call(friend_number, False) or self.stop())
-
-        class SoundPlay(QtCore.QThread):
-
-            def __init__(self):
-                QtCore.QThread.__init__(self)
-
-            def run(self):
-                class AudioFile:
-                    chunk = 1024
-
-                    def __init__(self, fl):
-                        self.stop = False
-                        self.fl = fl
-                        self.wf = wave.open(self.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):
-                        while not self.stop:
-                            data = self.wf.readframes(self.chunk)
-                            while data and not self.stop:
-                                self.stream.write(data)
-                                data = self.wf.readframes(self.chunk)
-                            self.wf = wave.open(self.fl, 'rb')
-
-                    def close(self):
-                        self.stream.close()
-                        self.p.terminate()
-
-                self.a = AudioFile(curr_directory() + '/sounds/call.wav')
-                self.a.play()
-                self.a.close()
-
-        if settings.Settings.get_instance()['calls_sound']:
-            self.thread = SoundPlay()
-            self.thread.start()
-        else:
-            self.thread = None
-
-    def stop(self):
-        if self.thread is not None:
-            self.thread.a.stop = True
-            self.thread.wait()
-        self.close()
-
-    def set_pixmap(self, pixmap):
-        self.avatar_label.setPixmap(pixmap)
-
-
-class AudioMessageRecorder(widgets.CenteredWidget):
-
-    def __init__(self, friend_number, name):
-        super(AudioMessageRecorder, self).__init__()
-        self.label = QtGui.QLabel(self)
-        self.label.setGeometry(QtCore.QRect(10, 20, 250, 20))
-        text = QtGui.QApplication.translate("MenuWindow", "Send audio message to friend {}", None, QtGui.QApplication.UnicodeUTF8)
-        self.label.setText(text.format(name))
-        self.record = QtGui.QPushButton(self)
-        self.record.setGeometry(QtCore.QRect(20, 100, 150, 150))
-
-        self.record.setText(QtGui.QApplication.translate("MenuWindow", "Start recording", None,
-                                                         QtGui.QApplication.UnicodeUTF8))
-        self.record.clicked.connect(self.start_or_stop_recording)
-        self.recording = False
-        self.friend_num = friend_number
-
-    def start_or_stop_recording(self):
-        if not self.recording:
-            self.recording = True
-            self.record.setText(QtGui.QApplication.translate("MenuWindow", "Stop recording", None,
-                                                             QtGui.QApplication.UnicodeUTF8))
-        else:
-            self.close()
-
-

src/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 self._ip, 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()
-

src/callbacks.py

@@ -1,325 +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
-
-
-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))
-
-# -----------------------------------------------------------------------------------------------------------------
-# 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! New status: {}".format(friend_num, new_status))
-    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(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_num, name)
-    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, status_message))
-    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']:
-                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']:
-                    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
-    """
-    if not length:
-        invoke_in_main_thread(Profile.get_instance().incoming_chunk,
-                              friend_number,
-                              file_number,
-                              position,
-                              None)
-    else:
-        Profile.get_instance().incoming_chunk(friend_number, file_number, position, chunk[:length])
-
-
-def file_chunk_request(tox, friend_number, file_number, position, size, user_data):
-    """
-    Outgoing chunk
-    """
-    if size:
-        Profile.get_instance().outgoing_chunk(friend_number, file_number, position, size)
-    else:
-        invoke_in_main_thread(Profile.get_instance().outgoing_chunk,
-                              friend_number,
-                              file_number,
-                              position,
-                              size)
-
-
-def file_recv_control(tox, friend_number, file_number, file_control, user_data):
-    """
-    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
-    """
-    # print(audio_samples_per_channel, audio_channels_count, rate)
-    Profile.get_instance().call.chunk(
-        bytes(samples[:audio_samples_per_channel * 2 * audio_channels_count]),
-        audio_channels_count,
-        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)
-

src/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
-

src/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/')
-        pixmap = QtGui.QPixmap(QtCore.QSize(64, 64))
-        pixmap.load(avatar_path)
-        self._widget.avatar_label.setScaledContents(False)
-        self._widget.avatar_label.setPixmap(pixmap.scaled(64, 64, QtCore.Qt.KeepAspectRatio))
-        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()

src/file_transfers.py

@@ -1,314 +0,0 @@
-from 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 tox import Tox
-import settings
-try:
-    from PySide import QtCore
-except ImportError:
-    from PyQt4 import QtCore
-
-# TODO: threads!
-
-
-TOX_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
-}
-
-ACTIVE_FILE_TRANSFERS = (0, 1, 4, 5, 6)
-
-PAUSED_FILE_TRANSFERS = (1, 4, 5, 6)
-
-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')
-
-
-class StateSignal(QtCore.QObject):
-    try:
-        signal = QtCore.Signal(int, float, int)  # state and progress
-    except:
-        signal = QtCore.pyqtSignal(int, float, int)  # state and progress - pyqt4
-
-
-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._file_number = file_number
-        self._creation_time = None
-        self._size = float(size)
-        self._done = 0
-        self._state_changed = StateSignal()
-
-    def set_tox(self, tox):
-        self._tox = tox
-
-    def set_state_changed_handler(self, handler):
-        self._state_changed.signal.connect(handler)
-
-    def signal(self):
-        percentage = self._done / self._size if self._size else 0
-        if self._creation_time is None or not percentage:
-            t = -1
-        else:
-            t = ((time() - self._creation_time) / percentage) * (1 - percentage)
-        self._state_changed.signal.emit(self.state, percentage, int(t))
-
-    def get_file_number(self):
-        return self._file_number
-
-    def get_friend_number(self):
-        return self._friend_number
-
-    def cancel(self):
-        self.send_control(TOX_FILE_CONTROL['CANCEL'])
-        if hasattr(self, '_file'):
-            self._file.close()
-        self.signal()
-
-    def cancelled(self):
-        if hasattr(self, '_file'):
-            sleep(0.1)
-            self._file.close()
-        self.state = TOX_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.signal()
-
-    def send_control(self, control):
-        if self._tox.file_control(self._friend_number, self._file_number, control):
-            self.state = control
-            self.signal()
-
-    def get_file_id(self):
-        return self._tox.file_get_file_id(self._friend_number, self._file_number)
-
-# -----------------------------------------------------------------------------------------------------------------
-# Send file
-# -----------------------------------------------------------------------------------------------------------------
-
-
-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')
-            size = getsize(path)
-        else:
-            size = 0
-        super(SendTransfer, self).__init__(path, tox, friend_number, size)
-        self.state = TOX_FILE_TRANSFER_STATE['OUTGOING_NOT_STARTED']
-        self._file_number = tox.file_send(friend_number, kind, size, file_id,
-                                          bytes(basename(path), 'utf-8') if path else b'')
-
-    def send_chunk(self, position, size):
-        """
-        Send chunk
-        :param position: start position in file
-        :param size: chunk max size
-        """
-        if self._creation_time is None:
-            self._creation_time = time()
-        if size:
-            self._file.seek(position)
-            data = self._file.read(size)
-            self._tox.file_send_chunk(self._friend_number, self._file_number, position, data)
-            self._done += size
-            self.signal()
-        else:
-            if hasattr(self, '_file'):
-                self._file.close()
-            self.state = TOX_FILE_TRANSFER_STATE['FINISHED']
-            self.signal()
-
-
-class SendAvatar(SendTransfer):
-    """
-    Send avatar to friend. Doesn't need file transfer item
-    """
-
-    def __init__(self, path, tox, friend_number):
-        if path is None:
-            hash = None
-        else:
-            with open(path, 'rb') as fl:
-                hash = Tox.hash(fl.read())
-        super(SendAvatar, self).__init__(path, tox, friend_number, TOX_FILE_KIND['AVATAR'], hash)
-
-
-class SendFromBuffer(FileTransfer):
-    """
-    Send inline image
-    """
-
-    def __init__(self, tox, friend_number, data, file_name):
-        super(SendFromBuffer, self).__init__(None, tox, friend_number, len(data))
-        self.state = TOX_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'))
-
-    def get_data(self):
-        return self._data
-
-    def send_chunk(self, position, size):
-        if self._creation_time is None:
-            self._creation_time = time()
-        if size:
-            data = self._data[position:position + size]
-            self._tox.file_send_chunk(self._friend_number, self._file_number, position, data)
-            self._done += size
-            self.signal()
-        else:
-            self.state = TOX_FILE_TRANSFER_STATE['FINISHED']
-            self.signal()
-
-
-class SendFromFileBuffer(SendTransfer):
-
-    def __init__(self, *args):
-        super(SendFromFileBuffer, self).__init__(*args)
-
-    def send_chunk(self, position, size):
-        super(SendFromFileBuffer, self).send_chunk(position, size)
-        if not size:
-            chdir(dirname(self._path))
-            remove(self._path)
-
-# -----------------------------------------------------------------------------------------------------------------
-# Receive file
-# -----------------------------------------------------------------------------------------------------------------
-
-
-class ReceiveTransfer(FileTransfer):
-
-    def __init__(self, path, tox, friend_number, size, file_number):
-        super(ReceiveTransfer, self).__init__(path, tox, friend_number, size, file_number)
-        self._file = open(self._path, 'wb')
-        self._file.truncate(0)
-        self._file_size = 0
-
-    def cancel(self):
-        super(ReceiveTransfer, self).cancel()
-        remove(self._path)
-
-    def write_chunk(self, position, data):
-        """
-        Incoming chunk
-        :param position: position in file to save data
-        :param data: raw data (string)
-        """
-        if self._creation_time is None:
-            self._creation_time = time()
-        if data is None:
-            self._file.close()
-            self.state = TOX_FILE_TRANSFER_STATE['FINISHED']
-            self.signal()
-        else:
-            data = bytearray(data)
-            if self._file_size < position:
-                self._file.seek(0, 2)
-                self._file.write(b'\0' * (position - self._file_size))
-            self._file.seek(position)
-            self._file.write(data)
-            l = len(data)
-            if position + l > self._file_size:
-                self._file_size = position + l
-            self._done += l
-            self.signal()
-
-
-class ReceiveToBuffer(FileTransfer):
-    """
-    Inline image - save in buffer not in file system
-    """
-
-    def __init__(self, tox, friend_number, size, file_number):
-        super(ReceiveToBuffer, self).__init__(None, tox, friend_number, size, file_number)
-        self._data = bytes()
-        self._data_size = 0
-
-    def get_data(self):
-        return self._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']
-        else:
-            data = bytes(data)
-            l = len(data)
-            if self._data_size < position:
-                self._data += (b'\0' * (position - self._data_size))
-            self._data = self._data[:position] + data + self._data[position + l:]
-            if position + l > self._data_size:
-                self._data_size = position + l
-            self._done += l
-        self.signal()
-
-
-class ReceiveAvatar(ReceiveTransfer):
-    """
-    Get friend's avatar. Doesn't need file transfer item
-    """
-    MAX_AVATAR_SIZE = 512 * 1024
-
-    def __init__(self, tox, friend_number, size, file_number):
-        path = settings.ProfileHelper.get_path() + 'avatars/{}.png'.format(tox.friend_get_public_key(friend_number))
-        super(ReceiveAvatar, self).__init__(path + '.tmp', 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')
-        elif not size:
-            self.send_control(TOX_FILE_CONTROL['CANCEL'])
-            self._file.close()
-            if exists(path):
-                remove(path)
-            self._file.close()
-            remove(path + '.tmp')
-        elif exists(path):
-            hash = self.get_file_id()
-            with open(path, 'rb') as fl:
-                data = fl.read()
-            existing_hash = Tox.hash(data)
-            if hash == existing_hash:
-                self.send_control(TOX_FILE_CONTROL['CANCEL'])
-                self._file.close()
-                remove(path + '.tmp')
-            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 self.state:
-            avatar_path = self._path[:-4]
-            if exists(avatar_path):
-                chdir(dirname(avatar_path))
-                remove(avatar_path)
-            rename(self._path, avatar_path)

src/friend.py

@@ -1,243 +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 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() in (2, 3) 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() in (2, 3) 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)

src/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 LibToxEncryptSave
-
-
-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 = LibToxEncryptSave.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 = LibToxEncryptSave.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 = LibToxEncryptSave.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()

src/libtox.py

@@ -1,50 +0,0 @@
-from platform import system
-from ctypes import CDLL
-import util
-
-
-class LibToxCore:
-
-    def __init__(self):
-        if system() == 'Linux':
-            # libtoxcore and libsodium must be installed in your os
-            self._libtoxcore = CDLL('libtoxcore.so')
-        elif system() == 'Windows':
-            self._libtoxcore = CDLL(util.curr_directory() + '/libs/libtox.dll')
-        else:
-            raise OSError('Unknown system.')
-
-    def __getattr__(self, item):
-        return self._libtoxcore.__getattr__(item)
-
-
-class LibToxAV:
-
-    def __init__(self):
-        if system() == 'Linux':
-            # that /usr/lib/libtoxav.so must exists
-            self._libtoxav = CDLL('libtoxav.so')
-        elif system() == 'Windows':
-            # on Windows av api is in libtox.dll
-            self._libtoxav = CDLL(util.curr_directory() + '/libs/libtox.dll')
-        else:
-            raise OSError('Unknown system.')
-
-    def __getattr__(self, item):
-        return self._libtoxav.__getattr__(item)
-
-
-class LibToxEncryptSave:
-
-    def __init__(self):
-        if system() == 'Linux':
-            # /usr/lib/libtoxencryptsave.so must exists
-            self._lib_tox_encrypt_save = CDLL('libtoxencryptsave.so')
-        elif system() == 'Windows':
-            # on Windows profile encryption api is in libtox.dll
-            self._lib_tox_encrypt_save = CDLL(util.curr_directory() + '/libs/libtox.dll')
-        else:
-            raise OSError('Unknown system.')
-
-    def __getattr__(self, item):
-        return self._lib_tox_encrypt_save.__getattr__(item)

src/list_items.py

@@ -1,498 +0,0 @@
-from toxcore_enums_and_consts import *
-try:
-    from PySide import QtCore, QtGui
-except ImportError:
-    from PyQt4 import QtCore, QtGui
-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("Times New Roman")
-        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()))
-        menu.popup(event.globalPos())
-        menu.exec_(event.globalPos())
-        del menu
-
-    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("Times New Roman")
-        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 = QtGui.QFont()
-        font.setFamily("Times New Roman")
-        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
-
-
-class ContactItem(QtGui.QWidget):
-    """
-    Contact in friends list
-    """
-
-    def __init__(self, parent=None):
-        QtGui.QWidget.__init__(self, parent)
-        self.setBaseSize(QtCore.QSize(250, 70))
-        self.avatar_label = QtGui.QLabel(self)
-        self.avatar_label.setGeometry(QtCore.QRect(3, 3, 64, 64))
-        self.avatar_label.setScaledContents(True)
-        self.name = DataLabel(self)
-        self.name.setGeometry(QtCore.QRect(75, 10, 150, 25))
-        font = QtGui.QFont()
-        font.setFamily("Times New Roman")
-        font.setPointSize(12)
-        font.setBold(True)
-        self.name.setFont(font)
-        self.status_message = DataLabel(self)
-        self.status_message.setGeometry(QtCore.QRect(75, 30, 170, 20))
-        font.setPointSize(10)
-        font.setBold(False)
-        self.status_message.setFont(font)
-        self.connection_status = StatusCircle(self)
-        self.connection_status.setGeometry(QtCore.QRect(230, 5, 32, 32))
-        self.messages = UnreadMessagesCount(self)
-        self.messages.setGeometry(QtCore.QRect(52, 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("Times New Roman")
-        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("Times New Roman")
-        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)
-            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:
-            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)
-            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
-
-
-
-

src/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, 10, 90, 21))
-        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()

src/main.py

@@ -1,350 +0,0 @@
-import sys
-from loginscreen import LoginScreen
-from settings import *
-try:
-    from PySide import QtCore, QtGui
-except ImportError:
-    from PyQt4 import QtCore, QtGui
-from bootstrap import node_generator
-from mainscreen import MainWindow
-from profile import tox_factory
-from callbacks import init_callbacks
-from util import curr_directory
-import styles.style
-import toxencryptsave
-from passwordscreen import PasswordScreen
-import profile
-from plugin_support import PluginLoader
-
-
-class Toxygen:
-
-    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.LibToxEncryptSave.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
-
-        # application color scheme
-        with open(curr_directory() + '/styles/style.qss') as fl:
-            dark_style = fl.read()
-        app.setStyleSheet(dark_style)
-
-        encrypt_save = toxencryptsave.LibToxEncryptSave()
-
-        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 = 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'
-                    self.tox = 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')
-                    ProfileHelper(Settings.get_default_path(), name).save_profile(self.tox.get_savedata())
-                    path = Settings.get_default_path()
-                    settings = Settings(name)
-                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 = 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 = 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", 'Looks like other instance of Toxygen uses this profile! 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:
-                    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)
-
-            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():
-            if not self.ms.isActiveWindow():
-                self.ms.setWindowState(self.ms.windowState() & ~QtCore.Qt.WindowMinimized | QtCore.Qt.WindowActive)
-                self.ms.activateWindow()
-            self.ms.show()
-
-        m.connect(show, QtCore.SIGNAL("triggered()"), show_window)
-        m.connect(exit, QtCore.SIGNAL("triggered()"), lambda: app.exit())
-        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.ms.show()
-
-        plugin_helper = PluginLoader(self.tox, settings)  # plugin support
-        plugin_helper.load()
-
-        # 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()
-        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 = 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)
-            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)
-                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]
-
-
-if __name__ == '__main__':
-    if len(sys.argv) == 1:
-        toxygen = Toxygen()
-    else:  # path to profile or tox: uri
-        toxygen = Toxygen(sys.argv[1])
-    toxygen.main()

src/mainscreen.py

@@ -1,554 +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 *
-
-
-class MainWindow(QtGui.QMainWindow):
-
-    def __init__(self, tox, reset, tray):
-        super(MainWindow, self).__init__()
-        self.reset = reset
-        self.tray = tray
-        self.setAcceptDrops(True)
-        self.initUI(tox)
-
-    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.actionProfile_settings = QtGui.QAction(MainWindow)
-        self.actionProfile_settings.setObjectName("actionProfile_settings")
-        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.menuProfile.addAction(self.actionAdd_friend)
-        self.menuProfile.addAction(self.actionSettings)
-        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.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)
-        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'))
-        return super(MainWindow, self).event(event)
-
-    def retranslateUi(self):
-        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.actionProfile_settings.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']))
-
-    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)
-        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(True)
-        self.name = Form.name = DataLabel(Form)
-        Form.name.setGeometry(QtCore.QRect(75, 40, 150, 25))
-        font = QtGui.QFont()
-        font.setFamily("Times New Roman")
-        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(True)
-        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("Times New Roman")
-        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)
-
-    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, *args, **kwargs):
-        self.profile.save_history()
-        self.profile.close()
-        s = Settings.get_instance()
-        s['x'] = self.pos().x()
-        s['y'] = self.pos().y()
-        s['width'] = self.width()
-        s['height'] = self.height()
-        s.save()
-        QtGui.QApplication.closeAllWindows()
-
-    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()
-        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: github.com/xveduk/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)
-        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 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() - 100,
-                                           150,
-                                           100))
-        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)
-            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))
-            clear_history_item = self.listMenu.addAction(QtGui.QApplication.translate("MainWindow", 'Clear history', None, QtGui.QApplication.UnicodeUTF8))
-            copy_key_item = self.listMenu.addAction(QtGui.QApplication.translate("MainWindow", 'Copy 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))
-            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 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 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())
-

src/mainscreen_widgets.py

@@ -1,314 +0,0 @@
-try:
-    from PySide import QtCore, QtGui
-except ImportError:
-    from PyQt4 import QtCore, QtGui
-from widgets import RubberBand, create_menu, QRightClickButton
-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):
-            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'):
-            e.accept()
-            self.pasteEvent(e.mimeData().text())
-        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(150, 100)
-        self.setMinimumSize(150, 100)
-        self.screenshotButton = QRightClickButton(self)
-        self.screenshotButton.setGeometry(QtCore.QRect(0, 50, 50, 50))
-        self.screenshotButton.setObjectName("screenshotButton")
-
-        self.fileTransferButton = QtGui.QPushButton(self)
-        self.fileTransferButton.setGeometry(QtCore.QRect(50, 50, 50, 50))
-        self.fileTransferButton.setObjectName("fileTransferButton")
-
-        self.audioMessageButton = QtGui.QPushButton(self)
-        self.audioMessageButton.setGeometry(QtCore.QRect(100, 50, 50, 50))
-
-        self.smileyButton = QtGui.QPushButton(self)
-        self.smileyButton.setGeometry(QtCore.QRect(0, 0, 50, 50))
-
-        self.videoMessageButton = QtGui.QPushButton(self)
-        self.videoMessageButton.setGeometry(QtCore.QRect(100, 0, 50, 50))
-
-        self.stickerButton = QtGui.QPushButton(self)
-        self.stickerButton.setGeometry(QtCore.QRect(50, 0, 50, 50))
-
-        pixmap = QtGui.QPixmap(util.curr_directory() + '/images/file.png')
-        icon = QtGui.QIcon(pixmap)
-        self.fileTransferButton.setIcon(icon)
-        self.fileTransferButton.setIconSize(QtCore.QSize(40, 40))
-        pixmap = QtGui.QPixmap(util.curr_directory() + '/images/screenshot.png')
-        icon = QtGui.QIcon(pixmap)
-        self.screenshotButton.setIcon(icon)
-        self.screenshotButton.setIconSize(QtCore.QSize(40, 50))
-        pixmap = QtGui.QPixmap(util.curr_directory() + '/images/audio_message.png')
-        icon = QtGui.QIcon(pixmap)
-        self.audioMessageButton.setIcon(icon)
-        self.audioMessageButton.setIconSize(QtCore.QSize(40, 40))
-        pixmap = QtGui.QPixmap(util.curr_directory() + '/images/smiley.png')
-        icon = QtGui.QIcon(pixmap)
-        self.smileyButton.setIcon(icon)
-        self.smileyButton.setIconSize(QtCore.QSize(40, 40))
-        pixmap = QtGui.QPixmap(util.curr_directory() + '/images/video_message.png')
-        icon = QtGui.QIcon(pixmap)
-        self.videoMessageButton.setIcon(icon)
-        self.videoMessageButton.setIconSize(QtCore.QSize(45, 45))
-        pixmap = QtGui.QPixmap(util.curr_directory() + '/images/sticker.png')
-        icon = QtGui.QIcon(pixmap)
-        self.stickerButton.setIcon(icon)
-        self.stickerButton.setIconSize(QtCore.QSize(45, 45))
-
-        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()
-
-

src/menu.py

@@ -1,785 +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
-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)
-
-    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.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 = QtGui.QFont()
-        font.setPointSize(12)
-        font.setBold(True)
-        self.label.setFont(font)
-        self.message.setFont(font)
-        QtCore.QMetaObject.connectSlotsByName(self)
-
-    def add_friend(self):
-        profile = Profile.get_instance()
-        send = profile.send_friend_request(self.tox_id.text(), self.message_edit.toPlainText())
-        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.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.new_avatar = QtGui.QPushButton(self)
-        self.new_avatar.setGeometry(QtCore.QRect(40, 300, 180, 30))
-        self.delete_avatar = QtGui.QPushButton(self)
-        self.delete_avatar.setGeometry(QtCore.QRect(230, 300, 180, 30))
-        self.delete_avatar.clicked.connect(self.reset_avatar)
-        self.new_avatar.clicked.connect(self.set_avatar)
-        self.profile_pass = QtGui.QLabel(self)
-        self.profile_pass.setGeometry(QtCore.QRect(40, 340, 300, 30))
-        font.setPointSize(18)
-        self.profile_pass.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.profile_pass.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))
-        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.LibToxEncryptSave.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 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)')
-        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(str(byte_array.data()))
-
-    def export_profile(self):
-        directory = QtGui.QFileDialog.getExistingDirectory() + '/'
-        if directory != '/':
-            ProfileHelper.get_instance().export_profile(directory)
-            settings = Settings.get_instance()
-            settings.export(directory)
-            profile = Profile.get_instance()
-            profile.export_history(directory)
-
-    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, 330, 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() + '/'
-        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()
-        font.setPointSize(12)
-        self.callsSound.setFont(font)
-        self.soundNotifications.setFont(font)
-        self.enableNotifications.setFont(font)
-        s = Settings.get_instance()
-        self.enableNotifications.setChecked(s['notifications'])
-        self.soundNotifications.setChecked(s['sound_notifications'])
-        self.callsSound.setChecked(s['calls_sound'])
-        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, 450))
-        self.setMaximumSize(QtCore.QSize(400, 450))
-        self.label = QtGui.QLabel(self)
-        self.label.setGeometry(QtCore.QRect(30, 10, 370, 20))
-        font = QtGui.QFont()
-        font.setPointSize(14)
-        font.setBold(True)
-        self.label.setFont(font)
-        self.themeSelect = QtGui.QComboBox(self)
-        self.themeSelect.setGeometry(QtCore.QRect(30, 40, 120, 30))
-        list_of_themes = ['dark']
-        self.themeSelect.addItems(list_of_themes)
-        settings = Settings.get_instance()
-        theme = settings['theme']
-        if theme in list_of_themes:
-            index = list_of_themes.index(theme)
-        else:
-            index = 0
-        self.themeSelect.setCurrentIndex(index)
-        self.lang_choose = QtGui.QComboBox(self)
-        self.lang_choose.setGeometry(QtCore.QRect(30, 110, 120, 30))
-        supported = Settings.supported_languages()
-        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, 380, 340, 40))
-        self.unread.clicked.connect(self.select_color)
-
-        self.retranslateUi()
-        QtCore.QMetaObject.connectSlotsByName(self)
-
-    def retranslateUi(self):
-        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))
-
-    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()
-        if settings['mirror_mode'] != self.mirror_mode.isChecked():
-            settings['mirror_mode'] = self.mirror_mode.isChecked()
-            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_()
-        settings['smiley_pack'] = self.smiley_pack.currentText()
-        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()
-
-
-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))
-        font = QtGui.QFont()
-        font.setPointSize(16)
-        font.setBold(True)
-        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()
-        settings = Settings.get_instance()
-        self.in_indexes, self.out_indexes = [], []
-        for i in range(p.get_device_count()):
-            device = p.get_device_info_by_index(i)
-            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))

src/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'])

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

src/passwordscreen.py

@@ -1,77 +0,0 @@
-from widgets import CenteredWidget, LineEdit
-try:
-    from PySide import QtCore, QtGui
-except ImportError:
-    from PyQt4 import QtCore, QtGui
-
-
-class PasswordArea(LineEdit):
-
-    def __init__(self, parent):
-        super(PasswordArea, self).__init__(parent)
-        self.parent = parent
-        self.setEchoMode(QtGui.QLineEdit.EchoMode.Password)
-
-    def keyPressEvent(self, event):
-        if event.key() == QtCore.Qt.Key_Return:
-            self.parent.button_click()
-        else:
-            super(PasswordArea, self).keyPressEvent(event)
-
-
-class PasswordScreen(CenteredWidget):
-
-    def __init__(self, encrypt, data):
-        super(PasswordScreen, self).__init__()
-        self._encrypt = encrypt
-        self._data = data
-        self.initUI()
-
-    def initUI(self):
-        self.resize(360, 170)
-        self.setMinimumSize(QtCore.QSize(360, 170))
-        self.setMaximumSize(QtCore.QSize(360, 170))
-
-        self.enter_pass = QtGui.QLabel(self)
-        self.enter_pass.setGeometry(QtCore.QRect(30, 10, 300, 30))
-
-        self.password = PasswordArea(self)
-        self.password.setGeometry(QtCore.QRect(30, 50, 300, 30))
-
-        self.button = QtGui.QPushButton(self)
-        self.button.setGeometry(QtCore.QRect(30, 90, 300, 30))
-        self.button.setText('OK')
-        self.button.clicked.connect(self.button_click)
-
-        self.warning = QtGui.QLabel(self)
-        self.warning.setGeometry(QtCore.QRect(30, 130, 300, 30))
-        self.warning.setStyleSheet('QLabel { color: #F70D1A; }')
-        self.warning.setVisible(False)
-
-        self.retranslateUi()
-        self.center()
-        QtCore.QMetaObject.connectSlotsByName(self)
-
-    def button_click(self):
-        if self.password.text():
-            try:
-                self._encrypt.set_password(self.password.text())
-                new_data = self._encrypt.pass_decrypt(self._data[0])
-            except Exception as ex:
-                self.warning.setVisible(True)
-                print('Decryption error:', ex)
-            else:
-                self._data[0] = new_data
-                self.close()
-
-    def keyPressEvent(self, event):
-        if event.key() == QtCore.Qt.Key_Enter:
-            self.button_click()
-        else:
-            super(PasswordScreen, self).keyPressEvent(event)
-
-    def retranslateUi(self):
-        self.setWindowTitle(QtGui.QApplication.translate("pass", "Enter password", None, QtGui.QApplication.UnicodeUTF8))
-        self.enter_pass.setText(QtGui.QApplication.translate("pass", "Password:", None, QtGui.QApplication.UnicodeUTF8))
-        self.warning.setText(QtGui.QApplication.translate("pass", "Incorrect password", None, QtGui.QApplication.UnicodeUTF8))
-

src/plugin_support.py

@@ -1,156 +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.LibToxEncryptSave.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 stop(self):
-        """
-        App is closing, stop all plugins
-        """
-        for key in list(self._plugins.keys()):
-            self._plugins[key][0].close()
-            del self._plugins[key]

src/plugins/plugin_super_class.py

@@ -1,239 +0,0 @@
-import os
-try:
-    from PySide import QtCore, QtGui
-except ImportError:
-    from PyQt4 import QtCore, QtGui
-
-
-MAX_SHORT_NAME_LENGTH = 5
-
-LOSSY_FIRST_BYTE = 200
-
-LOSSLESS_FIRST_BYTE = 160
-
-
-def path_to_data(name):
-    """
-    :param name: plugin unique name
-    :return path do plugin's directory
-    """
-    return os.path.dirname(os.path.realpath(__file__)) + '/' + name + '/'
-
-
-def log(name, data):
-    """
-    :param name: plugin unique name
-    :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')
-
-
-class PluginSuperClass:
-    """
-    Superclass for all plugins. Plugin is python 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):
-        """
-        :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 profile: profile instance
-        :param settings: profile settings
-        :param encrypt_save: LibToxEncryptSave instance.
-        """
-        self._settings = settings
-        self._profile = profile
-        self._tox = tox
-        name = name.strip()
-        short_name = short_name.strip()
-        if not name or not short_name:
-            raise NameError('Wrong name')
-        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
-    # -----------------------------------------------------------------------------------------------------------------
-
-    def get_name(self):
-        """
-        :return plugin full name
-        """
-        return self._name
-
-    def get_short_name(self):
-        """
-        :return plugin unique (short) name
-        """
-        return self._short_name
-
-    def get_description(self):
-        """
-        Should return plugin description
-        """
-        return self.__doc__
-
-    def get_menu(self, menu, 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 []
-
-    def get_window(self):
-        """
-        This method should return window for plugins with GUI or None
-        """
-        return None
-
-    def set_tox(self, tox):
-        """
-        New tox instance
-        """
-        self._tox = tox
-
-    # -----------------------------------------------------------------------------------------------------------------
-    # Plugin was stopped, started or new command received
-    # -----------------------------------------------------------------------------------------------------------------
-
-    def start(self):
-        """
-        This method called when plugin was started
-        """
-        pass
-
-    def stop(self):
-        """
-        This method called when plugin was stopped
-        """
-        pass
-
-    def close(self):
-        """
-        App is closing
-        """
-        pass
-
-    def command(self, command):
-        """
-        New command. On 'help' this method should provide user list of available commands
-        :param command: string with command
-        """
-        if command == 'help':
-            msgbox = QtGui.QMessageBox()
-            title = QtGui.QApplication.translate("PluginWindow", "List of commands for plugin {}", None, QtGui.QApplication.UnicodeUTF8)
-            msgbox.setWindowTitle(title.format(self._name))
-            msgbox.setText(QtGui.QApplication.translate("PluginWindow", "No commands available", None, QtGui.QApplication.UnicodeUTF8))
-            msgbox.exec_()
-
-    # -----------------------------------------------------------------------------------------------------------------
-    # Translations support
-    # -----------------------------------------------------------------------------------------------------------------
-
-    def load_translator(self):
-        """
-        This method loads translations for GUI
-        """
-        app = QtGui.QApplication.instance()
-        langs = self._settings.supported_languages()
-        curr_lang = self._settings['language']
-        if curr_lang in langs:
-            if self._translator is not None:
-                app.removeTranslator(self._translator)
-            self._translator = QtCore.QTranslator()
-            lang_path = langs[curr_lang]
-            self._translator.load(path_to_data(self._short_name) + lang_path)
-            app.installTranslator(self._translator)
-
-    # -----------------------------------------------------------------------------------------------------------------
-    # Settings loading and saving
-    # -----------------------------------------------------------------------------------------------------------------
-
-    def load_settings(self):
-        """
-        This method loads settings of plugin and returns raw data
-        """
-        with open(path_to_data(self._short_name) + 'settings.json', 'rb') as fl:
-            data = fl.read()
-        return str(data, 'utf-8')
-
-    def save_settings(self, data):
-        """
-        This method saves plugin's settings to file
-        :param data: string with data
-        """
-        with open(path_to_data(self._short_name) + 'settings.json', 'wb') as fl:
-            fl.write(bytes(data, 'utf-8'))
-
-    # -----------------------------------------------------------------------------------------------------------------
-    # Callbacks
-    # -----------------------------------------------------------------------------------------------------------------
-
-    def lossless_packet(self, data, friend_number):
-        """
-        Incoming lossless packet
-        :param data: string with data
-        :param friend_number: number of friend who sent packet
-        """
-        pass
-
-    def lossy_packet(self, data, friend_number):
-        """
-        Incoming lossy packet
-        :param data: string with data
-        :param friend_number: number of friend who sent packet
-        """
-        pass
-
-    def friend_connected(self, friend_number):
-        """
-        Friend with specified number is online now
-        """
-        pass
-
-    # -----------------------------------------------------------------------------------------------------------------
-    # Custom packets sending
-    # -----------------------------------------------------------------------------------------------------------------
-
-    def send_lossless(self, data, friend_number):
-        """
-        This method sends lossless packet to friend
-        Wrapper for self._tox.friend_send_lossless_packet
-        Use it instead of direct using self._tox.friend_send_lossless_packet
-        :return True on success
-        """
-        if data is None:
-            data = ''
-        try:
-            return self._tox.friend_send_lossless_packet(friend_number,
-                                                         bytes([ord(x) for x in
-                                                                chr(len(self._short_name) + LOSSLESS_FIRST_BYTE) +
-                                                                self._short_name + str(data)
-                                                                ]))
-        except:
-            return False
-
-    def send_lossy(self, data, friend_number):
-        """
-        This method sends lossy packet to friend
-        Wrapper for self._tox.friend_send_lossy_packet
-        Use it instead of direct using self._tox.friend_send_lossy_packet
-        :return True on success
-        """
-        if data is None:
-            data = ''
-        try:
-            return self._tox.friend_send_lossy_packet(friend_number,
-                                                      bytes([ord(x) for x in
-                                                             chr(len(self._short_name) + LOSSY_FIRST_BYTE) +
-                                                             self._short_name + str(data)
-                                                             ]))
-        except:
-            return False

src/settings.py

@@ -1,265 +0,0 @@
-from platform import system
-import json
-import os
-import locale
-from util import Singleton, curr_directory, log
-import pyaudio
-from toxencryptsave import LibToxEncryptSave
-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 = LibToxEncryptSave.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)
-        p = pyaudio.PyAudio()
-        self.audio = {'input': p.get_default_input_device_info()['index'],
-                      'output': p.get_default_output_device_info()['index']}
-
-    @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': '0',
-            'proxy_port': 0,
-            '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': [],
-            'friends_aliases': [],
-            '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
-        }
-
-    @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 = LibToxEncryptSave.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'] = []
-        profile_path = ProfileHelper.get_path()
-        app_settings['active_profile'].append(str(profile_path + 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)
-
-    @staticmethod
-    def get_default_path():
-        if system() == 'Linux':
-            return os.getenv('HOME') + '/.config/tox/'
-        elif system() == 'Windows':
-            return os.getenv('APPDATA') + '/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 = LibToxEncryptSave.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):
-        new_path += os.path.basename(self._path)
-        with open(self._path, 'rb') as fin:
-            data = fin.read()
-        with open(new_path, 'wb') as fout:
-            fout.write(data)
-        print('Profile exported successfully')
-
-    @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()

src/smileys.py

@@ -1,91 +0,0 @@
-import util
-import json
-import os
-from collections import OrderedDict
-try:
-    from PySide import QtCore
-except ImportError:
-    from PyQt4 import QtCore
-
-
-class SmileyLoader(util.Singleton):
-    """
-    Class which loads smileys packs and insert smileys into messages
-    """
-
-    def __init__(self, settings):
-        super().__init__()
-        self._settings = settings
-        self._curr_pack = None  # current pack name
-        self._smileys = {}  # smileys dict. key - smiley (str), value - path to image (str)
-        self._list = []  # smileys list without duplicates
-        self.load_pack()
-
-    def load_pack(self):
-        """
-        Loads smiley pack
-        """
-        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'
-            try:
-                with open(path, encoding='utf8') as fl:
-                    self._smileys = json.loads(fl.read())
-                    fl.seek(0)
-                    tmp = json.loads(fl.read(), object_pairs_hook=OrderedDict)
-                print('Smiley pack {} loaded'.format(pack_name))
-                keys, values, self._list = [], [], []
-                for key, value in tmp.items():
-                    value = self.get_smileys_path() + value
-                    if value not in values:
-                        keys.append(key)
-                        values.append(value)
-                self._list = list(zip(keys, values))
-            except Exception as ex:
-                self._smileys = {}
-                self._list = []
-                print('Smiley pack {} was not loaded. Error: {}'.format(pack_name, ex))
-
-    def get_smileys_path(self):
-        return util.curr_directory() + '/smileys/' + self._curr_pack + '/'
-
-    def get_packs_list(self):
-        d = util.curr_directory() + '/smileys/'
-        return [x[1] for x in os.walk(d)][0]
-
-    def get_smileys(self):
-        return list(self._list)
-
-    def add_smileys_to_text(self, text, edit):
-        """
-        Adds smileys to text
-        :param text: message
-        :param edit: MessageEdit instance
-        :return text with smileys
-        """
-        if not self._settings['smileys'] or not len(self._smileys):
-            return text
-        arr = text.split(' ')
-        for i in range(len(arr)):
-            if arr[i] in self._smileys:
-                file_name = self._smileys[arr[i]]  # image name
-                arr[i] = '<img title=\"{}\" src=\"{}\" />'.format(arr[i], file_name)
-                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