def run(self):
self.ui.label.setText(self.ui.ui.nereyeEdit.text())
dosyaListesi = self.birlestir(self.ui.ui.neredenEdit.text())
dosyaYaz = QFile(self.ui.ui.nereyeEdit.text())
if dosyaYaz.exists() and not self.uzerineYaz:
self.emit(SIGNAL("durdur"))
return
dosyaYaz.open(QIODevice.WriteOnly)
oku = 1024*1024
boyut = self.toplamBoyut(dosyaListesi)/oku
self.ui.progressBar.setMaximum(boyut)
sayac = 0
for i in dosyaListesi:
self.ui.label2.setText(i)
dosyaOku = QFile(i)
dosyaOku.open(QIODevice.ReadOnly)
while not dosyaOku.atEnd():
dosyaYaz.writeData(dosyaOku.read(oku))
sayac += 1
self.emit(SIGNAL("value"), sayac)
self.msleep(1)
if dosyaOku.atEnd(): break
dosyaYaz.close()
self.msleep(500)
def run(self):
self.ui.label.setText(self.ui.ui.neredenEdit.text())
dosyaOku = QFile(self.ui.ui.neredenEdit.text())
dosyaOku.open(QIODevice.ReadOnly)
oku = 1024*1024
partBoyutu = int(self.ui.ui.mbEdit.text())
self.ui.progressBar.setMaximum(dosyaOku.size()/oku)
partAdi = self.ui.ui.nereyeEdit.text()
sayac = 0
partSayici = 1
while not dosyaOku.atEnd():
partAdi = "%s%s"%(partAdi[:-3], str(partSayici).zfill(3))
self.ui.label2.setText(partAdi)
partSayici += 1
dosyaYaz = QFile(partAdi)
if dosyaYaz.exists() and not self.uzerineYaz:
self.emit(SIGNAL("durdur"))
return
dosyaYaz.open(QIODevice.WriteOnly)
#self.uzerineYaz = False
for i in range(partBoyutu):
dosyaYaz.writeData(dosyaOku.read(oku))
sayac += 1
self.emit(SIGNAL("value"), sayac)
self.msleep(1)
if dosyaOku.atEnd(): break
dosyaYaz.close()
self.msleep(500)
def open(self):
self.offerSave()
path = (QFileInfo(self.filename).path()
if not self.filename.isEmpty() else ".")
fname = QFileDialog.getOpenFileName(self,
"Page Designer - Open", path,
"Page Designer Files (*.pgd)")
if fname.isEmpty():
return
self.filename = fname
fh = None
try:
fh = QFile(self.filename)
if not fh.open(QIODevice.ReadOnly):
raise IOError, unicode(fh.errorString())
items = self.scene.items()
while items:
item = items.pop()
self.scene.removeItem(item)
del item
self.addBorders()
stream = QDataStream(fh)
stream.setVersion(QDataStream.Qt_4_2)
magic = stream.readInt32()
if magic != MagicNumber:
raise IOError, "not a valid .pgd file"
fileVersion = stream.readInt16()
if fileVersion != FileVersion:
raise IOError, "unrecognised .pgd file version"
while not fh.atEnd():
self.readItemFromStream(stream)
except IOError, e:
QMessageBox.warning(self, "Page Designer -- Open Error",
"Failed to open {0}: {1}".format(self.filename, e))
def _parseConnection(self):
mapFile = QFile('maps' + os.path.sep + self.mapName + '.map')
mapFile.open(QFile.ReadOnly)
self.connections = [[] for dummy in xrange(self.countries + 1)]
while not mapFile.atEnd():
connection = QString(mapFile.readLine()).split(QRegExp(r'\D'), QString.SkipEmptyParts)
country = connection[0].toInt()[0]
for other in xrange(1, len(connection)):
self.connections[country].append(connection[other].toInt()[0])
def run(self):
fh = QFile(self.filename)
fhlen = self._file_len(self.filename)
if not fh.open(QIODevice.ReadOnly):
raise IOError, unicode(fh.errorString())
self.data_block = {}
stream = QDataStream(fh)
stream.setVersion(QDataStream.Qt_4_2)
magic = stream.readInt32()
if magic != gMAGICNUM:
raise IOError, "not a valid .jd file"
fileVersion = stream.readInt16()
if fileVersion != gFILEVERSION:
raise IOError, "unrecognised .jd file version"
while not fh.atEnd():
self._ReadItemFromStream(stream)
self.emit(SIGNAL("PROJECTLOADERDONE(PyQt_PyObject)"), self.data_block)
def run(self):
dosyaAdi = self.ui.ui.neredenEdit.text()
dosya = QFile(dosyaAdi)
dosya.open(QIODevice.ReadOnly)
oku = 1024*1024
yuzde = dosya.size()/oku+1
self.ui.progressBar.setMaximum(yuzde)
hash = self.ui.ui.comboBox.currentText()
if hash == "MD5":
self.sum = md5()
elif hash == "SHA1":
self.sum = sha1()
self.ui.label.setText(dosyaAdi)
sayac = 0
while not dosya.atEnd():
self.sum.update(dosya.read(oku))
sayac += 1
self.emit(SIGNAL("value"), sayac)
self.ui.ui.hashEdit.setText(self.sum.hexdigest())
self.msleep(500)
class ResourceRenderReply(QNetworkReply):
def __init__(self, parent, request):
QNetworkReply.__init__(self, parent)
res = ":" + str(request.url().path().toUtf8())
self.file = None
self.filepath = res
self.connect(self, SIGNAL('aboutToClose()'), self.__close)
self.setRequest(request)
self.setOperation(QNetworkAccessManager.GetOperation)
self.open()
self.setUrl(request.url())
self.connect(parent, SIGNAL("ready"), self.ready)
def ready(self):
self.emit(SIGNAL("readyRead()"))
self.emit(SIGNAL("finished()"))
def abort(self):
self.close()
def __del__(self):
if self.file:
self.__close()
def open(self, mode=None):
try:
self.file = QFile(self)
self.file.setFileName(QString(self.filepath))
self.file.open(QIODevice.ReadOnly | QIODevice.Unbuffered)
self.setOpenMode(QIODevice.ReadOnly | QIODevice.Unbuffered)
return True
except (AttributeError, IOError):
return False
def seek(self, pos):
if self.file:
return self.file.seek(pos)
return False
def __close(self):
if self.file:
self.file.close()
self.file = None
return True
def readData(self, size):
if self.file:
return self.file.read(size)
return ""
def pos(self):
if self.file:
self.file.pos()
return 0
def isSequential(self):
if self.file:
return self.file.isSequential()
return False
def size(self):
return self.file.size()
def reset(self):
if self.file:
self.file.seek(0)
return True
return False
def atEnd(self):
if self.file:
return self.file.atEnd()
return False
class LocalClient( MocapTread ):
def __init__(self, rawTempFile, parent = None):
MocapTread.__init__(self, parent)
self.exiting = False
self.curRecordFile = rawTempFile#'C:\\Users\\gregmeeresyoung\\Desktop\\mocapRecording.tmp'
self._serverThred = None
def __del__(self):
print "deleting thred"
self.exiting = True
self.wait()
def render(self,lisenPort,mocapclientIP,pluginClientIP):
if self._serverThred:
self._serverThred.render(lisenPort,mocapclientIP,pluginClientIP)
self._tmpfile = QFile(self.curRecordFile)
if not self._tmpfile.open(QFile.ReadOnly | QFile.Text):
QMessageBox.warning(self, "Nagapi Mocap",
"Cannot write file %s:\n%s." % (self.curRecordFile, self._tmpfile.errorString()))
else:
self.start()
def closeThred(self):
if self._serverThred:
self._serverThred.closeThred()
self._tmpfile.close()
self.exiting = True
#self.exit()
self.wait()
def run(self):
maxPoints = MAX_NUM_POINTS
pointDataSize = POINT_DATA_SIZE
# Note: This is never called directly. It is called by Qt once the
# thread environment has been set up.
while not self.exiting:
while not self._tmpfile.atEnd() and not self.exiting:
line = str(self._tmpfile.readLine())
line = line.replace("[",'')
line = line.replace("]",'')
unpacked_data = line.split(', ')
for index in xrange(0,maxPoints):
dataIndexOffset = 0
if index != 0:
dataIndexOffset = index * pointDataSize
tag = int(unpacked_data[dataIndexOffset])
#if tag == MOCAP_ROGE_DATA and index < maxPoints:
# print "balls",index
coltag = int(unpacked_data[dataIndexOffset+1])
x = long(unpacked_data[dataIndexOffset+2])
y = long(unpacked_data[dataIndexOffset+3])
w = long(unpacked_data[dataIndexOffset+4])
h = long(unpacked_data[dataIndexOffset+5])
if self.setClasifydata:
# setup nural pos tages done once to enable consistant traking
# of named points , once done smart clasification is used
tag = self._clasfyRegens.regenClasify(tag,coltag,x,y)
if int(tag) != MOCAP_ROGE_DATA:
if self.filterDataFlag:
x,y,w,h = self.applyFiltering(tag, x, y, w, h)
##
# emit point data to update the UI draw
#
self.emit(SIGNAL("subFrame(int, long, long, long, long)"),
tag, x, y,w,h)
self.frameDataBuffer[dataIndexOffset] = float(tag)
self.frameDataBuffer[dataIndexOffset+1] = float(coltag)
self.frameDataBuffer[dataIndexOffset+2] = float(x)
self.frameDataBuffer[dataIndexOffset+3] = float(y)
self.frameDataBuffer[dataIndexOffset+4] = float( w)
self.frameDataBuffer[dataIndexOffset+5] = float( h)
# loop throught maybe points and try and clasify
else:
self.frameDataBuffer[dataIndexOffset] = 9999
self.frameDataBuffer[dataIndexOffset+1] = 9999
self.frameDataBuffer[dataIndexOffset+2] = 9999
self.frameDataBuffer[dataIndexOffset+3] = 9999
self.frameDataBuffer[dataIndexOffset+4] = 9999
self.frameDataBuffer[dataIndexOffset+5] = 9999
if self.setClasifydata:
self._clasfyRegens.updateBoxesForNextFrame()
self.emit(SIGNAL("frameEnd()"))
if self.openRecording:
self.openRecording.write(str(self.frameDataBuffer) + "\n")
if self._serverThred:
self.frameDataBuffer= self.frameDataBuffer
self.packer_data.pack_into(self.sendDataBuffer, 0, *self.frameDataBuffer)
for key in self._serverThred.data_queues.keys():
self._serverThred.data_queues[key].append(self.sendDataBuffer)
fpsclock.sleep()
self._tmpfile.seek(0)
def setServer(self,serverThread):
self._serverThred = serverThread
