Fix group join by chat id

.gitignore

@@ -1,17 +1,23 @@
 *.pyc
 *.pyo
 *.ui
-src/toxcore
+toxygen/toxcore
 tests/tests
 tests/libs
 tests/.cache
 tests/__pycache__
-src/libs
+toxygen/libs
 .idea
 *~
 *.iml
 *.so
 *.log
-src/build
+toxygen/build
-src/dist
+toxygen/dist
 *.spec
+dist/
+toxygen/avatars
+toxygen/__pycache__
+/*.egg-info
+/*.egg
+

MANIFEST.in

@@ -0,0 +1,18 @@
+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/styles/style.qss
+include toxygen/translations/*.qm
+include toxygen/libs/libtox.dll
+include toxygen/libs/libsodium.a
+include toxygen/libs/libtox64.dll
+include toxygen/libs/libsodium64.a

README.md

@@ -1,5 +1,5 @@
 # Toxygen 
-Toxygen is cross-platform [Tox](https://tox.chat/) client written on Python
+Toxygen is cross-platform [Tox](https://tox.chat/) client written in Python3
 
 [![Release](https://img.shields.io/github/release/xveduk/toxygen.svg?style=flat)](https://github.com/xveduk/toxygen/releases/latest)
 [![Open issues](https://img.shields.io/github/issues/xveduk/toxygen.svg?style=flat)](https://github.com/xveduk/toxygen/issues)
@@ -15,10 +15,16 @@ Toxygen is cross-platform [Tox](https://tox.chat/) client written on Python
 - [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
@@ -31,13 +37,10 @@ Toxygen is cross-platform [Tox](https://tox.chat/) client written on Python
 - [x] Typing notifications
 - [x] Changing nospam
 - [x] File resuming
-- [x] Save file encryption
-- [x] Plugins support
 - [x] Read receipts
-- [x] Faux offline messaging
 - [ ] Video
-- [ ] Group chats
 - [ ] Desktop sharing
+- [ ] Group chats
 
 ###Downloads
 [Releases](https://github.com/xveduk/toxygen/releases)

docs/compile.md

@@ -3,14 +3,8 @@
 You can compile Toxygen using [PyInstaller](http://www.pyinstaller.org/)
 
 Install PyInstaller: 
-``pip install pyinstaller``
+``pip3 install pyinstaller``
-
-On Linux:
-
-``pyinstaller --windowed main.py``
-
-On Windows:
 
 ``pyinstaller --windowed --icon images/icon.ico main.py``
 
-Don't forget to copy /images/, /sounds/, /translations/, /styles/, to /dist/main/
+Don't forget to copy /images/, /sounds/, /translations/, /styles/, /smileys/, /stickers/ (and /libs/libtox.dll on Windows) to /dist/main/

docs/contributing.md

@@ -1,5 +1,3 @@
-
-
 #Issues
 
 Help us find all bugs in Toxygen! Please provide following info:
@@ -15,8 +13,8 @@ Want to see new feature in Toxygen? [Ask for it!](https://github.com/xveduk/toxy
 
 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.
-You can find our TODO's in code and [here](/README.md). Also you can implement plugins for Toxygen.
+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
 
-Help us translate Toxygen! Translate can be created using pyside-lupdate and QT Linguist.
+Help us translate Toxygen! Translation can be created using pyside-lupdate (``pyside-lupdate toxygen.pro``) and QT Linguist.

docs/install.md

@@ -3,17 +3,33 @@
 ## Use precompiled binary:
 [Check our releases page](https://github.com/xveduk/toxygen/releases)
 
+##Using pip3
+
+### Windows  (32-bit interpreter)
+
+``pip3.4 install toxygen``
+Run app using ``toxygen`` command.
+
+##Linux
+
+1. Install [toxcore](https://github.com/irungentoo/toxcore/blob/master/INSTALL.md) with toxav support in your system (install in /usr/lib/)
+2. Install PortAudio: 
+``sudo apt-get install portaudio19-dev``
+3. Install toxygen: 
+``sudo pip3.4 install toxygen``
+4 Run toxygen using ``toxygen`` command.
+
 ## From source code (recommended for developers)
 
 ### Windows
 
-1. [Download and install latest Python 2.7](https://www.python.org/downloads/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: ``python -m pip install pyaudio``
+3. Install PyAudio: ``pip3.4 install pyaudio``
 4. [Download toxygen](https://github.com/xveduk/toxygen/archive/master.zip)
 5. Unpack archive  
 6. Download latest libtox.dll build, download latest libsodium.a build, put it into \src\libs\
-7. Run \src\main.py
+7. Run \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)
 
@@ -28,21 +44,16 @@
 
 Dependencies:
 
-1. Install Python2.7: 
+1. Install latest Python3.4: 
-``sudo apt-get install python2.7``
+``sudo apt-get install python3``
-2. [Install PySide](https://wiki.qt.io/PySide_Binaries_Linux)  (recommended) or [PyQt4](https://riverbankcomputing.com/software/pyqt/download)
+2. [Install PySide](https://wiki.qt.io/PySide_Binaries_Linux) (recommended), using terminal - ``sudo apt-get install python3-pyside``, or install [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`` and ``sudo apt-get install python3-pyaudio``
-sudo apt-get install portaudio19-dev
+5. [Download toxygen](https://github.com/xveduk/toxygen/archive/master.zip)
-sudo pip install pyaudio
+6. Unpack archive 
-```
+7. Run app:
-Toxygen:
+``python3.4 main.py``
-
-1. [Download toxygen](https://github.com/xveduk/toxygen/archive/master.zip)
-2. Unpack archive 
-3. Run app:
-``python main.py``
 
 ## Compile Toxygen
 Check [compile.md](/docs/compile.md) for more info

docs/plugin_api.md

@@ -1,9 +1,9 @@
 #Plugins API
 
-In Toxygen plugin is single python module (.py file) and directory with data associated with it. 
+In Toxygen plugin is single python (supported Python 3.0 - 3.4) module (.py file) and directory with data associated with it. 
 Every module must contain one class derived from PluginSuperClass defined in [plugin_super_class.py](/src/plugins/plugin_super_class.py). Instance of this class will be created by PluginLoader class (defined in [plugin_support.py](/src/plugin_support.py) ). This class can enable/disable plugins and send data to it. 
 
-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:
 
@@ -16,36 +16,39 @@ All plugin's data should be stored in following structure:
 	|---other_files
 ```
 
+Plugin MUST override:
+-  __init__ with params: tox (Tox instance), profile (Profile instance), settings (Settings instance), encrypt_save (ToxEncryptSave instance). Call super().__init__ with params plugin_full_name, plugin_short_name, tox, profile, settings, encrypt_save.
+
 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_lossless - this method sends 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_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 imp module and 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.
+It's strictly recommended to support both PySide and PyQt4 in GUI. Plugin can have no GUI at all.
 
 Exceptions:
 
-Plugin's methods should not raise exceptions.
+Plugin's methods MUST NOT raise exceptions.
 
 #Examples
 

docs/plugins.md

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

docs/smileys_and_stickers.md

@@ -1,6 +1,6 @@
 #Smileys
 
-Toxygen support smileys. Smiley is small picture which replaces some 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:
+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:
 
 {":)": "one.png", ":(": "two.png"}
 
@@ -9,3 +9,5 @@ Animated smileys (.gif) are supported too.
 #Stickers
 
 Sticker is inline image. If you want to create your own smiley pack, create directory in src/stickers/ and place your stickers there.
+
+Users can import plugins and stickers packs using menu: Settings -> Interface

setup.py

@@ -0,0 +1,51 @@
+from setuptools import setup
+from setuptools.command.install import install
+from platform import system
+from subprocess import call
+from toxygen.util import program_version
+
+
+version = program_version + '.0'
+
+MODULES = ['PyAudio']
+
+if system() == 'Windows':
+    MODULES.append('PySide')
+
+
+class InstallScript(install):
+    """This class configures Toxygen after installation"""
+
+    def run(self):
+        install.run(self)
+        OS = system()
+        if OS == 'Windows':
+            call(["toxygen", "--configure"])
+        elif OS == 'Linux':
+            call(["toxygen", "--clean"])
+
+setup(name='Toxygen',
+      version=version,
+      description='Toxygen - Tox client',
+      long_description='Toxygen is powerful Tox client written in Python3',
+      url='https://github.com/xveduk/toxygen/',
+      keywords='toxygen tox messenger',
+      author='Ingvar',
+      maintainer='Ingvar',
+      license='GPL3',
+      packages=['toxygen', 'toxygen.plugins', 'toxygen.styles'],
+      install_requires=MODULES,
+      include_package_data=True,
+      classifiers=[
+          'Programming Language :: Python :: 3 :: Only',
+          'Programming Language :: Python :: 3.2',
+          'Programming Language :: Python :: 3.3',
+          'Programming Language :: Python :: 3.4',
+      ],
+      entry_points={
+          'console_scripts': ['toxygen=toxygen.main:main'],
+      },
+      cmdclass={
+          'install': InstallScript,
+      },
+      )

src/passwordscreen.py

@@ -1,76 +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:
-                self.warning.setVisible(True)
-            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/tox_dns.py

@@ -1,30 +0,0 @@
-import json
-import urllib2
-from util import log
-
-
-def tox_dns(email):
-    """
-    TOX DNS 4
-    :param email: data like 'groupbot@toxme.io'
-    :return: tox id on success else None
-    """
-    site = email.split('@')[1]
-    data = {"action": 3, "name": "{}".format(email)}
-    for url in ('https://{}/api'.format(site), 'http://{}/api'.format(site)):
-        try:
-            return send_request(url, data)
-        except Exception as ex:  # try http
-            log('TOX DNS ERROR: ' + str(ex))
-    return None  # error
-
-
-def send_request(url, data):
-    req = urllib2.Request(url)
-    req.add_header('Content-Type', 'application/json')
-    response = urllib2.urlopen(req, json.dumps(data))
-    res = json.loads(response.read())
-    if not res['c']:
-        return res['tox_id']
-    else:
-        raise LookupError()

src/toxcore_enums_and_consts.py

@@ -1,209 +0,0 @@
-TOX_USER_STATUS = {
-    'NONE': 0,
-    'AWAY': 1,
-    'BUSY': 2,
-}
-
-TOX_MESSAGE_TYPE = {
-    'NORMAL': 0,
-    'ACTION': 1,
-}
-
-TOX_PROXY_TYPE = {
-    'NONE': 0,
-    'HTTP': 1,
-    'SOCKS5': 2,
-}
-
-TOX_SAVEDATA_TYPE = {
-    'NONE': 0,
-    'TOX_SAVE': 1,
-    'SECRET_KEY': 2,
-}
-
-TOX_ERR_OPTIONS_NEW = {
-    'OK': 0,
-    'MALLOC': 1,
-}
-
-TOX_ERR_NEW = {
-    'OK': 0,
-    'NULL': 1,
-    'MALLOC': 2,
-    'PORT_ALLOC': 3,
-    'PROXY_BAD_TYPE': 4,
-    'PROXY_BAD_HOST': 5,
-    'PROXY_BAD_PORT': 6,
-    'PROXY_NOT_FOUND': 7,
-    'LOAD_ENCRYPTED': 8,
-    'LOAD_BAD_FORMAT': 9,
-}
-
-TOX_ERR_BOOTSTRAP = {
-    'OK': 0,
-    'NULL': 1,
-    'BAD_HOST': 2,
-    'BAD_PORT': 3,
-}
-
-TOX_CONNECTION = {
-    'NONE': 0,
-    'TCP': 1,
-    'UDP': 2,
-}
-
-TOX_ERR_SET_INFO = {
-    'OK': 0,
-    'NULL': 1,
-    'TOO_LONG': 2,
-}
-
-TOX_ERR_FRIEND_ADD = {
-    'OK': 0,
-    'NULL': 1,
-    'TOO_LONG': 2,
-    'NO_MESSAGE': 3,
-    'OWN_KEY': 4,
-    'ALREADY_SENT': 5,
-    'BAD_CHECKSUM': 6,
-    'SET_NEW_NOSPAM': 7,
-    'MALLOC': 8,
-}
-
-TOX_ERR_FRIEND_DELETE = {
-    'OK': 0,
-    'FRIEND_NOT_FOUND': 1,
-}
-
-TOX_ERR_FRIEND_BY_PUBLIC_KEY = {
-    'OK': 0,
-    'NULL': 1,
-    'NOT_FOUND': 2,
-}
-
-TOX_ERR_FRIEND_GET_PUBLIC_KEY = {
-    'OK': 0,
-    'FRIEND_NOT_FOUND': 1,
-}
-
-TOX_ERR_FRIEND_GET_LAST_ONLINE = {
-    'OK': 0,
-    'FRIEND_NOT_FOUND': 1,
-}
-
-TOX_ERR_FRIEND_QUERY = {
-    'OK': 0,
-    'NULL': 1,
-    'FRIEND_NOT_FOUND': 2,
-}
-
-TOX_ERR_SET_TYPING = {
-    'OK': 0,
-    'FRIEND_NOT_FOUND': 1,
-}
-
-TOX_ERR_FRIEND_SEND_MESSAGE = {
-    'OK': 0,
-    'NULL': 1,
-    'FRIEND_NOT_FOUND': 2,
-    'FRIEND_NOT_CONNECTED': 3,
-    'SENDQ': 4,
-    'TOO_LONG': 5,
-    'EMPTY': 6,
-}
-
-TOX_FILE_KIND = {
-    'DATA': 0,
-    'AVATAR': 1,
-}
-
-TOX_FILE_CONTROL = {
-    'RESUME': 0,
-    'PAUSE': 1,
-    'CANCEL': 2,
-}
-
-TOX_ERR_FILE_CONTROL = {
-    'OK': 0,
-    'FRIEND_NOT_FOUND': 1,
-    'FRIEND_NOT_CONNECTED': 2,
-    'NOT_FOUND': 3,
-    'NOT_PAUSED': 4,
-    'DENIED': 5,
-    'ALREADY_PAUSED': 6,
-    'SENDQ': 7,
-}
-
-TOX_ERR_FILE_SEEK = {
-    'OK': 0,
-    'FRIEND_NOT_FOUND': 1,
-    'FRIEND_NOT_CONNECTED': 2,
-    'NOT_FOUND': 3,
-    'DENIED': 4,
-    'INVALID_POSITION': 5,
-    'SENDQ': 6,
-}
-
-TOX_ERR_FILE_GET = {
-    'OK': 0,
-    'NULL': 1,
-    'FRIEND_NOT_FOUND': 2,
-    'NOT_FOUND': 3,
-}
-
-TOX_ERR_FILE_SEND = {
-    'OK': 0,
-    'NULL': 1,
-    'FRIEND_NOT_FOUND': 2,
-    'FRIEND_NOT_CONNECTED': 3,
-    'NAME_TOO_LONG': 4,
-    'TOO_MANY': 5,
-}
-
-TOX_ERR_FILE_SEND_CHUNK = {
-    'OK': 0,
-    'NULL': 1,
-    'FRIEND_NOT_FOUND': 2,
-    'FRIEND_NOT_CONNECTED': 3,
-    'NOT_FOUND': 4,
-    'NOT_TRANSFERRING': 5,
-    'INVALID_LENGTH': 6,
-    'SENDQ': 7,
-    'WRONG_POSITION': 8,
-}
-
-TOX_ERR_FRIEND_CUSTOM_PACKET = {
-    'OK': 0,
-    'NULL': 1,
-    'FRIEND_NOT_FOUND': 2,
-    'FRIEND_NOT_CONNECTED': 3,
-    'INVALID': 4,
-    'EMPTY': 5,
-    'TOO_LONG': 6,
-    'SENDQ': 7,
-}
-
-TOX_ERR_GET_PORT = {
-    'OK': 0,
-    'NOT_BOUND': 1,
-}
-
-TOX_PUBLIC_KEY_SIZE = 32
-
-TOX_ADDRESS_SIZE = TOX_PUBLIC_KEY_SIZE + 6
-
-TOX_MAX_FRIEND_REQUEST_LENGTH = 1016
-
-TOX_MAX_MESSAGE_LENGTH = 1372
-
-TOX_MAX_NAME_LENGTH = 128
-
-TOX_MAX_STATUS_MESSAGE_LENGTH = 1007
-
-TOX_SECRET_KEY_SIZE = 32
-
-TOX_FILE_ID_LENGTH = 32
-
-TOX_HASH_LENGTH = 32
-
-TOX_MAX_CUSTOM_PACKET_SIZE = 1373

tests/tests.py

@@ -1,40 +1,22 @@
-from src.bootstrap import node_generator
+from toxygen.bootstrap import node_generator
-from src.profile import *
+from toxygen.profile import *
-from src.settings import ProfileHelper
+from toxygen.settings import ProfileHelper
-from src.tox_dns import tox_dns
+from toxygen.tox_dns import tox_dns
-from src.toxencryptsave import LibToxEncryptSave
+import toxygen.toxencryptsave as encr
 
 
-class TestProfile():
+class TestProfile:
 
     def test_search(self):
         arr = ProfileHelper.find_profiles()
-        assert arr
         assert len(arr) >= 2
 
     def test_open(self):
         data = ProfileHelper(Settings.get_default_path(), 'alice').open_profile()
         assert data
 
-    def test_open_save(self):
-        data = ProfileHelper(Settings.get_default_path(), 'alice').open_profile()
-        ProfileHelper.get_instance().save_profile(data)
-        new_data = ProfileHelper(Settings.get_default_path(), 'alice').open_profile()
-        assert new_data == data
 
-
+class TestTox:
-class TestNodeGen():
-
-    def test_generator(self):
-        for elem in node_generator():
-            assert len(elem) == 3
-
-    def test_ports(self):
-        for elem in node_generator():
-            assert elem[1] in [33445, 443, 5190, 2306, 1813]
-
-
-class TestTox():
 
     def test_loading(self):
         data = ProfileHelper(Settings.get_default_path(), 'alice').open_profile()
@@ -45,16 +27,16 @@ class TestTox():
         del tox
 
     def test_creation(self):
-        name = 'Toxygen User'
+        name = b'Toxygen User'
-        status_message = 'Toxing on Toxygen'
+        status_message = b'Toxing on Toxygen'
         tox = tox_factory()
         tox.self_set_name(name)
         tox.self_set_status_message(status_message)
         data = tox.get_savedata()
         del tox
         tox = tox_factory(data)
-        assert tox.self_get_name() == name
+        assert tox.self_get_name() == str(name, 'utf-8')
-        assert tox.self_get_status_message() == status_message
+        assert tox.self_get_status_message() == str(status_message, 'utf-8')
 
     def test_friend_list(self):
         data = ProfileHelper(Settings.get_default_path(), 'bob').open_profile()
@@ -67,7 +49,7 @@ class TestTox():
         del tox
 
 
-class TestDNS():
+class TestDNS:
 
     def test_dns(self):
         bot_id = '56A1ADE4B65B86BCD51CC73E2CD4E542179F47959FE3E0E21B4B0ACDADE51855D34D34D37CB5'
@@ -75,12 +57,13 @@ class TestDNS():
         assert tox_id == bot_id
 
 
-class TestEncryption():
+class TestEncryption:
 
     def test_encr_decr(self):
-        with open(settings.Settings.get_default_path() + '/alice.tox') as fl:
+        with open(settings.Settings.get_default_path() + '/alice.tox', 'rb') as fl:
             data = fl.read()
-        lib = LibToxEncryptSave('easypassword')
+        lib = encr.ToxEncryptSave()
+        lib.set_password('easypassword')
         copy_data = data[:]
         data = lib.pass_encrypt(data)
         data = lib.pass_decrypt(data)

toxygen/__init__.py

@@ -0,0 +1,8 @@
+import os
+import sys
+
+path = os.path.dirname(os.path.realpath(__file__))  # curr dir
+
+sys.path.insert(0, os.path.join(path, 'styles'))
+sys.path.insert(0, os.path.join(path, 'plugins'))
+sys.path.insert(0, path)

toxygen/avwidgets.py

@@ -65,7 +65,7 @@ class IncomingCallWidget(widgets.CenteredWidget):
                 QtCore.QThread.__init__(self)
 
             def run(self):
-                class AudioFile(object):
+                class AudioFile:
                     chunk = 1024
 
                     def __init__(self, fl):

toxygen/basecontact.py

@@ -7,7 +7,7 @@ except ImportError:
 from toxcore_enums_and_consts import TOX_PUBLIC_KEY_SIZE
 
 
-class Contact(object):
+class BaseContact:
     """
     Class encapsulating TOX contact
     Properties: name (alias of contact or name), status_message, status (connection status)
@@ -29,28 +29,28 @@ class Contact(object):
         self.load_avatar()
 
     # -----------------------------------------------------------------------------------------------------------------
-    # name - current name or alias of user
+    # Name - current name or alias of user
     # -----------------------------------------------------------------------------------------------------------------
 
     def get_name(self):
         return self._name
 
     def set_name(self, value):
-        self._name = value.decode('utf-8')
+        self._name = str(value, 'utf-8')
         self._widget.name.setText(self._name)
         self._widget.name.repaint()
 
     name = property(get_name, set_name)
 
     # -----------------------------------------------------------------------------------------------------------------
-    # Status message
+    # Status message or group topic
     # -----------------------------------------------------------------------------------------------------------------
 
     def get_status_message(self):
         return self._status_message
 
     def set_status_message(self, value):
-        self._status_message = value.decode('utf-8')
+        self._status_message = str(value, 'utf-8')
         self._widget.status_message.setText(self._status_message)
         self._widget.status_message.repaint()
 
@@ -82,19 +82,20 @@ class Contact(object):
     # Avatars
     # -----------------------------------------------------------------------------------------------------------------
 
-    def load_avatar(self):
+    def load_avatar(self, default_path='avatar.png'):
         """
         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'
+            avatar_path = default_path
             os.chdir(curr_directory() + '/images/')
-        pixmap = QtGui.QPixmap(QtCore.QSize(64, 64))
+        width = self._widget.avatar_label.width()
+        pixmap = QtGui.QPixmap(QtCore.QSize(width, width))
         pixmap.load(avatar_path)
         self._widget.avatar_label.setScaledContents(False)
-        self._widget.avatar_label.setPixmap(pixmap.scaled(64, 64, QtCore.Qt.KeepAspectRatio))
+        self._widget.avatar_label.setPixmap(pixmap.scaled(width, width, QtCore.Qt.KeepAspectRatio))
         self._widget.avatar_label.repaint()
 
     def reset_avatar(self):

toxygen/bootstrap.py

@@ -1,12 +1,12 @@
 import random
 
 
-class Node(object):
+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
+        return bytes(self._ip, 'utf-8'), self._port, self._tox_key
 
 
 def node_generator():
@@ -75,13 +75,9 @@ def node_generator():
         "5625A62618CB4FCA70E147A71B29695F38CC65FF0CBD68AD46254585BE564802",
         "31910C0497D347FF160D6F3A6C0E317BAFA71E8E03BC4CBB2A185C9D4FB8B31E"
     ]
-    for i in xrange(len(ips)):
+    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()
 
-
-if __name__ == "__main__":
-    for elem in node_generator():
-        print str(elem)

toxygen/callbacks.py

@@ -43,7 +43,7 @@ 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)
+        print('Connection status: ', str(connection))
         profile = Profile.get_instance()
         if profile.status is None:
             status = tox_link.self_get_status()
@@ -62,7 +62,7 @@ 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)
+    print("Friend's #{} status changed!".format(friend_num))
     profile = Profile.get_instance()
     friend = profile.get_friend_by_number(friend_num)
     if friend.status is None and Settings.get_instance()['sound_notifications'] and profile.status != TOX_USER_STATUS['BUSY']:
@@ -76,7 +76,7 @@ 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)
+    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']:
@@ -94,7 +94,7 @@ def friend_name(tox, friend_num, name, size, user_data):
     Friend changed his name
     """
     profile = Profile.get_instance()
-    print 'New name: ', friend_num, name
+    print('New name friend #' + str(friend_num))
     invoke_in_main_thread(profile.new_name, friend_num, name)
 
 
@@ -106,7 +106,7 @@ def friend_status_message(tox, friend_num, status_message, size, user_data):
     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)
+    print('User #{} has new status'.format(friend_num))
     invoke_in_main_thread(profile.send_messages, friend_num)
     if profile.get_active_number() == friend_num:
         invoke_in_main_thread(profile.set_active)
@@ -119,11 +119,12 @@ def friend_message(window, tray):
     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']:
+            if settings['notifications'] and profile.status != TOX_USER_STATUS['BUSY'] and not settings.locked:
-                invoke_in_main_thread(tray_notification, friend.name, message.decode('utf8'), tray, window)
+                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'))
@@ -134,12 +135,12 @@ def friend_request(tox, public_key, message, message_size, user_data):
     """
     Called when user get new friend request
     """
-    print '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, message.decode('utf-8'))
+        invoke_in_main_thread(profile.process_friend_request, tox_id, str(message, 'utf-8'))
 
 
 def friend_typing(tox, friend_number, typing, user_data):
@@ -165,11 +166,11 @@ def tox_file_recv(window, tray):
         profile = Profile.get_instance()
         settings = Settings.get_instance()
         if file_type == TOX_FILE_KIND['DATA']:
-            print 'file'
+            print('File')
             try:
-                file_name = unicode(file_name[:file_name_size].decode('utf-8'))
+                file_name = str(file_name[:file_name_size], 'utf-8')
             except:
-                file_name = u'toxygen_file'
+                file_name = 'toxygen_file'
             invoke_in_main_thread(profile.incoming_file_transfer,
                                   friend_number,
                                   file_number,
@@ -177,14 +178,14 @@ def tox_file_recv(window, tray):
                                   file_name)
             if not window.isActiveWindow():
                 friend = profile.get_friend_by_number(friend_number)
-                if settings['notifications'] and profile.status != TOX_USER_STATUS['BUSY']:
+                if settings['notifications'] and profile.status != TOX_USER_STATUS['BUSY'] and not settings.locked:
                     file_from = QtGui.QApplication.translate("Callback", "File from", None, QtGui.QApplication.UnicodeUTF8)
                     invoke_in_main_thread(tray_notification, file_from + ' ' + friend.name, file_name, tray, window)
                 if settings['sound_notifications'] and profile.status != TOX_USER_STATUS['BUSY']:
                     sound_notification(SOUND_NOTIFICATION['FILE_TRANSFER'])
                 invoke_in_main_thread(tray.setIcon, QtGui.QIcon(curr_directory() + '/images/icon_new_messages.png'))
         else:  # AVATAR
-            print 'Avatar'
+            print('Avatar')
             invoke_in_main_thread(profile.incoming_avatar,
                                   friend_number,
                                   file_number,
@@ -260,7 +261,7 @@ def call_state(toxav, friend_number, mask, user_data):
     """
     New call state
     """
-    print friend_number, mask
+    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:
@@ -271,7 +272,7 @@ def call(toxav, friend_number, audio, video, user_data):
     """
     Incoming call from friend
     """
-    print friend_number, audio, video
+    print(friend_number, audio, video)
     invoke_in_main_thread(Profile.get_instance().incoming_call, audio, video, friend_number)
 
 
@@ -279,13 +280,56 @@ def callback_audio(toxav, friend_number, samples, audio_samples_per_channel, aud
     """
     New audio chunk
     """
-    # print audio_samples_per_channel, audio_channels_count, rate
+    # print(audio_samples_per_channel, audio_channels_count, rate)
     Profile.get_instance().call.chunk(
-        ''.join(chr(x) for x in samples[:audio_samples_per_channel * 2 * audio_channels_count]),
+        bytes(samples[:audio_samples_per_channel * 2 * audio_channels_count]),
         audio_channels_count,
         rate)
 
 
+# -----------------------------------------------------------------------------------------------------------------
+# Callbacks - group chats
+# -----------------------------------------------------------------------------------------------------------------
+
+def group_message(window, tray, tox):
+    """
+    New message in group chat
+    """
+    def wrapped(tox_link, group_number, peer_id, message_type, message, length, user_data):
+        profile = Profile.get_instance()
+        settings = Settings.get_instance()
+        message = str(message[:length], 'utf-8')
+        invoke_in_main_thread(profile.new_message, group_number, message_type, message, True, peer_id)
+        if not window.isActiveWindow():
+            bl = settings['notify_all_gc'] or profile.name in message
+            name = tox.group_peer_get_name(group_number, peer_id)
+            if settings['notifications'] and profile.status != TOX_USER_STATUS['BUSY'] and (not settings.locked) and bl:
+                invoke_in_main_thread(tray_notification, name, message, tray, window)
+            if settings['sound_notifications'] and bl and profile.status != TOX_USER_STATUS['BUSY']:
+                sound_notification(SOUND_NOTIFICATION['MESSAGE'])
+            invoke_in_main_thread(tray.setIcon, QtGui.QIcon(curr_directory() + '/images/icon_new_messages.png'))
+    return wrapped
+
+
+def group_invite(tox, friend_number, invite_data, length, user_data):
+    invoke_in_main_thread(Profile.get_instance().process_group_invite,
+                          friend_number,
+                          bytes(invite_data[:length]))
+
+
+def group_self_join(tox, group_number, user_data):
+    pr = Profile.get_instance()
+    gc = pr.get_gc_by_number(group_number)
+    invoke_in_main_thread(gc.set_status, TOX_USER_STATUS['NONE'])
+    if not pr.is_active_a_friend() and pr.get_active_number() == group_number:
+        invoke_in_main_thread(pr.set_active)
+
+
+def group_peer_join(tox, group_number, peer_id, user_data):
+    gc = Profile.get_instance().get_gc_by_number(group_number)
+    gc.add_peer(peer_id)
+
+
 # -----------------------------------------------------------------------------------------------------------------
 # Callbacks - initialization
 # -----------------------------------------------------------------------------------------------------------------
@@ -322,3 +366,8 @@ def init_callbacks(tox, window, tray):
     tox.callback_friend_lossless_packet(lossless_packet, 0)
     tox.callback_friend_lossy_packet(lossy_packet, 0)
 
+    tox.callback_group_message(group_message(window, tray, tox), 0)
+    tox.callback_group_invite(group_invite, 0)
+    tox.callback_group_self_join(group_self_join, 0)
+    tox.callback_group_peer_join(group_peer_join, 0)
+

toxygen/calls.py

@@ -13,7 +13,7 @@ CALL_TYPE = {
 }
 
 
-class AV(object):
+class AV:
 
     def __init__(self, toxav):
         self._toxav = toxav
@@ -30,7 +30,7 @@ class AV(object):
         self._audio_rate = 8000
         self._audio_channels = 1
         self._audio_duration = 60
-        self._audio_sample_count = self._audio_rate * self._audio_channels * self._audio_duration / 1000
+        self._audio_sample_count = self._audio_rate * self._audio_channels * self._audio_duration // 1000
 
     def __contains__(self, friend_number):
         return friend_number in self._calls

toxygen/contact.py

@@ -1,29 +1,37 @@
-import contact
+try:
+    from PySide import QtCore, QtGui
+except ImportError:
+    from PyQt4 import QtCore, QtGui
+import basecontact
 from messages import *
 from history import *
+import file_transfers as ft
 import util
 
 
-class Friend(contact.Contact):
+class Contact(basecontact.BaseContact):
     """
-    Friend in list of friends. Can be hidden, properties 'has unread messages' and 'has alias' added
+    Class encapsulating TOX contact
+    Properties: name (alias of contact or name), status_message, status (connection status)
+    widget - widget for update
     """
 
-    def __init__(self, message_getter, number, *args):
+    def __init__(self, number, message_getter, name, status_message, widget, tox_id):
         """
-        :param message_getter: gets messages from db
+        :param name: name, example: 'Toxygen user'
-        :param number: number of friend.
+        :param status_message: status message, example: 'Toxing on Toxygen'
+        :param widget: ContactItem instance
+        :param tox_id: tox id of contact
         """
-        super(Friend, self).__init__(*args)
+        super().__init__(name, status_message, widget, tox_id)
-        self._number = number
+        self._message_getter = message_getter
         self._new_messages = False
         self._visible = True
         self._alias = False
-        self._message_getter = message_getter
+        self._number = number
         self._corr = []
         self._unsaved_messages = 0
         self._history_loaded = self._new_actions = False
-        self._receipts = 0
         self._curr_text = ''
 
     def __del__(self):
@@ -32,35 +40,18 @@ class Friend(contact.Contact):
         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 = self._message_getter.get(PAGE_SIZE)
+        data = list(self._message_getter.get(PAGE_SIZE))
         if data is not None and len(data):
             data.reverse()
         else:
             return
-        data = map(lambda tupl: TextMessage(*tupl), data)
+        data = list(map(lambda tupl: TextMessage(*tupl), data))
         self._corr = data + self._corr
         self._history_loaded = True
 
@@ -69,10 +60,8 @@ class Friend(contact.Contact):
         Get data to save in db
         :return: list of unsaved messages or []
         """
-        if hasattr(self, '_message_getter'):
+        messages = list(filter(lambda x: x.get_type() <= 1, self._corr))
-            del self._message_getter
+        return list(map(lambda x: x.get_data(), messages[-self._unsaved_messages:])) if self._unsaved_messages else []
-        messages = filter(lambda x: x.get_type() <= 1, self._corr)
-        return map(lambda x: x.get_data(), messages[-self._unsaved_messages:]) if self._unsaved_messages else []
 
     def get_corr(self):
         return self._corr[:]
@@ -86,35 +75,64 @@ class Friend(contact.Contact):
             self._unsaved_messages += 1
 
     def get_last_message_text(self):
-        messages = filter(lambda x: x.get_type() <= 1 and x.get_owner() != MESSAGE_OWNER['FRIEND'], self._corr)
+        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 unsent_messages(self):
+    def get_unsent_messages(self):
         """
         :return list of unsent messages
         """
         messages = filter(lambda x: x.get_owner() == MESSAGE_OWNER['NOT_SENT'], self._corr)
-        return messages
+        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 delete_old_messages(self):
+        old = filter(lambda x: x.get_type() in (2, 3) and (x.get_status() >= 2 or x.get_status() is None),
+                     self._corr[:-SAVE_MESSAGES])
+        old = list(old)
+        l = max(len(self._corr) - SAVE_MESSAGES, 0) - len(old)
+        self._unsaved_messages -= l
+        self._corr = old + self._corr[-SAVE_MESSAGES:]
 
     def mark_as_sent(self):
         try:
-            message = filter(lambda x: x.get_owner() == MESSAGE_OWNER['NOT_SENT'], self._corr)[0]
+            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):
+    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
-        self._corr = filter(lambda x: x.get_type() in (2, 3) and x.get_status() >= 2, self._corr)
+        if not save_unsent:
-        self._unsaved_messages = 0
+            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
@@ -124,50 +142,6 @@ class Friend(contact.Contact):
 
     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 = 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 = filter(lambda x: type(x) is not UnsentFile, self._corr)
-
-    def delete_one_unsent_file(self, time):
-        self._corr = 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
     # -----------------------------------------------------------------------------------------------------------------
@@ -181,7 +155,7 @@ class Friend(contact.Contact):
     visibility = property(get_visibility, set_visibility)
 
     # -----------------------------------------------------------------------------------------------------------------
-    # Unread messages from friend
+    # Unread messages and actions
     # -----------------------------------------------------------------------------------------------------------------
 
     def get_actions(self):
@@ -211,7 +185,7 @@ class Friend(contact.Contact):
     messages = property(get_messages)
 
     # -----------------------------------------------------------------------------------------------------------------
-    # Friend's number (can be used in toxcore)
+    # Number (can be used in toxcore)
     # -----------------------------------------------------------------------------------------------------------------
 
     def get_number(self):
@@ -221,3 +195,18 @@ class Friend(contact.Contact):
         self._number = value
 
     number = property(get_number, set_number)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Alias support
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def set_name(self, value):
+        """
+        Set new name or ignore if alias exists
+        :param value: new name
+        """
+        if not self._alias:
+            super(Contact, self).set_name(value)
+
+    def set_alias(self, alias):
+        self._alias = bool(alias)

toxygen/file_transfers.py

@@ -121,7 +121,7 @@ class SendTransfer(FileTransfer):
         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,
-                                          basename(path).encode('utf-8') if path else '')
+                                          bytes(basename(path), 'utf-8') if path else b'')
 
     def send_chunk(self, position, size):
         """
@@ -167,7 +167,8 @@ class SendFromBuffer(FileTransfer):
         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, file_name)
+        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
@@ -229,7 +230,7 @@ class ReceiveTransfer(FileTransfer):
             data = bytearray(data)
             if self._file_size < position:
                 self._file.seek(0, 2)
-                self._file.write('\0' * (position - self._file_size))
+                self._file.write(b'\0' * (position - self._file_size))
             self._file.seek(position)
             self._file.write(data)
             l = len(data)
@@ -246,7 +247,7 @@ class ReceiveToBuffer(FileTransfer):
 
     def __init__(self, tox, friend_number, size, file_number):
         super(ReceiveToBuffer, self).__init__(None, tox, friend_number, size, file_number)
-        self._data = ''
+        self._data = bytes()
         self._data_size = 0
 
     def get_data(self):
@@ -257,17 +258,16 @@ class ReceiveToBuffer(FileTransfer):
             self._creation_time = time()
         if data is None:
             self.state = TOX_FILE_TRANSFER_STATE['FINISHED']
-            self.signal()
         else:
-            data = ''.join(chr(x) for x in data)
+            data = bytes(data)
             l = len(data)
             if self._data_size < position:
-                self._data += ('\0' * (position - self._data_size))
+                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()
+        self.signal()
 
 
 class ReceiveAvatar(ReceiveTransfer):
@@ -281,20 +281,23 @@ class ReceiveAvatar(ReceiveTransfer):
         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) as fl:
+            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'])
@@ -309,5 +312,3 @@ class ReceiveAvatar(ReceiveTransfer):
                 chdir(dirname(avatar_path))
                 remove(avatar_path)
             rename(self._path, avatar_path)
-
-

toxygen/friend.py

@@ -0,0 +1,64 @@
+import contact
+from messages import *
+
+
+class Friend(contact.Contact):
+    """
+    Friend in list of friends. Can be hidden, properties 'has unread messages' and 'has alias' added
+    """
+
+    def __init__(self, *args):
+        """
+        :param number: number of friend.
+        """
+        super(Friend, self).__init__(*args)
+        self._receipts = 0
+
+    def __del__(self):
+        super().__del__()
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # 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()
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # 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))

toxygen/groupchat.py

@@ -0,0 +1,36 @@
+import contact
+
+
+class GroupChat(contact.Contact):
+
+    def __init__(self, tox, *args):
+        super().__init__(*args)
+        self._tox = tox
+
+    def load_avatar(self, default_path='group.png'):
+        super().load_avatar(default_path)
+
+    def set_status(self, value):
+        print('In gc set_status')
+        super().set_status(value)
+        self.name = bytes(self._tox.group_get_name(self._number), 'utf-8')
+        self._tox_id = self._tox.group_get_chat_id(self._number)
+        self.status_message = bytes(self._tox.group_get_topic(self._number), 'utf-8')
+
+    def add_peer(self, peer_id):
+        print(peer_id)
+        print(self._tox.group_peer_get_name(self._number, peer_id))
+
+    # TODO: get peers list and add other methods
+
+    def get_peers_list(self):
+        return []
+
+
+class Peer:
+
+    def __init__(self, peer_id, name, status, role):
+        self._data = (peer_id, name, status, role)
+
+    def get_data(self):
+        return self._data

toxygen/history.py

@@ -3,11 +3,13 @@ from sqlite3 import connect
 import settings
 from os import chdir
 import os.path
-from toxencryptsave import LibToxEncryptSave
+from toxencryptsave import ToxEncryptSave
 
 
 PAGE_SIZE = 42
 
+SAVE_MESSAGES = 150
+
 MESSAGE_OWNER = {
     'ME': 0,
     'FRIEND': 1,
@@ -15,14 +17,14 @@ MESSAGE_OWNER = {
 }
 
 
-class History(object):
+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()
+            decr = ToxEncryptSave.get_instance()
             try:
                 with open(path, 'rb') as fin:
                     data = fin.read()
@@ -40,12 +42,12 @@ class History(object):
         db.close()
 
     def save(self):
-        encr = LibToxEncryptSave.get_instance()
+        encr = ToxEncryptSave.get_instance()
         if encr.has_password():
             path = settings.ProfileHelper.get_path() + self._name + '.hstr'
             with open(path, 'rb') as fin:
                 data = fin.read()
-            data = encr.pass_encrypt(data)
+            data = encr.pass_encrypt(bytes(data))
             with open(path, 'wb') as fout:
                 fout.write(data)
 
@@ -54,7 +56,7 @@ class History(object):
         new_path = directory + self._name + '.hstr'
         with open(path, 'rb') as fin:
             data = fin.read()
-        encr = LibToxEncryptSave.get_instance()
+        encr = ToxEncryptSave.get_instance()
         if encr.has_password():
             data = encr.pass_encrypt(data)
         with open(new_path, 'wb') as fout:
@@ -132,6 +134,19 @@ class History(object):
             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')
@@ -148,7 +163,7 @@ class History(object):
     def messages_getter(self, tox_id):
         return History.MessageGetter(self._name, tox_id)
 
-    class MessageGetter(object):
+    class MessageGetter:
         def __init__(self, name, tox_id):
             chdir(settings.ProfileHelper.get_path())
             self._db = connect(name + '.hstr')

toxygen/libtox.py

@@ -1,15 +1,16 @@
 from platform import system
 from ctypes import CDLL
+import util
 
 
-class LibToxCore(object):
+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('libs/libtox.dll')
+            self._libtoxcore = CDLL(util.curr_directory() + '/libs/libtox.dll')
         else:
             raise OSError('Unknown system.')
 
@@ -17,7 +18,7 @@ class LibToxCore(object):
         return self._libtoxcore.__getattr__(item)
 
 
-class LibToxAV(object):
+class LibToxAV:
 
     def __init__(self):
         if system() == 'Linux':
@@ -25,7 +26,7 @@ class LibToxAV(object):
             self._libtoxav = CDLL('libtoxav.so')
         elif system() == 'Windows':
             # on Windows av api is in libtox.dll
-            self._libtoxav = CDLL('libs/libtox.dll')
+            self._libtoxav = CDLL(util.curr_directory() + '/libs/libtox.dll')
         else:
             raise OSError('Unknown system.')
 
@@ -33,7 +34,7 @@ class LibToxAV(object):
         return self._libtoxav.__getattr__(item)
 
 
-class LibToxEncryptSave(object):
+class LibToxEncryptSave:
 
     def __init__(self):
         if system() == 'Linux':
@@ -41,7 +42,7 @@ class LibToxEncryptSave(object):
             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('libs/libtox.dll')
+            self._lib_tox_encrypt_save = CDLL(util.curr_directory() + '/libs/libtox.dll')
         else:
             raise OSError('Unknown system.')
 

toxygen/list_items.py

@@ -7,7 +7,7 @@ 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 cgi
+import html as h
 import smileys
 import settings
 
@@ -70,7 +70,7 @@ class MessageEdit(QtGui.QTextBrowser):
         self.setLineWrapColumnOrWidth(self.lineWrapColumnOrWidth())
 
     def decoratedText(self, text):
-        text = cgi.escape(text)  # replace < and >
+        text = h.escape(text)  # replace < and >
         exp = QtCore.QRegExp(
             '('
             '(?:\\b)((www\\.)|(http[s]?|ftp)://)'
@@ -121,14 +121,15 @@ class MessageItem(QtGui.QWidget):
         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 = time
+            self.t = True
         else:
-            self.time.setText(time)
+            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']:
@@ -138,10 +139,23 @@ class MessageItem(QtGui.QWidget):
         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 hasattr(self, 't'):
+        if self.t:
-            self.time.setText(self.t)
+            self.time.setText(convert_time(self._time))
-            del self.t
+            self.t = False
             return True
         return False
 
@@ -153,26 +167,28 @@ class ContactItem(QtGui.QWidget):
 
     def __init__(self, parent=None):
         QtGui.QWidget.__init__(self, parent)
-        self.setBaseSize(QtCore.QSize(250, 70))
+        mode = settings.Settings.get_instance()['compact_mode']
+        self.setBaseSize(QtCore.QSize(250, 40 if mode else 70))
         self.avatar_label = QtGui.QLabel(self)
-        self.avatar_label.setGeometry(QtCore.QRect(3, 3, 64, 64))
+        size = 32 if mode else 64
+        self.avatar_label.setGeometry(QtCore.QRect(3, 4, size, size))
         self.avatar_label.setScaledContents(True)
         self.name = DataLabel(self)
-        self.name.setGeometry(QtCore.QRect(75, 10, 150, 25))
+        self.name.setGeometry(QtCore.QRect(50 if mode else 75, 3 if mode else 10, 150, 15 if mode else 25))
         font = QtGui.QFont()
         font.setFamily("Times New Roman")
-        font.setPointSize(12)
+        font.setPointSize(10 if mode else 12)
         font.setBold(True)
         self.name.setFont(font)
         self.status_message = DataLabel(self)
-        self.status_message.setGeometry(QtCore.QRect(75, 30, 170, 20))
+        self.status_message.setGeometry(QtCore.QRect(50 if mode else 75, 20 if mode else 30, 170, 15 if mode else 20))
         font.setPointSize(10)
         font.setBold(False)
         self.status_message.setFont(font)
         self.connection_status = StatusCircle(self)
-        self.connection_status.setGeometry(QtCore.QRect(230, 5, 32, 32))
+        self.connection_status.setGeometry(QtCore.QRect(230, -2 if mode else 5, 32, 32))
         self.messages = UnreadMessagesCount(self)
-        self.messages.setGeometry(QtCore.QRect(52, 50, 30, 20))
+        self.messages.setGeometry(QtCore.QRect(20 if mode else 52, 20 if mode else 50, 30, 20))
 
 
 class StatusCircle(QtGui.QWidget):
@@ -303,14 +319,14 @@ class FileTransferItem(QtGui.QListWidget):
         self.file_name.setGeometry(QtCore.QRect(210, 7, width - 420, 20))
         font.setPointSize(12)
         self.file_name.setFont(font)
-        file_size = size / 1024
+        file_size = size // 1024
         if not file_size:
             file_size = '{}B'.format(size)
         elif file_size >= 1024:
-            file_size = '{}MB'.format(file_size / 1024)
+            file_size = '{}MB'.format(file_size // 1024)
         else:
             file_size = '{}KB'.format(file_size)
-        file_data = u'{} {}'.format(file_size, file_name)
+        file_data = '{} {}'.format(file_size, file_name)
         self.file_name.setText(file_data)
         self.file_name.setToolTip(file_name)
         self.saved_name = file_name
@@ -335,7 +351,7 @@ class FileTransferItem(QtGui.QListWidget):
             directory = QtGui.QFileDialog.getExistingDirectory(self,
                                                                QtGui.QApplication.translate("MainWindow", 'Choose folder', None, QtGui.QApplication.UnicodeUTF8),
                                                                curr_directory(),
-                                                               QtGui.QFileDialog.ShowDirsOnly)
+                                                               QtGui.QFileDialog.ShowDirsOnly | QtGui.QFileDialog.DontUseNativeDialog)
             self.pb.setVisible(True)
             if directory:
                 pr = profile.Profile.get_instance()
@@ -435,7 +451,7 @@ class InlineImageItem(QtGui.QScrollArea):
         self.setWidget(self._image_label)
         self._image_label.setScaledContents(False)
         self._pixmap = QtGui.QPixmap()
-        self._pixmap.loadFromData(QtCore.QByteArray(data), "PNG")
+        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
@@ -469,7 +485,7 @@ class InlineImageItem(QtGui.QScrollArea):
                                                                                             'Choose folder', None,
                                                                                             QtGui.QApplication.UnicodeUTF8),
                                                                curr_directory(),
-                                                               QtGui.QFileDialog.ShowDirsOnly)
+                                                               QtGui.QFileDialog.ShowDirsOnly | QtGui.QFileDialog.DontUseNativeDialog)
             if directory:
                 fl = QtCore.QFile(directory + '/toxygen_inline_' + curr_time().replace(':', '_') + '.png')
                 self._pixmap.save(fl, 'PNG')

toxygen/loginscreen.py

@@ -83,7 +83,7 @@ class LoginScreen(CenteredWidget):
 
     def create_profile(self):
         self.type = 1
-        self.name = self.new_name.toPlainText()
+        self.name = self.new_name.text()
         self.close()
 
     def load_ex_profile(self):

toxygen/main.py

@@ -1,5 +1,6 @@
 import sys
 from loginscreen import LoginScreen
+import profile
 from settings import *
 try:
     from PySide import QtCore, QtGui
@@ -7,18 +8,15 @@ 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
+from util import curr_directory, program_version
 import styles.style
-import locale
 import toxencryptsave
-from passwordscreen import PasswordScreen
+from passwordscreen import PasswordScreen, UnlockAppScreen, SetProfilePasswordScreen
-import profile
 from plugin_support import PluginLoader
 
 
-class Toxygen(object):
+class Toxygen:
 
     def __init__(self, path_or_uri=None):
         super(Toxygen, self).__init__()
@@ -37,7 +35,7 @@ class Toxygen(object):
         Show password screen
         """
         tmp = [data]
-        p = PasswordScreen(toxencryptsave.LibToxEncryptSave.get_instance(), tmp)
+        p = PasswordScreen(toxencryptsave.ToxEncryptSave.get_instance(), tmp)
         p.show()
         self.app.connect(self.app, QtCore.SIGNAL("lastWindowClosed()"), self.app, QtCore.SLOT("quit()"))
         self.app.exec_()
@@ -59,16 +57,16 @@ class Toxygen(object):
             dark_style = fl.read()
         app.setStyleSheet(dark_style)
 
-        encrypt_save = toxencryptsave.LibToxEncryptSave()
+        encrypt_save = toxencryptsave.ToxEncryptSave()
 
         if self.path is not None:
-            path = os.path.dirname(self.path.encode(locale.getpreferredencoding())) + '/'
+            path = os.path.dirname(self.path) + '/'
-            name = os.path.basename(self.path.encode(locale.getpreferredencoding()))[:-4]
+            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)
+            self.tox = profile.tox_factory(data, settings)
         else:
             auto_profile = Settings.get_auto_profile()
             if not auto_profile[0]:
@@ -94,13 +92,41 @@ class Toxygen(object):
                 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()
+                    pr = map(lambda x: x[1], ProfileHelper.find_profiles())
-                    self.tox.self_set_name(_login.name if _login.name else 'Toxygen User')
+                    if name in list(pr):
-                    self.tox.self_set_status_message('Toxing on Toxygen')
+                        msgBox = QtGui.QMessageBox()
+                        msgBox.setWindowTitle(
+                            QtGui.QApplication.translate("MainWindow", "Error", None, QtGui.QApplication.UnicodeUTF8))
+                        text = (QtGui.QApplication.translate("MainWindow",
+                                                             'Profile with this name already exists',
+                                                             None, QtGui.QApplication.UnicodeUTF8))
+                        msgBox.setText(text)
+                        msgBox.exec_()
+                        return
+                    self.tox = profile.tox_factory()
+                    self.tox.self_set_name(bytes(_login.name, 'utf-8') if _login.name else b'Toxygen User')
+                    self.tox.self_set_status_message(b'Toxing on Toxygen')
+                    reply = QtGui.QMessageBox.question(None,
+                                                       'Profile {}'.format(name),
+                                                       QtGui.QApplication.translate("login",
+                                                                                    'Do you want to set profile password?',
+                                                                                    None,
+                                                                                    QtGui.QApplication.UnicodeUTF8),
+                                                       QtGui.QMessageBox.Yes,
+                                                       QtGui.QMessageBox.No)
+                    if reply == QtGui.QMessageBox.Yes:
+                        set_pass = SetProfilePasswordScreen(encrypt_save)
+                        set_pass.show()
+                        self.app.connect(self.app, QtCore.SIGNAL("lastWindowClosed()"), self.app, QtCore.SLOT("quit()"))
+                        self.app.exec_()
                     ProfileHelper(Settings.get_default_path(), name).save_profile(self.tox.get_savedata())
                     path = Settings.get_default_path()
                     settings = Settings(name)
+                    if curr_lang in langs:
+                        settings['language'] = curr_lang
+                    settings.save()
                 else:  # load existing profile
                     path, name = _login.get_data()
                     if _login.default:
@@ -109,20 +135,19 @@ class Toxygen(object):
                     if encrypt_save.is_data_encrypted(data):
                         data = self.enter_pass(data)
                     settings = Settings(name)
-                    self.tox = tox_factory(data, settings)
+                    self.tox = profile.tox_factory(data, settings)
             else:
                 path, name = auto_profile
-                path = path.encode(locale.getpreferredencoding())
                 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)
+                self.tox = profile.tox_factory(data, settings)
 
         if Settings.is_active_profile(path, name):  # profile is in use
             reply = QtGui.QMessageBox.question(None,
                                                'Profile {}'.format(name),
-                                               QtGui.QApplication.translate("login", 'Looks like other instance of Toxygen uses this profile! Continue?', None, QtGui.QApplication.UnicodeUTF8),
+                                               QtGui.QApplication.translate("login", 'Other instance of Toxygen uses this profile or profile was not properly closed. Continue?', None, QtGui.QApplication.UnicodeUTF8),
                                                QtGui.QMessageBox.Yes,
                                                QtGui.QMessageBox.No)
             if reply != QtGui.QMessageBox.Yes:
@@ -152,7 +177,7 @@ class Toxygen(object):
             def aboutToShow(self):
                 status = profile.Profile.get_instance().status
                 act = self.act
-                if status is None:
+                if status is None or Settings.get_instance().locked:
                     self.actions()[1].setVisible(False)
                 else:
                     self.actions()[1].setVisible(True)
@@ -160,6 +185,7 @@ class Toxygen(object):
                     act.actions()[1].setChecked(False)
                     act.actions()[2].setChecked(False)
                     act.actions()[status].setChecked(True)
+                self.actions()[2].setVisible(not Settings.get_instance().locked)
 
             def languageChange(self, *args, **kwargs):
                 self.actions()[0].setText(QtGui.QApplication.translate('tray', 'Open Toxygen', None, QtGui.QApplication.UnicodeUTF8))
@@ -182,10 +208,19 @@ class Toxygen(object):
         exit = m.addAction(QtGui.QApplication.translate('tray', 'Exit', None, QtGui.QApplication.UnicodeUTF8))
 
         def show_window():
-            if not self.ms.isActiveWindow():
+            def show():
-                self.ms.setWindowState(self.ms.windowState() & ~QtCore.Qt.WindowMinimized | QtCore.Qt.WindowActive)
+                if not self.ms.isActiveWindow():
-                self.ms.activateWindow()
+                    self.ms.setWindowState(self.ms.windowState() & ~QtCore.Qt.WindowMinimized | QtCore.Qt.WindowActive)
-            self.ms.show()
+                    self.ms.activateWindow()
+                self.ms.show()
+            if not Settings.get_instance().locked:
+                show()
+            else:
+                def correct_pass():
+                    show()
+                    Settings.get_instance().locked = False
+                self.p = UnlockAppScreen(toxencryptsave.ToxEncryptSave.get_instance(), correct_pass)
+                self.p.show()
 
         m.connect(show, QtCore.SIGNAL("triggered()"), show_window)
         m.connect(exit, QtCore.SIGNAL("triggered()"), lambda: app.exit())
@@ -244,7 +279,7 @@ class Toxygen(object):
         ProfileHelper.get_instance().save_profile(data)
         del self.tox
         # create new tox instance
-        self.tox = tox_factory(data, Settings.get_instance())
+        self.tox = profile.tox_factory(data, Settings.get_instance())
         # init thread
         self.init = self.InitThread(self.tox, self.ms, self.tray)
         self.init.start()
@@ -281,9 +316,10 @@ class Toxygen(object):
                     if self.stop:
                         return
                     self.tox.bootstrap(*data)
+                    self.tox.add_tcp_relay(*data)
             except:
                 pass
-            for _ in xrange(10):
+            for _ in range(10):
                 if self.stop:
                     return
                 self.msleep(1000)
@@ -293,6 +329,7 @@ class Toxygen(object):
                         if self.stop:
                             return
                         self.tox.bootstrap(*data)
+                        self.tox.add_tcp_relay(*data)
                 except:
                     pass
                 finally:
@@ -322,7 +359,7 @@ class Toxygen(object):
                 self.toxav.iterate()
                 self.msleep(self.toxav.iteration_interval())
 
-    class Login(object):
+    class Login:
 
         def __init__(self, arr):
             self.arr = arr
@@ -343,9 +380,56 @@ class Toxygen(object):
             return self.arr[self.num]
 
 
-if __name__ == '__main__':
+def clean():
+    """Removes all windows libs from libs folder"""
+    d = curr_directory() + '/libs/'
+    for fl in ('libtox64.dll', 'libtox.dll', 'libsodium64.a', 'libsodium.a'):
+        if os.path.exists(d + fl):
+            os.remove(d + fl)
+
+
+def configure():
+    """Removes unused libs"""
+    d = curr_directory() + '/libs/'
+    is_64bits = sys.maxsize > 2 ** 32
+    if not is_64bits:
+        if os.path.exists(d + 'libtox64.dll'):
+            os.remove(d + 'libtox64.dll')
+        if os.path.exists(d + 'libsodium64.a'):
+            os.remove(d + 'libsodium64.a')
+    else:
+        if os.path.exists(d + 'libtox.dll'):
+            os.remove(d + 'libtox.dll')
+        if os.path.exists(d + 'libsodium.a'):
+            os.remove(d + 'libsodium.a')
+        try:
+            os.rename(d + 'libtox64.dll', d + 'libtox.dll')
+            os.rename(d + 'libsodium64.a', d + 'libsodium.a')
+        except:
+            pass
+
+
+def main():
     if len(sys.argv) == 1:
         toxygen = Toxygen()
-    else:  # path to profile or tox: uri
+    else:  # started with argument(s)
-        toxygen = Toxygen(sys.argv[1])
+        arg = sys.argv[1]
+        if arg == '--version':
+            print('Toxygen ' + program_version)
+            return
+        elif arg == '--help':
+            print('Usage:\ntoxygen path_to_profile\ntoxygen tox_id\ntoxygen --version')
+            return
+        elif arg == '--configure':
+            configure()
+            return
+        elif arg == '--clean':
+            clean()
+            return
+        else:
+            toxygen = Toxygen(arg)
     toxygen.main()
+
+
+if __name__ == '__main__':
+    main()

toxygen/mainscreen.py

@@ -16,6 +16,8 @@ class MainWindow(QtGui.QMainWindow):
         self.tray = tray
         self.setAcceptDrops(True)
         self.initUI(tox)
+        if settings.Settings.get_instance()['show_welcome_screen']:
+            self.ws = WelcomeScreen()
 
     def setup_menu(self, MainWindow):
         self.menubar = QtGui.QMenuBar(MainWindow)
@@ -27,6 +29,8 @@ class MainWindow(QtGui.QMainWindow):
 
         self.menuProfile = QtGui.QMenu(self.menubar)
         self.menuProfile.setObjectName("menuProfile")
+        self.menuGroupChats = QtGui.QMenu(self.menubar)
+        self.menuGroupChats.setObjectName("menuGroupChats")
         self.menuSettings = QtGui.QMenu(self.menubar)
         self.menuSettings.setObjectName("menuSettings")
         self.menuPlugins = QtGui.QMenu(self.menubar)
@@ -36,8 +40,8 @@ class MainWindow(QtGui.QMainWindow):
 
         self.actionAdd_friend = QtGui.QAction(MainWindow)
         self.actionAdd_friend.setObjectName("actionAdd_friend")
-        self.actionProfile_settings = QtGui.QAction(MainWindow)
+        self.actionprofilesettings = QtGui.QAction(MainWindow)
-        self.actionProfile_settings.setObjectName("actionProfile_settings")
+        self.actionprofilesettings.setObjectName("actionprofilesettings")
         self.actionPrivacy_settings = QtGui.QAction(MainWindow)
         self.actionPrivacy_settings.setObjectName("actionPrivacy_settings")
         self.actionInterface_settings = QtGui.QAction(MainWindow)
@@ -52,16 +56,27 @@ class MainWindow(QtGui.QMainWindow):
         self.actionSettings.setObjectName("actionSettings")
         self.audioSettings = QtGui.QAction(MainWindow)
         self.pluginData = QtGui.QAction(MainWindow)
+        self.importPlugin = QtGui.QAction(MainWindow)
+        self.lockApp = QtGui.QAction(MainWindow)
+        self.createGC = QtGui.QAction(MainWindow)
+        self.joinGC = QtGui.QAction(MainWindow)
+        self.gcRequests = QtGui.QAction(MainWindow)
+        self.menuGroupChats.addAction(self.createGC)
+        self.menuGroupChats.addAction(self.joinGC)
+        self.menuGroupChats.addAction(self.gcRequests)
         self.menuProfile.addAction(self.actionAdd_friend)
         self.menuProfile.addAction(self.actionSettings)
+        self.menuProfile.addAction(self.lockApp)
         self.menuSettings.addAction(self.actionPrivacy_settings)
         self.menuSettings.addAction(self.actionInterface_settings)
         self.menuSettings.addAction(self.actionNotifications)
         self.menuSettings.addAction(self.actionNetwork)
         self.menuSettings.addAction(self.audioSettings)
         self.menuPlugins.addAction(self.pluginData)
+        self.menuPlugins.addAction(self.importPlugin)
         self.menuAbout.addAction(self.actionAbout_program)
         self.menubar.addAction(self.menuProfile.menuAction())
+        self.menubar.addAction(self.menuGroupChats.menuAction())
         self.menubar.addAction(self.menuSettings.menuAction())
         self.menubar.addAction(self.menuPlugins.menuAction())
         self.menubar.addAction(self.menuAbout.menuAction())
@@ -75,6 +90,12 @@ class MainWindow(QtGui.QMainWindow):
         self.actionNotifications.triggered.connect(self.notification_settings)
         self.audioSettings.triggered.connect(self.audio_settings)
         self.pluginData.triggered.connect(self.plugins_menu)
+
+        self.lockApp.triggered.connect(self.lock_app)
+        self.importPlugin.triggered.connect(self.import_plugin)
+        self.createGC.triggered.connect(self.create_groupchat)
+        self.joinGC.triggered.connect(self.join_groupchat)
+
         QtCore.QMetaObject.connectSlotsByName(MainWindow)
 
     def languageChange(self, *args, **kwargs):
@@ -86,13 +107,18 @@ class MainWindow(QtGui.QMainWindow):
         return super(MainWindow, self).event(event)
 
     def retranslateUi(self):
+        self.joinGC.setText(QtGui.QApplication.translate("MainWindow", "Join group chat", None, QtGui.QApplication.UnicodeUTF8))
+        self.lockApp.setText(QtGui.QApplication.translate("MainWindow", "Lock", None, QtGui.QApplication.UnicodeUTF8))
+        self.menuGroupChats.setTitle(QtGui.QApplication.translate("MainWindow", "Group chats", None, QtGui.QApplication.UnicodeUTF8))
+        self.createGC.setText(QtGui.QApplication.translate("MainWindow", "Create group chat", None, QtGui.QApplication.UnicodeUTF8))
+        self.gcRequests.setText(QtGui.QApplication.translate("MainWindow", "Groupchat requests", None, QtGui.QApplication.UnicodeUTF8))
         self.menuPlugins.setTitle(QtGui.QApplication.translate("MainWindow", "Plugins", None, QtGui.QApplication.UnicodeUTF8))
         self.pluginData.setText(QtGui.QApplication.translate("MainWindow", "List of plugins", None, QtGui.QApplication.UnicodeUTF8))
         self.menuProfile.setTitle(QtGui.QApplication.translate("MainWindow", "Profile", None, QtGui.QApplication.UnicodeUTF8))
         self.menuSettings.setTitle(QtGui.QApplication.translate("MainWindow", "Settings", None, QtGui.QApplication.UnicodeUTF8))
         self.menuAbout.setTitle(QtGui.QApplication.translate("MainWindow", "About", None, QtGui.QApplication.UnicodeUTF8))
         self.actionAdd_friend.setText(QtGui.QApplication.translate("MainWindow", "Add contact", None, QtGui.QApplication.UnicodeUTF8))
-        self.actionProfile_settings.setText(QtGui.QApplication.translate("MainWindow", "Profile", None, QtGui.QApplication.UnicodeUTF8))
+        self.actionprofilesettings.setText(QtGui.QApplication.translate("MainWindow", "Profile", None, QtGui.QApplication.UnicodeUTF8))
         self.actionPrivacy_settings.setText(QtGui.QApplication.translate("MainWindow", "Privacy", None, QtGui.QApplication.UnicodeUTF8))
         self.actionInterface_settings.setText(QtGui.QApplication.translate("MainWindow", "Interface", None, QtGui.QApplication.UnicodeUTF8))
         self.actionNotifications.setText(QtGui.QApplication.translate("MainWindow", "Notifications", None, QtGui.QApplication.UnicodeUTF8))
@@ -107,6 +133,7 @@ class MainWindow(QtGui.QMainWindow):
         self.online_contacts.addItem(QtGui.QApplication.translate("MainWindow", "All", None, QtGui.QApplication.UnicodeUTF8))
         self.online_contacts.addItem(QtGui.QApplication.translate("MainWindow", "Online", None, QtGui.QApplication.UnicodeUTF8))
         self.online_contacts.setCurrentIndex(int(Settings.get_instance()['show_online_friends']))
+        self.importPlugin.setText(QtGui.QApplication.translate("MainWindow", "Import plugin", None, QtGui.QApplication.UnicodeUTF8))
 
     def setup_right_bottom(self, Form):
         Form.resize(650, 60)
@@ -210,6 +237,11 @@ class MainWindow(QtGui.QMainWindow):
         font.setBold(False)
         self.account_status.setFont(font)
         self.account_status.setObjectName("account_status")
+
+        self.account_status.mouseReleaseEvent = self.show_chat_menu
+        self.account_name.mouseReleaseEvent = self.show_chat_menu
+        self.account_avatar.mouseReleaseEvent = self.show_chat_menu
+
         self.callButton = QtGui.QPushButton(Form)
         self.callButton.setGeometry(QtCore.QRect(550, 30, 50, 50))
         self.callButton.setObjectName("callButton")
@@ -387,15 +419,61 @@ class MainWindow(QtGui.QMainWindow):
         self.audio_s = AudioSettings()
         self.audio_s.show()
 
+    def import_plugin(self):
+        import util
+        directory = QtGui.QFileDialog.getExistingDirectory(self,
+                                                           QtGui.QApplication.translate("MainWindow", 'Choose folder with plugin',
+                                                                                        None,
+                                                                                        QtGui.QApplication.UnicodeUTF8),
+                                                           util.curr_directory(),
+                                                           QtGui.QFileDialog.ShowDirsOnly | QtGui.QFileDialog.DontUseNativeDialog)
+        if directory:
+            src = directory + '/'
+            dest = curr_directory() + '/plugins/'
+            util.copy(src, dest)
+            msgBox = QtGui.QMessageBox()
+            msgBox.setWindowTitle(
+                QtGui.QApplication.translate("MainWindow", "Restart Toxygen", None, QtGui.QApplication.UnicodeUTF8))
+            msgBox.setText(
+                QtGui.QApplication.translate("MainWindow", 'Plugin will be loaded after restart', None,
+                                             QtGui.QApplication.UnicodeUTF8))
+            msgBox.exec_()
+
+    def lock_app(self):
+        if toxencryptsave.ToxEncryptSave.get_instance().has_password():
+            Settings.get_instance().locked = True
+            self.hide()
+        else:
+            msgBox = QtGui.QMessageBox()
+            msgBox.setWindowTitle(
+                QtGui.QApplication.translate("MainWindow", "Cannot lock app", None, QtGui.QApplication.UnicodeUTF8))
+            msgBox.setText(
+                QtGui.QApplication.translate("MainWindow", 'Error. Profile password is not set.', None,
+                                             QtGui.QApplication.UnicodeUTF8))
+            msgBox.exec_()
+
     def show_menu(self):
         if not hasattr(self, 'menu'):
             self.menu = DropdownMenu(self)
         self.menu.setGeometry(QtCore.QRect(0 if Settings.get_instance()['mirror_mode'] else 270,
-                                           self.height() - 100,
+                                           self.height() - 120,
-                                           150,
+                                           180,
-                                           100))
+                                           120))
         self.menu.show()
 
+    def create_groupchat(self):
+        self.gc = AddGroupchat()
+        self.gc.show()
+
+    def join_groupchat(self):
+        self.gc = JoinGroupchat()
+        self.gc.show()
+
+    def show_chat_menu(self):
+        pr = Profile.get_instance()
+        if not pr.is_active_a_friend():
+            pass  # TODO: show list of users in chat
+
     # -----------------------------------------------------------------------------------------------------------------
     # Messages, calls and file transfers
     # -----------------------------------------------------------------------------------------------------------------
@@ -406,14 +484,18 @@ class MainWindow(QtGui.QMainWindow):
 
     def send_file(self):
         self.menu.hide()
+        if not self.profile.is_active_a_friend():
+            return
         if self.profile.active_friend + 1:
             choose = QtGui.QApplication.translate("MainWindow", 'Choose file', None, QtGui.QApplication.UnicodeUTF8)
-            name = QtGui.QFileDialog.getOpenFileName(self, choose)
+            name = QtGui.QFileDialog.getOpenFileName(self, choose, options=QtGui.QFileDialog.DontUseNativeDialog)
             if name[0]:
                 self.profile.send_file(name[0])
 
     def send_screenshot(self, hide=False):
         self.menu.hide()
+        if not self.profile.is_active_a_friend():
+            return
         if self.profile.active_friend + 1:
             self.sw = ScreenShotWindow(self)
             self.sw.show()
@@ -432,6 +514,8 @@ class MainWindow(QtGui.QMainWindow):
 
     def send_sticker(self):
         self.menu.hide()
+        if not self.profile.is_active_a_friend():
+            return
         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(),
@@ -468,29 +552,60 @@ class MainWindow(QtGui.QMainWindow):
     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)
+        friend = Profile.get_instance().get_friend_or_gc(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))
+            if type(friend) is Friend:
-            clear_history_item = self.listMenu.addAction(QtGui.QApplication.translate("MainWindow", 'Clear history', None, QtGui.QApplication.UnicodeUTF8))
+                arr = Profile.get_instance().get_all_gc()
-            copy_key_item = self.listMenu.addAction(QtGui.QApplication.translate("MainWindow", 'Copy public key', None, QtGui.QApplication.UnicodeUTF8))
+                if arr:
-            auto_accept_item = self.listMenu.addAction(auto)
+                    gc_menu = self.listMenu.addMenu(QtGui.QApplication.translate("MainWindow", 'Invite to group chat', None, QtGui.QApplication.UnicodeUTF8))
-            remove_item = self.listMenu.addAction(QtGui.QApplication.translate("MainWindow", 'Remove friend', None, QtGui.QApplication.UnicodeUTF8))
+                    for gc in arr:
-            notes_item = self.listMenu.addAction(QtGui.QApplication.translate("MainWindow", 'Notes', None, QtGui.QApplication.UnicodeUTF8))
+                        item = gc_menu.addAction(gc.name)
+                        self.connect(item, QtCore.SIGNAL("triggered()"),
+                                     lambda: Profile.get_instance().invite_friend(gc.number, friend.number))
+
+                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_menu = self.listMenu.addMenu(QtGui.QApplication.translate("MainWindow", 'Copy', None, QtGui.QApplication.UnicodeUTF8))
+                copy_name_item = copy_menu.addAction(QtGui.QApplication.translate("MainWindow", 'Name', None, QtGui.QApplication.UnicodeUTF8))
+                copy_status_item = copy_menu.addAction(QtGui.QApplication.translate("MainWindow", 'Status message', None, QtGui.QApplication.UnicodeUTF8))
+                copy_key_item = copy_menu.addAction(QtGui.QApplication.translate("MainWindow", 'Public key', None, QtGui.QApplication.UnicodeUTF8))
+
+                auto_accept_item = self.listMenu.addAction(auto)
+                remove_item = self.listMenu.addAction(QtGui.QApplication.translate("MainWindow", 'Remove friend', None, QtGui.QApplication.UnicodeUTF8))
+                notes_item = self.listMenu.addAction(QtGui.QApplication.translate("MainWindow", 'Notes', None, QtGui.QApplication.UnicodeUTF8))
+
+                submenu = plugin_support.PluginLoader.get_instance().get_menu(self.listMenu, num)
+                if len(submenu):
+                    plug = self.listMenu.addMenu(QtGui.QApplication.translate("MainWindow", 'Plugins', None, QtGui.QApplication.UnicodeUTF8))
+                    plug.addActions(submenu)
+                self.connect(remove_item, QtCore.SIGNAL("triggered()"), lambda: self.remove_friend(num))
+                self.connect(auto_accept_item, QtCore.SIGNAL("triggered()"), lambda: self.auto_accept(num, not allowed))
+            else:
+                copy_menu = self.listMenu.addMenu(
+                    QtGui.QApplication.translate("MainWindow", 'Copy', None, QtGui.QApplication.UnicodeUTF8))
+                copy_name_item = copy_menu.addAction(
+                    QtGui.QApplication.translate("MainWindow", 'Name', None, QtGui.QApplication.UnicodeUTF8))
+                copy_status_item = copy_menu.addAction(
+                    QtGui.QApplication.translate("MainWindow", 'Topic', None, QtGui.QApplication.UnicodeUTF8))
+                copy_key_item = copy_menu.addAction(
+                    QtGui.QApplication.translate("MainWindow", 'Public key', None, QtGui.QApplication.UnicodeUTF8))
+                leave_item = self.listMenu.addAction(QtGui.QApplication.translate("MainWindow", 'Leave group', None, QtGui.QApplication.UnicodeUTF8))
+                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))
+                notes_item = self.listMenu.addAction(QtGui.QApplication.translate("MainWindow", 'Notes', None, QtGui.QApplication.UnicodeUTF8))
+                self.connect(leave_item, QtCore.SIGNAL("triggered()"), lambda: Profile.get_instance().leave_group(num))
 
-            submenu = plugin_support.PluginLoader.get_instance().get_menu(self.listMenu, num)
-            if len(submenu):
-                plug = self.listMenu.addMenu(QtGui.QApplication.translate("MainWindow", 'Plugins', None, QtGui.QApplication.UnicodeUTF8))
-                plug.addActions(submenu)
-            self.connect(set_alias_item, QtCore.SIGNAL("triggered()"), lambda: self.set_alias(num))
-            self.connect(remove_item, QtCore.SIGNAL("triggered()"), lambda: self.remove_friend(num))
-            self.connect(copy_key_item, QtCore.SIGNAL("triggered()"), lambda: self.copy_friend_key(num))
-            self.connect(clear_history_item, QtCore.SIGNAL("triggered()"), lambda: self.clear_history(num))
-            self.connect(auto_accept_item, QtCore.SIGNAL("triggered()"), lambda: self.auto_accept(num, not allowed))
             self.connect(notes_item, QtCore.SIGNAL("triggered()"), lambda: self.show_note(friend))
+            self.connect(set_alias_item, QtCore.SIGNAL("triggered()"), lambda: self.set_alias(num))
+            self.connect(clear_history_item, QtCore.SIGNAL("triggered()"), lambda: self.clear_history(num))
+            self.connect(copy_name_item, QtCore.SIGNAL("triggered()"), lambda: self.copy_name(friend))
+            self.connect(copy_status_item, QtCore.SIGNAL("triggered()"), lambda: self.copy_status(friend))
+            self.connect(copy_key_item, QtCore.SIGNAL("triggered()"), lambda: self.copy_friend_key(num))
+
             parent_position = self.friends_list.mapToGlobal(QtCore.QPoint(0, 0))
             self.listMenu.move(parent_position + pos)
             self.listMenu.show()
@@ -499,7 +614,7 @@ class MainWindow(QtGui.QMainWindow):
         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 = u'{} {}'.format(user, friend.name)
+        user = '{} {}'.format(user, friend.name)
 
         def save_note(text):
             if friend.tox_id in s['notes']:
@@ -514,13 +629,21 @@ class MainWindow(QtGui.QMainWindow):
         self.profile.set_alias(num)
 
     def remove_friend(self, num):
-        self.profile.delete_friend(num)
+        self.profile.delete_friend_or_gc(num)
 
     def copy_friend_key(self, num):
         tox_id = self.profile.friend_public_key(num)
         clipboard = QtGui.QApplication.clipboard()
         clipboard.setText(tox_id)
 
+    def copy_name(self, friend):
+        clipboard = QtGui.QApplication.clipboard()
+        clipboard.setText(friend.name)
+
+    def copy_status(self, friend):
+        clipboard = QtGui.QApplication.clipboard()
+        clipboard.setText(friend.status_message)
+
     def clear_history(self, num):
         self.profile.clear_history(num)
 

toxygen/mainscreen_widgets.py

@@ -2,7 +2,7 @@ try:
     from PySide import QtCore, QtGui
 except ImportError:
     from PyQt4 import QtCore, QtGui
-from widgets import RubberBand, create_menu, QRightClickButton
+from widgets import RubberBand, create_menu, QRightClickButton, CenteredWidget
 from profile import Profile
 import smileys
 import util
@@ -99,7 +99,6 @@ class ScreenShotWindow(QtGui.QWidget):
         if self.rubberband.isVisible():
             self.rubberband.hide()
             rect = self.rubberband.geometry()
-            print rect
             if rect.width() and rect.height():
                 p = QtGui.QPixmap.grabWindow(QtGui.QApplication.desktop().winId(),
                                              rect.x() + 4,
@@ -110,7 +109,7 @@ class ScreenShotWindow(QtGui.QWidget):
                 buffer = QtCore.QBuffer(byte_array)
                 buffer.open(QtCore.QIODevice.WriteOnly)
                 p.save(buffer, 'PNG')
-                Profile.get_instance().send_screenshot(str(byte_array.data()))
+                Profile.get_instance().send_screenshot(bytes(byte_array.data()))
             self.close()
 
     def keyPressEvent(self, event):
@@ -132,12 +131,14 @@ class SmileyWindow(QtGui.QWidget):
         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
+            self.page_count = count // self.page_size
         else:
-            self.page_count = int(count / float(self.page_size) + 0.5)
+            self.page_count = round(count / self.page_size + 0.5)
-        self.page = 0
+        self.page = -1
         self.radio = []
         self.parent = parent
         for i in range(self.page_count):  # buttons with smileys
@@ -145,13 +146,13 @@ class SmileyWindow(QtGui.QWidget):
             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)
+        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.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)
@@ -197,52 +198,52 @@ class DropdownMenu(QtGui.QWidget):
         super(DropdownMenu, self).__init__(parent)
         self.installEventFilter(self)
         self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
-        self.setMaximumSize(150, 100)
+        self.setMaximumSize(180, 120)
-        self.setMinimumSize(150, 100)
+        self.setMinimumSize(180, 120)
         self.screenshotButton = QRightClickButton(self)
-        self.screenshotButton.setGeometry(QtCore.QRect(0, 50, 50, 50))
+        self.screenshotButton.setGeometry(QtCore.QRect(0, 60, 60, 60))
         self.screenshotButton.setObjectName("screenshotButton")
 
         self.fileTransferButton = QtGui.QPushButton(self)
-        self.fileTransferButton.setGeometry(QtCore.QRect(50, 50, 50, 50))
+        self.fileTransferButton.setGeometry(QtCore.QRect(60, 60, 60, 60))
         self.fileTransferButton.setObjectName("fileTransferButton")
 
         self.audioMessageButton = QtGui.QPushButton(self)
-        self.audioMessageButton.setGeometry(QtCore.QRect(100, 50, 50, 50))
+        self.audioMessageButton.setGeometry(QtCore.QRect(120, 60, 60, 60))
 
         self.smileyButton = QtGui.QPushButton(self)
-        self.smileyButton.setGeometry(QtCore.QRect(0, 0, 50, 50))
+        self.smileyButton.setGeometry(QtCore.QRect(0, 0, 60, 60))
 
         self.videoMessageButton = QtGui.QPushButton(self)
-        self.videoMessageButton.setGeometry(QtCore.QRect(100, 0, 50, 50))
+        self.videoMessageButton.setGeometry(QtCore.QRect(120, 0, 60, 60))
 
         self.stickerButton = QtGui.QPushButton(self)
-        self.stickerButton.setGeometry(QtCore.QRect(50, 0, 50, 50))
+        self.stickerButton.setGeometry(QtCore.QRect(60, 0, 60, 60))
 
         pixmap = QtGui.QPixmap(util.curr_directory() + '/images/file.png')
         icon = QtGui.QIcon(pixmap)
         self.fileTransferButton.setIcon(icon)
-        self.fileTransferButton.setIconSize(QtCore.QSize(40, 40))
+        self.fileTransferButton.setIconSize(QtCore.QSize(50, 50))
         pixmap = QtGui.QPixmap(util.curr_directory() + '/images/screenshot.png')
         icon = QtGui.QIcon(pixmap)
         self.screenshotButton.setIcon(icon)
-        self.screenshotButton.setIconSize(QtCore.QSize(40, 50))
+        self.screenshotButton.setIconSize(QtCore.QSize(50, 60))
         pixmap = QtGui.QPixmap(util.curr_directory() + '/images/audio_message.png')
         icon = QtGui.QIcon(pixmap)
         self.audioMessageButton.setIcon(icon)
-        self.audioMessageButton.setIconSize(QtCore.QSize(40, 40))
+        self.audioMessageButton.setIconSize(QtCore.QSize(50, 50))
         pixmap = QtGui.QPixmap(util.curr_directory() + '/images/smiley.png')
         icon = QtGui.QIcon(pixmap)
         self.smileyButton.setIcon(icon)
-        self.smileyButton.setIconSize(QtCore.QSize(40, 40))
+        self.smileyButton.setIconSize(QtCore.QSize(50, 50))
         pixmap = QtGui.QPixmap(util.curr_directory() + '/images/video_message.png')
         icon = QtGui.QIcon(pixmap)
         self.videoMessageButton.setIcon(icon)
-        self.videoMessageButton.setIconSize(QtCore.QSize(45, 45))
+        self.videoMessageButton.setIconSize(QtCore.QSize(55, 55))
         pixmap = QtGui.QPixmap(util.curr_directory() + '/images/sticker.png')
         icon = QtGui.QIcon(pixmap)
         self.stickerButton.setIcon(icon)
-        self.stickerButton.setIconSize(QtCore.QSize(45, 45))
+        self.stickerButton.setIconSize(QtCore.QSize(55, 55))
 
         self.screenshotButton.setToolTip(QtGui.QApplication.translate("MenuWindow", "Send screenshot", None, QtGui.QApplication.UnicodeUTF8))
         self.fileTransferButton.setToolTip(QtGui.QApplication.translate("MenuWindow", "Send file", None, QtGui.QApplication.UnicodeUTF8))
@@ -311,3 +312,67 @@ class StickerWindow(QtGui.QWidget):
         self.close()
 
 
+class WelcomeScreen(CenteredWidget):
+
+    def __init__(self):
+        super().__init__()
+        self.setMaximumSize(250, 200)
+        self.setMinimumSize(250, 200)
+        self.center()
+        self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
+        self.text = QtGui.QTextBrowser(self)
+        self.text.setGeometry(QtCore.QRect(0, 0, 250, 170))
+        self.text.setOpenExternalLinks(True)
+        self.checkbox = QtGui.QCheckBox(self)
+        self.checkbox.setGeometry(QtCore.QRect(5, 170, 240, 30))
+        self.checkbox.setText(QtGui.QApplication.translate('WelcomeScreen', "Don't show again",
+                                                           None, QtGui.QApplication.UnicodeUTF8))
+        self.setWindowTitle(QtGui.QApplication.translate('WelcomeScreen', 'Tip of the day',
+                                                         None, QtGui.QApplication.UnicodeUTF8))
+        import random
+        num = random.randint(0, 8)
+        if num == 0:
+            text = QtGui.QApplication.translate('WelcomeScreen', 'Press Esc if you want hide app to tray.',
+                                                None, QtGui.QApplication.UnicodeUTF8)
+        elif num == 1:
+            text = QtGui.QApplication.translate('WelcomeScreen',
+                                                'Right click on screenshot button hides app to tray during screenshot.',
+                                                None, QtGui.QApplication.UnicodeUTF8)
+        elif num == 2:
+            text = QtGui.QApplication.translate('WelcomeScreen',
+                                                'You can use Tox over Tor. For more info read <a href="https://wiki.tox.chat/users/tox_over_tor_tot">this post</a>',
+                                                None, QtGui.QApplication.UnicodeUTF8)
+        elif num == 3:
+            text = QtGui.QApplication.translate('WelcomeScreen',
+                                                'Use Settings -> Interface to customize interface.',
+                                                None, QtGui.QApplication.UnicodeUTF8)
+        elif num == 4:
+            text = QtGui.QApplication.translate('WelcomeScreen',
+                                                'Set profile password via Profile -> Settings. Password allows Toxygen encrypt your history and settings.',
+                                                None, QtGui.QApplication.UnicodeUTF8)
+        elif num == 5:
+            text = QtGui.QApplication.translate('WelcomeScreen',
+                                                'Since v0.1.3 Toxygen supports plugins. <a href="https://github.com/xveduk/toxygen/blob/master/docs/plugins.md">Read more</a>',
+                                                None, QtGui.QApplication.UnicodeUTF8)
+        elif num == 6:
+            text = QtGui.QApplication.translate('WelcomeScreen',
+                                                'New in Toxygen v0.2.2:<br>Users can lock application using profile password.<br>Compact contact list support<br>Bug fixes<br>Tox DNS improvements',
+                                                None, QtGui.QApplication.UnicodeUTF8)
+        elif num == 7:
+            text = QtGui.QApplication.translate('WelcomeScreen',
+                                                'Toxygen supports faux offline messages and file transfers. Send message or file to offline friend and he will get it later.',
+                                                None, QtGui.QApplication.UnicodeUTF8)
+        else:
+            text = QtGui.QApplication.translate('WelcomeScreen',
+                                                'Set new NoSpam to avoid spam friend requests: Profile -> Settings -> Set new NoSpam.',
+                                                None, QtGui.QApplication.UnicodeUTF8)
+        self.text.setHtml(text)
+        self.checkbox.stateChanged.connect(self.not_show)
+        QtCore.QTimer.singleShot(1000, self.show)
+
+    def not_show(self):
+        import settings
+        s = settings.Settings.get_instance()
+        s['show_welcome_screen'] = False
+        s.save()
+

toxygen/menu.py

@@ -4,19 +4,111 @@ except ImportError:
     from PyQt4 import QtCore, QtGui
 from settings import *
 from profile import Profile
-from util import curr_directory
+from util import curr_directory, copy
 from widgets import CenteredWidget, DataLabel, LineEdit
 import pyaudio
 import toxencryptsave
 import plugin_support
 
 
+class AddGroupchat(CenteredWidget):
+
+    def __init__(self):
+        super().__init__()
+        self.initUI()
+        self.retranslateUi()
+        self.center()
+
+    def initUI(self):
+        self.setObjectName('AddGC')
+        self.resize(570, 240)
+        self.setMaximumSize(QtCore.QSize(570, 240))
+        self.setMinimumSize(QtCore.QSize(570, 240))
+        self.label = QtGui.QLabel(self)
+        self.label.setGeometry(QtCore.QRect(50, 20, 470, 20))
+        self.createGCButton = QtGui.QPushButton(self)
+        self.createGCButton.setGeometry(QtCore.QRect(50, 190, 470, 30))
+        self.name = LineEdit(self)
+        self.name.setGeometry(QtCore.QRect(50, 40, 470, 27))
+        self.privacy_type = QtGui.QLabel(self)
+        self.privacy_type.setGeometry(QtCore.QRect(50, 70, 470, 20))
+        self.privacy_combobox = QtGui.QComboBox(self)
+        self.privacy_combobox.setGeometry(QtCore.QRect(50, 90, 470, 30))
+        self.pass_label = QtGui.QLabel(self)
+        self.pass_label.setGeometry(QtCore.QRect(50, 130, 470, 20))
+        self.password = LineEdit(self)
+        self.password.setGeometry(QtCore.QRect(50, 150, 470, 27))
+        self.password.setEchoMode(QtGui.QLineEdit.EchoMode.Password)
+
+        self.createGCButton.clicked.connect(self.button_click)
+        QtCore.QMetaObject.connectSlotsByName(self)
+
+    def retranslateUi(self):
+        self.setWindowTitle(QtGui.QApplication.translate('AddGC', "Create group chat", None, QtGui.QApplication.UnicodeUTF8))
+        self.createGCButton.setText(QtGui.QApplication.translate("AddGC", "Create", None, QtGui.QApplication.UnicodeUTF8))
+        self.label.setText(QtGui.QApplication.translate('AddGC', "Name:", None, QtGui.QApplication.UnicodeUTF8))
+        self.privacy_type.setText(QtGui.QApplication.translate('AddGC', "Privacy type:", None, QtGui.QApplication.UnicodeUTF8))
+        self.privacy_combobox.addItem(QtGui.QApplication.translate('AddGC', "Public", None, QtGui.QApplication.UnicodeUTF8))
+        self.privacy_combobox.addItem(QtGui.QApplication.translate('AddGC', "Private", None, QtGui.QApplication.UnicodeUTF8))
+        self.name.setPlaceholderText(QtGui.QApplication.translate('AddGC', "Not empty group name", None, QtGui.QApplication.UnicodeUTF8))
+        self.password.setPlaceholderText(QtGui.QApplication.translate('AddGC', "Optional password", None, QtGui.QApplication.UnicodeUTF8))
+        self.pass_label.setText(QtGui.QApplication.translate('AddGC', "Password:", None, QtGui.QApplication.UnicodeUTF8))
+
+    def button_click(self):
+        if self.name.text():
+            Profile.get_instance().create_gc(self.name.text(),
+                                             self.privacy_combobox.currentIndex() == 0,
+                                             self.password.text())
+            self.close()
+
+
+class JoinGroupchat(CenteredWidget):
+
+    def __init__(self):
+        super().__init__()
+        self.initUI()
+        self.retranslateUi()
+        self.center()
+
+    def initUI(self):
+        self.setObjectName('AddGC')
+        self.resize(570, 150)
+        self.setMaximumSize(QtCore.QSize(570, 150))
+        self.setMinimumSize(QtCore.QSize(570, 150))
+        self.joinGCButton = QtGui.QPushButton(self)
+        self.joinGCButton.setGeometry(QtCore.QRect(50, 110, 470, 30))
+        self.id = LineEdit(self)
+        self.id.setGeometry(QtCore.QRect(50, 10, 470, 30))
+        self.password = LineEdit(self)
+        self.password.setGeometry(QtCore.QRect(50, 50, 470, 30))
+        self.password.setEchoMode(QtGui.QLineEdit.EchoMode.Password)
+
+        self.joinGCButton.clicked.connect(self.button_click)
+        QtCore.QMetaObject.connectSlotsByName(self)
+
+    def retranslateUi(self):
+        self.setWindowTitle(
+            QtGui.QApplication.translate('JoinGC', "Join group chat", None, QtGui.QApplication.UnicodeUTF8))
+        self.joinGCButton.setText(
+            QtGui.QApplication.translate("JoinGC", "Join", None, QtGui.QApplication.UnicodeUTF8))
+        self.id.setPlaceholderText(
+            QtGui.QApplication.translate('JoinGC', "Group ID", None, QtGui.QApplication.UnicodeUTF8))
+        self.password.setPlaceholderText(
+            QtGui.QApplication.translate('JoinGC', "Optional password", None, QtGui.QApplication.UnicodeUTF8))
+
+    def button_click(self):
+        if self.id.text():
+            Profile.get_instance().join_gc(self.id.text().strip(), self.password.text())
+            self.close()
+
+
 class AddContact(CenteredWidget):
     """Add contact form"""
 
     def __init__(self, tox_id=''):
         super(AddContact, self).__init__()
         self.initUI(tox_id)
+        self._adding = False
 
     def initUI(self, tox_id):
         self.setObjectName('AddContact')
@@ -58,8 +150,12 @@ class AddContact(CenteredWidget):
         QtCore.QMetaObject.connectSlotsByName(self)
 
     def add_friend(self):
+        if self._adding:
+            return
+        self._adding = True
         profile = Profile.get_instance()
-        send = profile.send_friend_request(self.tox_id.text(), self.message_edit.toPlainText())
+        send = profile.send_friend_request(self.tox_id.text().strip(), self.message_edit.toPlainText())
+        self._adding = False
         if send is True:
             # request was successful
             self.close()
@@ -122,17 +218,19 @@ class ProfileSettings(CenteredWidget):
         self.new_nospam = QtGui.QPushButton(self)
         self.new_nospam.setGeometry(QtCore.QRect(420, 250, 180, 30))
         self.new_nospam.clicked.connect(self.new_no_spam)
-
+        self.copy_pk = QtGui.QPushButton(self)
+        self.copy_pk.setGeometry(QtCore.QRect(40, 300, 180, 30))
+        self.copy_pk.clicked.connect(self.copy_public_key)
         self.new_avatar = QtGui.QPushButton(self)
-        self.new_avatar.setGeometry(QtCore.QRect(40, 300, 180, 30))
+        self.new_avatar.setGeometry(QtCore.QRect(230, 300, 180, 30))
         self.delete_avatar = QtGui.QPushButton(self)
-        self.delete_avatar.setGeometry(QtCore.QRect(230, 300, 180, 30))
+        self.delete_avatar.setGeometry(QtCore.QRect(420, 300, 180, 30))
         self.delete_avatar.clicked.connect(self.reset_avatar)
         self.new_avatar.clicked.connect(self.set_avatar)
-        self.profile_pass = QtGui.QLabel(self)
+        self.profilepass = QtGui.QLabel(self)
-        self.profile_pass.setGeometry(QtCore.QRect(40, 340, 300, 30))
+        self.profilepass.setGeometry(QtCore.QRect(40, 340, 300, 30))
         font.setPointSize(18)
-        self.profile_pass.setFont(font)
+        self.profilepass.setFont(font)
         self.password = LineEdit(self)
         self.password.setGeometry(QtCore.QRect(40, 380, 300, 30))
         self.password.setEchoMode(QtGui.QLineEdit.EchoMode.Password)
@@ -173,7 +271,7 @@ class ProfileSettings(CenteredWidget):
         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.profilepass.setText(QtGui.QApplication.translate("ProfileSettingsForm", "Profile password", None, QtGui.QApplication.UnicodeUTF8))
         self.password.setPlaceholderText(QtGui.QApplication.translate("ProfileSettingsForm", "Password (at least 8 symbols)", None, QtGui.QApplication.UnicodeUTF8))
         self.confirm_password.setPlaceholderText(QtGui.QApplication.translate("ProfileSettingsForm", "Confirm password", None, QtGui.QApplication.UnicodeUTF8))
         self.set_password.setText(QtGui.QApplication.translate("ProfileSettingsForm", "Set password", None, QtGui.QApplication.UnicodeUTF8))
@@ -183,6 +281,7 @@ class ProfileSettings(CenteredWidget):
         self.status.addItem(QtGui.QApplication.translate("ProfileSettingsForm", "Online", None, QtGui.QApplication.UnicodeUTF8))
         self.status.addItem(QtGui.QApplication.translate("ProfileSettingsForm", "Away", None, QtGui.QApplication.UnicodeUTF8))
         self.status.addItem(QtGui.QApplication.translate("ProfileSettingsForm", "Busy", None, QtGui.QApplication.UnicodeUTF8))
+        self.copy_pk.setText(QtGui.QApplication.translate("ProfileSettingsForm", "Copy public key", None, QtGui.QApplication.UnicodeUTF8))
         if self.auto:
             self.default.setText(QtGui.QApplication.translate("ProfileSettingsForm", "Mark as not default profile", None, QtGui.QApplication.UnicodeUTF8))
         else:
@@ -205,7 +304,7 @@ class ProfileSettings(CenteredWidget):
     def new_password(self):
         if self.password.text() == self.confirm_password.text():
             if not len(self.password.text()) or len(self.password.text()) >= 8:
-                e = toxencryptsave.LibToxEncryptSave.get_instance()
+                e = toxencryptsave.ToxEncryptSave.get_instance()
                 e.set_password(self.password.text())
                 self.close()
             else:
@@ -227,6 +326,15 @@ class ProfileSettings(CenteredWidget):
         self.copyId.setIcon(icon)
         self.copyId.setIconSize(QtCore.QSize(10, 10))
 
+    def copy_public_key(self):
+        clipboard = QtGui.QApplication.clipboard()
+        profile = Profile.get_instance()
+        clipboard.setText(profile.tox_id[:64])
+        pixmap = QtGui.QPixmap(curr_directory() + '/images/accept.png')
+        icon = QtGui.QIcon(pixmap)
+        self.copy_pk.setIcon(icon)
+        self.copy_pk.setIconSize(QtCore.QSize(10, 10))
+
     def new_no_spam(self):
         self.tox_id.setText(Profile.get_instance().new_nospam())
 
@@ -235,7 +343,8 @@ class ProfileSettings(CenteredWidget):
 
     def set_avatar(self):
         choose = QtGui.QApplication.translate("ProfileSettingsForm", "Choose avatar", None, QtGui.QApplication.UnicodeUTF8)
-        name = QtGui.QFileDialog.getOpenFileName(self, choose, None, 'Images (*.png)')
+        name = QtGui.QFileDialog.getOpenFileName(self, choose, None, 'Images (*.png)',
+                                                 options=QtGui.QFileDialog.DontUseNativeDialog)
         if name[0]:
             bitmap = QtGui.QPixmap(name[0])
             bitmap.scaled(QtCore.QSize(128, 128), aspectMode=QtCore.Qt.KeepAspectRatio,
@@ -248,7 +357,7 @@ class ProfileSettings(CenteredWidget):
             Profile.get_instance().set_avatar(str(byte_array.data()))
 
     def export_profile(self):
-        directory = QtGui.QFileDialog.getExistingDirectory() + '/'
+        directory = QtGui.QFileDialog.getExistingDirectory(options=QtGui.QFileDialog.DontUseNativeDialog) + '/'
         if directory != '/':
             ProfileHelper.get_instance().export_profile(directory)
             settings = Settings.get_instance()
@@ -258,7 +367,7 @@ class ProfileSettings(CenteredWidget):
 
     def closeEvent(self, event):
         profile = Profile.get_instance()
-        profile.set_name(self.nick.text().encode('utf-8'))
+        profile.set_name(self.nick.text())
         profile.set_status_message(self.status_message.text().encode('utf-8'))
         profile.set_status(self.status.currentIndex())
 
@@ -306,7 +415,7 @@ class NetworkSettings(CenteredWidget):
         self.udp.setChecked(settings['udp_enabled'])
         self.proxy.setChecked(settings['proxy_type'])
         self.proxyip.setText(settings['proxy_host'])
-        self.proxyport.setText(unicode(settings['proxy_port']))
+        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))
@@ -360,45 +469,51 @@ class PrivacySettings(CenteredWidget):
 
     def initUI(self):
         self.setObjectName("privacySettings")
-        self.resize(350, 550)
+        self.resize(370, 600)
-        self.setMinimumSize(QtCore.QSize(350, 550))
+        self.setMinimumSize(QtCore.QSize(370, 600))
-        self.setMaximumSize(QtCore.QSize(350, 550))
+        self.setMaximumSize(QtCore.QSize(370, 600))
         self.saveHistory = QtGui.QCheckBox(self)
-        self.saveHistory.setGeometry(QtCore.QRect(10, 20, 291, 22))
+        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, 60, 271, 22))
+        self.fileautoaccept.setGeometry(QtCore.QRect(10, 100, 350, 22))
 
         self.typingNotifications = QtGui.QCheckBox(self)
-        self.typingNotifications.setGeometry(QtCore.QRect(10, 100, 350, 30))
+        self.typingNotifications.setGeometry(QtCore.QRect(10, 140, 350, 30))
         self.inlines = QtGui.QCheckBox(self)
-        self.inlines.setGeometry(QtCore.QRect(10, 140, 350, 30))
+        self.inlines.setGeometry(QtCore.QRect(10, 180, 350, 30))
         self.auto_path = QtGui.QLabel(self)
-        self.auto_path.setGeometry(QtCore.QRect(10, 190, 350, 30))
+        self.auto_path.setGeometry(QtCore.QRect(10, 230, 350, 30))
         self.path = QtGui.QPlainTextEdit(self)
-        self.path.setGeometry(QtCore.QRect(10, 225, 330, 45))
+        self.path.setGeometry(QtCore.QRect(10, 265, 350, 45))
         self.change_path = QtGui.QPushButton(self)
-        self.change_path.setGeometry(QtCore.QRect(10, 280, 330, 30))
+        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, 320, 330, 30))
+        self.block_user_label.setGeometry(QtCore.QRect(10, 360, 350, 30))
         self.block_id = QtGui.QPlainTextEdit(self)
-        self.block_id.setGeometry(QtCore.QRect(10, 350, 330, 30))
+        self.block_id.setGeometry(QtCore.QRect(10, 390, 350, 30))
         self.block = QtGui.QPushButton(self)
-        self.block.setGeometry(QtCore.QRect(10, 390, 330, 30))
+        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, 430, 330, 30))
+        self.blocked_users_label.setGeometry(QtCore.QRect(10, 470, 350, 30))
         self.comboBox = QtGui.QComboBox(self)
-        self.comboBox.setGeometry(QtCore.QRect(10, 460, 330, 30))
+        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, 500, 330, 30))
+        self.unblock.setGeometry(QtCore.QRect(10, 540, 350, 30))
         self.unblock.clicked.connect(lambda: self.unblock_user())
         self.retranslateUi()
         QtCore.QMetaObject.connectSlotsByName(self)
@@ -415,6 +530,12 @@ class PrivacySettings(CenteredWidget):
         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():
@@ -429,6 +550,7 @@ class PrivacySettings(CenteredWidget):
         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",
@@ -444,12 +566,27 @@ class PrivacySettings(CenteredWidget):
                 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() + '/'
+        directory = QtGui.QFileDialog.getExistingDirectory(options=QtGui.QFileDialog.DontUseNativeDialog) + '/'
         if directory != '/':
             self.path.setPlainText(directory)
 
@@ -464,28 +601,33 @@ class NotificationsSettings(CenteredWidget):
 
     def initUI(self):
         self.setObjectName("notificationsForm")
-        self.resize(350, 180)
+        self.resize(350, 200)
-        self.setMinimumSize(QtCore.QSize(350, 180))
+        self.setMinimumSize(QtCore.QSize(350, 200))
-        self.setMaximumSize(QtCore.QSize(350, 180))
+        self.setMaximumSize(QtCore.QSize(350, 200))
         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))
+        self.gcNotifications = QtGui.QCheckBox(self)
+        self.gcNotifications.setGeometry(QtCore.QRect(10, 170, 340, 18))
         font = QtGui.QFont()
         font.setPointSize(12)
         self.callsSound.setFont(font)
         self.soundNotifications.setFont(font)
         self.enableNotifications.setFont(font)
+        self.gcNotifications.setFont(font)
         s = Settings.get_instance()
         self.enableNotifications.setChecked(s['notifications'])
         self.soundNotifications.setChecked(s['sound_notifications'])
         self.callsSound.setChecked(s['calls_sound'])
+        self.gcNotifications.setChecked(s['notify_all_gc'])
         self.retranslateUi()
         QtCore.QMetaObject.connectSlotsByName(self)
 
     def retranslateUi(self):
+        self.gcNotifications.setText(QtGui.QApplication.translate("notificationsForm", "Enable group chat notifications", None, QtGui.QApplication.UnicodeUTF8))
         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))
@@ -496,6 +638,7 @@ class NotificationsSettings(CenteredWidget):
         settings['notifications'] = self.enableNotifications.isChecked()
         settings['sound_notifications'] = self.soundNotifications.isChecked()
         settings['calls_sound'] = self.callsSound.isChecked()
+        settings['notify_all_gc'] = self.gcNotifications.isChecked()
         settings.save()
 
 
@@ -508,8 +651,8 @@ class InterfaceSettings(CenteredWidget):
 
     def initUI(self):
         self.setObjectName("interfaceForm")
-        self.setMinimumSize(QtCore.QSize(400, 450))
+        self.setMinimumSize(QtCore.QSize(400, 550))
-        self.setMaximumSize(QtCore.QSize(400, 450))
+        self.setMaximumSize(QtCore.QSize(400, 550))
         self.label = QtGui.QLabel(self)
         self.label.setGeometry(QtCore.QRect(30, 10, 370, 20))
         font = QtGui.QFont()
@@ -529,7 +672,7 @@ class InterfaceSettings(CenteredWidget):
         self.themeSelect.setCurrentIndex(index)
         self.lang_choose = QtGui.QComboBox(self)
         self.lang_choose.setGeometry(QtCore.QRect(30, 110, 120, 30))
-        supported = Settings.supported_languages()
+        supported = sorted(Settings.supported_languages().keys(), reverse=True)
         for key in supported:
             self.lang_choose.insertItem(0, key)
             if settings['language'] == key:
@@ -564,9 +707,21 @@ class InterfaceSettings(CenteredWidget):
         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.setGeometry(QtCore.QRect(30, 425, 340, 30))
         self.unread.clicked.connect(self.select_color)
 
+        self.compact_mode = QtGui.QCheckBox(self)
+        self.compact_mode.setGeometry(QtCore.QRect(30, 380, 370, 20))
+        self.compact_mode.setChecked(settings['compact_mode'])
+
+        self.import_smileys = QtGui.QPushButton(self)
+        self.import_smileys.setGeometry(QtCore.QRect(30, 465, 340, 30))
+        self.import_smileys.clicked.connect(self.import_sm)
+
+        self.import_stickers = QtGui.QPushButton(self)
+        self.import_stickers.setGeometry(QtCore.QRect(30, 505, 340, 30))
+        self.import_stickers.clicked.connect(self.import_st)
+
         self.retranslateUi()
         QtCore.QMetaObject.connectSlotsByName(self)
 
@@ -579,6 +734,37 @@ class InterfaceSettings(CenteredWidget):
         self.mirror_mode.setText(QtGui.QApplication.translate("interfaceForm", "Mirror mode", None, QtGui.QApplication.UnicodeUTF8))
         self.messages_font_size_label.setText(QtGui.QApplication.translate("interfaceForm", "Messages font size:", None, QtGui.QApplication.UnicodeUTF8))
         self.unread.setText(QtGui.QApplication.translate("interfaceForm", "Select unread messages notification color", None, QtGui.QApplication.UnicodeUTF8))
+        self.compact_mode.setText(QtGui.QApplication.translate("interfaceForm", "Compact contact list", None, QtGui.QApplication.UnicodeUTF8))
+        self.import_smileys.setText(QtGui.QApplication.translate("interfaceForm", "Import smiley pack", None, QtGui.QApplication.UnicodeUTF8))
+        self.import_stickers.setText(QtGui.QApplication.translate("interfaceForm", "Import sticker pack", None, QtGui.QApplication.UnicodeUTF8))
+
+    def import_st(self):
+        directory = QtGui.QFileDialog.getExistingDirectory(self,
+                                                           QtGui.QApplication.translate("MainWindow",
+                                                                                        'Choose folder with sticker pack',
+                                                                                        None,
+                                                                                        QtGui.QApplication.UnicodeUTF8),
+                                                           curr_directory(),
+                                                           QtGui.QFileDialog.ShowDirsOnly | QtGui.QFileDialog.DontUseNativeDialog)
+
+        if directory:
+            src = directory + '/'
+            dest = curr_directory() + '/stickers/' + os.path.basename(directory) + '/'
+            copy(src, dest)
+
+    def import_sm(self):
+        directory = QtGui.QFileDialog.getExistingDirectory(self,
+                                                           QtGui.QApplication.translate("MainWindow",
+                                                                                        'Choose folder with smiley pack',
+                                                                                        None,
+                                                                                        QtGui.QApplication.UnicodeUTF8),
+                                                           curr_directory(),
+                                                           QtGui.QFileDialog.ShowDirsOnly | QtGui.QFileDialog.DontUseNativeDialog)
+
+        if directory:
+            src = directory + '/'
+            dest = curr_directory() + '/smileys/' + os.path.basename(directory) + '/'
+            copy(src, dest)
 
     def select_color(self):
         col = QtGui.QColorDialog.getColor()
@@ -593,15 +779,13 @@ class InterfaceSettings(CenteredWidget):
         settings = Settings.get_instance()
         settings['theme'] = str(self.themeSelect.currentText())
         settings['smileys'] = self.smileys.isChecked()
+        restart = False
         if settings['mirror_mode'] != self.mirror_mode.isChecked():
             settings['mirror_mode'] = self.mirror_mode.isChecked()
-            msgBox = QtGui.QMessageBox()
+            restart = True
-            text = QtGui.QApplication.translate("interfaceForm", 'Restart app to apply settings', None,
+        if settings['compact_mode'] != self.compact_mode.isChecked():
-                                                QtGui.QApplication.UnicodeUTF8)
+            settings['compact_mode'] = self.compact_mode.isChecked()
-            msgBox.setWindowTitle(QtGui.QApplication.translate("interfaceForm", 'Restart required', None,
+            restart = True
-                                                               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()
@@ -616,6 +800,14 @@ class InterfaceSettings(CenteredWidget):
         settings['message_font_size'] = self.messages_font_size.currentIndex() + 10
         Profile.get_instance().update()
         settings.save()
+        if restart:
+            msgBox = QtGui.QMessageBox()
+            text = QtGui.QApplication.translate("interfaceForm", 'Restart app to apply settings', None,
+                                                QtGui.QApplication.UnicodeUTF8)
+            msgBox.setWindowTitle(QtGui.QApplication.translate("interfaceForm", 'Restart required', None,
+                                                               QtGui.QApplication.UnicodeUTF8))
+            msgBox.setText(text)
+            msgBox.exec_()
 
 
 class AudioSettings(CenteredWidget):
@@ -650,13 +842,13 @@ class AudioSettings(CenteredWidget):
         p = pyaudio.PyAudio()
         settings = Settings.get_instance()
         self.in_indexes, self.out_indexes = [], []
-        for i in xrange(p.get_device_count()):
+        for i in range(p.get_device_count()):
             device = p.get_device_info_by_index(i)
             if device["maxInputChannels"]:
-                self.input.addItem(unicode(device["name"]))
+                self.input.addItem(str(device["name"]))
                 self.in_indexes.append(i)
             if device["maxOutputChannels"]:
-                self.output.addItem(unicode(device["name"]))
+                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']))
@@ -728,7 +920,7 @@ class PluginsSettings(CenteredWidget):
     def update_list(self):
         self.comboBox.clear()
         data = self.pl_loader.get_plugins_list()
-        self.comboBox.addItems(map(lambda x: x[0], data))
+        self.comboBox.addItems(list(map(lambda x: x[0], data)))
         self.data = data
 
     def show_data(self):

toxygen/messages.py

@@ -9,7 +9,7 @@ MESSAGE_TYPE = {
 }
 
 
-class Message(object):
+class Message:
 
     def __init__(self, message_type, owner, time):
         self._time = time
@@ -39,6 +39,18 @@ class TextMessage(Message):
         return self._message, self._owner, self._time, self._type
 
 
+class GroupChatTextMessage(TextMessage):
+
+    def __init__(self, friend_name, *args):
+        super().__init__(*args)
+        self._name = friend_name
+
+    def get_data(self):
+        data = list(super().get_data())
+        data.append(self._name)
+        return tuple(data)
+
+
 class TransferMessage(Message):
     """
     Message with info about file transfer
@@ -71,6 +83,7 @@ class TransferMessage(Message):
 
 
 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

toxygen/notifications.py

@@ -35,7 +35,7 @@ def tray_notification(title, text, tray, window):
         tray.connect(tray, QtCore.SIGNAL("messageClicked()"), message_clicked)
 
 
-class AudioFile(object):
+class AudioFile:
     chunk = 1024
 
     def __init__(self, fl):

toxygen/passwordscreen.py

@@ -0,0 +1,164 @@
+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 PasswordScreenBase(CenteredWidget):
+
+    def __init__(self, encrypt):
+        super(PasswordScreenBase, self).__init__()
+        self._encrypt = encrypt
+        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):
+        pass
+
+    def keyPressEvent(self, event):
+        if event.key() == QtCore.Qt.Key_Enter:
+            self.button_click()
+        else:
+            super(PasswordScreenBase, 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))
+
+
+class PasswordScreen(PasswordScreenBase):
+
+    def __init__(self, encrypt, data):
+        super(PasswordScreen, self).__init__(encrypt)
+        self._data = data
+
+    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()
+
+
+class UnlockAppScreen(PasswordScreenBase):
+
+    def __init__(self, encrypt, callback):
+        super(UnlockAppScreen, self).__init__(encrypt)
+        self._callback = callback
+        self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
+
+    def button_click(self):
+        if self.password.text():
+            if self._encrypt.is_password(self.password.text()):
+                self._callback()
+                self.close()
+            else:
+                self.warning.setVisible(True)
+                print('Wrong password!')
+
+
+class SetProfilePasswordScreen(CenteredWidget):
+
+    def __init__(self, encrypt):
+        super(SetProfilePasswordScreen, self).__init__()
+        self._encrypt = encrypt
+        self.initUI()
+        self.retranslateUi()
+        self.center()
+
+    def initUI(self):
+        self.setMinimumSize(QtCore.QSize(700, 200))
+        self.setMaximumSize(QtCore.QSize(700, 200))
+        self.password = LineEdit(self)
+        self.password.setGeometry(QtCore.QRect(40, 10, 300, 30))
+        self.password.setEchoMode(QtGui.QLineEdit.EchoMode.Password)
+        self.confirm_password = LineEdit(self)
+        self.confirm_password.setGeometry(QtCore.QRect(40, 50, 300, 30))
+        self.confirm_password.setEchoMode(QtGui.QLineEdit.EchoMode.Password)
+        self.set_password = QtGui.QPushButton(self)
+        self.set_password.setGeometry(QtCore.QRect(40, 100, 300, 30))
+        self.set_password.clicked.connect(self.new_password)
+        self.not_match = QtGui.QLabel(self)
+        self.not_match.setGeometry(QtCore.QRect(350, 50, 300, 30))
+        self.not_match.setVisible(False)
+        self.not_match.setStyleSheet('QLabel { color: #BC1C1C; }')
+        self.warning = QtGui.QLabel(self)
+        self.warning.setGeometry(QtCore.QRect(40, 160, 500, 30))
+        self.warning.setStyleSheet('QLabel { color: #BC1C1C; }')
+
+    def retranslateUi(self):
+        self.setWindowTitle(QtGui.QApplication.translate("PasswordScreen", "Profile password", None,
+                                                              QtGui.QApplication.UnicodeUTF8))
+        self.password.setPlaceholderText(
+            QtGui.QApplication.translate("PasswordScreen", "Password (at least 8 symbols)", None,
+                                         QtGui.QApplication.UnicodeUTF8))
+        self.confirm_password.setPlaceholderText(
+            QtGui.QApplication.translate("PasswordScreen", "Confirm password", None,
+                                         QtGui.QApplication.UnicodeUTF8))
+        self.set_password.setText(
+            QtGui.QApplication.translate("PasswordScreen", "Set password", None, QtGui.QApplication.UnicodeUTF8))
+        self.not_match.setText(QtGui.QApplication.translate("PasswordScreen", "Passwords do not match", None,
+                                                            QtGui.QApplication.UnicodeUTF8))
+        self.warning.setText(
+            QtGui.QApplication.translate("PasswordScreen", "There is no way to recover lost passwords", None,
+                                         QtGui.QApplication.UnicodeUTF8))
+
+    def new_password(self):
+        if self.password.text() == self.confirm_password.text():
+            if len(self.password.text()) >= 8:
+                self._encrypt.set_password(self.password.text())
+                self.close()
+            else:
+                self.not_match.setText(
+                    QtGui.QApplication.translate("PasswordScreen", "Password must be at least 8 symbols", None,
+                                                 QtGui.QApplication.UnicodeUTF8))
+            self.not_match.setVisible(True)
+        else:
+            self.not_match.setText(QtGui.QApplication.translate("PasswordScreen", "Passwords do not match", None,
+                                                                QtGui.QApplication.UnicodeUTF8))
+            self.not_match.setVisible(True)

toxygen/plugin_support.py

@@ -1,20 +1,22 @@
 import util
 import profile
 import os
-import imp
+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()
+        self._encr = toxencryptsave.ToxEncryptSave.get_instance()
 
     def set_tox(self, tox):
         """
@@ -32,13 +34,15 @@ class PluginLoader(util.Singleton):
         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 = imp.load_source('plugins.' + name, path + fl)  # import plugin
+                module = importlib.import_module(name)  # import plugin
             except ImportError:
                 util.log('Import error in module ' + name)
                 continue
@@ -47,8 +51,8 @@ class PluginLoader(util.Singleton):
                 continue
             for elem in dir(module):
                 obj = getattr(module, elem)
-                if inspect.isclass(obj) and issubclass(obj, pl.PluginSuperClass):  # looking for plugin class in module
+                if inspect.isclass(obj) and hasattr(obj, 'is_plugin') and obj.is_plugin:  # looking for plugin class in module
-                    print 'Plugin', elem
+                    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']
@@ -147,6 +151,7 @@ class PluginLoader(util.Singleton):
         """
         App is closing, stop all plugins
         """
-        for key in self._plugins.keys():
+        for key in list(self._plugins.keys()):
-            self._plugins[key][0].close()
+            if self._plugins[key][1]:
+                self._plugins[key][0].close()
             del self._plugins[key]

toxygen/plugins/plugin_super_class.py

@@ -26,16 +26,18 @@ def log(name, data):
     :param data: data for saving in log
     """
     with open(path_to_data(name) + 'logs.txt', 'a') as fl:
-        fl.write(str(data) + '\n')
+        fl.write(bytes(data, 'utf-8') + b'\n')
 
 
-class PluginSuperClass(object):
+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):
         """
+        Constructor. In plugin __init__ should take only 4 last arguments
         :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
@@ -159,9 +161,9 @@ class PluginSuperClass(object):
         """
         This method loads settings of plugin and returns raw data
         """
-        with open(path_to_data(self._short_name) + 'settings.json') as fl:
+        with open(path_to_data(self._short_name) + 'settings.json', 'rb') as fl:
             data = fl.read()
-        return data
+        return str(data, 'utf-8')
 
     def save_settings(self, data):
         """
@@ -169,7 +171,7 @@ class PluginSuperClass(object):
         :param data: string with data
         """
         with open(path_to_data(self._short_name) + 'settings.json', 'wb') as fl:
-            fl.write(data)
+            fl.write(bytes(data, 'utf-8'))
 
     # -----------------------------------------------------------------------------------------------------------------
     # Callbacks
@@ -212,8 +214,10 @@ class PluginSuperClass(object):
             data = ''
         try:
             return self._tox.friend_send_lossless_packet(friend_number,
-                                                         chr(len(self._short_name) + LOSSLESS_FIRST_BYTE) +
+                                                         bytes([ord(x) for x in
-                                                         self._short_name + str(data))
+                                                                chr(len(self._short_name) + LOSSLESS_FIRST_BYTE) +
+                                                                self._short_name + str(data)
+                                                                ]))
         except:
             return False
 
@@ -228,7 +232,9 @@ class PluginSuperClass(object):
             data = ''
         try:
             return self._tox.friend_send_lossy_packet(friend_number,
-                                                      chr(len(self._short_name) + LOSSY_FIRST_BYTE) +
+                                                      bytes([ord(x) for x in
-                                                      self._short_name + str(data))
+                                                             chr(len(self._short_name) + LOSSY_FIRST_BYTE) +
+                                                             self._short_name + str(data)
+                                                             ]))
         except:
             return False

toxygen/profile.py

@@ -7,7 +7,7 @@ from friend import *
 from settings import *
 from toxcore_enums_and_consts import *
 from ctypes import *
-from util import curr_time, log, Singleton, curr_directory, convert_time
+from util import log, Singleton, curr_directory
 from tox_dns import tox_dns
 from history import *
 from file_transfers import *
@@ -15,9 +15,11 @@ import time
 import calls
 import avwidgets
 import plugin_support
+import basecontact
+from groupchat import *
 
 
-class Profile(contact.Contact, Singleton):
+class Profile(basecontact.BaseContact, Singleton):
     """
     Profile of current toxygen user. Contains friends list, tox instance
     """
@@ -26,38 +28,60 @@ class Profile(contact.Contact, Singleton):
         :param tox: tox instance
         :param screen: ref to main screen
         """
-        super(Profile, self).__init__(tox.self_get_name(),
+        basecontact.BaseContact.__init__(self,
-                                      tox.self_get_status_message(),
+                                         tox.self_get_name(),
-                                      screen.user_info,
+                                         tox.self_get_status_message(),
-                                      tox.self_get_address())
+                                         screen.user_info,
+                                         tox.self_get_address())
+        Singleton.__init__(self)
         self._screen = screen
         self._messages = screen.messages
         self._tox = tox
         self._file_transfers = {}  # dict of file transfers. key - tuple (friend_number, file_number)
         self._call = calls.AV(tox.AV)  # object with data about calls
         self._incoming_calls = set()
+        self._load_history = True
+        self._gc_invites = {}  # dict of gc invites. key - friend number, value - list of gc data
         settings = Settings.get_instance()
         self._show_online = settings['show_online_friends']
         screen.online_contacts.setCurrentIndex(int(self._show_online))
         aliases = settings['friends_aliases']
         data = tox.self_get_friend_list()
         self._history = History(tox.self_get_public_key())  # connection to db
-        self._friends, self._active_friend = [], -1
+        self._friends_and_gc, self._active_friend_or_gc = [], -1
         for i in data:  # creates list of friends
             tox_id = tox.friend_get_public_key(i)
-            if not self._history.friend_exists_in_db(tox_id):
-                self._history.add_friend_to_db(tox_id)
             try:
-                alias = filter(lambda x: x[0] == tox_id, aliases)[0][1]
+                alias = list(filter(lambda x: x[0] == tox_id, aliases))[0][1]
             except:
                 alias = ''
             item = self.create_friend_item()
             name = alias or tox.friend_get_name(i) or tox_id
             status_message = tox.friend_get_status_message(i)
+            if not self._history.friend_exists_in_db(tox_id):
+                self._history.add_friend_to_db(tox_id)
             message_getter = self._history.messages_getter(tox_id)
-            friend = Friend(message_getter, i, name, status_message, item, tox_id)
+            friend = Friend(i, message_getter, name, status_message, item, tox_id)
             friend.set_alias(alias)
-            self._friends.append(friend)
+            self._friends_and_gc.append(friend)
+
+        l = self._tox.group_get_number_groups()
+        for i in range(l):  # creates list of group chats
+            tox_id = tox.group_get_chat_id(i)
+            try:
+                alias = list(filter(lambda x: x[0] == tox_id, aliases))[0][1]
+            except:
+                alias = ''
+            item = self.create_friend_item()
+            name = alias or tox.group_get_name(i) or tox_id
+            status_message = tox.group_get_topic(i)
+            if not self._history.friend_exists_in_db(tox_id):
+                self._history.add_friend_to_db(tox_id)
+            message_getter = self._history.messages_getter(tox_id)
+            gc = GroupChat(self._tox, i, message_getter, name, status_message, item, tox_id)
+            gc.set_alias(alias)
+            self._friends_and_gc.append(gc)
+
         self.filtration(self._show_online)
 
     # -----------------------------------------------------------------------------------------------------------------
@@ -72,23 +96,27 @@ class Profile(contact.Contact, Singleton):
             self.set_status((self._status + 1) % 3)
 
     def set_status(self, status):
+        if self.status is None:
+            for gc in filter(lambda x: type(x) is GroupChat, self._friends_and_gc):
+                self._tox.group_reconnect(gc.number)
         super(Profile, self).set_status(status)
         if status is not None:
             self._tox.self_set_status(status)
 
     def set_name(self, value):
+        if self.name == value:
+            return
         tmp = self.name
-        super(Profile, self).set_name(value)
+        super(Profile, self).set_name(value.encode('utf-8'))
         self._tox.self_set_name(self._name.encode('utf-8'))
-        if tmp != value:
+        message = QtGui.QApplication.translate("MainWindow", 'User {} is now known as {}', None,
-            message = QtGui.QApplication.translate("MainWindow", 'User {} is now known as {}', None,
+                                               QtGui.QApplication.UnicodeUTF8)
-                                                   QtGui.QApplication.UnicodeUTF8)
+        message = message.format(tmp, str(value, 'utf-8'))
-            message = message.format(tmp, value)
+        for friend in self._friends_and_gc:
-            for friend in self._friends:
+            friend.append_message(InfoMessage(message, time.time()))
-                friend.append_message(InfoMessage(message, time.time()))
+        if self._active_friend_or_gc + 1:
-            if self._active_friend + 1:
+            self.create_message_item(message, curr_time(), '', MESSAGE_TYPE['INFO_MESSAGE'])
-                self.create_message_item(message, curr_time(), '', MESSAGE_TYPE['INFO_MESSAGE'])
+            self._messages.scrollToBottom()
-                self._messages.scrollToBottom()
 
     def set_status_message(self, value):
         super(Profile, self).set_status_message(value)
@@ -112,15 +140,16 @@ class Profile(contact.Contact, Singleton):
         :param filter_str: show contacts which name contains this substring
         """
         filter_str = filter_str.lower()
-        for index, friend in enumerate(self._friends):
+        settings = Settings.get_instance()
+        for index, friend in enumerate(self._friends_and_gc):
             friend.visibility = (friend.status is not None or not show_online) and (filter_str in friend.name.lower())
             friend.visibility = friend.visibility or friend.messages or friend.actions
             if friend.visibility:
-                self._screen.friends_list.item(index).setSizeHint(QtCore.QSize(250, 70))
+                self._screen.friends_list.item(index).setSizeHint(QtCore.QSize(250,
+                                                                               40 if settings['compact_mode'] else 70))
             else:
                 self._screen.friends_list.item(index).setSizeHint(QtCore.QSize(250, 0))
         self._show_online, self._filter_string = show_online, filter_str
-        settings = Settings.get_instance()
         settings['show_online_friends'] = self._show_online
         settings.save()
 
@@ -131,29 +160,32 @@ class Profile(contact.Contact, Singleton):
         self.filtration(self._show_online, self._filter_string)
 
     def get_friend_by_number(self, num):
-        return filter(lambda x: x.number == num, self._friends)[0]
+        return list(filter(lambda x: x.number == num and type(x) is Friend, self._friends_and_gc))[0]
 
-    def get_friend(self, num):
+    def get_gc_by_number(self, num):
-        return self._friends[num]
+        return list(filter(lambda x: x.number == num and type(x) is not Friend, self._friends_and_gc))[0]
+
+    def get_friend_or_gc(self, num):
+        return self._friends_and_gc[num]
 
     # -----------------------------------------------------------------------------------------------------------------
     # Work with active friend
     # -----------------------------------------------------------------------------------------------------------------
 
     def get_active(self):
-        return self._active_friend
+        return self._active_friend_or_gc
 
     def set_active(self, value=None):
         """
         Change current active friend or update info
         :param value: number of new active friend in friend's list or None to update active user's data
         """
-        if value is None and self._active_friend == -1:  # nothing to update
+        if value is None and self._active_friend_or_gc == -1:  # nothing to update
             return
         if value == -1:  # all friends were deleted
             self._screen.account_name.setText('')
             self._screen.account_status.setText('')
-            self._active_friend = -1
+            self._active_friend_or_gc = -1
             self._screen.account_avatar.setHidden(True)
             self._messages.clear()
             self._screen.messageEdit.clear()
@@ -162,25 +194,30 @@ class Profile(contact.Contact, Singleton):
             self.send_typing(False)
             self._screen.typing.setVisible(False)
             if value is not None:
-                if self._active_friend + 1:
+                if self._active_friend_or_gc + 1:
                     try:
-                        self._friends[self._active_friend].curr_text = self._screen.messageEdit.toPlainText()
+                        self._friends_and_gc[self._active_friend_or_gc].curr_text = self._screen.messageEdit.toPlainText()
                     except:
                         pass
-                self._active_friend = value
+                self._active_friend_or_gc = value
-                friend = self._friends[value]
+                friend_or_gc = self._friends_and_gc[value]
-                self._friends[value].reset_messages()
+                friend_or_gc.reset_messages()
-                self._screen.messageEdit.setPlainText(friend.curr_text)
+                friend_or_gc.delete_old_messages()
+                self._screen.messageEdit.setPlainText(friend_or_gc.curr_text)
                 self._messages.clear()
-                friend.load_corr()
+                friend_or_gc.load_corr()
-                messages = friend.get_corr()[-PAGE_SIZE:]
+                messages = friend_or_gc.get_corr()[-PAGE_SIZE:]
+                self._load_history = False
+
                 for message in messages:
                     if message.get_type() <= 1:
                         data = message.get_data()
                         self.create_message_item(data[0],
-                                                 convert_time(data[2]),
+                                                 data[2],
                                                  data[1],
-                                                 data[3])
+                                                 data[3],
+                                                 True,
+                                                 data[4] if len(data) == 5 else None)
                     elif message.get_type() == MESSAGE_TYPE['FILE_TRANSFER']:
                         if message.get_status() is None:
                             self.create_unsent_file_item(message)
@@ -192,16 +229,17 @@ class Profile(contact.Contact, Singleton):
                                 ft.set_state_changed_handler(item.update)
                                 ft.signal()
                             except:
-                                print 'Incoming not started transfer - no info found'
+                                print('Incoming not started transfer - no info found')
                     elif message.get_type() == MESSAGE_TYPE['INLINE']:  # inline
                         self.create_inline_item(message.get_data())
                     else:  # info message
                         data = message.get_data()
                         self.create_message_item(data[0],
-                                                 convert_time(data[2]),
+                                                 data[2],
                                                  '',
                                                  data[3])
                 self._messages.scrollToBottom()
+                self._load_history = True
                 if value in self._call:
                     self._screen.active_call()
                 elif value in self._incoming_calls:
@@ -209,55 +247,63 @@ class Profile(contact.Contact, Singleton):
                 else:
                     self._screen.call_finished()
             else:
-                friend = self._friends[self._active_friend]
+                friend_or_gc = self._friends_and_gc[self._active_friend_or_gc]
 
-            self._screen.account_name.setText(friend.name)
+            self._screen.account_name.setText(friend_or_gc.name)
-            self._screen.account_status.setText(friend.status_message)
+            self._screen.account_status.setText(friend_or_gc.status_message)
-            avatar_path = (ProfileHelper.get_path() + 'avatars/{}.png').format(friend.tox_id[:TOX_PUBLIC_KEY_SIZE * 2])
+            avatar_path = (ProfileHelper.get_path() + 'avatars/{}.png').format(friend_or_gc.tox_id[:TOX_PUBLIC_KEY_SIZE * 2])
             if not os.path.isfile(avatar_path):  # load default image
-                avatar_path = curr_directory() + '/images/avatar.png'
+                if type(friend_or_gc) is Friend:
+                    avatar_path = curr_directory() + '/images/avatar.png'
+                else:
+                    avatar_path = curr_directory() + '/images/group.png'
             os.chdir(os.path.dirname(avatar_path))
             pixmap = QtGui.QPixmap(QtCore.QSize(64, 64))
             pixmap.load(avatar_path)
             self._screen.account_avatar.setScaledContents(False)
             self._screen.account_avatar.setPixmap(pixmap.scaled(64, 64, QtCore.Qt.KeepAspectRatio))
             self._screen.account_avatar.repaint()  # comment?
-        except:  # no friend found. ignore
+            self.update_filtration()
-            log('Incorrect friend value: ' + str(value))
+        except Exception as ex:  # no friend found. ignore
+            log('Friend value: ' + str(value))
+            log('Error: ' + str(ex))
             raise
 
     active_friend = property(get_active, set_active)
 
+    def is_active_a_friend(self):
+        return type(self._friends_and_gc[self._active_friend_or_gc]) is Friend
+
     def get_last_message(self):
-        return self._friends[self._active_friend].get_last_message_text()
+        return self._friends_and_gc[self._active_friend_or_gc].get_last_message_text()
 
     def get_active_number(self):
-        return self._friends[self._active_friend].number if self._active_friend + 1 else -1
+        return self._friends_and_gc[self._active_friend_or_gc].number if self._active_friend_or_gc + 1 else -1
 
     def get_active_name(self):
-        return self._friends[self._active_friend].name if self._active_friend + 1 else ''
+        return self._friends_and_gc[self._active_friend_or_gc].name if self._active_friend_or_gc + 1 else ''
 
     def is_active_online(self):
-        return self._active_friend + 1 and self._friends[self._active_friend].status is not None
+        return self._active_friend_or_gc + 1 and self._friends_and_gc[self._active_friend_or_gc].status is not None
 
     def new_name(self, number, name):
         friend = self.get_friend_by_number(number)
         tmp = friend.name
         friend.set_name(name)
-        name = name.decode('utf-8')
+        name = str(name, 'utf-8')
         if friend.name == name and tmp != name:
             message = QtGui.QApplication.translate("MainWindow", 'User {} is now known as {}', None, QtGui.QApplication.UnicodeUTF8)
             message = message.format(tmp, name)
             friend.append_message(InfoMessage(message, time.time()))
             friend.actions = True
             if number == self.get_active_number():
-                self.create_message_item(message, curr_time(), '', MESSAGE_TYPE['INFO_MESSAGE'])
+                self.create_message_item(message, time.time(), '', MESSAGE_TYPE['INFO_MESSAGE'])
                 self._messages.scrollToBottom()
             self.set_active(None)
 
     def update(self):
-        if self._active_friend + 1:
+        if self._active_friend_or_gc + 1:
-            self.set_active(self._active_friend)
+            self.set_active(self._active_friend_or_gc)
 
     # -----------------------------------------------------------------------------------------------------------------
     # Friend connection status callbacks
@@ -277,7 +323,7 @@ class Profile(contact.Contact, Singleton):
             if friend_number == self.get_active_number():
                 self.update()
         except Exception as ex:
-            print 'Exception in file sending: ' + str(ex)
+            print('Exception in file sending: ' + str(ex))
 
     def friend_exit(self, friend_number):
         """
@@ -297,8 +343,8 @@ class Profile(contact.Contact, Singleton):
         """
         Send typing notification to a friend
         """
-        if Settings.get_instance()['typing_notifications'] and self._active_friend + 1:
+        if Settings.get_instance()['typing_notifications'] and self._active_friend_or_gc + 1:
-            friend = self._friends[self._active_friend]
+            friend = self._friends_and_gc[self._active_friend_or_gc]
             if friend.status is not None:
                 self._tox.self_set_typing(friend.number, typing)
 
@@ -324,19 +370,21 @@ class Profile(contact.Contact, Singleton):
         """
         friend = self.get_friend_by_number(friend_number)
         friend.load_corr()
-        messages = friend.unsent_messages()
+        messages = friend.get_unsent_messages()
         try:
             for message in messages:
                 self.split_and_send(friend_number, message.get_data()[-1], message.get_data()[0].encode('utf-8'))
+                friend.inc_receipts()
         except:
             pass
 
-    def split_and_send(self, number, message_type, message):
+    def split_and_send(self, number, message_type, message, is_group=False):
         """
         Message splitting
-        :param number: friend's number
+        :param number: friend or gc number
         :param message_type: type of message
         :param message: message text
+        :param is_group: send to group
         """
         while len(message) > TOX_MAX_MESSAGE_LENGTH:
             size = TOX_MAX_MESSAGE_LENGTH * 4 / 5
@@ -350,52 +398,98 @@ class Profile(contact.Contact, Singleton):
             else:
                 index = TOX_MAX_MESSAGE_LENGTH - size - 1
             index += size + 1
-            self._tox.friend_send_message(number, message_type, message[:index])
+            if not is_group:
+                self._tox.friend_send_message(number, message_type, message[:index])
+            else:
+                self._tox.group_send_message(number, message_type, message[:index])
             message = message[index:]
-        self._tox.friend_send_message(number, message_type, message)
+        if not is_group:
+            self._tox.friend_send_message(number, message_type, message)
+        else:
+            self._tox.group_send_message(number, message_type, message)
 
-    def new_message(self, friend_num, message_type, message):
+    def new_message(self, num, message_type, message, is_group=False, peer_id=-1):
         """
         Current user gets new message
-        :param friend_num: friend_num of friend who sent message
+        :param num: num of friend or gc who sent message
         :param message_type: message type - plain text or action message (/me)
         :param message: text of message
+        :param is_group: is group chat message or not
+        :param peer_id: if gc - peer id
         """
-        if friend_num == self.get_active_number():  # add message to list
+        t = time.time()
-            self.create_message_item(message.decode('utf-8'), curr_time(), MESSAGE_OWNER['FRIEND'], message_type)
+        active = False
+        if num == self.get_active_number() and is_group != self.is_active_a_friend():  # add message to list
+            if not is_group:
+                self.create_message_item(message, t, MESSAGE_OWNER['FRIEND'], message_type)
+            else:
+                self.create_message_item(message, t, MESSAGE_OWNER['FRIEND'], message_type, True,
+                                         self._tox.group_peer_get_name(num, peer_id))
             self._messages.scrollToBottom()
-            self._friends[self._active_friend].append_message(
+            active = True
-                TextMessage(message.decode('utf-8'), MESSAGE_OWNER['FRIEND'], time.time(), message_type))
+        if is_group:
+            friend_or_gc = self.get_gc_by_number(num)
+            friend_or_gc.append_message(GroupChatTextMessage(self._tox.group_peer_get_name(num, peer_id),
+                                                             message, MESSAGE_OWNER['FRIEND'],
+                                                             time.time(), message_type))
         else:
-            friend = self.get_friend_by_number(friend_num)
+            friend_or_gc = self.get_friend_by_number(num)
-            friend.inc_messages()
+            friend_or_gc.append_message(TextMessage(message, MESSAGE_OWNER['FRIEND'], time.time(), message_type))
-            friend.append_message(
+        if not active:
-                TextMessage(message.decode('utf-8'), MESSAGE_OWNER['FRIEND'], time.time(), message_type))
+            friend_or_gc.inc_messages()
-            if not friend.visibility:
+        if not friend_or_gc.visibility:
-                self.update_filtration()
+            self.update_filtration()
 
-    def send_message(self, text):
+    def send_message(self, text, number=None, is_gc=False):
         """
-        Send message to active friend
+        Send message
         :param text: message text
+        :param number: num of friend or gc
+        :param is_gc: is group chat
         """
+        if number is None:
+            number = self.get_active_number()
+            is_gc = not self.is_active_a_friend()
         if text.startswith('/plugin '):
             plugin_support.PluginLoader.get_instance().command(text[8:])
             self._screen.messageEdit.clear()
-        elif text and self._active_friend + 1:
+        elif text and number + 1:
+            text = ''.join(c if c <= '\u10FFFF' else '\u25AF' for c in text)
+
             if text.startswith('/me '):
                 message_type = TOX_MESSAGE_TYPE['ACTION']
                 text = text[4:]
             else:
                 message_type = TOX_MESSAGE_TYPE['NORMAL']
-            friend = self._friends[self._active_friend]
+
-            friend.inc_receipts()
+            if not is_gc:
-            if friend.status is not None:
+                friend_or_gc = self.get_friend_by_number(number)
-                self.split_and_send(friend.number, message_type, text.encode('utf-8'))
+            else:
-            self.create_message_item(text, curr_time(), MESSAGE_OWNER['NOT_SENT'], message_type)
+                friend_or_gc = self.get_gc_by_number(number)
-            self._screen.messageEdit.clear()
+            t = time.time()
-            self._messages.scrollToBottom()
+
-            friend.append_message(TextMessage(text, MESSAGE_OWNER['NOT_SENT'], time.time(), message_type))
+            if not is_gc:
+                friend_or_gc.inc_receipts()
+                if friend_or_gc.status is not None:
+                    self.split_and_send(friend_or_gc.number, message_type, text.encode('utf-8'))
+                if friend_or_gc.number == self.get_active_number() and self.is_active_a_friend():
+                    self.create_message_item(text, t, MESSAGE_OWNER['NOT_SENT'], message_type)
+                    self._screen.messageEdit.clear()
+                    self._messages.scrollToBottom()
+                friend_or_gc.append_message(TextMessage(text, MESSAGE_OWNER['NOT_SENT'], t, message_type))
+            else:
+                self.split_and_send(friend_or_gc.number, message_type, text.encode('utf-8'), True)
+                if friend_or_gc.number == self.get_active_number() and not self.is_active_a_friend():
+                    self.create_message_item(text, t, MESSAGE_OWNER['ME'], message_type)
+                    self._screen.messageEdit.clear()
+                    self._messages.scrollToBottom()
+                friend_or_gc.append_message(TextMessage(text, MESSAGE_OWNER['ME'], t, message_type))
+
+    def delete_message(self, time):
+        friend = self._friends_and_gc[self._active_friend_or_gc]
+        friend.delete_message(time)
+        self._history.delete_message(friend.tox_id, time)
+        self.update()
 
     # -----------------------------------------------------------------------------------------------------------------
     # History support
@@ -405,43 +499,53 @@ class Profile(contact.Contact, Singleton):
         """
         Save history to db
         """
+        s = Settings.get_instance()
+        # TODO: different saving for friends and gc
         if hasattr(self, '_history'):
-            if Settings.get_instance()['save_history']:
+            if s['save_history']:
-                for friend in self._friends:
+                for friend_or_gc in self._friends_and_gc:
-                    messages = friend.get_corr_for_saving()
+                    if not self._history.friend_exists_in_db(friend_or_gc.tox_id):
-                    if not self._history.friend_exists_in_db(friend.tox_id):
+                        self._history.add_friend_to_db(friend_or_gc.tox_id)
-                        self._history.add_friend_to_db(friend.tox_id)
+                    if not s['save_unsent_only']:
-                    self._history.save_messages_to_db(friend.tox_id, messages)
+                        messages = friend_or_gc.get_corr_for_saving()
-                    unsent_messages = friend.unsent_messages()
+                    else:
+                        messages = friend_or_gc.get_unsent_messages_for_saving()
+                        self._history.delete_messages(friend_or_gc.tox_id)
+                    self._history.save_messages_to_db(friend_or_gc.tox_id, messages)
+                    unsent_messages = friend_or_gc.get_unsent_messages()
                     unsent_time = unsent_messages[0].get_data()[2] if len(unsent_messages) else time.time() + 1
-                    self._history.update_messages(friend.tox_id, unsent_time)
+                    self._history.update_messages(friend_or_gc.tox_id, unsent_time)
             self._history.save()
             del self._history
 
-    def clear_history(self, num=None):
+    def clear_history(self, num=None, save_unsent=False):
         """
         Clear chat history
         """
         if num is not None:
-            friend = self._friends[num]
+            friend = self._friends_and_gc[num]
-            friend.clear_corr()
+            friend.clear_corr(save_unsent)
             if self._history.friend_exists_in_db(friend.tox_id):
                 self._history.delete_messages(friend.tox_id)
                 self._history.delete_friend_from_db(friend.tox_id)
         else:  # clear all history
-            for number in xrange(len(self._friends)):
+            for number in range(len(self._friends_and_gc)):
-                self.clear_history(number)
+                self.clear_history(number, save_unsent)
+
         if num is None or num == self.get_active_number():
-            self._messages.clear()
+            self.update()
-            self._messages.repaint()
 
     def load_history(self):
         """
         Tries to load next part of messages
         """
-        friend = self._friends[self._active_friend]
+        if not self._load_history:
-        friend.load_corr(False)
+            return
-        data = friend.get_corr()
+        self._load_history = False
+        friend_or_gc = self._friends_and_gc[self._active_friend_or_gc]
+
+        friend_or_gc.load_corr(False)
+        data = friend_or_gc.get_corr()
         if not data:
             return
         data.reverse()
@@ -450,7 +554,7 @@ class Profile(contact.Contact, Singleton):
             if message.get_type() <= 1:  # text message
                 data = message.get_data()
                 self.create_message_item(data[0],
-                                         convert_time(data[2]),
+                                         data[2],
                                          data[1],
                                          data[3],
                                          False)
@@ -465,15 +569,16 @@ class Profile(contact.Contact, Singleton):
                         ft.set_state_changed_handler(item.update)
                         ft.signal()
                     except:
-                        print 'Incoming not started transfer - no info found'
+                        print('Incoming not started transfer - no info found')
             elif message.get_type() == MESSAGE_TYPE['INLINE']:  # inline
                 self.create_inline_item(message.get_data())
             else:  # info message
                 data = message.get_data()
                 self.create_message_item(data[0],
-                                         convert_time(data[2]),
+                                         data[2],
                                          '',
                                          data[3])
+        self._load_history = True
 
     def export_history(self, directory):
         self._history.export(directory)
@@ -489,16 +594,16 @@ class Profile(contact.Contact, Singleton):
         """
         item = ContactItem()
         elem = QtGui.QListWidgetItem(self._screen.friends_list)
-        elem.setSizeHint(QtCore.QSize(250, 70))
+        elem.setSizeHint(QtCore.QSize(250, item.height()))
         self._screen.friends_list.addItem(elem)
         self._screen.friends_list.setItemWidget(elem, item)
         return item
 
-    def create_message_item(self, text, time, owner, message_type, append=True):
+    def create_message_item(self, text, time, owner, message_type, append=True, friend_name=None):
         if message_type == MESSAGE_TYPE['INFO_MESSAGE']:
             name = ''
         elif owner == MESSAGE_OWNER['FRIEND']:
-            name = self.get_active_name()
+            name = friend_name or self.get_active_name()
         else:
             name = self._name
         item = MessageItem(text, time, name, owner != MESSAGE_OWNER['NOT_SENT'], message_type, self._messages)
@@ -557,12 +662,12 @@ class Profile(contact.Contact, Singleton):
         """
         Set new alias for friend
         """
-        friend = self._friends[num]
+        friend = self._friends_and_gc[num]
-        name = friend.name.encode('utf-8')
+        name = friend.name
         dialog = QtGui.QApplication.translate('MainWindow',
                                               "Enter new alias for friend {} or leave empty to use friend's name:",
                                               None, QtGui.QApplication.UnicodeUTF8)
-        dialog = dialog.format(name.decode('utf-8'))
+        dialog = dialog.format(name)
         title = QtGui.QApplication.translate('MainWindow',
                                              'Set alias',
                                              None, QtGui.QApplication.UnicodeUTF8)
@@ -570,41 +675,44 @@ class Profile(contact.Contact, Singleton):
                                               title,
                                               dialog,
                                               QtGui.QLineEdit.Normal,
-                                              name.decode('utf-8'))
+                                              name)
         if ok:
             settings = Settings.get_instance()
             aliases = settings['friends_aliases']
             if text:
-                friend.name = text.encode('utf-8')
+                friend.name = bytes(text, 'utf-8')
                 try:
-                    index = map(lambda x: x[0], aliases).index(friend.tox_id)
+                    index = list(map(lambda x: x[0], aliases)).index(friend.tox_id)
                     aliases[index] = (friend.tox_id, text)
                 except:
                     aliases.append((friend.tox_id, text))
                 friend.set_alias(text)
             else:  # use default name
-                friend.name = self._tox.friend_get_name(friend.number).encode('utf-8')
+                friend.name = bytes(self._tox.friend_get_name(friend.number), 'utf-8')
                 friend.set_alias('')
                 try:
-                    index = map(lambda x: x[0], aliases).index(friend.tox_id)
+                    index = list(map(lambda x: x[0], aliases)).index(friend.tox_id)
                     del aliases[index]
                 except:
                     pass
             settings.save()
-            self.set_active()
+        if num == self.get_active_number():
+            self.update()
 
     def friend_public_key(self, num):
-        return self._friends[num].tox_id
+        return self._friends_and_gc[num].tox_id
 
-    def delete_friend(self, num):
+    def delete_friend_or_gc(self, num, is_gc=False, message=None):
         """
-        Removes friend from contact list
+        Removes friend or gc from contact list
-        :param num: number of friend in list
+        :param num: number of friend or gc in list
+        :param is_gc: is a group chat
+        :param message: message in gc
         """
-        friend = self._friends[num]
+        friend = self._friends_and_gc[num]
         settings = Settings.get_instance()
         try:
-            index = map(lambda x: x[0], settings['friends_aliases']).index(friend.tox_id)
+            index = list(map(lambda x: x[0], settings['friends_aliases'])).index(friend.tox_id)
             del settings['friends_aliases'][index]
         except:
             pass
@@ -614,11 +722,14 @@ class Profile(contact.Contact, Singleton):
         self.clear_history(num)
         if self._history.friend_exists_in_db(friend.tox_id):
             self._history.delete_friend_from_db(friend.tox_id)
-        self._tox.friend_delete(friend.number)
+        if not is_gc:
-        del self._friends[num]
+            self._tox.friend_delete(friend.number)
+        else:
+            self._tox.group_leave(friend.number, message.encode('utf-8') if message is not None else None)
+        del self._friends_and_gc[num]
         self._screen.friends_list.takeItem(num)
-        if num == self._active_friend:  # active friend was deleted
+        if num == self._active_friend_or_gc:  # active friend or gc was deleted
-            if not len(self._friends):  # last friend was deleted
+            if not len(self._friends_and_gc):  # last contact was deleted
                 self.set_active(-1)
             else:
                 self.set_active(0)
@@ -639,7 +750,7 @@ class Profile(contact.Contact, Singleton):
             log('Accept friend request failed! ' + str(ex))
             message_getter = None
         friend = Friend(message_getter, num, tox_id, '', item, tox_id)
-        self._friends.append(friend)
+        self._friends_and_gc.append(friend)
 
     def block_user(self, tox_id):
         """
@@ -654,7 +765,7 @@ class Profile(contact.Contact, Singleton):
             settings.save()
         try:
             num = self._tox.friend_by_public_key(tox_id)
-            self.delete_friend(num)
+            self.delete_friend_or_gc(num)
             data = self._tox.get_savedata()
             ProfileHelper.get_instance().save_profile(data)
         except:  # not in friend list
@@ -706,7 +817,7 @@ class Profile(contact.Contact, Singleton):
                     self._history.add_friend_to_db(tox_id)
                 message_getter = self._history.messages_getter(tox_id)
                 friend = Friend(message_getter, result, tox_id, '', item, tox_id)
-                self._friends.append(friend)
+                self._friends_and_gc.append(friend)
             data = self._tox.get_savedata()
             ProfileHelper.get_instance().save_profile(data)
             return True
@@ -741,20 +852,24 @@ class Profile(contact.Contact, Singleton):
         Recreate tox instance
         :param restart: method which calls restart and returns new tox instance
         """
-        for key in self._file_transfers.keys():
+        # TODO: file transfers!!
-            self._file_transfers[key].cancel()
+        for key in list(self._file_transfers.keys()):
+            self._file_transfers[key].cancelled()
             del self._file_transfers[key]
         self._call.stop()
         del self._tox
         self._tox = restart()
         self.status = None
-        for friend in self._friends:
+        for friend in self._friends_and_gc:
             friend.status = None
+        self.update_filtration()
 
     def close(self):
         if hasattr(self, '_call'):
             self._call.stop()
             del self._call
+        for i in range(len(self._friends_and_gc)):
+            del self._friends_and_gc[0]
 
     # -----------------------------------------------------------------------------------------------------------------
     # File transfers support
@@ -784,22 +899,12 @@ class Profile(contact.Contact, Singleton):
 
         elif auto:
             path = settings['auto_accept_path'] or curr_directory()
-            if not os.path.isdir(path):
+            self.accept_transfer(None, path + '/' + file_name, friend_number, file_number, size)
-                path = curr_directory()
-            new_file_name, i = file_name, 1
-            while os.path.isfile(path + '/' + new_file_name):  # file with same name already exists
-                if '.' in file_name:  # has extension
-                    d = file_name.rindex('.')
-                else:  # no extension
-                    d = len(file_name)
-                new_file_name = file_name[:d] + ' ({})'.format(i) + file_name[d:]
-                i += 1
-            self.accept_transfer(None, path + '/' + new_file_name, friend_number, file_number, size)
             tm = TransferMessage(MESSAGE_OWNER['FRIEND'],
                                  time.time(),
                                  TOX_FILE_TRANSFER_STATE['RUNNING'],
                                  size,
-                                 new_file_name,
+                                 file_name,
                                  friend_number,
                                  file_number)
         else:
@@ -848,7 +953,7 @@ class Profile(contact.Contact, Singleton):
                                                                                0, -1)
 
     def cancel_not_started_transfer(self, time):
-        self._friends[self._active_friend].delete_one_unsent_file(time)
+        self._friends_and_gc[self._active_friend_or_gc].delete_one_unsent_file(time)
         self.update()
 
     def pause_transfer(self, friend_number, file_number, by_friend=False):
@@ -886,6 +991,16 @@ class Profile(contact.Contact, Singleton):
         :param size: file size
         :param inline: is inline image
         """
+        path, file_name = os.path.split(path)
+        new_file_name, i = file_name, 1
+        while os.path.isfile(path + '/' + new_file_name):  # file with same name already exists
+            if '.' in file_name:  # has extension
+                d = file_name.rindex('.')
+            else:  # no extension
+                d = len(file_name)
+            new_file_name = file_name[:d] + ' ({})'.format(i) + file_name[d:]
+            i += 1
+        path = os.path.join(path, new_file_name)
         if not inline:
             rt = ReceiveTransfer(path, self._tox, friend_number, size, file_number)
         else:
@@ -905,7 +1020,7 @@ class Profile(contact.Contact, Singleton):
         self.send_inline(data, 'toxygen_inline.png')
 
     def send_sticker(self, path):
-        with open(path) as fl:
+        with open(path, 'rb') as fl:
             data = fl.read()
         self.send_inline(data, 'sticker.png')
 
@@ -948,7 +1063,7 @@ class Profile(contact.Contact, Singleton):
             self.update()
             return
         elif friend.status is None and is_resend:
-            print 'Error in sending'
+            print('Error in sending')
             raise RuntimeError()
         st = SendTransfer(path, self._tox, friend_number)
         self._file_transfers[(friend_number, st.get_file_number())] = st
@@ -961,7 +1076,7 @@ class Profile(contact.Contact, Singleton):
                              st.get_file_number())
         item = self.create_file_transfer_item(tm)
         st.set_state_changed_handler(item.update)
-        self._friends[self._active_friend].append_message(tm)
+        self._friends_and_gc[self._active_friend_or_gc].append_message(tm)
         self._messages.scrollToBottom()
 
     def incoming_chunk(self, friend_number, file_number, position, data):
@@ -976,6 +1091,7 @@ class Profile(contact.Contact, Singleton):
                     self.get_friend_by_number(friend_number).load_avatar()
                     self.set_active(None)
                 elif type(transfer) is ReceiveToBuffer:  # inline image
+                    print('inline')
                     inline = InlineImage(transfer.get_data())
                     i = self.get_friend_by_number(friend_number).update_transfer_data(file_number,
                                                                                       TOX_FILE_TRANSFER_STATE['FINISHED'],
@@ -1005,6 +1121,7 @@ class Profile(contact.Contact, Singleton):
                 if type(transfer) is not SendAvatar:
                     if type(transfer) is SendFromBuffer and Settings.get_instance()['allow_inline']:  # inline
                         inline = InlineImage(transfer.get_data())
+                        print('inline')
                         i = self.get_friend_by_number(friend_number).update_transfer_data(file_number,
                                                                                           TOX_FILE_TRANSFER_STATE[
                                                                                               'FINISHED'],
@@ -1052,12 +1169,12 @@ class Profile(contact.Contact, Singleton):
 
     def reset_avatar(self):
         super(Profile, self).reset_avatar()
-        for friend in filter(lambda x: x.status is not None, self._friends):
+        for friend in filter(lambda x: x.status is not None, self._friends_and_gc):
             self.send_avatar(friend.number)
 
     def set_avatar(self, data):
         super(Profile, self).set_avatar(data)
-        for friend in filter(lambda x: x.status is not None, self._friends):
+        for friend in filter(lambda x: x.status is not None, self._friends_and_gc):
             self.send_avatar(friend.number)
 
     # -----------------------------------------------------------------------------------------------------------------
@@ -1071,6 +1188,8 @@ class Profile(contact.Contact, Singleton):
 
     def call_click(self, audio=True, video=False):
         """User clicked audio button in main window"""
+        if not self.is_active_a_friend():
+            return
         num = self.get_active_number()
         if num not in self._call and self.is_active_online():  # start call
             self._call(num, audio, video)
@@ -1081,8 +1200,9 @@ class Profile(contact.Contact, Singleton):
             else:
                 text = QtGui.QApplication.translate("incoming_call", "Outgoing audio call", None,
                                                     QtGui.QApplication.UnicodeUTF8)
-            self._friends[self._active_friend].append_message(InfoMessage(text, time.time()))
+
-            self.create_message_item(text, curr_time(), '', MESSAGE_TYPE['INFO_MESSAGE'])
+            self._friends_and_gc[self._active_friend_or_gc].append_message(InfoMessage(text, time.time()))
+            self.create_message_item(text, time.time(), '', MESSAGE_TYPE['INFO_MESSAGE'])
             self._messages.scrollToBottom()
         elif num in self._call:  # finish or cancel call if you call with active friend
             self.stop_call(num, False)
@@ -1102,7 +1222,7 @@ class Profile(contact.Contact, Singleton):
         self._incoming_calls.add(friend_number)
         if friend_number == self.get_active_number():
             self._screen.incoming_call()
-            self.create_message_item(text, curr_time(), '', MESSAGE_TYPE['INFO_MESSAGE'])
+            self.create_message_item(text, time.time(), '', MESSAGE_TYPE['INFO_MESSAGE'])
             self._messages.scrollToBottom()
         else:
             friend.actions = True
@@ -1136,9 +1256,77 @@ class Profile(contact.Contact, Singleton):
         friend = self.get_friend_by_number(friend_number)
         friend.append_message(InfoMessage(text, time.time()))
         if friend_number == self.get_active_number():
-            self.create_message_item(text, curr_time(), '', MESSAGE_TYPE['INFO_MESSAGE'])
+            self.create_message_item(text, time.time(), '', MESSAGE_TYPE['INFO_MESSAGE'])
             self._messages.scrollToBottom()
 
+    # -----------------------------------------------------------------------------------------------------------------
+    # Group chats support
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def get_all_gc(self):
+        return list(filter(lambda x: type(x) is GroupChat, self._friends_and_gc))
+
+    def add_gc(self, num):
+        try:
+            tox_id = self._tox.group_get_chat_id(num)
+            name = self._tox.group_get_name(num)
+            topic = self._tox.group_get_topic(num)
+        except:
+            tox_id = name = topic = ''
+        item = self.create_friend_item()
+        try:
+            if not self._history.friend_exists_in_db(tox_id):
+                self._history.add_friend_to_db(tox_id)
+            message_getter = self._history.messages_getter(tox_id)
+        except Exception as ex:  # something is wrong
+            log('Accept friend request failed! ' + str(ex))
+            message_getter = None
+        gc = GroupChat(self._tox, num, message_getter, name, topic, item, tox_id)
+        self._friends_and_gc.append(gc)
+
+    def join_gc(self, chat_id, password):
+        num = self._tox.group_join(chat_id, password if password else None)
+        if num != 2 ** 32 - 1:
+            self.add_gc(num)
+        else:
+            pass  # TODO: join failed, show error
+
+    def create_gc(self, name, is_public, password):
+        privacy_state = TOX_GROUP_PRIVACY_STATE['TOX_GROUP_PRIVACY_STATE_PUBLIC'] if is_public else TOX_GROUP_PRIVACY_STATE['TOX_GROUP_PRIVACY_STATE_PRIVATE']
+        num = self._tox.group_new(privacy_state, bytes(name, 'utf-8'))
+        if password:
+            self._tox.group_founder_set_password(num, bytes(password, 'utf-8'))
+        self.add_gc(num)
+        self.get_gc_by_number(num).set_status(TOX_USER_STATUS['NONE'])
+
+    def process_group_invite(self, friend_num, data):
+        # TODO: support password
+        try:
+            text = QtGui.QApplication.translate('MainWindow', 'User {} invites you to group',
+                                                None, QtGui.QApplication.UnicodeUTF8)
+            info = text.format(self.get_friend_by_number(friend_num).name)
+            fr_req = QtGui.QApplication.translate('MainWindow', 'Group chat invite', None, QtGui.QApplication.UnicodeUTF8)
+            reply = QtGui.QMessageBox.question(None, fr_req, info, QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)
+            if reply == QtGui.QMessageBox.Yes:  # accepted
+                num = self._tox.group_invite_accept(data, friend_num)
+                data = self._tox.get_savedata()
+                ProfileHelper.get_instance().save_profile(data)
+                print('In gc invite', num)
+                self.add_gc(num)
+            elif reply != QtGui.QMessageBox.No:
+                if friend_num in self._gc_invites:
+                    self._gc_invites[friend_num].append(data)
+                else:
+                    self._gc_invites[friend_num] = data
+        except Exception as ex:  # something is wrong
+            log('Accept group chat invite failed! ' + str(ex))
+
+    def invite_friend(self, group_number, friend_number):
+        self._tox.group_invite_friend(group_number, friend_number)
+
+    def leave_group(self, num, message=None):
+        self.delete_friend_or_gc(num, True, message)
+
 
 def tox_factory(data=None, settings=None):
     """
@@ -1151,7 +1339,7 @@ def tox_factory(data=None, settings=None):
     tox_options = Tox.options_new()
     tox_options.contents.udp_enabled = settings['udp_enabled']
     tox_options.contents.proxy_type = settings['proxy_type']
-    tox_options.contents.proxy_host = settings['proxy_host']
+    tox_options.contents.proxy_host = bytes(settings['proxy_host'], 'UTF-8')
     tox_options.contents.proxy_port = settings['proxy_port']
     tox_options.contents.start_port = settings['start_port']
     tox_options.contents.end_port = settings['end_port']

toxygen/settings.py

@@ -4,26 +4,27 @@ import os
 import locale
 from util import Singleton, curr_directory, log
 import pyaudio
-from toxencryptsave import LibToxEncryptSave
+from toxencryptsave import ToxEncryptSave
 import smileys
 
 
-class Settings(Singleton, dict):
+class Settings(dict, Singleton):
     """
     Settings of current profile + global app settings
     """
 
     def __init__(self, name):
-        self.path = ProfileHelper.get_path() + unicode(name) + '.json'
+        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()
+            inst = ToxEncryptSave.get_instance()
             try:
                 if inst.is_data_encrypted(data):
                     data = inst.pass_decrypt(data)
-                info = json.loads(data)
+                info = json.loads(str(data, 'utf-8'))
             except Exception as ex:
                 info = Settings.get_default_settings()
                 log('Parsing settings error: ' + str(ex))
@@ -34,6 +35,7 @@ class Settings(Singleton, dict):
             self.save()
         smileys.SmileyLoader(self)
         p = pyaudio.PyAudio()
+        self.locked = False
         self.audio = {'input': p.get_default_input_device_info()['index'],
                       'output': p.get_default_output_device_info()['index']}
 
@@ -45,7 +47,7 @@ class Settings(Singleton, dict):
                 data = fl.read()
             auto = json.loads(data)
             if 'path' in auto and 'name' in auto:
-                return unicode(auto['path']), unicode(auto['name'])
+                return str(auto['path']), str(auto['name'])
         return '', ''
 
     @staticmethod
@@ -54,8 +56,8 @@ class Settings(Singleton, dict):
         with open(p) as fl:
             data = fl.read()
         data = json.loads(data)
-        data['path'] = unicode(path.decode(locale.getpreferredencoding()))
+        data['path'] = str(path)
-        data['name'] = unicode(name)
+        data['name'] = str(name)
         with open(p, 'w') as fl:
             fl.write(json.dumps(data))
 
@@ -73,7 +75,7 @@ class Settings(Singleton, dict):
 
     @staticmethod
     def is_active_profile(path, name):
-        path = path.decode(locale.getpreferredencoding()) + name + '.tox'
+        path = path + name + '.tox'
         settings = Settings.get_default_path() + 'toxygen.json'
         if os.path.isfile(settings):
             with open(settings) as fl:
@@ -93,8 +95,8 @@ class Settings(Singleton, dict):
             'ipv6_enabled': True,
             'udp_enabled': True,
             'proxy_type': 0,
-            'proxy_host': '0',
+            'proxy_host': '127.0.0.1',
-            'proxy_port': 0,
+            'proxy_port': 9050,
             'start_port': 0,
             'end_port': 0,
             'tcp_port': 0,
@@ -121,7 +123,11 @@ class Settings(Singleton, dict):
             'x': 400,
             'y': 400,
             'message_font_size': 14,
-            'unread_color': 'red'
+            'unread_color': 'red',
+            'save_unsent_only': False,
+            'compact_mode': False,
+            'show_welcome_screen': True,
+            'notify_all_gc': False
         }
 
     @staticmethod
@@ -136,15 +142,17 @@ class Settings(Singleton, dict):
         default = Settings.get_default_settings()
         for key in default:
             if key not in self:
-                print key
+                print(key)
                 self[key] = default[key]
         self.save()
 
     def save(self):
         text = json.dumps(self)
-        inst = LibToxEncryptSave.get_instance()
+        inst = ToxEncryptSave.get_instance()
         if inst.has_password():
-            text = inst.pass_encrypt(text)
+            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)
 
@@ -155,7 +163,7 @@ class Settings(Singleton, dict):
                 data = fl.read()
             app_settings = json.loads(data)
             try:
-                app_settings['active_profile'].remove(unicode(ProfileHelper.get_path() + self.name + '.tox'))
+                app_settings['active_profile'].remove(str(ProfileHelper.get_path() + self.name + '.tox'))
             except:
                 pass
             data = json.dumps(app_settings)
@@ -175,8 +183,8 @@ class Settings(Singleton, dict):
             app_settings = {}
         if 'active_profile' not in app_settings:
             app_settings['active_profile'] = []
-        profile_path = ProfileHelper.get_path()
+        profilepath = ProfileHelper.get_path()
-        app_settings['active_profile'].append(unicode(profile_path + str(self.name) + '.tox'))
+        app_settings['active_profile'].append(str(profilepath + str(self.name) + '.tox'))
         data = json.dumps(app_settings)
         with open(path, 'w') as fl:
             fl.write(data)
@@ -199,7 +207,7 @@ class ProfileHelper(Singleton):
     Class with methods for search, load and save profiles
     """
     def __init__(self, path, name):
-        path = path.decode(locale.getpreferredencoding())
+        Singleton.__init__(self)
         self._path = path + name + '.tox'
         self._directory = path
         # create /avatars if not exists:
@@ -219,12 +227,12 @@ class ProfileHelper(Singleton):
         return self._directory
 
     def save_profile(self, data):
-        inst = LibToxEncryptSave.get_instance()
+        inst = ToxEncryptSave.get_instance()
         if inst.has_password():
             data = inst.pass_encrypt(data)
         with open(self._path, 'wb') as fl:
             fl.write(data)
-        print 'Profile saved successfully'
+        print('Profile saved successfully')
 
     def export_profile(self, new_path):
         new_path += os.path.basename(self._path)
@@ -232,7 +240,7 @@ class ProfileHelper(Singleton):
             data = fin.read()
         with open(new_path, 'wb') as fout:
             fout.write(data)
-        print 'Profile exported successfully'
+        print('Profile exported successfully')
 
     @staticmethod
     def find_profiles():

toxygen/smileys.py

@@ -14,6 +14,7 @@ class SmileyLoader(util.Singleton):
     """
 
     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)
@@ -29,22 +30,22 @@ class SmileyLoader(util.Singleton):
             self._curr_pack = pack_name
             path = self.get_smileys_path() + 'config.json'
             try:
-                with open(path) as fl:
+                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)
+                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 = zip(keys, values)
+                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)
+                print('Smiley pack {} was not loaded. Error: {}'.format(pack_name, ex))
 
     def get_smileys_path(self):
         return util.curr_directory() + '/smileys/' + self._curr_pack + '/'
@@ -54,7 +55,7 @@ class SmileyLoader(util.Singleton):
         return [x[1] for x in os.walk(d)][0]
 
     def get_smileys(self):
-        return self._list[:]
+        return list(self._list)
 
     def add_smileys_to_text(self, text, edit):
         """
@@ -69,7 +70,7 @@ class SmileyLoader(util.Singleton):
         for i in range(len(arr)):
             if arr[i] in self._smileys:
                 file_name = self._smileys[arr[i]]  # image name
-                arr[i] = u'<img title=\"{}\" src=\"{}\" />'.format(arr[i], file_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)
@@ -85,6 +86,6 @@ def sticker_loader():
     for key in keys:
         path = d + key + '/'
         files = filter(lambda f: f.endswith('.png'), os.listdir(path))
-        files = map(lambda f: unicode(path + f), files)
+        files = map(lambda f: str(path + f), files)
         result.extend(files)
     return result