def __init__(self, argv, application_id=None):
QApplication.__init__(self, argv)
self.socket_filename = unicode(
os.path.expanduser("~/.ipc_%s" % self.generate_ipc_id()))
self.shared_mem = QSharedMemory()
self.shared_mem.setKey(self.socket_filename)
if self.shared_mem.attach():
self.is_running = True
return
self.is_running = False
if not self.shared_mem.create(1):
print >> sys.stderr, "Unable to create single instance"
return
# start local server
self.server = QLocalServer(self)
# connect signal for incoming connections
self.connect(self.server, SIGNAL("newConnection()"),
self.receive_message)
# if socket file exists, delete it
if os.path.exists(self.socket_filename):
os.remove(self.socket_filename)
# listen
self.server.listen(self.socket_filename)
def __init__(self, *args):
QApplication.__init__(self, *args)
self._memory = QSharedMemory(self)
self._memory.setKey("d2mp")
if self._memory.attach():
self._running = True
else:
self._running = False
if not self._memory.create(1):
raise RuntimeError(self._memory.errorString().toLocal8Bit().data())
def main():
app = QApplication(sys.argv)
# Prevent more than one instance from running at once
lock = QSharedMemory('ob-exit')
if lock.create(1):
view = ExitGUI()
presenter = ExitPresenter(lock, view)
view.logout.connect(presenter.logout)
view.reboot.connect(presenter.reboot)
view.poweroff.connect(presenter.poweroff)
view.closed.connect(presenter.releaseLock)
view.show()
sys.exit(app.exec_())
def __init__(self, argv, application_id=None):
QApplication.__init__(self, argv)
self.socket_filename = unicode(os.path.expanduser("~/.ipc_%s"
% self.generate_ipc_id()) )
self.shared_mem = QSharedMemory()
self.shared_mem.setKey(self.socket_filename)
if self.shared_mem.attach():
self.is_running = True
return
self.is_running = False
if not self.shared_mem.create(1):
print >>sys.stderr, "Unable to create single instance"
return
# start local server
self.server = QLocalServer(self)
# connect signal for incoming connections
self.connect(self.server, SIGNAL("newConnection()"), self.receive_message)
# if socket file exists, delete it
if os.path.exists(self.socket_filename):
os.remove(self.socket_filename)
# listen
self.server.listen(self.socket_filename)
class SingleApplication(QApplication):
def __init__(self, *argv):
QApplication.__init__(self, *argv)
self._memory = QSharedMemory(self)
self._memory.setKey("pfTool")
if self._memory.attach():
self._running = True
else:
self._running = False
if not self._memory.create(1):
raise RuntimeError(
self._memory.errorString().toLocal8Bit().data())
def is_running(self):
return self._running
def exec_(self):
mainWindow = MainWindow()
mainWindow.show()
return super(SingleApplication, self).exec_()
def __init__(self, timeout=2000, size=2**20):
self.app = QCoreApplication.instance()
if self.app is None:
self.app = QCoreApplication([])
self.sock = QLocalSocket()
self.sock.connectToServer("LivePlot")
if not self.sock.waitForConnected():
raise EnvironmentError("Couldn't find LivePlotter instance")
self.sock.disconnected.connect(self.disconnect_received)
key = str(uuid.uuid4())
self.shared_mem = QSharedMemory(key)
if not self.shared_mem.create(size):
raise Exception("Couldn't create shared memory %s" %
self.shared_mem.errorString())
logging.debug('Memory created with key %s and size %s' %
(key, self.shared_mem.size()))
self.sock.write(key)
self.sock.waitForBytesWritten()
self.is_connected = True
self.timeout = timeout
atexit.register(self.close)
def accept(self):
logging.debug('connection accepted')
conn = self.server.nextPendingConnection()
conn.waitForReadyRead()
key = str(conn.read(36))
memory = QSharedMemory()
memory.setKey(key)
memory.attach()
logging.debug('attached to memory %s with size %s'%(key, memory.size()))
atexit.register(memory.detach)
self.conns.append(conn)
self.shared_mems.append(memory)
conn.readyRead.connect(lambda: self.read_from(conn, memory))
conn.disconnected.connect(memory.detach)
conn.write('ok')
def __init__(self, timeout=2000, size=2**20):
self.app = QCoreApplication.instance()
if self.app is None:
self.app = QCoreApplication([])
self.sock = QLocalSocket()
self.sock.connectToServer("LivePlot")
if not self.sock.waitForConnected():
raise EnvironmentError("Couldn't find LivePlotter instance")
self.sock.disconnected.connect(self.disconnect_received)
key = str(uuid.uuid4())
self.shared_mem = QSharedMemory(key)
if not self.shared_mem.create(size):
raise Exception("Couldn't create shared memory %s" % self.shared_mem.errorString())
logging.debug('Memory created with key %s and size %s' % (key, self.shared_mem.size()))
self.sock.write(key)
self.sock.waitForBytesWritten()
self.is_connected = True
self.timeout = timeout
atexit.register(self.close)
class LivePlotClient(object):
def __init__(self, timeout=2000, size=2**20):
self.app = QCoreApplication.instance()
if self.app is None:
self.app = QCoreApplication([])
self.sock = QLocalSocket()
self.sock.connectToServer("LivePlot")
if not self.sock.waitForConnected():
raise EnvironmentError("Couldn't find LivePlotter instance")
self.sock.disconnected.connect(self.disconnect_received)
key = str(uuid.uuid4())
self.shared_mem = QSharedMemory(key)
if not self.shared_mem.create(size):
raise Exception("Couldn't create shared memory %s" %
self.shared_mem.errorString())
logging.debug('Memory created with key %s and size %s' %
(key, self.shared_mem.size()))
self.sock.write(key)
self.sock.waitForBytesWritten()
self.is_connected = True
self.timeout = timeout
atexit.register(self.close)
def close(self):
self.shared_mem.detach()
def send_to_plotter(self, meta, arr=None):
if not self.is_connected:
return
if meta["name"] is None:
meta["name"] = "*"
if arr is not None:
arrbytes = bytearray(arr)
arrsize = len(arrbytes)
if arrsize > self.shared_mem.size():
raise ValueError("Array too big %s > %s" %
(arrsize, self.shared_mem.size()))
meta['arrsize'] = arrsize
meta['dtype'] = str(arr.dtype)
meta['shape'] = arr.shape
else:
meta['arrsize'] = 0
meta_bytes = json.dumps(meta).ljust(200)
if len(meta_bytes) > 200:
raise ValueError("meta object is too large (> 200 char)")
if arr is None:
self.sock.write(meta_bytes)
else:
if not self.sock.bytesAvailable():
self.sock.waitForReadyRead()
self.sock.read(2)
self.shared_mem.lock()
self.sock.write(meta_bytes)
region = self.shared_mem.data()
region[:arrsize] = arrbytes
self.shared_mem.unlock()
def plot_y(self, name, arr, extent=None, start_step=None):
arr = np.array(arr)
if extent is not None and start_step is not None:
raise ValueError(
'extent and start_step provide the same info and are thus mutually exclusive'
)
if extent is not None:
x0, x1 = extent
nx = len(arr)
start_step = x0, float(x1 - x0) / nx
meta = {
'name': name,
'operation': 'plot_y',
'start_step': start_step,
'rank': 1,
}
self.send_to_plotter(meta, arr)
def plot_z(self, name, arr, extent=None, start_step=None):
'''
extent is ((initial x, final x), (initial y, final y))
start_step is ((initial x, delta x), (initial_y, final_y))
'''
arr = np.array(arr)
if extent is not None and start_step is not None:
raise ValueError(
'extent and start_step provide the same info and are thus mutually exclusive'
)
if extent is not None:
(x0, x1), (y0, y1) = extent
nx, ny = arr.shape
start_step = (x0, float(x1 - x0) / nx), (y0, float(y1 - y0) / ny)
meta = {
'name': name,
'operation': 'plot_z',
'rank': 2,
'start_step': start_step,
}
self.send_to_plotter(meta, arr)
def plot_xy(self, name, xs, ys):
arr = np.array([xs, ys])
meta = {
'name': name,
'operation': 'plot_xy',
'rank': 1,
}
self.send_to_plotter(meta, np.array([xs, ys]))
def append_y(self, name, point, start_step=None):
self.send_to_plotter({
'name': name,
'operation': 'append_y',
'value': point,
'start_step': start_step,
'rank': 1,
})
def append_xy(self, name, x, y):
self.send_to_plotter({
'name': name,
'operation': 'append_xy',
'value': (x, y),
'rank': 1,
})
def append_z(self, name, arr, start_step=None):
arr = np.array(arr)
meta = {
'name': name,
'operation': 'append_z',
'rank': 2,
'start_step': start_step,
}
self.send_to_plotter(meta, arr)
def clear(self, name=None):
self.send_to_plotter({'name': name, 'operation': 'clear'})
def hide(self, name=None):
self.send_to_plotter({'name': name, 'operation': 'close'})
def remove(self, name=None):
self.send_to_plotter({'name': name, 'operation': 'remove'})
def disconnect_received(self):
self.is_connected = False
warnings.warn(
'Disconnected from LivePlotter server, plotting has been disabled')
class LivePlotClient(object):
def __init__(self, timeout=2000, size=2**20):
self.app = QCoreApplication.instance()
if self.app is None:
self.app = QCoreApplication([])
self.sock = QLocalSocket()
self.sock.connectToServer("LivePlot")
if not self.sock.waitForConnected():
raise EnvironmentError("Couldn't find LivePlotter instance")
self.sock.disconnected.connect(self.disconnect_received)
key = str(uuid.uuid4())
self.shared_mem = QSharedMemory(key)
if not self.shared_mem.create(size):
raise Exception("Couldn't create shared memory %s" % self.shared_mem.errorString())
logging.debug('Memory created with key %s and size %s' % (key, self.shared_mem.size()))
self.sock.write(key)
self.sock.waitForBytesWritten()
self.is_connected = True
self.timeout = timeout
atexit.register(self.close)
def close(self):
self.shared_mem.detach()
def send_to_plotter(self, meta, arr=None):
if not self.is_connected:
return
if meta["name"] is None:
meta["name"] = "*";
if arr is not None:
arrbytes = bytearray(arr)
arrsize = len(arrbytes)
if arrsize > self.shared_mem.size():
raise ValueError("Array too big %s > %s" % (arrsize, self.shared_mem.size()))
meta['arrsize'] = arrsize
meta['dtype'] = str(arr.dtype)
meta['shape'] = arr.shape
else:
meta['arrsize'] = 0
meta_bytes = json.dumps(meta).ljust(200)
if len(meta_bytes) > 200:
raise ValueError("meta object is too large (> 200 char)")
if arr is None:
self.sock.write(meta_bytes)
else:
if not self.sock.bytesAvailable():
self.sock.waitForReadyRead()
self.sock.read(2)
self.shared_mem.lock()
self.sock.write(meta_bytes)
region = self.shared_mem.data()
region[:arrsize] = arrbytes
self.shared_mem.unlock()
def plot_y(self, name, arr, extent=None, start_step=None):
arr = np.array(arr)
if extent is not None and start_step is not None:
raise ValueError('extent and start_step provide the same info and are thus mutually exclusive')
if extent is not None:
x0, x1 = extent
nx = len(arr)
start_step = x0, float(x1 - x0)/nx
meta = {
'name': name,
'operation':'plot_y',
'start_step': start_step,
'rank': 1,
}
self.send_to_plotter(meta, arr)
def plot_z(self, name, arr, extent=None, start_step=None):
'''
extent is ((initial x, final x), (initial y, final y))
start_step is ((initial x, delta x), (initial_y, final_y))
'''
arr = np.array(arr)
if extent is not None and start_step is not None:
raise ValueError('extent and start_step provide the same info and are thus mutually exclusive')
if extent is not None:
(x0, x1), (y0, y1) = extent
nx, ny = arr.shape
start_step = (x0, float(x1 - x0)/nx), (y0, float(y1 - y0)/ny)
meta = {
'name': name,
'operation':'plot_z',
'rank': 2,
'start_step': start_step,
}
self.send_to_plotter(meta, arr)
def plot_xy(self, name, xs, ys):
arr = np.array([xs, ys])
meta = {
'name': name,
'operation':'plot_xy',
'rank': 1,
}
self.send_to_plotter(meta, np.array([xs, ys]))
def append_y(self, name, point, start_step=None):
self.send_to_plotter({
'name': name,
'operation': 'append_y',
'value': point,
'start_step': start_step,
'rank': 1,
})
def append_xy(self, name, x, y):
self.send_to_plotter({
'name': name,
'operation': 'append_xy',
'value': (x, y),
'rank': 1,
})
def append_z(self, name, arr, start_step=None):
arr = np.array(arr)
meta = {
'name': name,
'operation':'append_z',
'rank': 2,
'start_step': start_step,
}
self.send_to_plotter(meta, arr)
def clear(self, name=None):
self.send_to_plotter({
'name': name,
'operation': 'clear'
})
def hide(self, name=None):
self.send_to_plotter({
'name': name,
'operation': 'close'
})
def remove(self, name=None):
self.send_to_plotter({
'name': name,
'operation': 'remove'
})
def disconnect_received(self):
self.is_connected = False
warnings.warn('Disconnected from LivePlotter server, plotting has been disabled')
self.setWindowIcon(QIcon(":/logo/data/logo.png"))
self.systemTray = SystemTray(self)
self.systemTray.show()
def closeEvent(self, event):
event.ignore()
self.hide()
if __name__ == "__main__":
app = QApplication(sys.argv)
app.setQuitOnLastWindowClosed(False)
app.setApplicationName("Virux")
app.setApplicationVersion("0.5")
sharedMemory = QSharedMemory("f33a4b06-72f5-4b72-90f4-90d606cdf98c")
if sharedMemory.create(512, QSharedMemory.ReadWrite) == False:
sys.exit()
if sys.platform == "win32":
setting = QSettings("Virux.conf", QSettings.IniFormat)
else:
setting = QSettings("Virux", "Virux")
if not os.path.isfile(setting.fileName()):
setting.setValue("ContextMenu/AcilistaBaslat", False)
setting.setValue("ContextMenu/Koru", True)
setting.setValue("DialogOpen/MinimumSure", 1000 * 7200)
setting.setValue("DialogOpen/MaksimumSure", 1000 * 36000)
gui = HideWidget()
#gui.show()
#-*- coding: utf-8 -*-
from __future__ import absolute_import
import socket
from PyQt4.QtCore import QThread
from PyQt4.QtCore import QSettings
from PyQt4.QtCore import QSharedMemory
from PyQt4.QtCore import SIGNAL
sharedMemory = QSharedMemory('shared_ninja')
file_delimiter = '<-nf>'
project_delimiter = '<-np>'
class SessionListener(QThread):
###############################################################################
# SessionListener SIGNALS
###############################################################################
"""
fileOpenRequested(QString)
projectOpenRequested(QString)
"""
###############################################################################
def __init__(self):
QThread.__init__(self)
self.s_listener = socket.socket()
self.port = 9990
class SingleApplication(QApplication):
def __init__(self, *args):
QApplication.__init__(self, *args)
self._memory = QSharedMemory(self)
self._memory.setKey("d2mp")
if self._memory.attach():
self._running = True
else:
self._running = False
if not self._memory.create(1):
raise RuntimeError(self._memory.errorString().toLocal8Bit().data())
def is_running(self):
return self._running
def exec_(self):
self._create_tray_icon()
self._create_mod_manager()
self._start_file_watcher()
self._create_socket()
Settings()
return super(SingleApplication, self).exec_()
def _create_mod_manager(self):
self.manager = ModManager()
self.manager.mod_game_info()
self.manager.signals.message.connect(self.show_message_from_mod_manager)
self.manager.signals.error.connect(self.show_error_from_mod_manager)
def _create_socket(self):
self.socket = ConnectionManager()
self.manager.signals.contact_server.connect(self.socket.send)
self.socket.message.connect(self.show_message_from_socket)
self.socket.error.connect(self.show_error_from_socket)
@property
def _watcher_file_name(self):
return "d2mp.pid"
def _start_file_watcher(self):
self.watcher = QFileSystemWatcher()
self.watcher_file_path = join(abspath("."), self._watcher_file_name)
log.DEBUG("creating watcher file: %s" %(self.watcher_file_path))
write_to_file(self.watcher_file_path, "Delete this file to shutdown D2MP\n")
self.watcher.addPath(abspath("."))
self.watcher.directoryChanged.connect(self._watcher_changed_callback)
def _watcher_changed_callback(self, val):
if self._watcher_file_name not in os.listdir(val):
secs = 3
self.show_message("Shutdown", "Watcher file was deleted. D2MP will shotdown in %d seconds." %(secs))
sleep(secs)
self.exit()
def _create_tray_icon(self):
self.tray = QSystemTrayIcon(self)
self.tray.setToolTip("D2Moddin Manager")
self.tray.setIcon(QIcon(SETTINGS['icon']))
traymenu = QMenu()
traymenu.addAction("Restart", self.restart)
traymenu.addAction("Uninstall", self.uninstall)
traymenu.addAction("Preferences", UIManager().open_preferences)
traymenu.addAction("Show mod list", self.show_mod_list)
traymenu.addSeparator()
traymenu.addAction("Exit", self.exit)
self.tray.setContextMenu(traymenu)
self.tray.show()
def restart(self):
python = sys.executable
args = set(sys.argv)
args.add("restart")
os.execl(python, python, *list(sys.argv))
self.exit()
def uninstall(self):
ModManager().delete_mods()
# ModManager().uninstall_d2mp()
self.exit()
def exit(self):
# do some cleanup
return super(SingleApplication, self).exit()
def show_mod_list(self):
self.show_message("Mod List", ModManager().mod_names_as_string())
def show_message_from_socket(self, message):
self.show_message("Server message", message)
def show_error_from_socket(self, message):
self.show_message("Server error", message, QSystemTrayIcon.Critical)
def show_message_from_mod_manager(self, message):
self.show_message("ModManager message", message)
def show_error_from_mod_manager(self, message):
self.show_message("ModManager error", message, QSystemTrayIcon.Critical)
def show_message(self, title, message, icon = QSystemTrayIcon.Information):
self.tray.showMessage(title, message, icon)
class SingletonApp(QApplication):
timeout = 1000
def __init__(self, argv, application_id=None):
QApplication.__init__(self, argv)
self.socket_filename = unicode(os.path.expanduser("~/.ipc_%s" % self.generate_ipc_id()) )
self.shared_mem = QSharedMemory()
self.shared_mem.setKey(self.socket_filename)
if self.shared_mem.attach():
self.is_running = True
return
self.is_running = False
if not self.shared_mem.create(1):
print >>sys.stderr, "Unable to create single instance"
return
# start local server
self.server = QLocalServer(self)
# connect signal for incoming connections
self.connect(self.server, SIGNAL("newConnection()"), self.receive_message)
# if socket file exists, delete it
if os.path.exists(self.socket_filename):
os.remove(self.socket_filename)
# listen
self.server.listen(self.socket_filename)
def __del__(self):
self.shared_mem.detach()
if not self.is_running:
if os.path.exists(self.socket_filename):
os.remove(self.socket_filename)
def generate_ipc_id(self, channel=None):
if channel is None:
channel = os.path.basename(sys.argv[0])
return "%s_%s" % (channel, getpass.getuser())
def send_message(self, message):
if not self.is_running:
raise Exception("Client cannot connect to IPC server. Not running.")
socket = QLocalSocket(self)
socket.connectToServer(self.socket_filename, QIODevice.WriteOnly)
if not socket.waitForConnected(self.timeout):
raise Exception(str(socket.errorString()))
socket.write(pickle.dumps(message))
if not socket.waitForBytesWritten(self.timeout):
raise Exception(str(socket.errorString()))
socket.disconnectFromServer()
def receive_message(self):
socket = self.server.nextPendingConnection()
if not socket.waitForReadyRead(self.timeout):
print >>sys.stderr, socket.errorString()
return
byte_array = socket.readAll()
self.handle_new_message(pickle.loads(str(byte_array)))
def handle_new_message(self, message):
self.emit( SIGNAL("message"), message )
class SingletonApp(QApplication):
'''
Simple server based on QLocalServer, QLocalSocket, QSharedMemory
that sends and receives messages and data with a socket connection and shared memory
'''
timeout = 1000
running_apps = []
def __init__(self, argv=sys.argv, application_id=None, size=2**24):
QApplication.__init__(self, argv)
self.socket_filename = os.path.expanduser(os.path.join(os.getcwd(),'.ipc_%s' % self.generate_ipc_id()))
self.shared_mem = QSharedMemory()
self.shared_mem.setKey(self.socket_filename)
if self.shared_mem.attach():
self.is_running = True
return
self.is_running = False
if not self.shared_mem.create(size):
print >>sys.stderr, "Unable to create single instance"
return
# start local server
self.server = QLocalServer(self)
# connect signal for incoming connections
self.connect(self.server, SIGNAL("newConnection()"), self.receive_message)
# if socket file exists, delete it
if os.path.exists(self.socket_filename):
os.remove(self.socket_filename)
# listen
self.server.listen(self.socket_filename)
SingletonApp.running_apps.append(self)
def __del__(self):
logging.debug('Detaching shared memory and closing socket connection.')
self.shared_mem.detach()
if not self.is_running:
if os.path.exists(self.socket_filename):
os.remove(self.socket_filename)
def generate_ipc_id(self, channel=None):
if channel:
return '%s_%s' %(channel,getpass.get_user())
else:
return getpass.getuser()
def send_message(self, message):
if not self.is_running:
raise Exception("Client cannot connect to IPC server. Not running.")
socket = QLocalSocket(self)
socket.connectToServer(self.socket_filename, QIODevice.WriteOnly)
if not socket.waitForConnected(self.timeout):
self.__del__()
if not socket.waitForConnected(self.timeout):
raise Exception(str(socket.errorString()))
socket.write(pickle.dumps(message))
if not socket.waitForBytesWritten(self.timeout):
raise Exception(str(socket.errorString()))
socket.disconnectFromServer()
def receive_message(self):
socket = self.server.nextPendingConnection()
if not socket.waitForReadyRead(self.timeout):
print >>sys.stderr, socket.errorString()
return
byte_array = socket.readAll()
self.handle_new_message(pickle.loads(byte_array))
def handle_new_message(self, message):
logging.debug("Received: %s" %message)
self.setWindowIcon(QIcon(":/logo/data/logo.png"))
self.systemTray = SystemTray(self)
self.systemTray.show()
def closeEvent(self, event):
event.ignore()
self.hide()
if __name__ == "__main__":
app = QApplication(sys.argv)
app.setQuitOnLastWindowClosed(False)
app.setApplicationName("Virux")
app.setApplicationVersion("0.5")
sharedMemory = QSharedMemory("f33a4b06-72f5-4b72-90f4-90d606cdf98c")
if sharedMemory.create(512, QSharedMemory.ReadWrite) == False:
sys.exit()
if sys.platform == "win32":
setting = QSettings("Virux.conf", QSettings.IniFormat)
else:
setting = QSettings("Virux", "Virux")
if not os.path.isfile(setting.fileName()):
setting.setValue("ContextMenu/AcilistaBaslat", False)
setting.setValue("ContextMenu/Koru", True)
setting.setValue("DialogOpen/MinimumSure", 1000 * 7200)
setting.setValue("DialogOpen/MaksimumSure", 1000 * 36000)
gui = HideWidget()
# gui.show()
class SingletonApp(QApplication):
timeout = 1000
def __init__(self, argv, application_id=None):
QApplication.__init__(self, argv)
self.socket_filename = unicode(
os.path.expanduser("~/.ipc_%s" % self.generate_ipc_id()))
self.shared_mem = QSharedMemory()
self.shared_mem.setKey(self.socket_filename)
if self.shared_mem.attach():
self.is_running = True
return
self.is_running = False
if not self.shared_mem.create(1):
print >> sys.stderr, "Unable to create single instance"
return
# start local server
self.server = QLocalServer(self)
# connect signal for incoming connections
self.connect(self.server, SIGNAL("newConnection()"),
self.receive_message)
# if socket file exists, delete it
if os.path.exists(self.socket_filename):
os.remove(self.socket_filename)
# listen
self.server.listen(self.socket_filename)
def __del__(self):
self.shared_mem.detach()
if not self.is_running:
if os.path.exists(self.socket_filename):
os.remove(self.socket_filename)
def generate_ipc_id(self, channel=None):
if channel is None:
channel = os.path.basename(sys.argv[0])
return "%s_%s" % (channel, getpass.getuser())
def send_message(self, message):
if not self.is_running:
raise Exception(
"Client cannot connect to IPC server. Not running.")
socket = QLocalSocket(self)
socket.connectToServer(self.socket_filename, QIODevice.WriteOnly)
if not socket.waitForConnected(self.timeout):
raise Exception(str(socket.errorString()))
socket.write(pickle.dumps(message))
if not socket.waitForBytesWritten(self.timeout):
raise Exception(str(socket.errorString()))
socket.disconnectFromServer()
def receive_message(self):
socket = self.server.nextPendingConnection()
if not socket.waitForReadyRead(self.timeout):
print >> sys.stderr, socket.errorString()
return
byte_array = socket.readAll()
self.handle_new_message(pickle.loads(str(byte_array)))
def handle_new_message(self, message):
self.emit(SIGNAL("loadPgLayer"), message)