def save(self):
fileName = QFileDialog.getSaveFileName(self, caption='Save As...')
try:
file = QFile(fileName + '.txt')
file.open( QIODevice.WriteOnly | QIODevice.Text )
out = QTextStream(file)
out << self.plainTextEdit.toPlainText()
out.flush()
file.close()
self.close()
return True
except IOError:
return False
def save(self):
fileName = QFileDialog.getSaveFileName(self, caption='Save As...')
try:
file = QFile(fileName + '.txt')
file.open(QIODevice.WriteOnly | QIODevice.Text)
out = QTextStream(file)
out << self.plainTextEdit.toPlainText()
out.flush()
file.close()
self.close()
return True
except IOError:
return False
def exportDocument(self, task, fileName, format):
"""
:type task: QUrl
:type fileName: str
:type format: self.ExportFormat
:return: bool
"""
fileOut = QFile(fileName)
if not fileOut.open(QIODevice.WriteOnly | QIODevice.Text):
return False
taskMap = self.__parseTask(task)
text = self.__documentContent(taskMap, format)
streamFileOut = QTextStream(fileOut)
streamFileOut.setCodec("UTF-8")
streamFileOut << text
streamFileOut.flush()
fileOut.close()
return True
class LogsReadThread(QThread):
MAX_INITIAL_SIZE = 2*1024*1024 # 2Mb
def __init__(self, parent):
QThread.__init__(self, parent)
self.fCloseNow = False
self.fPurgeLogs = False
self.fRealParent = parent
# -------------------------------------------------------------
# Take some values from Logs Window
self.LOG_FILE_JACK = LogsW.LOG_FILE_JACK
self.LOG_FILE_A2J = LogsW.LOG_FILE_A2J
self.LOG_FILE_LASH = LogsW.LOG_FILE_LASH
self.LOG_FILE_LADISH = LogsW.LOG_FILE_LADISH
# -------------------------------------------------------------
# Init logs
if self.LOG_FILE_JACK is not None:
self.fLogFileJACK = QFile(self.LOG_FILE_JACK)
self.fLogFileJACK.open(QIODevice.ReadOnly)
self.fLogStreamJACK = QTextStream(self.fLogFileJACK)
self.fLogStreamJACK.setCodec("UTF-8")
if self.fLogFileJACK.size() > self.MAX_INITIAL_SIZE:
self.fLogStreamJACK.seek(self.fLogFileJACK.size() - self.MAX_INITIAL_SIZE)
if self.LOG_FILE_A2J is not None:
self.fLogFileA2J = QFile(self.LOG_FILE_A2J)
self.fLogFileA2J.open(QIODevice.ReadOnly)
self.fLogStreamA2J = QTextStream(self.fLogFileA2J)
self.fLogStreamA2J.setCodec("UTF-8")
if self.fLogFileA2J.size() > self.MAX_INITIAL_SIZE:
self.fLogStreamA2J.seek(self.fLogFileA2J.size() - self.MAX_INITIAL_SIZE)
if self.LOG_FILE_LASH is not None:
self.fLogFileLASH = QFile(self.LOG_FILE_LASH)
self.fLogFileLASH.open(QIODevice.ReadOnly)
self.fLogStreamLASH = QTextStream(self.fLogFileLASH)
self.fLogStreamLASH.setCodec("UTF-8")
if self.fLogFileLASH.size() > self.MAX_INITIAL_SIZE:
self.fLogStreamLASH.seek(self.fLogFileLASH.size() - self.MAX_INITIAL_SIZE)
if self.LOG_FILE_LADISH is not None:
self.fLogFileLADISH = QFile(self.LOG_FILE_LADISH)
self.fLogFileLADISH.open(QIODevice.ReadOnly)
self.fLogStreamLADISH = QTextStream(self.fLogFileLADISH)
self.fLogStreamLADISH.setCodec("UTF-8")
if self.fLogFileLADISH.size() > self.MAX_INITIAL_SIZE:
self.fLogStreamLADISH.seek(self.fLogFileLADISH.size() - self.MAX_INITIAL_SIZE)
def closeNow(self):
self.fCloseNow = True
def purgeLogs(self):
self.fPurgeLogs = True
def run(self):
# -------------------------------------------------------------
# Read logs and set text in main thread
while not self.fCloseNow:
if self.fPurgeLogs:
if self.LOG_FILE_JACK:
self.fLogStreamJACK.flush()
self.fLogFileJACK.close()
self.fLogFileJACK.open(QIODevice.WriteOnly)
self.fLogFileJACK.close()
self.fLogFileJACK.open(QIODevice.ReadOnly)
if self.LOG_FILE_A2J:
self.fLogStreamA2J.flush()
self.fLogFileA2J.close()
self.fLogFileA2J.open(QIODevice.WriteOnly)
self.fLogFileA2J.close()
self.fLogFileA2J.open(QIODevice.ReadOnly)
if self.LOG_FILE_LASH:
self.fLogStreamLASH.flush()
self.fLogFileLASH.close()
self.fLogFileLASH.open(QIODevice.WriteOnly)
self.fLogFileLASH.close()
self.fLogFileLASH.open(QIODevice.ReadOnly)
if self.LOG_FILE_LADISH:
self.fLogStreamLADISH.flush()
self.fLogFileLADISH.close()
self.fLogFileLADISH.open(QIODevice.WriteOnly)
self.fLogFileLADISH.close()
self.fLogFileLADISH.open(QIODevice.ReadOnly)
self.fPurgeLogs = False
else:
if self.LOG_FILE_JACK:
textJACK = fixLogText(self.fLogStreamJACK.readAll()).strip()
else:
textJACK = ""
if self.LOG_FILE_A2J:
textA2J = fixLogText(self.fLogStreamA2J.readAll()).strip()
else:
textA2J = ""
if self.LOG_FILE_LASH:
textLASH = fixLogText(self.fLogStreamLASH.readAll()).strip()
else:
textLASH = ""
if self.LOG_FILE_LADISH:
textLADISH = fixLogText(self.fLogStreamLADISH.readAll()).strip()
else:
textLADISH = ""
self.fRealParent.setLogsText(textJACK, textA2J, textLASH, textLADISH)
self.emit(SIGNAL("updateLogs()"))
if not self.fCloseNow:
self.sleep(1)
# -------------------------------------------------------------
# Close logs before closing thread
if self.LOG_FILE_JACK:
self.fLogFileJACK.close()
if self.LOG_FILE_A2J:
self.fLogFileA2J.close()
if self.LOG_FILE_LASH:
self.fLogFileLASH.close()
if self.LOG_FILE_LADISH:
self.fLogFileLADISH.close()
def accept(self):
self.buttonOk.setEnabled(False)
if self.inShape.currentText() == "":
QMessageBox.information(self, self.tr("Define current projection"), self.tr("No input shapefile specified"))
elif self.txtProjection.text() == "" and self.rdoProjection.isChecked():
QMessageBox.information(self, self.tr("Define current projection"), self.tr("Please specify spatial reference system"))
elif self.cmbLayer.currentText() == "" and self.rdoLayer.isChecked():
QMessageBox.information(self, self.tr("Define current projection"), self.tr("Please specify spatial reference system"))
else:
self.progressBar.setValue(5)
inName = self.inShape.currentText()
self.progressBar.setValue(10)
vLayer = ftools_utils.getVectorLayerByName(inName)
self.progressBar.setValue(30)
if vLayer == "Error":
QMessageBox.information(self, self.tr("Define current projection"), self.tr("Cannot define projection for PostGIS data...yet!"))
else:
srsDefine = None
if self.rdoProjection.isChecked():
srsDefine = self.crs
else:
destLayer = ftools_utils.getVectorLayerByName(self.cmbLayer.currentText())
srsDefine = destLayer.crs()
if srsDefine == vLayer.crs():
responce = QMessageBox.question(self, self.tr("Define current projection"),
self.tr("Identical output spatial reference system chosen\n\nAre you sure you want to proceed?"),
QMessageBox.Yes, QMessageBox.No, QMessageBox.NoButton)
if responce == QMessageBox.No:
self.progressBar.setValue(0)
self.buttonOk.setEnabled(True)
return
provider = vLayer.dataProvider()
self.progressBar.setValue(35)
inPath = provider.dataSourceUri()
p = re.compile("\|.*")
inPath = p.sub("", inPath)
self.progressBar.setValue(40)
if inPath.endswith(".shp"):
inPath = inPath[:-4]
self.progressBar.setValue(55)
if not srsDefine.isValid():
QMessageBox.information(self, self.tr("Define current projection"), self.tr("Output spatial reference system is not valid"))
else:
self.progressBar.setValue(60)
outputWkt = srsDefine.toWkt()
self.progressBar.setValue(65)
outputFile = QFile(inPath + ".prj")
outputFile.open(QIODevice.WriteOnly | QIODevice.Text)
outputPrj = QTextStream(outputFile)
outputPrj << outputWkt
outputPrj.flush()
outputFile.close()
self.progressBar.setValue(70)
checkFile = QFile(inPath + ".qpj")
if checkFile.exists():
checkFile.open(QIODevice.WriteOnly | QIODevice.Text)
outputPrj = QTextStream(checkFile)
outputPrj << outputWkt
outputPrj.flush()
checkFile.close()
self.progressBar.setValue(95)
vLayer.setCrs(srsDefine)
self.progressBar.setValue(100)
QMessageBox.information(self, self.tr("Define current projection"),
self.tr("Defined Projection For:\n%s.shp") % (inPath))
self.progressBar.setValue(0)
self.buttonOk.setEnabled(True)
def accept(self):
self.buttonOk.setEnabled(False)
if self.inShape.currentText() == "":
QMessageBox.information(self, self.tr("Define current projection"),
self.tr("No input shapefile specified"))
elif self.txtProjection.text() == "" and self.rdoProjection.isChecked(
):
QMessageBox.information(
self, self.tr("Define current projection"),
self.tr("Please specify spatial reference system"))
elif self.cmbLayer.currentText() == "" and self.rdoLayer.isChecked():
QMessageBox.information(
self, self.tr("Define current projection"),
self.tr("Please specify spatial reference system"))
else:
self.progressBar.setValue(5)
inName = self.inShape.currentText()
self.progressBar.setValue(10)
vLayer = ftools_utils.getVectorLayerByName(inName)
self.progressBar.setValue(30)
if vLayer == "Error":
QMessageBox.information(
self, self.tr("Define current projection"),
self.tr(
"Cannot define projection for PostGIS data...yet!"))
else:
srsDefine = None
if self.rdoProjection.isChecked():
srsDefine = self.crs
else:
destLayer = ftools_utils.getVectorLayerByName(
self.cmbLayer.currentText())
srsDefine = destLayer.crs()
if srsDefine == vLayer.crs():
responce = QMessageBox.question(
self, self.tr("Define current projection"),
self.
tr("Identical output spatial reference system chosen\n\nAre you sure you want to proceed?"
), QMessageBox.Yes, QMessageBox.No,
QMessageBox.NoButton)
if responce == QMessageBox.No:
self.progressBar.setValue(0)
self.buttonOk.setEnabled(True)
return
provider = vLayer.dataProvider()
self.progressBar.setValue(35)
inPath = provider.dataSourceUri()
p = re.compile("\|.*")
inPath = p.sub("", inPath)
self.progressBar.setValue(40)
if inPath.endswith(".shp"):
inPath = inPath[:-4]
self.progressBar.setValue(55)
if not srsDefine.isValid():
QMessageBox.information(
self, self.tr("Define current projection"),
self.tr(
"Output spatial reference system is not valid"))
else:
self.progressBar.setValue(60)
outputWkt = srsDefine.toWkt()
self.progressBar.setValue(65)
outputFile = QFile(inPath + ".prj")
outputFile.open(QIODevice.WriteOnly | QIODevice.Text)
outputPrj = QTextStream(outputFile)
outputPrj << outputWkt
outputPrj.flush()
outputFile.close()
self.progressBar.setValue(70)
checkFile = QFile(inPath + ".qpj")
if checkFile.exists():
checkFile.open(QIODevice.WriteOnly | QIODevice.Text)
outputPrj = QTextStream(checkFile)
outputPrj << outputWkt
outputPrj.flush()
checkFile.close()
self.progressBar.setValue(95)
vLayer.setCrs(srsDefine)
self.progressBar.setValue(100)
QMessageBox.information(
self, self.tr("Define current projection"),
self.tr("Defined Projection For:\n%s.shp") % (inPath))
self.progressBar.setValue(0)
self.buttonOk.setEnabled(True)
#coding=utf-8
from time import sleep
from PyQt4.QtCore import QTextStream,QString
from PyQt4.QtNetwork import QLocalSocket
import random
import os
if __name__ == "__main__":
pid = os.getpid()
ls = QLocalSocket()
ls.connectToServer("localserver-test")
if ls.waitForConnected():
print "连接成功"
while True:
try:
ts = QTextStream(ls)
ts << QString.number(random.randrange(1000)) + "\nTTTTTTTTTT" + "\n PID = " + QString.number(pid) + "\n"
ts.flush()
print "werite :", ls.waitForBytesWritten()
print pid
sleep(1)
except Exception as e:
print e.message
class QtSingleApplication(QApplication):
messageReceived = pyqtSignal(unicode)
def __init__(self, id, *argv):
super(QtSingleApplication, self).__init__(*argv)
self._id = id
self._activationWindow = None
self._activateOnMessage = False
# Is there another instance running?
self._outSocket = QLocalSocket()
self._outSocket.connectToServer(self._id)
self._isRunning = self._outSocket.waitForConnected()
if self._isRunning:
# Yes, there is.
self._outStream = QTextStream(self._outSocket)
self._outStream.setCodec('UTF-8')
else:
# No, there isn't.
self._outSocket = None
self._outStream = None
self._inSocket = None
self._inStream = None
self._server = QLocalServer()
self._server.listen(self._id)
self._server.newConnection.connect(self._onNewConnection)
def isRunning(self):
return self._isRunning
def id(self):
return self._id
def activationWindow(self):
return self._activationWindow
def setActivationWindow(self, activationWindow, activateOnMessage = True):
self._activationWindow = activationWindow
self._activateOnMessage = activateOnMessage
def activateWindow(self):
if not self._activationWindow:
return
self._activationWindow.setWindowState(
self._activationWindow.windowState() & ~Qt.WindowMinimized)
self._activationWindow.raise_()
self._activationWindow.activateWindow()
def sendMessage(self, msg):
if not self._outStream:
return False
self._outStream << msg << '\n'
self._outStream.flush()
return self._outSocket.waitForBytesWritten()
def _onNewConnection(self):
if self._inSocket:
self._inSocket.readyRead.disconnect(self._onReadyRead)
self._inSocket = self._server.nextPendingConnection()
if not self._inSocket:
return
self._inStream = QTextStream(self._inSocket)
self._inStream.setCodec('UTF-8')
self._inSocket.readyRead.connect(self._onReadyRead)
if self._activateOnMessage:
self.activateWindow()
def _onReadyRead(self):
while True:
msg = self._inStream.readLine()
if not msg: break
self.messageReceived.emit(msg)
