shared "clipboard"

app.py

# -*- coding: utf-8 -*-
from kivy.support import install_twisted_reactor; install_twisted_reactor()

from twisted.internet import reactor
from twisted.internet import protocol
from twisted.protocols.basic import NetstringReceiver

from kivy.app import App
from kivy.uix.textinput import TextInput
from kivy.uix.button import Button
from kivy.uix.boxlayout import BoxLayout
from kivy.logger import Logger


class ShareProtocol(NetstringReceiver):
    def connectionMade(self):
        self.factory.register(self)

    def stringReceived(self, string):
        self.factory.received(string, self)

    def connectionLost(self, reason):
        Logger.debug("Connection lost")
        self.factory.unregister(self)


class SharedMixin:
    protocol = ShareProtocol

    def __init__(self, app):
        self.app = app
        self.clients = []

    def register(self, client):
        self.clients.append(client)

    def unregister(self, client):
        self.clients.remove(client)

    def received(self, message, client):
        self.app.update_message(message)
        self.send(message, client)

    def send(self, message, ignored=None):
        message = str(message)
        for client in self.clients:
            if client is not ignored:
                client.sendString(message)



class ServerFactory(SharedMixin, protocol.Factory):
    def register(self, client):
        client.sendString(self.app.get_message())
        SharedMixin.register(self, client)


class ClientFactory(SharedMixin, protocol.ClientFactory):
    def register(self, client):
        self.app.ready_mode()
        SharedMixin.register(self, client)


class Shared(App):
    def build(self):
        root = self.login_screen()
        self.sender = None
        self.lock = False
        return root

    def login_screen(self):
        self.host_button = Button(text="Host Mode")
        self.host_button.bind(on_press=self.host_mode)
        self.server_input = TextInput(multiline=False, hint="server.local:port")
        self.connect_button = Button(text="Connect")
        self.connect_button.bind(on_press=self.client_mode)
        self.layout = BoxLayout(orientation='vertical')
        self.layout.add_widget(self.host_button)
        self.layout.add_widget(self.server_input)
        self.layout.add_widget(self.connect_button)
        return self.layout

    def client_mode(self, *args):
        Logger.debug("Entering Client Mode")
        factory = ClientFactory(self)
        hostname, port = self.server_input.text.split(':')
        reactor.connectTCP(hostname, int(port), factory)
        self.sender = factory.send

    def host_mode(self, *args):
        Logger.debug("Entering Host Mode")
        factory = ServerFactory(self)
        port = reactor.listenTCP(0, factory).getHost().port
        self.sender = factory.send
        self.ready_mode("Hosting on port %s" % port)
        from kivy.base import EventLoop; EventLoop.window.title = 'Shared | Hosting on %s' % port

    def send_message(self, *args, **kwargs):
        if self.sender and not self.lock :
            self.sender(self.textbox.text)

    def print_message(self, msg):
        self.update_message(self.textbox.text + '\n' + msg)

    def update_message(self, message):
        self.lock = True
        self.textbox.text = message
        self.lock = False

    def get_message(self):
        return self.textbox.text

    def ready_mode(self, message=""):
        self.textbox = TextInput(multiline=True, readonly=True, text='searching for host...')
        self.textbox.bind(text=self.send_message)
        self.layout.remove_widget(self.host_button)
        self.layout.remove_widget(self.server_input)
        self.layout.remove_widget(self.connect_button)
        self.layout.add_widget(self.textbox)
        self.update_message(message)
        self.textbox.readonly = False


if __name__ == '__main__':
    Shared().run()