pip3 version

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

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

toxygen/bootstrap.py

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

toxygen/callbacks.py

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

toxygen/calls.py

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

toxygen/contact.py

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

toxygen/file_transfers.py

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

toxygen/friend.py

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

toxygen/history.py

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

toxygen/libtox.py

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

toxygen/list_items.py

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

toxygen/loginscreen.py

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

toxygen/main.py

@@ -0,0 +1,408 @@
+import sys
+from loginscreen import LoginScreen
+import profile
+from settings import *
+try:
+    from PySide import QtCore, QtGui
+except ImportError:
+    from PyQt4 import QtCore, QtGui
+from bootstrap import node_generator
+from mainscreen import MainWindow
+from callbacks import init_callbacks
+from util import curr_directory, program_version
+import styles.style
+import toxencryptsave
+from passwordscreen import PasswordScreen, UnlockAppScreen
+from plugin_support import PluginLoader
+
+
+class Toxygen:
+
+    def __init__(self, path_or_uri=None):
+        super(Toxygen, self).__init__()
+        self.tox = self.ms = self.init = self.mainloop = self.avloop = None
+        if path_or_uri is None:
+            self.uri = self.path = None
+        elif path_or_uri.startswith('tox:'):
+            self.path = None
+            self.uri = path_or_uri[4:]
+        else:
+            self.path = path_or_uri
+            self.uri = None
+
+    def enter_pass(self, data):
+        """
+        Show password screen
+        """
+        tmp = [data]
+        p = PasswordScreen(toxencryptsave.ToxEncryptSave.get_instance(), tmp)
+        p.show()
+        self.app.connect(self.app, QtCore.SIGNAL("lastWindowClosed()"), self.app, QtCore.SLOT("quit()"))
+        self.app.exec_()
+        if tmp[0] == data:
+            raise SystemExit()
+        else:
+            return tmp[0]
+
+    def main(self):
+        """
+        Main function of app. loads login screen if needed and starts main screen
+        """
+        app = QtGui.QApplication(sys.argv)
+        app.setWindowIcon(QtGui.QIcon(curr_directory() + '/images/icon.png'))
+        self.app = app
+
+        # application color scheme
+        with open(curr_directory() + '/styles/style.qss') as fl:
+            dark_style = fl.read()
+        app.setStyleSheet(dark_style)
+
+        encrypt_save = toxencryptsave.ToxEncryptSave()
+
+        if self.path is not None:
+            path = os.path.dirname(self.path) + '/'
+            name = os.path.basename(self.path)[:-4]
+            data = ProfileHelper(path, name).open_profile()
+            if encrypt_save.is_data_encrypted(data):
+                data = self.enter_pass(data)
+            settings = Settings(name)
+            self.tox = profile.tox_factory(data, settings)
+        else:
+            auto_profile = Settings.get_auto_profile()
+            if not auto_profile[0]:
+                # show login screen if default profile not found
+                current_locale = QtCore.QLocale()
+                curr_lang = current_locale.languageToString(current_locale.language())
+                langs = Settings.supported_languages()
+                if curr_lang in langs:
+                    lang_path = langs[curr_lang]
+                    translator = QtCore.QTranslator()
+                    translator.load(curr_directory() + '/translations/' + lang_path)
+                    app.installTranslator(translator)
+                    app.translator = translator
+                ls = LoginScreen()
+                ls.setWindowIconText("Toxygen")
+                profiles = ProfileHelper.find_profiles()
+                ls.update_select(map(lambda x: x[1], profiles))
+                _login = self.Login(profiles)
+                ls.update_on_close(_login.login_screen_close)
+                ls.show()
+                app.connect(app, QtCore.SIGNAL("lastWindowClosed()"), app, QtCore.SLOT("quit()"))
+                app.exec_()
+                if not _login.t:
+                    return
+                elif _login.t == 1:  # create new profile
+                    _login.name = _login.name.strip()
+                    name = _login.name if _login.name else 'toxygen_user'
+                    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')
+                    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:
+                        Settings.set_auto_profile(path, name)
+                    data = ProfileHelper(path, name).open_profile()
+                    if encrypt_save.is_data_encrypted(data):
+                        data = self.enter_pass(data)
+                    settings = Settings(name)
+                    self.tox = profile.tox_factory(data, settings)
+            else:
+                path, name = auto_profile
+                data = ProfileHelper(path, name).open_profile()
+                if encrypt_save.is_data_encrypted(data):
+                    data = self.enter_pass(data)
+                settings = Settings(name)
+                self.tox = profile.tox_factory(data, settings)
+
+        if Settings.is_active_profile(path, name):  # profile is in use
+            reply = QtGui.QMessageBox.question(None,
+                                               'Profile {}'.format(name),
+                                               QtGui.QApplication.translate("login", 'Other instance of Toxygen uses this profile or profile was not properly closed. Continue?', None, QtGui.QApplication.UnicodeUTF8),
+                                               QtGui.QMessageBox.Yes,
+                                               QtGui.QMessageBox.No)
+            if reply != QtGui.QMessageBox.Yes:
+                return
+        else:
+            settings.set_active_profile()
+
+        lang = Settings.supported_languages()[settings['language']]
+        translator = QtCore.QTranslator()
+        translator.load(curr_directory() + '/translations/' + lang)
+        app.installTranslator(translator)
+        app.translator = translator
+
+        # tray icon
+        self.tray = QtGui.QSystemTrayIcon(QtGui.QIcon(curr_directory() + '/images/icon.png'))
+        self.tray.setObjectName('tray')
+
+        self.ms = MainWindow(self.tox, self.reset, self.tray)
+
+        class Menu(QtGui.QMenu):
+
+            def newStatus(self, status):
+                profile.Profile.get_instance().set_status(status)
+                self.aboutToShow()
+                self.hide()
+
+            def aboutToShow(self):
+                status = profile.Profile.get_instance().status
+                act = self.act
+                if status is None or Settings.get_instance().locked:
+                    self.actions()[1].setVisible(False)
+                else:
+                    self.actions()[1].setVisible(True)
+                    act.actions()[0].setChecked(False)
+                    act.actions()[1].setChecked(False)
+                    act.actions()[2].setChecked(False)
+                    act.actions()[status].setChecked(True)
+                self.actions()[2].setVisible(not Settings.get_instance().locked)
+
+            def languageChange(self, *args, **kwargs):
+                self.actions()[0].setText(QtGui.QApplication.translate('tray', 'Open Toxygen', None, QtGui.QApplication.UnicodeUTF8))
+                self.actions()[1].setText(QtGui.QApplication.translate('tray', 'Set status', None, QtGui.QApplication.UnicodeUTF8))
+                self.actions()[2].setText(QtGui.QApplication.translate('tray', 'Exit', None, QtGui.QApplication.UnicodeUTF8))
+                self.act.actions()[0].setText(QtGui.QApplication.translate('tray', 'Online', None, QtGui.QApplication.UnicodeUTF8))
+                self.act.actions()[1].setText(QtGui.QApplication.translate('tray', 'Away', None, QtGui.QApplication.UnicodeUTF8))
+                self.act.actions()[2].setText(QtGui.QApplication.translate('tray', 'Busy', None, QtGui.QApplication.UnicodeUTF8))
+
+        m = Menu()
+        show = m.addAction(QtGui.QApplication.translate('tray', 'Open Toxygen', None, QtGui.QApplication.UnicodeUTF8))
+        sub = m.addMenu(QtGui.QApplication.translate('tray', 'Set status', None, QtGui.QApplication.UnicodeUTF8))
+        onl = sub.addAction(QtGui.QApplication.translate('tray', 'Online', None, QtGui.QApplication.UnicodeUTF8))
+        away = sub.addAction(QtGui.QApplication.translate('tray', 'Away', None, QtGui.QApplication.UnicodeUTF8))
+        busy = sub.addAction(QtGui.QApplication.translate('tray', 'Busy', None, QtGui.QApplication.UnicodeUTF8))
+        onl.setCheckable(True)
+        away.setCheckable(True)
+        busy.setCheckable(True)
+        m.act = sub
+        exit = m.addAction(QtGui.QApplication.translate('tray', 'Exit', None, QtGui.QApplication.UnicodeUTF8))
+
+        def show_window():
+            def show():
+                if not self.ms.isActiveWindow():
+                    self.ms.setWindowState(self.ms.windowState() & ~QtCore.Qt.WindowMinimized | QtCore.Qt.WindowActive)
+                    self.ms.activateWindow()
+                self.ms.show()
+            if not Settings.get_instance().locked:
+                show()
+            else:
+                def correct_pass():
+                    show()
+                    Settings.get_instance().locked = False
+                self.p = UnlockAppScreen(toxencryptsave.ToxEncryptSave.get_instance(), correct_pass)
+                self.p.show()
+
+        m.connect(show, QtCore.SIGNAL("triggered()"), show_window)
+        m.connect(exit, QtCore.SIGNAL("triggered()"), lambda: app.exit())
+        m.connect(m, QtCore.SIGNAL("aboutToShow()"), lambda: m.aboutToShow())
+        sub.connect(onl, QtCore.SIGNAL("triggered()"), lambda: m.newStatus(0))
+        sub.connect(away, QtCore.SIGNAL("triggered()"), lambda: m.newStatus(1))
+        sub.connect(busy, QtCore.SIGNAL("triggered()"), lambda: m.newStatus(2))
+
+        self.tray.setContextMenu(m)
+        self.tray.show()
+
+        self.ms.show()
+
+        plugin_helper = PluginLoader(self.tox, settings)  # plugin support
+        plugin_helper.load()
+
+        # init thread
+        self.init = self.InitThread(self.tox, self.ms, self.tray)
+        self.init.start()
+
+        # starting threads for tox iterate and toxav iterate
+        self.mainloop = self.ToxIterateThread(self.tox)
+        self.mainloop.start()
+        self.avloop = self.ToxAVIterateThread(self.tox.AV)
+        self.avloop.start()
+
+        if self.uri is not None:
+            self.ms.add_contact(self.uri)
+
+        app.connect(app, QtCore.SIGNAL("lastWindowClosed()"), app, QtCore.SLOT("quit()"))
+        app.exec_()
+        self.init.stop = True
+        self.mainloop.stop = True
+        self.avloop.stop = True
+        plugin_helper.stop()
+        self.mainloop.wait()
+        self.init.wait()
+        self.avloop.wait()
+        data = self.tox.get_savedata()
+        ProfileHelper.get_instance().save_profile(data)
+        settings.close()
+        del self.tox
+
+    def reset(self):
+        """
+        Create new tox instance (new network settings)
+        :return: tox instance
+        """
+        self.mainloop.stop = True
+        self.init.stop = True
+        self.avloop.stop = True
+        self.mainloop.wait()
+        self.init.wait()
+        self.avloop.wait()
+        data = self.tox.get_savedata()
+        ProfileHelper.get_instance().save_profile(data)
+        del self.tox
+        # create new tox instance
+        self.tox = profile.tox_factory(data, Settings.get_instance())
+        # init thread
+        self.init = self.InitThread(self.tox, self.ms, self.tray)
+        self.init.start()
+
+        # starting threads for tox iterate and toxav iterate
+        self.mainloop = self.ToxIterateThread(self.tox)
+        self.mainloop.start()
+
+        self.avloop = self.ToxAVIterateThread(self.tox.AV)
+        self.avloop.start()
+
+        plugin_helper = PluginLoader.get_instance()
+        plugin_helper.set_tox(self.tox)
+
+        return self.tox
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Inner classes
+    # -----------------------------------------------------------------------------------------------------------------
+
+    class InitThread(QtCore.QThread):
+
+        def __init__(self, tox, ms, tray):
+            QtCore.QThread.__init__(self)
+            self.tox, self.ms, self.tray = tox, ms, tray
+            self.stop = False
+
+        def run(self):
+            # initializing callbacks
+            init_callbacks(self.tox, self.ms, self.tray)
+            # bootstrap
+            try:
+                for data in node_generator():
+                    if self.stop:
+                        return
+                    self.tox.bootstrap(*data)
+            except:
+                pass
+            for _ in range(10):
+                if self.stop:
+                    return
+                self.msleep(1000)
+            while not self.tox.self_get_connection_status():
+                try:
+                    for data in node_generator():
+                        if self.stop:
+                            return
+                        self.tox.bootstrap(*data)
+                except:
+                    pass
+                finally:
+                    self.msleep(5000)
+
+    class ToxIterateThread(QtCore.QThread):
+
+        def __init__(self, tox):
+            QtCore.QThread.__init__(self)
+            self.tox = tox
+            self.stop = False
+
+        def run(self):
+            while not self.stop:
+                self.tox.iterate()
+                self.msleep(self.tox.iteration_interval())
+
+    class ToxAVIterateThread(QtCore.QThread):
+
+        def __init__(self, toxav):
+            QtCore.QThread.__init__(self)
+            self.toxav = toxav
+            self.stop = False
+
+        def run(self):
+            while not self.stop:
+                self.toxav.iterate()
+                self.msleep(self.toxav.iteration_interval())
+
+    class Login:
+
+        def __init__(self, arr):
+            self.arr = arr
+
+        def login_screen_close(self, t, number=-1, default=False, name=None):
+            """ Function which processes data from login screen
+            :param t: 0 - window was closed, 1 - new profile was created, 2 - profile loaded
+            :param number: num of chosen profile in list (-1 by default)
+            :param default: was or not chosen profile marked as default
+            :param name: name of new profile
+            """
+            self.t = t
+            self.num = number
+            self.default = default
+            self.name = name
+
+        def get_data(self):
+            return self.arr[self.num]
+
+
+def clean():
+    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():
+    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 or --version or --help
+        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

@@ -0,0 +1,587 @@
+# -*- coding: utf-8 -*-
+
+from menu import *
+from profile import *
+from list_items import *
+from widgets import MultilineEdit, LineEdit
+import plugin_support
+from mainscreen_widgets import *
+
+
+class MainWindow(QtGui.QMainWindow):
+
+    def __init__(self, tox, reset, tray):
+        super(MainWindow, self).__init__()
+        self.reset = reset
+        self.tray = tray
+        self.setAcceptDrops(True)
+        self.initUI(tox)
+        if settings.Settings.get_instance()['show_welcome_screen']:
+            self.ws = WelcomeScreen()
+
+    def setup_menu(self, MainWindow):
+        self.menubar = QtGui.QMenuBar(MainWindow)
+        self.menubar.setObjectName("menubar")
+        self.menubar.setNativeMenuBar(False)
+        self.menubar.setMinimumSize(self.width(), 25)
+        self.menubar.setMaximumSize(self.width(), 25)
+        self.menubar.setBaseSize(self.width(), 25)
+
+        self.menuProfile = QtGui.QMenu(self.menubar)
+        self.menuProfile.setObjectName("menuProfile")
+        self.menuSettings = QtGui.QMenu(self.menubar)
+        self.menuSettings.setObjectName("menuSettings")
+        self.menuPlugins = QtGui.QMenu(self.menubar)
+        self.menuPlugins.setObjectName("menuPlugins")
+        self.menuAbout = QtGui.QMenu(self.menubar)
+        self.menuAbout.setObjectName("menuAbout")
+
+        self.actionAdd_friend = QtGui.QAction(MainWindow)
+        self.actionAdd_friend.setObjectName("actionAdd_friend")
+        self.actionprofilesettings = QtGui.QAction(MainWindow)
+        self.actionprofilesettings.setObjectName("actionprofilesettings")
+        self.actionPrivacy_settings = QtGui.QAction(MainWindow)
+        self.actionPrivacy_settings.setObjectName("actionPrivacy_settings")
+        self.actionInterface_settings = QtGui.QAction(MainWindow)
+        self.actionInterface_settings.setObjectName("actionInterface_settings")
+        self.actionNotifications = QtGui.QAction(MainWindow)
+        self.actionNotifications.setObjectName("actionNotifications")
+        self.actionNetwork = QtGui.QAction(MainWindow)
+        self.actionNetwork.setObjectName("actionNetwork")
+        self.actionAbout_program = QtGui.QAction(MainWindow)
+        self.actionAbout_program.setObjectName("actionAbout_program")
+        self.actionSettings = QtGui.QAction(MainWindow)
+        self.actionSettings.setObjectName("actionSettings")
+        self.audioSettings = QtGui.QAction(MainWindow)
+        self.pluginData = QtGui.QAction(MainWindow)
+        self.lockApp = QtGui.QAction(MainWindow)
+        self.menuProfile.addAction(self.actionAdd_friend)
+        self.menuProfile.addAction(self.actionSettings)
+        self.menuProfile.addAction(self.lockApp)
+        self.menuSettings.addAction(self.actionPrivacy_settings)
+        self.menuSettings.addAction(self.actionInterface_settings)
+        self.menuSettings.addAction(self.actionNotifications)
+        self.menuSettings.addAction(self.actionNetwork)
+        self.menuSettings.addAction(self.audioSettings)
+        self.menuPlugins.addAction(self.pluginData)
+        self.menuAbout.addAction(self.actionAbout_program)
+        self.menubar.addAction(self.menuProfile.menuAction())
+        self.menubar.addAction(self.menuSettings.menuAction())
+        self.menubar.addAction(self.menuPlugins.menuAction())
+        self.menubar.addAction(self.menuAbout.menuAction())
+
+        self.actionAbout_program.triggered.connect(self.about_program)
+        self.actionNetwork.triggered.connect(self.network_settings)
+        self.actionAdd_friend.triggered.connect(self.add_contact)
+        self.actionSettings.triggered.connect(self.profilesettings)
+        self.actionPrivacy_settings.triggered.connect(self.privacy_settings)
+        self.actionInterface_settings.triggered.connect(self.interface_settings)
+        self.actionNotifications.triggered.connect(self.notification_settings)
+        self.audioSettings.triggered.connect(self.audio_settings)
+        self.pluginData.triggered.connect(self.plugins_menu)
+        self.lockApp.triggered.connect(self.lock_app)
+        QtCore.QMetaObject.connectSlotsByName(MainWindow)
+
+    def languageChange(self, *args, **kwargs):
+        self.retranslateUi()
+
+    def event(self, event):
+        if event.type() == QtCore.QEvent.WindowActivate:
+            self.tray.setIcon(QtGui.QIcon(curr_directory() + '/images/icon.png'))
+        return super(MainWindow, self).event(event)
+
+    def retranslateUi(self):
+        self.lockApp.setText(QtGui.QApplication.translate("MainWindow", "Lock", None, QtGui.QApplication.UnicodeUTF8))
+        self.menuPlugins.setTitle(QtGui.QApplication.translate("MainWindow", "Plugins", None, QtGui.QApplication.UnicodeUTF8))
+        self.pluginData.setText(QtGui.QApplication.translate("MainWindow", "List of plugins", None, QtGui.QApplication.UnicodeUTF8))
+        self.menuProfile.setTitle(QtGui.QApplication.translate("MainWindow", "Profile", None, QtGui.QApplication.UnicodeUTF8))
+        self.menuSettings.setTitle(QtGui.QApplication.translate("MainWindow", "Settings", None, QtGui.QApplication.UnicodeUTF8))
+        self.menuAbout.setTitle(QtGui.QApplication.translate("MainWindow", "About", None, QtGui.QApplication.UnicodeUTF8))
+        self.actionAdd_friend.setText(QtGui.QApplication.translate("MainWindow", "Add contact", None, QtGui.QApplication.UnicodeUTF8))
+        self.actionprofilesettings.setText(QtGui.QApplication.translate("MainWindow", "Profile", None, QtGui.QApplication.UnicodeUTF8))
+        self.actionPrivacy_settings.setText(QtGui.QApplication.translate("MainWindow", "Privacy", None, QtGui.QApplication.UnicodeUTF8))
+        self.actionInterface_settings.setText(QtGui.QApplication.translate("MainWindow", "Interface", None, QtGui.QApplication.UnicodeUTF8))
+        self.actionNotifications.setText(QtGui.QApplication.translate("MainWindow", "Notifications", None, QtGui.QApplication.UnicodeUTF8))
+        self.actionNetwork.setText(QtGui.QApplication.translate("MainWindow", "Network", None, QtGui.QApplication.UnicodeUTF8))
+        self.actionAbout_program.setText(QtGui.QApplication.translate("MainWindow", "About program", None, QtGui.QApplication.UnicodeUTF8))
+        self.actionSettings.setText(QtGui.QApplication.translate("MainWindow", "Settings", None, QtGui.QApplication.UnicodeUTF8))
+        self.audioSettings.setText(QtGui.QApplication.translate("MainWindow", "Audio", None, QtGui.QApplication.UnicodeUTF8))
+        self.contact_name.setPlaceholderText(QtGui.QApplication.translate("MainWindow", "Search", None, QtGui.QApplication.UnicodeUTF8))
+        self.sendMessageButton.setToolTip(QtGui.QApplication.translate("MainWindow", "Send message", None, QtGui.QApplication.UnicodeUTF8))
+        self.callButton.setToolTip(QtGui.QApplication.translate("MainWindow", "Start audio call with friend", None, QtGui.QApplication.UnicodeUTF8))
+        self.online_contacts.clear()
+        self.online_contacts.addItem(QtGui.QApplication.translate("MainWindow", "All", None, QtGui.QApplication.UnicodeUTF8))
+        self.online_contacts.addItem(QtGui.QApplication.translate("MainWindow", "Online", None, QtGui.QApplication.UnicodeUTF8))
+        self.online_contacts.setCurrentIndex(int(Settings.get_instance()['show_online_friends']))
+
+    def setup_right_bottom(self, Form):
+        Form.resize(650, 60)
+        self.messageEdit = MessageArea(Form, self)
+        self.messageEdit.setGeometry(QtCore.QRect(0, 3, 450, 55))
+        self.messageEdit.setObjectName("messageEdit")
+        font = QtGui.QFont()
+        font.setPointSize(10)
+        self.messageEdit.setFont(font)
+
+        self.sendMessageButton = QtGui.QPushButton(Form)
+        self.sendMessageButton.setGeometry(QtCore.QRect(565, 3, 60, 55))
+        self.sendMessageButton.setObjectName("sendMessageButton")
+
+        self.menuButton = MenuButton(Form, self.show_menu)
+        self.menuButton.setGeometry(QtCore.QRect(QtCore.QRect(455, 3, 55, 55)))
+
+        pixmap = QtGui.QPixmap('send.png')
+        icon = QtGui.QIcon(pixmap)
+        self.sendMessageButton.setIcon(icon)
+        self.sendMessageButton.setIconSize(QtCore.QSize(45, 60))
+
+        pixmap = QtGui.QPixmap('menu.png')
+        icon = QtGui.QIcon(pixmap)
+        self.menuButton.setIcon(icon)
+        self.menuButton.setIconSize(QtCore.QSize(40, 40))
+
+        self.sendMessageButton.clicked.connect(self.send_message)
+
+        QtCore.QMetaObject.connectSlotsByName(Form)
+
+    def setup_left_center_menu(self, Form):
+        Form.resize(270, 25)
+        self.search_label = QtGui.QLabel(Form)
+        self.search_label.setGeometry(QtCore.QRect(3, 2, 20, 20))
+        pixmap = QtGui.QPixmap()
+        pixmap.load(curr_directory() + '/images/search.png')
+        self.search_label.setScaledContents(False)
+        self.search_label.setPixmap(pixmap)
+
+        self.contact_name = LineEdit(Form)
+        self.contact_name.setGeometry(QtCore.QRect(0, 0, 150, 25))
+        self.contact_name.setObjectName("contact_name")
+        self.contact_name.textChanged.connect(self.filtering)
+
+        self.online_contacts = QtGui.QComboBox(Form)
+        self.online_contacts.setGeometry(QtCore.QRect(150, 0, 120, 25))
+        self.online_contacts.activated[int].connect(lambda x: self.filtering())
+        self.search_label.raise_()
+
+        QtCore.QMetaObject.connectSlotsByName(Form)
+
+    def setup_left_top(self, Form):
+        Form.setCursor(QtCore.Qt.PointingHandCursor)
+        Form.setMinimumSize(QtCore.QSize(270, 100))
+        Form.setMaximumSize(QtCore.QSize(270, 100))
+        Form.setBaseSize(QtCore.QSize(270, 100))
+        self.avatar_label = Form.avatar_label = QtGui.QLabel(Form)
+        self.avatar_label.setGeometry(QtCore.QRect(5, 30, 64, 64))
+        self.avatar_label.setScaledContents(True)
+        self.name = Form.name = DataLabel(Form)
+        Form.name.setGeometry(QtCore.QRect(75, 40, 150, 25))
+        font = QtGui.QFont()
+        font.setFamily("Times New Roman")
+        font.setPointSize(14)
+        font.setBold(True)
+        Form.name.setFont(font)
+        Form.name.setObjectName("name")
+        self.status_message = Form.status_message = DataLabel(Form)
+        Form.status_message.setGeometry(QtCore.QRect(75, 60, 170, 25))
+        font.setPointSize(12)
+        font.setBold(False)
+        Form.status_message.setFont(font)
+        Form.status_message.setObjectName("status_message")
+        self.connection_status = Form.connection_status = StatusCircle(Form)
+        Form.connection_status.setGeometry(QtCore.QRect(230, 35, 32, 32))
+        self.avatar_label.mouseReleaseEvent = self.profilesettings
+        self.status_message.mouseReleaseEvent = self.profilesettings
+        self.name.mouseReleaseEvent = self.profilesettings
+        self.connection_status.raise_()
+        Form.connection_status.setObjectName("connection_status")
+
+    def setup_right_top(self, Form):
+        Form.resize(650, 100)
+        self.account_avatar = QtGui.QLabel(Form)
+        self.account_avatar.setGeometry(QtCore.QRect(10, 30, 64, 64))
+        self.account_avatar.setScaledContents(True)
+        self.account_name = DataLabel(Form)
+        self.account_name.setGeometry(QtCore.QRect(100, 25, 400, 25))
+        self.account_name.setTextInteractionFlags(QtCore.Qt.LinksAccessibleByMouse)
+        font = QtGui.QFont()
+        font.setFamily("Times New Roman")
+        font.setPointSize(14)
+        font.setBold(True)
+        self.account_name.setFont(font)
+        self.account_name.setObjectName("account_name")
+        self.account_status = DataLabel(Form)
+        self.account_status.setGeometry(QtCore.QRect(100, 45, 400, 25))
+        self.account_status.setTextInteractionFlags(QtCore.Qt.LinksAccessibleByMouse)
+        font.setPointSize(12)
+        font.setBold(False)
+        self.account_status.setFont(font)
+        self.account_status.setObjectName("account_status")
+        self.callButton = QtGui.QPushButton(Form)
+        self.callButton.setGeometry(QtCore.QRect(550, 30, 50, 50))
+        self.callButton.setObjectName("callButton")
+        self.callButton.clicked.connect(lambda: self.profile.call_click(True))
+        self.videocallButton = QtGui.QPushButton(Form)
+        self.videocallButton.setGeometry(QtCore.QRect(550, 30, 50, 50))
+        self.videocallButton.setObjectName("videocallButton")
+        self.videocallButton.clicked.connect(lambda: self.profile.call_click(True, True))
+        self.update_call_state('call')
+        self.typing = QtGui.QLabel(Form)
+        self.typing.setGeometry(QtCore.QRect(500, 50, 50, 30))
+        pixmap = QtGui.QPixmap(QtCore.QSize(50, 30))
+        pixmap.load(curr_directory() + '/images/typing.png')
+        self.typing.setScaledContents(False)
+        self.typing.setPixmap(pixmap.scaled(50, 30, QtCore.Qt.KeepAspectRatio))
+        self.typing.setVisible(False)
+        QtCore.QMetaObject.connectSlotsByName(Form)
+
+    def setup_left_center(self, widget):
+        self.friends_list = QtGui.QListWidget(widget)
+        self.friends_list.setObjectName("friends_list")
+        self.friends_list.setGeometry(0, 0, 270, 310)
+        self.friends_list.clicked.connect(self.friend_click)
+        self.friends_list.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
+        self.friends_list.connect(self.friends_list, QtCore.SIGNAL("customContextMenuRequested(QPoint)"),
+                                  self.friend_right_click)
+        self.friends_list.setVerticalScrollMode(QtGui.QAbstractItemView.ScrollPerPixel)
+
+    def setup_right_center(self, widget):
+        self.messages = QtGui.QListWidget(widget)
+        self.messages.setGeometry(0, 0, 620, 310)
+        self.messages.setObjectName("messages")
+        self.messages.setSpacing(1)
+        self.messages.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOn)
+        self.messages.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
+        self.messages.setFocusPolicy(QtCore.Qt.NoFocus)
+
+        def load(pos):
+            if not pos:
+                self.profile.load_history()
+                self.messages.verticalScrollBar().setValue(1)
+        self.messages.verticalScrollBar().valueChanged.connect(load)
+        self.messages.setVerticalScrollMode(QtGui.QAbstractItemView.ScrollPerPixel)
+
+    def initUI(self, tox):
+        self.setMinimumSize(920, 500)
+        s = Settings.get_instance()
+        self.setGeometry(s['x'], s['y'], s['width'], s['height'])
+        self.setWindowTitle('Toxygen')
+        os.chdir(curr_directory() + '/images/')
+        main = QtGui.QWidget()
+        grid = QtGui.QGridLayout()
+        search = QtGui.QWidget()
+        name = QtGui.QWidget()
+        info = QtGui.QWidget()
+        main_list = QtGui.QWidget()
+        messages = QtGui.QWidget()
+        message_buttons = QtGui.QWidget()
+        self.setup_left_center_menu(search)
+        self.setup_left_top(name)
+        self.setup_right_center(messages)
+        self.setup_right_top(info)
+        self.setup_right_bottom(message_buttons)
+        self.setup_left_center(main_list)
+        if not Settings.get_instance()['mirror_mode']:
+            grid.addWidget(search, 1, 0)
+            grid.addWidget(name, 0, 0)
+            grid.addWidget(messages, 1, 1, 2, 1)
+            grid.addWidget(info, 0, 1)
+            grid.addWidget(message_buttons, 3, 1)
+            grid.addWidget(main_list, 2, 0, 2, 1)
+            grid.setColumnMinimumWidth(1, 500)
+            grid.setColumnMinimumWidth(0, 270)
+        else:
+            grid.addWidget(search, 1, 1)
+            grid.addWidget(name, 0, 1)
+            grid.addWidget(messages, 1, 0, 2, 1)
+            grid.addWidget(info, 0, 0)
+            grid.addWidget(message_buttons, 3, 0)
+            grid.addWidget(main_list, 2, 1, 2, 1)
+            grid.setColumnMinimumWidth(0, 500)
+            grid.setColumnMinimumWidth(1, 270)
+        grid.setSpacing(0)
+        grid.setContentsMargins(0, 0, 0, 0)
+        grid.setRowMinimumHeight(0, 100)
+        grid.setRowMinimumHeight(1, 25)
+        grid.setRowMinimumHeight(2, 320)
+        grid.setRowMinimumHeight(3, 55)
+        grid.setColumnStretch(1, 1)
+        grid.setRowStretch(2, 1)
+        main.setLayout(grid)
+        self.setCentralWidget(main)
+        self.setup_menu(self)
+        self.messageEdit.setFocus()
+        self.user_info = name
+        self.friend_info = info
+        self.retranslateUi()
+        self.profile = Profile(tox, self)
+
+    def closeEvent(self, *args, **kwargs):
+        self.profile.save_history()
+        self.profile.close()
+        s = Settings.get_instance()
+        s['x'] = self.pos().x()
+        s['y'] = self.pos().y()
+        s['width'] = self.width()
+        s['height'] = self.height()
+        s.save()
+        QtGui.QApplication.closeAllWindows()
+
+    def resizeEvent(self, *args, **kwargs):
+        self.messages.setGeometry(0, 0, self.width() - 270, self.height() - 155)
+        self.friends_list.setGeometry(0, 0, 270, self.height() - 125)
+
+        self.videocallButton.setGeometry(QtCore.QRect(self.width() - 330, 40, 50, 50))
+        self.callButton.setGeometry(QtCore.QRect(self.width() - 390, 40, 50, 50))
+        self.typing.setGeometry(QtCore.QRect(self.width() - 450, 50, 50, 30))
+
+        self.messageEdit.setGeometry(QtCore.QRect(55, 0, self.width() - 395, 55))
+        self.menuButton.setGeometry(QtCore.QRect(0, 0, 55, 55))
+        self.sendMessageButton.setGeometry(QtCore.QRect(self.width() - 340, 0, 70, 55))
+
+        self.account_name.setGeometry(QtCore.QRect(100, 40, self.width() - 560, 25))
+        self.account_status.setGeometry(QtCore.QRect(100, 60, self.width() - 560, 25))
+        self.messageEdit.setFocus()
+        self.profile.update()
+
+    def keyPressEvent(self, event):
+        if event.key() == QtCore.Qt.Key_Escape:
+            self.hide()
+        else:
+            super(MainWindow, self).keyPressEvent(event)
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Functions which called when user click in menu
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def about_program(self):
+        import util
+        msgBox = QtGui.QMessageBox()
+        msgBox.setWindowTitle(QtGui.QApplication.translate("MainWindow", "About", None, QtGui.QApplication.UnicodeUTF8))
+        text = (QtGui.QApplication.translate("MainWindow", 'Toxygen is Tox client written on Python.\nVersion: ', None, QtGui.QApplication.UnicodeUTF8))
+        msgBox.setText(text + util.program_version + '\nGitHub: github.com/xveduk/toxygen/')
+        msgBox.exec_()
+
+    def network_settings(self):
+        self.n_s = NetworkSettings(self.reset)
+        self.n_s.show()
+
+    def plugins_menu(self):
+        self.p_s = PluginsSettings()
+        self.p_s.show()
+
+    def add_contact(self, link=''):
+        self.a_c = AddContact(link)
+        self.a_c.show()
+
+    def profilesettings(self, *args):
+        self.p_s = ProfileSettings()
+        self.p_s.show()
+
+    def privacy_settings(self):
+        self.priv_s = PrivacySettings()
+        self.priv_s.show()
+
+    def notification_settings(self):
+        self.notif_s = NotificationsSettings()
+        self.notif_s.show()
+
+    def interface_settings(self):
+        self.int_s = InterfaceSettings()
+        self.int_s.show()
+
+    def audio_settings(self):
+        self.audio_s = AudioSettings()
+        self.audio_s.show()
+
+    def lock_app(self):
+        if toxencryptsave.ToxEncryptSave.get_instance().has_password():
+            Settings.get_instance().locked = True
+            self.hide()
+        else:
+            msgBox = QtGui.QMessageBox()
+            msgBox.setWindowTitle(
+                QtGui.QApplication.translate("MainWindow", "Cannot lock app", None, QtGui.QApplication.UnicodeUTF8))
+            msgBox.setText(
+                QtGui.QApplication.translate("MainWindow", 'Error. Profile password is not set.', None,
+                                             QtGui.QApplication.UnicodeUTF8))
+            msgBox.exec_()
+
+    def show_menu(self):
+        if not hasattr(self, 'menu'):
+            self.menu = DropdownMenu(self)
+        self.menu.setGeometry(QtCore.QRect(0 if Settings.get_instance()['mirror_mode'] else 270,
+                                           self.height() - 120,
+                                           180,
+                                           120))
+        self.menu.show()
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Messages, calls and file transfers
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def send_message(self):
+        text = self.messageEdit.toPlainText()
+        self.profile.send_message(text)
+
+    def send_file(self):
+        self.menu.hide()
+        if self.profile.active_friend + 1:
+            choose = QtGui.QApplication.translate("MainWindow", 'Choose file', None, QtGui.QApplication.UnicodeUTF8)
+            name = QtGui.QFileDialog.getOpenFileName(self, choose, options=QtGui.QFileDialog.DontUseNativeDialog)
+            if name[0]:
+                self.profile.send_file(name[0])
+
+    def send_screenshot(self, hide=False):
+        self.menu.hide()
+        if self.profile.active_friend + 1:
+            self.sw = ScreenShotWindow(self)
+            self.sw.show()
+            if hide:
+                self.hide()
+
+    def send_smiley(self):
+        self.menu.hide()
+        if self.profile.active_friend + 1:
+            self.smiley = SmileyWindow(self)
+            self.smiley.setGeometry(QtCore.QRect(self.x() if Settings.get_instance()['mirror_mode'] else 270 + self.x(),
+                                                 self.y() + self.height() - 200,
+                                                 self.smiley.width(),
+                                                 self.smiley.height()))
+            self.smiley.show()
+
+    def send_sticker(self):
+        self.menu.hide()
+        if self.profile.active_friend + 1:
+            self.sticker = StickerWindow(self)
+            self.sticker.setGeometry(QtCore.QRect(self.x() if Settings.get_instance()['mirror_mode'] else 270 + self.x(),
+                                                 self.y() + self.height() - 200,
+                                                 self.sticker.width(),
+                                                 self.sticker.height()))
+            self.sticker.show()
+
+    def active_call(self):
+        self.update_call_state('finish_call')
+
+    def incoming_call(self):
+        self.update_call_state('incoming_call')
+
+    def call_finished(self):
+        self.update_call_state('call')
+
+    def update_call_state(self, fl):
+        # TODO: do smth with video call button
+        os.chdir(curr_directory() + '/images/')
+        pixmap = QtGui.QPixmap(curr_directory() + '/images/{}.png'.format(fl))
+        icon = QtGui.QIcon(pixmap)
+        self.callButton.setIcon(icon)
+        self.callButton.setIconSize(QtCore.QSize(50, 50))
+        pixmap = QtGui.QPixmap(curr_directory() + '/images/videocall.png')
+        icon = QtGui.QIcon(pixmap)
+        self.videocallButton.setIcon(icon)
+        self.videocallButton.setIconSize(QtCore.QSize(35, 35))
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Functions which called when user open context menu in friends list
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def friend_right_click(self, pos):
+        item = self.friends_list.itemAt(pos)
+        num = self.friends_list.indexFromItem(item).row()
+        friend = Profile.get_instance().get_friend(num)
+        settings = Settings.get_instance()
+        allowed = friend.tox_id in settings['auto_accept_from_friends']
+        auto = QtGui.QApplication.translate("MainWindow", 'Disallow auto accept', None, QtGui.QApplication.UnicodeUTF8) if allowed else QtGui.QApplication.translate("MainWindow", 'Allow auto accept', None, QtGui.QApplication.UnicodeUTF8)
+        if item is not None:
+            self.listMenu = QtGui.QMenu()
+            set_alias_item = self.listMenu.addAction(QtGui.QApplication.translate("MainWindow", 'Set alias', None, QtGui.QApplication.UnicodeUTF8))
+            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(set_alias_item, QtCore.SIGNAL("triggered()"), lambda: self.set_alias(num))
+            self.connect(remove_item, QtCore.SIGNAL("triggered()"), lambda: self.remove_friend(num))
+            self.connect(copy_key_item, QtCore.SIGNAL("triggered()"), lambda: self.copy_friend_key(num))
+            self.connect(clear_history_item, QtCore.SIGNAL("triggered()"), lambda: self.clear_history(num))
+            self.connect(auto_accept_item, QtCore.SIGNAL("triggered()"), lambda: self.auto_accept(num, not allowed))
+            self.connect(notes_item, QtCore.SIGNAL("triggered()"), lambda: self.show_note(friend))
+            self.connect(copy_name_item, QtCore.SIGNAL("triggered()"), lambda: self.copy_name(friend))
+            self.connect(copy_status_item, QtCore.SIGNAL("triggered()"), lambda: self.copy_status(friend))
+            parent_position = self.friends_list.mapToGlobal(QtCore.QPoint(0, 0))
+            self.listMenu.move(parent_position + pos)
+            self.listMenu.show()
+
+    def show_note(self, friend):
+        s = Settings.get_instance()
+        note = s['notes'][friend.tox_id] if friend.tox_id in s['notes'] else ''
+        user = QtGui.QApplication.translate("MainWindow", 'Notes about user', None, QtGui.QApplication.UnicodeUTF8)
+        user = '{} {}'.format(user, friend.name)
+
+        def save_note(text):
+            if friend.tox_id in s['notes']:
+                del s['notes'][friend.tox_id]
+            if text:
+                s['notes'][friend.tox_id] = text
+            s.save()
+        self.note = MultilineEdit(user, note, save_note)
+        self.note.show()
+
+    def set_alias(self, num):
+        self.profile.set_alias(num)
+
+    def remove_friend(self, num):
+        self.profile.delete_friend(num)
+
+    def copy_friend_key(self, num):
+        tox_id = self.profile.friend_public_key(num)
+        clipboard = QtGui.QApplication.clipboard()
+        clipboard.setText(tox_id)
+
+    def copy_name(self, friend):
+        clipboard = QtGui.QApplication.clipboard()
+        clipboard.setText(friend.name)
+
+    def copy_status(self, friend):
+        clipboard = QtGui.QApplication.clipboard()
+        clipboard.setText(friend.status_message)
+
+    def clear_history(self, num):
+        self.profile.clear_history(num)
+
+    def auto_accept(self, num, value):
+        settings = Settings.get_instance()
+        tox_id = self.profile.friend_public_key(num)
+        if value:
+            settings['auto_accept_from_friends'].append(tox_id)
+        else:
+            settings['auto_accept_from_friends'].remove(tox_id)
+        settings.save()
+
+    # -----------------------------------------------------------------------------------------------------------------
+    # Functions which called when user click somewhere else
+    # -----------------------------------------------------------------------------------------------------------------
+
+    def friend_click(self, index):
+        num = index.row()
+        self.profile.set_active(num)
+
+    def mouseReleaseEvent(self, event):
+        pos = self.connection_status.pos()
+        x, y = pos.x() + self.user_info.pos().x(), pos.y() + self.user_info.pos().y()
+        if (x < event.x() < x + 32) and (y < event.y() < y + 32):
+            self.profile.change_status()
+        else:
+            super(MainWindow, self).mouseReleaseEvent(event)
+
+    def filtering(self):
+        self.profile.filtration(self.online_contacts.currentIndex() == 1, self.contact_name.text())
+

toxygen/mainscreen_widgets.py

@@ -0,0 +1,378 @@
+try:
+    from PySide import QtCore, QtGui
+except ImportError:
+    from PyQt4 import QtCore, QtGui
+from widgets import RubberBand, create_menu, QRightClickButton, CenteredWidget
+from profile import Profile
+import smileys
+import util
+
+
+class MessageArea(QtGui.QPlainTextEdit):
+    """User types messages here"""
+
+    def __init__(self, parent, form):
+        super(MessageArea, self).__init__(parent)
+        self.parent = form
+        self.setAcceptDrops(True)
+        self.timer = QtCore.QTimer(self)
+        self.timer.timeout.connect(lambda: self.parent.profile.send_typing(False))
+
+    def keyPressEvent(self, event):
+        if event.matches(QtGui.QKeySequence.Paste):
+            self.pasteEvent()
+        elif event.key() in (QtCore.Qt.Key_Return, QtCore.Qt.Key_Enter):
+            modifiers = event.modifiers()
+            if modifiers & QtCore.Qt.ControlModifier or modifiers & QtCore.Qt.ShiftModifier:
+                self.insertPlainText('\n')
+            else:
+                if self.timer.isActive():
+                    self.timer.stop()
+                self.parent.profile.send_typing(False)
+                self.parent.send_message()
+        elif event.key() == QtCore.Qt.Key_Up and not self.toPlainText():
+            self.appendPlainText(Profile.get_instance().get_last_message())
+        else:
+            self.parent.profile.send_typing(True)
+            if self.timer.isActive():
+                self.timer.stop()
+            self.timer.start(5000)
+            super(MessageArea, self).keyPressEvent(event)
+
+    def contextMenuEvent(self, event):
+        menu = create_menu(self.createStandardContextMenu())
+        menu.exec_(event.globalPos())
+        del menu
+
+    def dragEnterEvent(self, e):
+        e.accept()
+
+    def dragMoveEvent(self, e):
+        e.accept()
+
+    def dropEvent(self, e):
+        if e.mimeData().hasFormat('text/plain'):
+            e.accept()
+            self.pasteEvent(e.mimeData().text())
+        else:
+            e.ignore()
+
+    def pasteEvent(self, text=None):
+        text = text or QtGui.QApplication.clipboard().text()
+        if text.startswith('file://'):
+            self.parent.profile.send_file(text[7:])
+        else:
+            self.insertPlainText(text)
+
+
+class ScreenShotWindow(QtGui.QWidget):
+
+    def __init__(self, parent):
+        super(ScreenShotWindow, self).__init__()
+        self.parent = parent
+        self.setMouseTracking(True)
+        self.setWindowFlags(self.windowFlags() | QtCore.Qt.FramelessWindowHint | QtCore.Qt.WindowStaysOnTopHint)
+        self.showFullScreen()
+        self.setWindowOpacity(0.5)
+        self.rubberband = RubberBand()
+
+    def closeEvent(self, *args):
+        if self.parent.isHidden():
+            self.parent.show()
+
+    def mousePressEvent(self, event):
+        self.origin = event.pos()
+        self.rubberband.setGeometry(QtCore.QRect(self.origin, QtCore.QSize()))
+        self.rubberband.show()
+        QtGui.QWidget.mousePressEvent(self, event)
+
+    def mouseMoveEvent(self, event):
+        if self.rubberband.isVisible():
+            self.rubberband.setGeometry(QtCore.QRect(self.origin, event.pos()).normalized())
+            left = QtGui.QRegion(QtCore.QRect(0, 0, self.rubberband.x(), self.height()))
+            right = QtGui.QRegion(QtCore.QRect(self.rubberband.x() + self.rubberband.width(), 0, self.width(), self.height()))
+            top = QtGui.QRegion(0, 0, self.width(), self.rubberband.y())
+            bottom = QtGui.QRegion(0, self.rubberband.y() + self.rubberband.height(), self.width(), self.height())
+            self.setMask(left + right + top + bottom)
+
+    def mouseReleaseEvent(self, event):
+        if self.rubberband.isVisible():
+            self.rubberband.hide()
+            rect = self.rubberband.geometry()
+            if rect.width() and rect.height():
+                p = QtGui.QPixmap.grabWindow(QtGui.QApplication.desktop().winId(),
+                                             rect.x() + 4,
+                                             rect.y() + 4,
+                                             rect.width() - 8,
+                                             rect.height() - 8)
+                byte_array = QtCore.QByteArray()
+                buffer = QtCore.QBuffer(byte_array)
+                buffer.open(QtCore.QIODevice.WriteOnly)
+                p.save(buffer, 'PNG')
+                Profile.get_instance().send_screenshot(bytes(byte_array.data()))
+            self.close()
+
+    def keyPressEvent(self, event):
+        if event.key() == QtCore.Qt.Key_Escape:
+            self.rubberband.setHidden(True)
+            self.close()
+        else:
+            super(ScreenShotWindow, self).keyPressEvent(event)
+
+
+class SmileyWindow(QtGui.QWidget):
+    """
+    Smiley selection window
+    """
+
+    def __init__(self, parent):
+        super(SmileyWindow, self).__init__()
+        self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
+        inst = smileys.SmileyLoader.get_instance()
+        self.data = inst.get_smileys()
+        count = len(self.data)
+        if not count:
+            self.close()
+        self.page_size = int(pow(count / 8, 0.5) + 1) * 8  # smileys per page
+        if count % self.page_size == 0:
+            self.page_count = count // self.page_size
+        else:
+            self.page_count = round(count / self.page_size + 0.5)
+        self.page = -1
+        self.radio = []
+        self.parent = parent
+        for i in range(self.page_count):  # buttons with smileys
+            elem = QtGui.QRadioButton(self)
+            elem.setGeometry(QtCore.QRect(i * 20 + 5, 180, 20, 20))
+            elem.clicked.connect(lambda i=i: self.checked(i))
+            self.radio.append(elem)
+        width = max(self.page_count * 20 + 30, (self.page_size + 5) * 8 // 10)
+        self.setMaximumSize(width, 200)
+        self.setMinimumSize(width, 200)
+        self.buttons = []
+        for i in range(self.page_size):  # pages - radio buttons
+            b = QtGui.QPushButton(self)
+            b.setGeometry(QtCore.QRect((i // 8) * 20 + 5, (i % 8) * 20, 20, 20))
+            b.clicked.connect(lambda i=i: self.clicked(i))
+            self.buttons.append(b)
+        self.checked(0)
+
+    def checked(self, pos):  # new page opened
+        self.radio[self.page].setChecked(False)
+        self.radio[pos].setChecked(True)
+        self.page = pos
+        start = self.page * self.page_size
+        for i in range(self.page_size):
+            try:
+                self.buttons[i].setVisible(True)
+                pixmap = QtGui.QPixmap(self.data[start + i][1])
+                icon = QtGui.QIcon(pixmap)
+                self.buttons[i].setIcon(icon)
+            except:
+                self.buttons[i].setVisible(False)
+
+    def clicked(self, pos):  # smiley selected
+        pos += self.page * self.page_size
+        smiley = self.data[pos][0]
+        self.parent.messageEdit.insertPlainText(smiley)
+        self.close()
+
+    def leaveEvent(self, event):
+        self.close()
+
+
+class MenuButton(QtGui.QPushButton):
+
+    def __init__(self, parent, enter):
+        super(MenuButton, self).__init__(parent)
+        self.enter = enter
+
+    def enterEvent(self, event):
+        self.enter()
+        super(MenuButton, self).enterEvent(event)
+
+
+class DropdownMenu(QtGui.QWidget):
+
+    def __init__(self, parent):
+        super(DropdownMenu, self).__init__(parent)
+        self.installEventFilter(self)
+        self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
+        self.setMaximumSize(180, 120)
+        self.setMinimumSize(180, 120)
+        self.screenshotButton = QRightClickButton(self)
+        self.screenshotButton.setGeometry(QtCore.QRect(0, 60, 60, 60))
+        self.screenshotButton.setObjectName("screenshotButton")
+
+        self.fileTransferButton = QtGui.QPushButton(self)
+        self.fileTransferButton.setGeometry(QtCore.QRect(60, 60, 60, 60))
+        self.fileTransferButton.setObjectName("fileTransferButton")
+
+        self.audioMessageButton = QtGui.QPushButton(self)
+        self.audioMessageButton.setGeometry(QtCore.QRect(120, 60, 60, 60))
+
+        self.smileyButton = QtGui.QPushButton(self)
+        self.smileyButton.setGeometry(QtCore.QRect(0, 0, 60, 60))
+
+        self.videoMessageButton = QtGui.QPushButton(self)
+        self.videoMessageButton.setGeometry(QtCore.QRect(120, 0, 60, 60))
+
+        self.stickerButton = QtGui.QPushButton(self)
+        self.stickerButton.setGeometry(QtCore.QRect(60, 0, 60, 60))
+
+        pixmap = QtGui.QPixmap(util.curr_directory() + '/images/file.png')
+        icon = QtGui.QIcon(pixmap)
+        self.fileTransferButton.setIcon(icon)
+        self.fileTransferButton.setIconSize(QtCore.QSize(50, 50))
+        pixmap = QtGui.QPixmap(util.curr_directory() + '/images/screenshot.png')
+        icon = QtGui.QIcon(pixmap)
+        self.screenshotButton.setIcon(icon)
+        self.screenshotButton.setIconSize(QtCore.QSize(50, 60))
+        pixmap = QtGui.QPixmap(util.curr_directory() + '/images/audio_message.png')
+        icon = QtGui.QIcon(pixmap)
+        self.audioMessageButton.setIcon(icon)
+        self.audioMessageButton.setIconSize(QtCore.QSize(50, 50))
+        pixmap = QtGui.QPixmap(util.curr_directory() + '/images/smiley.png')
+        icon = QtGui.QIcon(pixmap)
+        self.smileyButton.setIcon(icon)
+        self.smileyButton.setIconSize(QtCore.QSize(50, 50))
+        pixmap = QtGui.QPixmap(util.curr_directory() + '/images/video_message.png')
+        icon = QtGui.QIcon(pixmap)
+        self.videoMessageButton.setIcon(icon)
+        self.videoMessageButton.setIconSize(QtCore.QSize(55, 55))
+        pixmap = QtGui.QPixmap(util.curr_directory() + '/images/sticker.png')
+        icon = QtGui.QIcon(pixmap)
+        self.stickerButton.setIcon(icon)
+        self.stickerButton.setIconSize(QtCore.QSize(55, 55))
+
+        self.screenshotButton.setToolTip(QtGui.QApplication.translate("MenuWindow", "Send screenshot", None, QtGui.QApplication.UnicodeUTF8))
+        self.fileTransferButton.setToolTip(QtGui.QApplication.translate("MenuWindow", "Send file", None, QtGui.QApplication.UnicodeUTF8))
+        self.audioMessageButton.setToolTip(QtGui.QApplication.translate("MenuWindow", "Send audio message", None, QtGui.QApplication.UnicodeUTF8))
+        self.videoMessageButton.setToolTip(QtGui.QApplication.translate("MenuWindow", "Send video message", None, QtGui.QApplication.UnicodeUTF8))
+        self.smileyButton.setToolTip(QtGui.QApplication.translate("MenuWindow", "Add smiley", None, QtGui.QApplication.UnicodeUTF8))
+        self.stickerButton.setToolTip(QtGui.QApplication.translate("MenuWindow", "Send sticker", None, QtGui.QApplication.UnicodeUTF8))
+
+        self.fileTransferButton.clicked.connect(parent.send_file)
+        self.screenshotButton.clicked.connect(parent.send_screenshot)
+        self.connect(self.screenshotButton, QtCore.SIGNAL("rightClicked()"), lambda: parent.send_screenshot(True))
+        self.smileyButton.clicked.connect(parent.send_smiley)
+        self.stickerButton.clicked.connect(parent.send_sticker)
+
+    def leaveEvent(self, event):
+        self.close()
+
+    def eventFilter(self, object, event):
+        if event.type() == QtCore.QEvent.WindowDeactivate:
+            self.close()
+        return False
+
+
+class StickerItem(QtGui.QWidget):
+
+    def __init__(self, fl):
+        super(StickerItem, self).__init__()
+        self._image_label = QtGui.QLabel(self)
+        self.path = fl
+        self.pixmap = QtGui.QPixmap()
+        self.pixmap.load(fl)
+        if self.pixmap.width() > 150:
+            self.pixmap = self.pixmap.scaled(150, 200, QtCore.Qt.KeepAspectRatio)
+        self.setFixedSize(150, self.pixmap.height())
+        self._image_label.setPixmap(self.pixmap)
+
+
+class StickerWindow(QtGui.QWidget):
+    """Sticker selection window"""
+
+    def __init__(self, parent):
+        super(StickerWindow, self).__init__()
+        self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
+        self.setMaximumSize(250, 200)
+        self.setMinimumSize(250, 200)
+        self.list = QtGui.QListWidget(self)
+        self.list.setGeometry(QtCore.QRect(0, 0, 250, 200))
+        self.arr = smileys.sticker_loader()
+        for sticker in self.arr:
+            item = StickerItem(sticker)
+            elem = QtGui.QListWidgetItem()
+            elem.setSizeHint(QtCore.QSize(250, item.height()))
+            self.list.addItem(elem)
+            self.list.setItemWidget(elem, item)
+        self.list.setVerticalScrollMode(QtGui.QAbstractItemView.ScrollPerPixel)
+        self.list.setSpacing(3)
+        self.list.clicked.connect(self.click)
+        self.parent = parent
+
+    def click(self, index):
+        num = index.row()
+        self.parent.profile.send_sticker(self.arr[num])
+        self.close()
+
+    def leaveEvent(self, event):
+        self.close()
+
+
+class WelcomeScreen(CenteredWidget):
+
+    def __init__(self):
+        super().__init__()
+        self.setMaximumSize(250, 200)
+        self.setMinimumSize(250, 200)
+        self.center()
+        self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
+        self.text = QtGui.QTextBrowser(self)
+        self.text.setGeometry(QtCore.QRect(0, 0, 250, 170))
+        self.text.setOpenExternalLinks(True)
+        self.checkbox = QtGui.QCheckBox(self)
+        self.checkbox.setGeometry(QtCore.QRect(5, 170, 240, 30))
+        self.checkbox.setText(QtGui.QApplication.translate('WelcomeScreen', "Don't show again",
+                                                           None, QtGui.QApplication.UnicodeUTF8))
+        self.setWindowTitle(QtGui.QApplication.translate('WelcomeScreen', 'Tip of the day',
+                                                         None, QtGui.QApplication.UnicodeUTF8))
+        import random
+        num = random.randint(0, 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

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

toxygen/messages.py

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

toxygen/notifications.py

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

toxygen/passwordscreen.py

@@ -0,0 +1,102 @@
+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!')

toxygen/plugin_support.py

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

toxygen/plugins/plugin_super_class.py

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

toxygen/settings.py

@@ -0,0 +1,268 @@
+from platform import system
+import json
+import os
+import locale
+from util import Singleton, curr_directory, log
+import pyaudio
+from toxencryptsave import ToxEncryptSave
+import smileys
+
+
+class Settings(dict, Singleton):
+    """
+    Settings of current profile + global app settings
+    """
+
+    def __init__(self, name):
+        Singleton.__init__(self)
+        self.path = ProfileHelper.get_path() + str(name) + '.json'
+        self.name = name
+        if os.path.isfile(self.path):
+            with open(self.path, 'rb') as fl:
+                data = fl.read()
+            inst = ToxEncryptSave.get_instance()
+            try:
+                if inst.is_data_encrypted(data):
+                    data = inst.pass_decrypt(data)
+                info = json.loads(str(data, 'utf-8'))
+            except Exception as ex:
+                info = Settings.get_default_settings()
+                log('Parsing settings error: ' + str(ex))
+            super(Settings, self).__init__(info)
+            self.upgrade()
+        else:
+            super(Settings, self).__init__(Settings.get_default_settings())
+            self.save()
+        smileys.SmileyLoader(self)
+        p = pyaudio.PyAudio()
+        self.locked = False
+        self.audio = {'input': p.get_default_input_device_info()['index'],
+                      'output': p.get_default_output_device_info()['index']}
+
+    @staticmethod
+    def get_auto_profile():
+        path = Settings.get_default_path() + 'toxygen.json'
+        if os.path.isfile(path):
+            with open(path) as fl:
+                data = fl.read()
+            auto = json.loads(data)
+            if 'path' in auto and 'name' in auto:
+                return str(auto['path']), str(auto['name'])
+        return '', ''
+
+    @staticmethod
+    def set_auto_profile(path, name):
+        p = Settings.get_default_path() + 'toxygen.json'
+        with open(p) as fl:
+            data = fl.read()
+        data = json.loads(data)
+        data['path'] = str(path)
+        data['name'] = str(name)
+        with open(p, 'w') as fl:
+            fl.write(json.dumps(data))
+
+    @staticmethod
+    def reset_auto_profile():
+        p = Settings.get_default_path() + 'toxygen.json'
+        with open(p) as fl:
+            data = fl.read()
+        data = json.loads(data)
+        if 'path' in data:
+            del data['path']
+            del data['name']
+        with open(p, 'w') as fl:
+            fl.write(json.dumps(data))
+
+    @staticmethod
+    def is_active_profile(path, name):
+        path = path + name + '.tox'
+        settings = Settings.get_default_path() + 'toxygen.json'
+        if os.path.isfile(settings):
+            with open(settings) as fl:
+                data = fl.read()
+            data = json.loads(data)
+            if 'active_profile' in data:
+                return path in data['active_profile']
+        return False
+
+    @staticmethod
+    def get_default_settings():
+        """
+        Default profile settings
+        """
+        return {
+            'theme': 'default',
+            'ipv6_enabled': True,
+            'udp_enabled': True,
+            'proxy_type': 0,
+            'proxy_host': '127.0.0.1',
+            'proxy_port': 9050,
+            'start_port': 0,
+            'end_port': 0,
+            'tcp_port': 0,
+            'notifications': True,
+            'sound_notifications': False,
+            'language': 'English',
+            'save_history': False,
+            'allow_inline': True,
+            'allow_auto_accept': True,
+            'auto_accept_path': None,
+            'show_online_friends': False,
+            'auto_accept_from_friends': [],
+            'friends_aliases': [],
+            'typing_notifications': False,
+            'calls_sound': True,
+            'blocked': [],
+            'plugins': [],
+            'notes': {},
+            'smileys': True,
+            'smiley_pack': 'default',
+            'mirror_mode': False,
+            'width': 920,
+            'height': 500,
+            'x': 400,
+            'y': 400,
+            'message_font_size': 14,
+            'unread_color': 'red',
+            'save_unsent_only': False,
+            'compact_mode': False,
+            'show_welcome_screen': True
+        }
+
+    @staticmethod
+    def supported_languages():
+        return {
+            'English': 'en_EN',
+            'Russian': 'ru_RU',
+            'French': 'fr_FR'
+        }
+
+    def upgrade(self):
+        default = Settings.get_default_settings()
+        for key in default:
+            if key not in self:
+                print(key)
+                self[key] = default[key]
+        self.save()
+
+    def save(self):
+        text = json.dumps(self)
+        inst = ToxEncryptSave.get_instance()
+        if inst.has_password():
+            text = bytes(inst.pass_encrypt(bytes(text, 'utf-8')))
+        else:
+            text = bytes(text, 'utf-8')
+        with open(self.path, 'wb') as fl:
+            fl.write(text)
+
+    def close(self):
+        path = Settings.get_default_path() + 'toxygen.json'
+        if os.path.isfile(path):
+            with open(path) as fl:
+                data = fl.read()
+            app_settings = json.loads(data)
+            try:
+                app_settings['active_profile'].remove(str(ProfileHelper.get_path() + self.name + '.tox'))
+            except:
+                pass
+            data = json.dumps(app_settings)
+            with open(path, 'w') as fl:
+                fl.write(data)
+
+    def set_active_profile(self):
+        """
+        Mark current profile as active
+        """
+        path = Settings.get_default_path() + 'toxygen.json'
+        if os.path.isfile(path):
+            with open(path) as fl:
+                data = fl.read()
+            app_settings = json.loads(data)
+        else:
+            app_settings = {}
+        if 'active_profile' not in app_settings:
+            app_settings['active_profile'] = []
+        profilepath = ProfileHelper.get_path()
+        app_settings['active_profile'].append(str(profilepath + str(self.name) + '.tox'))
+        data = json.dumps(app_settings)
+        with open(path, 'w') as fl:
+            fl.write(data)
+
+    def export(self, path):
+        text = json.dumps(self)
+        with open(path + str(self.name) + '.json', 'w') as fl:
+            fl.write(text)
+
+    @staticmethod
+    def get_default_path():
+        if system() == 'Linux':
+            return os.getenv('HOME') + '/.config/tox/'
+        elif system() == 'Windows':
+            return os.getenv('APPDATA') + '/Tox/'
+
+
+class ProfileHelper(Singleton):
+    """
+    Class with methods for search, load and save profiles
+    """
+    def __init__(self, path, name):
+        Singleton.__init__(self)
+        self._path = path + name + '.tox'
+        self._directory = path
+        # create /avatars if not exists:
+        directory = path + 'avatars'
+        if not os.path.exists(directory):
+            os.makedirs(directory)
+
+    def open_profile(self):
+        with open(self._path, 'rb') as fl:
+            data = fl.read()
+        if data:
+            return data
+        else:
+            raise IOError('Save file has zero size!')
+
+    def get_dir(self):
+        return self._directory
+
+    def save_profile(self, data):
+        inst = ToxEncryptSave.get_instance()
+        if inst.has_password():
+            data = inst.pass_encrypt(data)
+        with open(self._path, 'wb') as fl:
+            fl.write(data)
+        print('Profile saved successfully')
+
+    def export_profile(self, new_path):
+        new_path += os.path.basename(self._path)
+        with open(self._path, 'rb') as fin:
+            data = fin.read()
+        with open(new_path, 'wb') as fout:
+            fout.write(data)
+        print('Profile exported successfully')
+
+    @staticmethod
+    def find_profiles():
+        """
+        Find available tox profiles
+        """
+        path = Settings.get_default_path()
+        result = []
+        # check default path
+        if not os.path.exists(path):
+            os.makedirs(path)
+        for fl in os.listdir(path):
+            if fl.endswith('.tox'):
+                name = fl[:-4]
+                result.append((path, name))
+        path = curr_directory()
+        # check current directory
+        for fl in os.listdir(path):
+            if fl.endswith('.tox'):
+                name = fl[:-4]
+                result.append((path + '/', name))
+        return result
+
+    @staticmethod
+    def get_path():
+        return ProfileHelper.get_instance().get_dir()

toxygen/smileys.py

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