"
val = line[1].split("\"")
val = [v for v in val if v != " "]
self.set(section, line[0].strip(" "), val[0])
file.close()
class options(QtGui.QDialog):
''' Window to edit the values stored in config '''
def __init__(self, config, title=None, parent=None):
QtGui.QDialog.__init__(self, parent)
self.config = config
self.parent = parent
self.grid = QtGui.QGridLayout()
self.tree = QtGui.QTreeWidget()
self.tree.setColumnCount(1)
self.tree.setHeaderLabels(["Variable", "Value"])
self.tree.setSortingEnabled(True)
# Add all the variables
for key, item in self.config.sections.iteritems():
top = QtGui.QTreeWidgetItem(None, [key])
for k, i in item.iteritems():
widget = QtGui.QTreeWidgetItem(top, [unicode(k), unicode(i)])
widget.setFlags(widget.flags() | QtCore.Qt.ItemIsEditable)
self.tree.insertTopLevelItem(0, top)
self.connect(self.tree, QtCore.SIGNAL('itemChanged(QTreeWidgetItem *,int)'), self.action)
# Add tree
self.grid.addWidget(self.tree, 0, 0)
# Add buttons
self.buttons = QtGui.QHBoxLayout()
self.add_class = QtGui.QPushButton("Add class")
self.add_variable = QtGui.QPushButton("Add variable")
self.delete = QtGui.QPushButton("Delete")
self.exit = QtGui.QPushButton("Exit")
self.connect(self.add_class, QtCore.SIGNAL('pressed()'), self.add_class_action)
self.connect(self.add_variable, QtCore.SIGNAL('pressed()'), self.add_variable_action)
self.connect(self.delete, QtCore.SIGNAL('pressed()'), self.delete_action)
self.connect(self.exit, QtCore.SIGNAL('pressed()'), QtCore.SLOT('close()'))
self.buttons.addWidget(self.add_class)
self.buttons.addWidget(self.add_variable)
self.buttons.addWidget(self.delete)
self.buttons.addStretch(1)
self.buttons.addWidget(self.exit)
self.grid.addLayout(self.buttons, 1, 0)
self.resize(400, 400) # Random value, ugly on windows?
self.widget = QtGui.QWidget()
self.setLayout(self.grid)
self.tree.expandAll()
self.tree.adjustSize()
setStyle(self)
# Title
if title:
self.setWindowTitle(title)
else:
self.setWindowTitle("Options")
self.show()
self.exec_()
def add_class_action(self):
result = QtGui.QInputDialog.getText(self, "Add class", "Name:")
if result[1]:
self.tree.insertTopLevelItem(0, QtGui.QTreeWidgetItem(None, [unicode(result[0])]))
def add_variable_action(self):
top = self.tree.currentItem()
# Get top element
parent = top.parent()
while parent:
top = parent
parent = top.parent()
# Add variable
if top:
widget = QtGui.QTreeWidgetItem(top, ["", ""])
widget.setFlags(widget.flags() | QtCore.Qt.ItemIsEditable)
top.setExpanded(True)
def delete_action(self):
top = self.tree.currentItem()
parent = top.parent()
# Is not toplevel
if parent:
parent.removeChild(top)
else:
index = self.tree.indexOfTopLevelItem(top)
self.tree.takeTopLevelItem(index)
def action(self, item, column):
# Section
if item.parent():
section = item.parent().text(0)
self.config.set(unicode(section), unicode(item.text(0)), unicode(item.text(1)))
def __del__(self):
# Delete all the variables, to
# insert the new ones.
self.config.sections = {}
toplevels = self.tree.topLevelItemCount()
for i in range(0, toplevels):
top = self.tree.topLevelItem(i)
section = top.text(0)
children = top.childCount()
for n in range(0, children):
child = top.child(n)
key = child.text(0)
value = child.text(1)
# Store value
if key and value:
self.config.set(unicode(section), unicode(key), unicode(value))
# Refresh edits and style
if self.parent and hasattr(self.parent, "refresh_edits"):
self.parent.refresh_edits()
if self.parent and hasattr(self.parent, "refresh_style"):
self.parent.refresh_style()
# Windows showing file stats
import tempfile
import subprocess
class gplot(writer):
def header(self, x_rot=60, y_rot=30, header_len=400, drawMethod=0, choice=0):
splotWith = ["lines ", "points"]
choiceText = ["set pm3d\nset dgrid3d", ""]
head = """set term png
set output '%s'
%s
set view %s,%s
splot "-" using 1:2:3 with %s
\n""" % (self.bitmap, choiceText[choice], x_rot, y_rot, splotWith[drawMethod])
rest = header_len - len(head)
return head + " "*(rest-1) + "\n"
def before(self):
self.write_point(self.header())
self.highlow = {}
self.keys = []
def after(self):
self.write_point("""end""")
def write(self, dict):
self.write_point("%s, %s, %s\n" % (dict["x"], dict["y"], dict["z"]))
for key in dict.keys():
if key not in self.keys:
self.keys.append(key)
# Collect stats about variables
if key not in self.highlow.keys():
self.highlow[key] = ["NDEF","NDEF"]
try:
val = eval(dict[key])
if val < self.highlow[key][0] or self.highlow[key][0] == "NDEF": self.highlow[key][0] = val
if val > self.highlow[key][1] or self.highlow[key][1] == "NDEF": self.highlow[key][1] = val
except:
self.highlow[key][0] = dict[key]
self.highlow[key][1] = dict[key]
class stats(writer):
def before(self):
self.keys = []
self.x = [0,0]
self.y = [0,0]
self.z = [0,0]
self.highlow = {}
self.values = []
def write(self, dict):
for key in dict.keys():
if key not in self.keys:
self.keys.append(key)
# Collect stats about variables
if key not in self.highlow.keys():
self.highlow[key] = ["NDEF","NDEF"]
try:
val = eval(dict[key])
if val < self.highlow[key][0] or self.highlow[key][0] == "NDEF": self.highlow[key][0] = val
if val > self.highlow[key][1] or self.highlow[key][1] == "NDEF": self.highlow[key][1] = val
except:
self.highlow[key][0] = dict[key]
self.highlow[key][1] = dict[key]
self.values.append((dict["x"], dict["y"], dict["z"]))
class Dummy: pass
class graph_window(QtGui.QWidget):
def __init__(self, x, y, z, value=[], heigth=200, width=200):
QtGui.QWidget.__init__(self)
self.x = x; self.y = y; self.z = z
self.point = []
#self.drawMe()
self.heigth = heigth # self.x[1]-self.x[0]
self.width = width # self.y[1]-self.y[0]
def addPoints(self, points):
for x, y, z in points:
newx = ((self.x[1]-float(x)-self.x[0])+1) / self.width
self.point.append((newx, (int(float(y))-self.y[0])/self.heigth, int(float(z))-self.z[0]))
def next(self):
self.update()
def drawMe(self):
self.update()
def draw_picture(self):
#rect = QtCore.QRectF(10, 10, 380, 380)
self.pen = QtGui.QPen(QtCore.Qt.black)
self.pen.setWidth(1)
# self.pen.setCapStyle(QtCore.Qt.RoundCap)
#self.pen.setStyle(QtCore.Qt.SolidLine)
painter = QtGui.QPainter()
painter.begin(self)
painter.setPen(self.pen)
#painter.setRenderHint(QtGui.QPainter.Antialiasing)
#painter.setOpacity(self.opac)
#painter.drawText(rect, 4, self.text[self.pos])
#painter.drawPoint(10, 10)
for x, y, z in self.point:
print "Draw:", x, y, z
painter.drawPoint(x, y)
painter.end()
def paintEvent(self, event):
self.draw_picture()
class file_stats_window(QtGui.QDialog):
def __init__(self, parent=None):
QtGui.QDialog.__init__(self, parent)
self.parent = parent
self.grid = QtGui.QVBoxLayout()
self.splitter = QtGui.QSplitter()
self.splitter.setOrientation(0x2) # vertical QT::Vertical
self.tree = QtGui.QTreeWidget()
self.label = QtGui.QLabel()
self.label.setFrameStyle(QtGui.QFrame.Panel | QtGui.QFrame.Sunken);
self.label.setScaledContents(True)
self.splitter.addWidget(self.tree)
self.splitter.addWidget(self.label)
self.grid.addWidget(self.splitter)
self.options_box = QtGui.QHBoxLayout()
self.draw_box = QtGui.QComboBox()
self.draw_box.addItem("Surface")
self.draw_box.addItem("Datapoints")
self.with_box = QtGui.QComboBox()
self.with_box.addItem("Lines")
self.with_box.addItem("Points")
self.options_box.addWidget(self.draw_box)
self.options_box.addWidget(self.with_box)
self.grid.addLayout(self.options_box)
self.graph_box = QtGui.QHBoxLayout()
self.xrot_edit = QtGui.QSpinBox() #LineEdit()
self.xrot_edit.setMinimum(0)
self.xrot_edit.setMaximum(180)
self.zrot_edit = QtGui.QSpinBox() # QtGui.QLineEdit()
self.zrot_edit.setMinimum(0)
self.zrot_edit.setMaximum(180)
self.graph_box.addWidget(QtGui.QLabel("x_rot:"), 0)
self.graph_box.addWidget(self.xrot_edit, 0)
self.graph_box.addWidget(QtGui.QLabel("z_rot:"), 0)
self.graph_box.addWidget(self.zrot_edit, 0)
self.plot_button = QtGui.QPushButton('Plot')
self.connect(self.plot_button, QtCore.SIGNAL('pressed()'), self.changeAngle)
self.graph_box.addWidget(self.plot_button, 100)
self.grid.addLayout(self.graph_box)
# Create temporary file for gnuplot file
fd, tmpfile = tempfile.mkstemp(prefix="plot")
file_ = os.fdopen(fd)
file_.close()
# tmpfile = "gnuplotfile"
# Writer object creating gnuplot file
writerObj = gplot(tmpfile, job="writer")
# Create temporary file for bitmap file
fd, writerObj.bitmap = tempfile.mkstemp(prefix="FileConvert")
file_ = os.fdopen(fd)
file_.close()
try:
k = coords(unicode(parent.in_file_edit.text()), tmpfile, None, readers, writers, reader=parent.reader, writer=writerObj)
lines = k.convert(parent, title=["Analyzing file", "Cancelled process"])
except: return # Maybe show stats after all?
header = []
for key in writerObj.highlow.keys():
header.append(key)
self.tree.setHeaderLabels(["Variable", "Min", "Max"])
self.tree.setSortingEnabled(True)
# Add min, max for each variable
for key in writerObj.highlow.keys():
strList = [key] + [unicode(i) for i in writerObj.highlow[key]]
widget = QtGui.QTreeWidgetItem(None, strList)
self.tree.insertTopLevelItem(0, widget)
# Close file, it is also done in del
writerObj.file.close()
self.writer = writerObj
# Set angle
self.angle = [60, 30]
self.xrot_edit.setValue(self.angle[0])
self.zrot_edit.setValue(self.angle[1])
self.tmpfiles = [tmpfile, writerObj.bitmap]
# Create graph bitmap
#subprocess.call("gnuplot %s" % tmpfile, shell=True)
# self.generateGraph(tmpfile)
# Load bitmap into dialog
self.pix = QtGui.QPixmap()
self.changeAngle()
#self.loadGraph(writerObj.bitmap)
#self.connect(self, QtCore.SIGNAL("updateGraph()"), self.changeAngle)
#self.emit(QtCore.SIGNAL('updateGraph()'), self)
#self.pix.load(writerObj.bitmap)
#self.label.setPixmap(self.pix)
#self.timer = QtCore.QTimer(None);
#self.connect(self.timer, QtCore.SIGNAL("timeout()"), self.changeAngle);
#self.timer.start(2000) # Two seconds
self.setLayout(self.grid)
self.show()
self.exec_()
#def emit_trigger(self):
# self.emit(QtCore.SIGNAL('updateGraph()'), self)
def changeAngle(self):
class graphThread(QtCore.QThread):
def __init__(self, window):
self.window = window
QtCore.QThread.__init__(self)
def run(self):
self.progress = QtGui.QProgressDialog("Generating graph with Gnuplot", 'Cancel', 0, 100, None)
self.progress.setMinimumDuration(0)
self.progress.setValue(0)
#def stop(self):
# self.progress.setValue(100)
# thread = graphThread(self)
#thread.start()
self.parent.parent.processEvents()
#self.plot_button.setFlat(False)
#self.parent.parent.processEvents()
#progress = QtGui.QProgressDialog("Generating graph with Gnuplot", 'Cancel', 0, 100, self)
#progress.setMinimumDuration(0)
#progress.setValue(0)
self.angle[0] = int(self.xrot_edit.text())%180
self.angle[1] = int(self.zrot_edit.text())%180
self.setAngle(self.tmpfiles[0], self.angle[0], self.angle[1])
self.generateGraph(self.tmpfiles[0])
self.loadGraph(self.tmpfiles[1])
#progress.setValue(100)
#self.parent.parent.processEvents()
#thread.stop()
def loadGraph(self, bitmap):
self.pix.load(bitmap)
self.label.setPixmap(self.pix)
def setAngle(self, file, x, y):
# Change line in file about view
choice = self.draw_box.currentIndex()
drawMethod = self.with_box.currentIndex()
file_ = open(file, "r+")
file_.write(self.writer.header(x_rot=x, y_rot=y, choice=choice, drawMethod=drawMethod))
file_.close()
return
# Find view
#for line in file_:
# if line.find("set view") != -1:
# # Found line
# print line
# file_.seek(len(line)*-1, os.SEEK_CUR)
# print file_.tell()
# file_.write("set view %s,%s\n" % (str(x), str(y)))
# print file_.tell()
# break
lines = file_.readlines(6*100)
# draw = drawChoice[choice]
# draw = {"points": 1, "lines": 0}
splotWith = ["lines ", "points"]
pos = 0
for line in lines:
if line.find("set view") != -1:
file_.seek(pos)
out = "set view %s,%s" % (str(x), str(y))
file_.write(out)
if len(out) < len(line): # Get rid of old content
file_.write(" "*(len(line)-len(out)-1) + "\n")
else: file_.write("\n")
if line.find('splot "-" using 1:2:3 with') != -1:
file_.seek(pos)
out = 'splot "-" using 1:2:3 with ' + splotWith[drawMethod]
file_.write(out)
if choice == 0:
# set dgrid3d
if line.find('#et pm3d') != -1:
file_.seek(pos); file_.write('set pm3d')
if line.find('#et dgrid3d') != -1:
file_.seek(pos); file_.write('set dgrid3d')
if choice == 1:
# set dgrid3d
if line.find('set pm3d') != -1:
file_.seek(pos); file_.write('#et pm3d')
if line.find('set dgrid3d') != -1:
file_.seek(pos); file_.write('#et dgrid3d')
pos += len(line)
file_.close()
def generateGraph(self, file):
gnuplot = "gnuplot"
if (os.getenv("USERPROFILE")): gnuplot = "pgnuplot" # Windows :X
subprocess.call("%s %s" % (gnuplot, file), shell=True)
def __del__(self):
# Remove temporary files
#for file in self.tmpfiles:
# os.remove(file)
pass
# Send messsage window
class contact_me(QtGui.QDialog):
''' A window to send a message to me '''
def __init__(self, title=None, parent=None):
QtGui.QDialog.__init__(self, parent)
self.box = QtGui.QGridLayout(self)
# Name, contact, message
self.name_edit = QtGui.QLineEdit()
self.name_label = QtGui.QLabel("Name:")
self.box.addWidget(self.name_label, 0, 0)
self.box.addWidget(self.name_edit, 0, 1)
self.contact_edit = QtGui.QLineEdit()
self.contact_label = QtGui.QLabel("Email:")
self.box.addWidget(self.contact_label, 1, 0)
self.box.addWidget(self.contact_edit, 1, 1)
self.text_edit = QtGui.QTextEdit()
self.box.addWidget(self.text_edit, 2, 0, 1, 0)
self.send_button = QtGui.QPushButton("Send")
self.connect(self.send_button, QtCore.SIGNAL('pressed()'), self.send_action)
self.box.addWidget(self.send_button, 3, 0, 1, 0)
setStyle(self)
self.setWindowTitle("Send message")
self.show()
self.exec_()
# Implemented my own urllib.urlencode
def urlencode(self, txt):
new = txt.replace("", "")
i = 0
while i < len(new):
char = str(new[i])
if not char.isalnum() and not char == "%":
h = hex(ord(char))[2:]
if len(h) == 1:
h = "0" + h
new = new.replace(char, "%" + h )
i+=1
return new.replace(" ", "+")
# Send message
def send_action(self):
get = []
get.append("key=willywonka")
get.append("name=" + unicode(self.urlencode(self.name_edit.text().toAscii())))
get.append("email=" + unicode(self.urlencode(self.contact_edit.text().toAscii())))
get.append("version="+version)
get.append("text="+ unicode(self.urlencode(self.text_edit.toPlainText().toAscii())))
url = "http://www.0x6.org/FileConvert/message.php?"
res = urllib2.urlopen(url + "&".join(get))
res = res.readlines()
if "1" in res:
QtGui.QMessageBox.information(self, 'Message', "Message sendt.")
else:
QtGui.QMessageBox.warning(self, 'Message error', "Recieved the following error:\n\n" + "".join(res))
# Window showing long text
class textedit(QtGui.QDialog):
''' Class to show long texts '''
def __init__(self, text, title=None, parent = None):
QtGui.QDialog.__init__(self, parent)
self.grid = QtGui.QGridLayout(self)
self.text = QtGui.QTextEdit()
try: text = unicode(text, "utf-8")
except TypeError: pass
content = [""]
content.append("")
self.text.setHtml("".join(content))
# self.text.setSource(QtCore.QUrl("http://www.0x6.org"))
# self.text.setTextBackgroundColor(QtGui.QColor(255, 255, 255))
self.text.show()
# Show Image
self.grid.addWidget(self.text, 1, 0)
self.grid.setMargin(0)
self.text.setReadOnly(True)
self.resize(400, 400) # Random value, ugly on windows?
setStyle(self)
if title:
self.setWindowTitle(title)
self.show()
self.exec_()
# Code handling loading of custom classes
# Load file, adding global to the name
# to allow the classname be global
def load_file(filepath, classname):
fp = open(filepath, "r")
txt = fp.readlines()
txt = ["global " + classname + "\n"] + txt
exec("".join(txt))
fp.close()
# !! ADD check for illegal paths !!
def check_file(filepath):
if os.path.exists(filepath) and not os.path.isdir(filepath) and filepath.split(".")[-1] == "py":
# Open file to see what classes it contains
fp = open(filepath)
for line in fp:
pos = line.find("class")
if pos == 0:
rest = line[pos+len("class")+1:]
pos = rest.find("(")
if pos != -1:
name = rest[:pos]
types = rest[pos:].strip("():\n ").split(",")
# Strip the types
types = map(lambda x: x.strip(" "), types)
if "writer" in types:
writers[name] = name
if "reader" in types:
readers[name] = name
# Load the file
load_file(filepath, name)
fp.close()
def load_formats():
''' Load all custom formats in the formats directory '''
# Load all the file from the formats folder
path = os.path.join(folder,"formats")
if os.path.exists(path) and os.path.isdir(path):
for file in os.listdir(path):
filepath = os.path.join(path,file)
if not os.path.isdir(filepath) and filepath.split(".")[-1] == "py":
# Open file to see what classes it contains
fp = open(filepath)
for line in fp:
pos = line.find("class")
if pos == 0:
rest = line[pos+len("class")+1:]
pos = rest.find("(")
if pos != -1:
name = rest[:pos]
types = rest[pos:].strip("():\n ").split(",")
# Strip the types
types = map(lambda x: x.strip(" "), types)
if "writer" in types:
writers[name] = name
if "reader" in types:
readers[name] = name
# Load the file
load_file(filepath, name)
fp.close()
# Code defining and showing main window
import time
import traceback
# Main window
class window(QtGui.QMainWindow):
''' Main window, using PyQt '''
def __init__(self, parent=None, save=True):
# Main window
QtGui.QMainWindow.__init__(self, None)
# Accept drag-n-drop
self.setAcceptDrops(True)
# When running tests, don't save settings
self.save = save
# Timer for updates
self.newversion = False
# Set timer to look for new version.
self.timer = QtCore.QTimer(None);
self.connect(self.timer, QtCore.SIGNAL("timeout()"), self.newVersion);
self.timer.start(2000) # Two seconds
if (not os.path.exists(folder + filename + ".ini")):
# File does not exist. Create one
config = ConfigParser()
conf = open(folder + filename + ".ini", "w")
config.write(conf)
conf.close()
# Load settings
config = ConfigParser()
config.read(folder + filename + ".ini")
self.config = config
# Update times started
started = config.get("FileConvert", "started")
if started:
started = int(started)+1
else:
started = 1
config.set("FileConvert", "started", unicode(started))
# Skin
self.refresh_style()
self.parent = parent
self.setWindowTitle('FileConvert ' + version)
self.main_box = QtGui.QVBoxLayout()
self.content_box = QtGui.QGridLayout()
self.inout_box = QtGui.QGridLayout()
self.inout_groupbox = QtGui.QGroupBox("&File options")
# Infile
self.in_file_label = QtGui.QLabel("Infile")
self.in_file_button = QtGui.QPushButton('...')
self.in_file_button.setMaximumWidth(50) # ugh?
self.connect(self.in_file_button, QtCore.SIGNAL('pressed()'), self.in_file_get)
# Drag-and-drop
class edit_dragdrop1(QtGui.QLineEdit):
def dragEnterEvent(self, evt):
# See if it has text
data = evt.mimeData()
if data.hasText():
evt.accept()
def dropEvent(self, evt):
# Add the text to infile
data = evt.mimeData()
text = unicode(data.text())
# Get rid of file:// and \n\r (with X anyways)
text = text.replace("file://", "")
text = text.strip("\r\n")
self.setText(text)
# Drag-and-drop
class edit_dragdrop(QtGui.QLineEdit):
def dragEnterEvent(self, evt):
# See if it has text
data = evt.mimeData()
if data.hasText() or data.hasUrls():
evt.accept()
def dropEvent(self, evt):
# Add the text to infile
data = evt.mimeData()
text = ""
# Url or text? Prefer text in linux to avoid
# having to deal with leading / in linux/windows.
if data.hasText():
text = unicode(data.text())
text = text.replace("file://", "") # Linux stuff
text = text.strip("\r\n")
elif data.hasUrls():
text = unicode(data.urls()[0].path())
text = text.strip("\r\n/") # Windows stuff
self.setText(text)
self.in_file_edit = edit_dragdrop()
# Get from config
in_file = config.get("FileConvert", "infile")
if in_file:
self.in_file_edit.setText(in_file)
else:
self.in_file_edit.setText("")
self.connect(self.in_file_edit, QtCore.SIGNAL('textChanged(const QString&)'), self.in_file_edit_change)
self.inout_box.addWidget(self.in_file_label, 0, 0)
self.inout_box.addWidget(self.in_file_edit, 1, 0)
self.inout_box.addWidget(self.in_file_button, 1, 1)
# Outfile
self.out_file_label = QtGui.QLabel("Outfile")
self.out_file_button = QtGui.QPushButton('...')
self.out_file_button.setMaximumWidth(50) # ugh?
self.connect(self.out_file_button, QtCore.SIGNAL('pressed()'), self.out_file_get)
self.out_file_edit = QtGui.QLineEdit()
# Drag-and-drop
self.out_file_edit.setAcceptDrops(False)
# Get value from config
out_file = config.get("FileConvert", "outfile")
if out_file:
self.out_file_edit.setText(out_file)
else:
self.out_file_edit.setText("")
self.connect(self.out_file_edit, QtCore.SIGNAL('textChanged(const QString&)'), self.out_file_edit_change)
self.inout_box.addWidget(self.out_file_label, 2, 0)
self.inout_box.addWidget(self.out_file_edit, 3, 0)
self.inout_box.addWidget(self.out_file_button, 3, 1)
# Add layout to groupbox
self.inout_groupbox.setLayout(self.inout_box)
self.content_box.addWidget(self.inout_groupbox, 0, 0, 1, 3)
# Options
self.reader_box = QtGui.QGridLayout()
self.writer_box = QtGui.QGridLayout()
# Add options
self.reader_groupbox = QtGui.QGroupBox("&Reader options")
self.reader_groupbox.setLayout(self.reader_box)
self.writer_groupbox = QtGui.QGroupBox("&Writer options")
self.writer_groupbox.setLayout(self.writer_box)
self.content_box.addWidget(self.reader_groupbox, 1, 0, 1, 3)
self.content_box.addWidget(self.writer_groupbox, 2, 0, 1, 3)
# Main
self.main_box.addLayout(self.content_box)
self.main_box.addStretch(1)
# Convert
self.convert_button = QtGui.QPushButton('Convert')
self.connect(self.convert_button, QtCore.SIGNAL('pressed()'), self.convert)
self.main_box.addWidget(self.convert_button)
# widget
self.widget = QtGui.QWidget()
self.widget.setLayout(self.main_box)
self.setCentralWidget(self.widget)
# Menu
self.update_menu = QtGui.QAction(QtGui.QIcon('icons/exit.png'), 'Update', self)
self.update_menu.setShortcut('Ctrl+U')
self.update_menu.setStatusTip('Look for update')
self.connect(self.update_menu, QtCore.SIGNAL('triggered()'), self.update)
self.exit_menu = QtGui.QAction(QtGui.QIcon('icons/exit.png'), 'Exit', self)
self.exit_menu.setShortcut('Ctrl+Q')
self.exit_menu.setStatusTip('Exit application')
self.connect(self.exit_menu, QtCore.SIGNAL('triggered()'), QtCore.SLOT('close()'))
self.about_menu = QtGui.QAction(QtGui.QIcon('icons/exit.png'), 'About', self)
self.about_menu.setShortcut('Ctrl+B')
self.about_menu.setStatusTip('About')
self.connect(self.about_menu, QtCore.SIGNAL('triggered()'), self.show_about)
self.notes_menu = QtGui.QAction('Release notes', self)
self.notes_menu.setShortcut('Ctrl+N')
self.notes_menu.setStatusTip('Release notes')
self.connect(self.notes_menu, QtCore.SIGNAL('triggered()'), self.show_releasenotes)
self.contact_menu = QtGui.QAction('Give feedback', self)
self.contact_menu.setShortcut('Ctrl+G')
self.contact_menu.setStatusTip('Give feedback')
self.connect(self.contact_menu, QtCore.SIGNAL('triggered()'), self.contact_me)
self.formats_menu = QtGui.QAction('Supported formats', self)
self.formats_menu.setShortcut('Ctrl+F')
self.formats_menu.setStatusTip('Supported formats')
self.connect(self.formats_menu, QtCore.SIGNAL('triggered()'), self.show_supportedformats)
self.custom_menu = QtGui.QAction('Create custom format', self)
self.custom_menu.setShortcut('Ctrl+C')
self.custom_menu.setStatusTip('Howto custom formats')
self.connect(self.custom_menu, QtCore.SIGNAL('triggered()'), self.show_create_custom)
self.options_menu = QtGui.QAction('Options', self)
self.options_menu.setShortcut('Ctrl+O')
self.options_menu.setStatusTip('Options')
self.connect(self.options_menu, QtCore.SIGNAL('triggered()'), self.show_options)
self.analyze_menu = QtGui.QAction('Analyze file', self)
self.analyze_menu.setShortcut('Ctrl+A')
self.analyze_menu.setStatusTip('Analyze file')
self.connect(self.analyze_menu, QtCore.SIGNAL('triggered()'), self.show_analyze)
self.menubar = self.menuBar()
self.file_menu = self.menubar.addMenu('&File')
self.tools_menu = self.menubar.addMenu('&Tools')
self.help_menu = self.menubar.addMenu('&Help')
self.doc_menu = self.help_menu.addMenu("&Documentation")
self.file_menu.addAction(self.update_menu)
self.file_menu.addAction(self.exit_menu)
self.doc_menu.addAction(self.formats_menu)
self.doc_menu.addAction(self.notes_menu)
self.doc_menu.addAction(self.custom_menu)
self.help_menu.addAction(self.contact_menu)
self.help_menu.addAction(self.about_menu)
self.tools_menu.addAction(self.analyze_menu)
self.tools_menu.addAction(self.options_menu)
# Command arguments
if (len(sys.argv) >= 3):
self.in_file_edit.setText(sys.argv[1])
self.out_file_edit.setText(sys.argv[2])
if (len(sys.argv) == 2):
self.in_file_edit.setText(sys.argv[1])
self.guessOutfile(sys.argv[1], "csv")
self.resize(400, 400) # Looks ok at my dual monitor screen :x
# Update the widgets
self.in_file_edit_change(self.in_file_edit.text())
self.out_file_edit_change(self.out_file_edit.text())
# Show release notes
notes = self.config.get("FileConvert", "releasenotes")
if not notes or notes != version:
self.show_releasenotes()
# Set to shown
self.config.set("FileConvert", "releasenotes", version)
# Drag-and-drop
def dragEnterEvent(self, evt):
self.in_file_edit.dragEnterEvent(evt)
def dropEvent(self, evt):
self.in_file_edit.dropEvent(evt)
self.guessOutfile(self.in_file_edit.text(), "csv")
# Style
def refresh_style(self):
# Skin
skin = self.config.get("FileConvert", "skin")
if skin: useSkin(skin)
# Set style
setStyle(self)
def contact_me(self):
# Show contact_me window
contact_me(self)
# Update the edits
def refresh_edits(self):
inn = self.config.get("FileConvert", "infile")
if not inn:
inn = self.in_file_edit.text()
out = self.config.get("FileConvert", "outfile")
if not out:
out = self.out_file_edit.text()
self.in_file_edit.setText(inn)
self.out_file_edit.setText(out)
self.in_file_edit_change(inn)
self.out_file_edit_change(out)
def set_edits(self, infile=None, outfile=None):
if infile:
self.in_file_edit.setText(infile)
self.in_file_edit_change(infile)
if outfile:
self.out_file_edit.setText(outfile)
self.out_file_edit_change(outfile)
def show_options(self):
options(self.config, parent=self)
# Show release notes
def show_releasenotes(self):
textedit(reSmall(releasenotes), title="Release notes for " + version, parent=self)
# Show supported formats
def show_supportedformats(self):
#textedit("Supported formats
Readers
" + str(readers.keys()) + "Writers
" + str(writers.keys()), title="Supported formats", parent=self)
textedit(reSmall('''
Supported formats
-----------------
Readers
++++++
''' + unicode(readers.keys()) + '''
Writers
+++++++
''' + unicode(writers.keys()) + '''
Custom format dir
+++++++++++++++++
''' + os.path.join(folder,"formats")), title="Supported formats", parent=self)
def show_create_custom(self):
textedit(reSmall('''Create a custom reader/writer
------------------------------------
This program is written in Python, and you can create your own reader/writer by placing a python source (.py) file in the custom format directory. You can get the location of the custom format directory by going to help->documentation->"supported formats". The file must contain a class definition, that inherits "reader" and/or "writer".
A reader needs to
+++++++++++++++++
- Inherit reader
- Overload the next(self) method, which is called by the program until it recieves an exception.
- Call return_point(dict) in next() with a dictionary with x,y,z and other format specific data defined as strings.
The infile can be referenced with self.file. As with all file objects, self.file.next() gives the next line of the file. You can read line by line, or byte for byte with fread.
A writer needs to
+++++++++++++++++
- Inherit writer
- Overload the write(self, dict) method, where dict contains variables from the reader. These are x, y, z and other format specific data like pointcode. This method is called for each point found by the reader.
- Call write_point(string) in next() to write point to the outfile.
Input variables
+++++++++++++++
If the format needs input from the user, you can define a set of input varibles. You do this by overloading the writer_variables(self) for a writer and reader_variables(self) for a reader, which should return a list of dicts. Each dict must contain:
- "name": name of the variable (string)
- "type": type of variable, either "string", checkbox with string called "cstring", or "check"box. (string)
- "value": default value, True/False for checkboxes, text for strings. (bool) or (string)
- "label": optional label (string)
- "description": optional description. (string)
- "priority": optional priority, used to set the position of the widget. 99 is default and lowest position. (int)
In the reader/writer you can refer to the input variables with self.get_var("name") for strings, and self.is_checked("name") for checkboxes. The values of each input variable is stored between program runs, so the default value is not forced. If you want to change the value of an input varible, use the options editor.
Errors
++++++
If you reader or writer encounters a error, you can stop the conversion process by calling self.stop("message"). If you want to show a warning you can call self.warning("warning"). But please do not call warning() in next() or write(), as this will show a warning for each point found. The beste place for a warning is in before() or after().
Common methods
++++++++++++++
- before(self) is called before the conversion begins, and after(self) is called after. These can be used to add headers or tails.
- writer_report(self) and reader_report(self) are methods you can overload to give reports of the conversion. These should return html formated text, and will be shown when the user wants to look at a detailed report of the conversion.
- self.stop("error") and self.warning("warning") are methods you can call to stop the conversion process or give a warning to the user.
Examples
++++++++
If you want examples of readers/writers please look at FileConvert.py (located at %USERPROFILE% in windows, just write it in the explorer address.) and at the classes csv and text. csv is small class and should be a good starting point - it reads comma seperated files. txt is a larger class, and it uses more of the methods described above including input variables.'''))
# When the program ends, save settings
def __del__(self):
if hasattr(self, "save") and not self.save:
return
# Delete widgets, get settings.
if hasattr(self, "writer") and self.writer:
self.writer.deleteWidgets(self.writer_box)
if hasattr(self, "reader") and self.reader:
self.reader.deleteWidgets(self.reader_box)
# Save settings
if hasattr(self, "config") and self.config:
config = self.config
else:
config = ConfigParser()
# Setting for in and outfile
if hasattr(self, "in_file_edit"):
config.set("FileConvert", "infile", self.in_file_edit.text())
if hasattr(self, "out_file_edit"):
config.set("FileConvert", "outfile", self.out_file_edit.text())
# Save to file
conf = open(folder + filename + ".ini", "w")
config.write(conf)
conf.close()
def show_analyze(self):
file_stats_window(self)
def show_about(self):
"""QtGui.QMessageBox.information(self, 'About',
'''FileConvert %s (%s)
%s
%s
%s''' % (version, modified, author, contact, url))"""
about_window(self)
#a = plot_window(self)
#file_stats_window(self)
"""a.setText('''FileConvert %s (%s)
%s
%s
%s''' % (version, modified, author, contact, url))"""
#a.show()
#a.exec_()
def show_format_help(self):
QtGui.QMessageBox.information(self, 'Format info',
'''Variables:
$(pointcode) = pointcode from .kof
$(x), $(y), $(z) = x, y, z coordinates for each point
$(tab), $(space), $(newline), $(comma) = Tab, space, newline, comma
Functions:
$+, $/, $-, $* on the form $+(arg1,arg2,...) => arg1 + arg2 + ...
Valid arguments are numbers and variables as they are evaluated first. Call to functions are invalid arguments.
''')
# When the user browse (...) for the files
def in_file_get(self):
filename = QtGui.QFileDialog.getOpenFileName(self, 'Open file','')
if len(filename) > 0:
self.in_file_edit.setText(filename)
# Set outfile from infile
self.guessOutfile(self.in_file_edit.text(), "csv")
def out_file_get(self):
filename = QtGui.QFileDialog.getSaveFileName(self, 'Save file','')
if len(filename) > 0:
self.out_file_edit.setText(filename)
# This function is called when the user
# changes the text of in_file_edit. This is
# also called when the user selects the files
# through the "..." button.
#
# The function adds a reader so that the
# gui can show format-specific input boxes.
#
# As the reader is created before the user presses
# "convert", the object is kept alive until the
# text is changed.
#
# out_file_edit_change is just the same,
# but replace reader with writer. ugh.
def in_file_edit_change(self, text):
ext = unicode(text.split(".")[-1]).lower()
if ext in readers.keys():
# Delete current writer
if hasattr(self, "reader") and self.reader:
self.reader.deleteWidgets(self.reader_box)
# Add widgets
if ext in readers.keys():
self.reader = eval(str(ext + "('dummy', config=self.config, job='reader')"))
self.reader.addWidgets(self.reader_box, window=self)
else:
if hasattr(self, "reader") and self.reader:
self.reader.deleteWidgets(self.reader_box)
self.reader = None
# Hide label if reader_box is empty
if self.reader_box.count() == 0:
self.reader_groupbox.hide()
else:
self.reader_groupbox.setTitle("&Reader options (" + ext + ")")
self.reader_groupbox.show()
def out_file_edit_change(self, text):
ext = unicode(text.split(".")[-1]).lower()
if ext in writers.keys():
# Delete current writer
if hasattr(self, "writer") and self.writer:
self.writer.deleteWidgets(self.writer_box)
# Add widgets
if ext in writers.keys():
self.writer = eval(str(ext + "('dummy', config=self.config, job='writer')"))
self.writer.addWidgets(self.writer_box, window=self)
else:
if hasattr(self, "writer") and self.writer:
self.writer.deleteWidgets(self.writer_box)
self.writer = None
# Hide label if writer_box is empty
if self.writer_box.count() == 0:
self.writer_groupbox.hide()
else:
self.writer_groupbox.setTitle("&Writer options (" + ext + ")")
self.writer_groupbox.show()
# Guess outfile from filename
def guessOutfile(self, filename, ext="csv"):
try: filename = unicode(filename, "utf-8")
except Exception: pass
outfile = ".".join(filename.split(".")[:-1]) + "." + ext
if not (outfile == "." + ext):
self.out_file_edit.setText(outfile)
# Convert between fileformats
def convert(self, noask=False):
if (unicode(self.in_file_edit.text()) == "" or unicode(self.out_file_edit.text()) == ""):
QtGui.QMessageBox.warning(self, 'Error', "You need to specify a valid in and out file")
return
try:
# Reader
reader = None
if hasattr(self, "reader"):
reader = self.reader
writer = None
if hasattr(self, "writer"):
writer = self.writer
# Measure time
before = time.clock()
# Create a coords object, and start the conversion
k = coords(unicode(self.in_file_edit.text()), unicode(self.out_file_edit.text()), options, readers, writers, reader=reader, writer=writer, window=self)
lines = k.convert(self)
after = time.clock()
# Conversion complete, show report?
if noask: return
reply = QtGui.QMessageBox.question(self, 'Conversion complete', "Converted " + str(lines) + " entities in " + str(after-before) + ".\n\nDo you want to see a more detailed report?", QtGui.QMessageBox.No, QtGui.QMessageBox.Yes)
# Show report?
if reply == QtGui.QMessageBox.Yes:
# Create a report for the writer and reader
report = ["Report
", "Reader
",
"Read " + str(k.reader.file.tell()) + " byte(s) from " + k.reader.file.name + "
",
str(k.reader.reader_report()),
"Writer
",
"Wrote " + str(k.writer.file.tell()) + " byte(s) to " + k.writer.file.name + "
",
str(k.writer.writer_report()),
"Result
Exchanged:" + "".join(["- %s: %s
" % (type_, amount) for type_, amount in writer.stats.iteritems()]) + "
"]
# Show report
textedit("".join(report), title="Report")
# Save number of points converted
if self.config:
converted = self.config.get("FileConvert", "converted")
if converted:
converted = int(converted) + lines
else:
converted = lines
self.config.set("FileConvert", "converted", str(converted))
except Exception, msg:
if isinstance(msg, ConvertError):
QtGui.QMessageBox.critical(self, 'Error', str(msg))
else:
#filename, line, function, text = traceback.extract_stack()
#msg = "%s, %s, %s, %s" % (unicode(filename), str(line), str(function), str(text))
QtGui.QMessageBox.critical(self, 'Error', traceback.format_exc())
#tracebac
# Get version of file
def getVersion(self, file):
ver = file.find("version = ")
end = file.find("\n", ver)
version = file[ver:end].split(" ")
if (len(version) >= 3):
version = version[2]
return version.strip("\n").split('"')[1]
else:
return -1
# Update
def updateSilent(self):
self.update(silent=True)
def newVersion(self):
if self.newversion:
self.update(silent=True, ask=True)
self.newversion = False
# Double the timer interval
self.timer.setInterval(self.timer.interval()*2)
# Fetch newest file
def update(self, silent=False, force=False, ask=False):
global updated
updated = False
if (not silent):
progress = QtGui.QProgressDialog('Downloading latest version', 'Cancel', 0, 4, self)
progress.setMinimumDuration(0)
progress.setValue(1)
try:
global filename
current_version = version
self.parent.processEvents()
latest_file = urllib2.urlopen("http://www.0x6.org/FileConvert/" + filename + ".py")
if (not silent): progress.setValue(2)
self.parent.processEvents()
latest_content = latest_file.read()
if (not silent): progress.setValue(3)
self.parent.processEvents()
latest_version = self.getVersion(latest_content)
if (not silent): progress.setValue(4)
self.parent.processEvents()
# See if update was cancelled.
if (not silent and progress.wasCanceled()):
raise Exception("The update was cancelled.")
# Compare version numbers
if (latest_version > current_version):
self.newversion = True
reply = QtGui.QMessageBox.No
if not silent or ask:
reply = QtGui.QMessageBox.question(self, 'Update', "There is a new version of the program available.\n\nDo you want to update?", QtGui.QMessageBox.No, QtGui.QMessageBox.Yes)
if force:
reply = QtGui.QMessageBox.Yes
if reply == QtGui.QMessageBox.Yes:
# Update the program
current_file = open(folder + filename + ".new", "w")
current_file.write(latest_content)
current_file.close()
updated = True
else:
if (not silent):
QtGui.QMessageBox.information(self, 'Update',"This is the latest version.")
except Exception, e:
if (not silent):
QtGui.QMessageBox.critical(self, 'Error updating', str(e) + "\n\nCancelling the update process.")
progress.setValue(4)
updated = False
if updated:
self.close()
class about_window_old(QtGui.QMessageBox):
def __init__(self, parent=None, save=True):
QtGui.QMessageBox.__init__(self, parent)
#self.timer = QtCore.QTimer()
self.connect(self.timer, QtCore.SIGNAL("timeout()"), self.timeout)
self.timer.start(1000/25)
self.setWindowTitle("About")
self.content = ["" + name, " %s (%s)
Erik ", "Solhaug Fløisbonn
%s
%s"""]
self.fadecolors = ["#DDDDDD", "#DDDDDD", "#DDDDDD","#CCCCCC", "#BBBBBB", "#AAAAAA", "#AAAAAA", "#999999", "#888888", "#777777", "#666666", "#555555", "#444444", "#333333", "#222222", "#111111", "#000000", "#000000", "#000000"]
self.pos = len(self.fadecolors)-1; self.dx = 1
# Converted
self.converted = None
self.conv_count = 0
self.conv_d = 1
# Get statistics
self.stats = []
if parent != None and parent.config != None:
self.stats.append("
")
# Get value from config
started = parent.config.get("FileConvert", "started")
if started:
self.stats.append("Started " + started + " time(s)
")
else: self.stats.append("")
self.converted = parent.config.get("FileConvert", "converted")
if self.converted:
self.stats.append("Converted " + self.converted + u" point(s)
")
self.conv_d = int(self.converted)/(4.0*25.0)
#self.stats.append("Amounts to " + str(int(converted)*0.005) + u" NOK (0.5 øre p/point:)
")
else: self.stats.append("")
self.timeout()
self.show()
self.exec_()
def timeout(self):
# Converted count
if self.converted:
if self.conv_count < int(self.converted):
self.conv_count += self.conv_d
self.stats[-1] = "Converted " + str(int(self.conv_count)) + u" point(s)
"
# Change color of the name
self.content[-2] = self.fadecolors[self.pos]
self.setText(("".join(self.content) + ("", "".join(self.stats))[self.stats != []]) % (version, modified, contact, url))
# Get next color
if self.pos == len(self.fadecolors)-1:
self.dx = -1
if self.pos == 0:
self.dx = 1
self.pos += self.dx
def __del__(self):
self.timer.stop() # Stop the timer
class about_window(QtGui.QDialog):
def __init__(self, parent=None):
QtGui.QDialog.__init__(self, parent)
self.parent = parent
self.grid = QtGui.QVBoxLayout()
self.label_img = QtGui.QLabel()
# self.label_img.setFrameStyle(QtGui.QFrame.Panel | QtGui.QFrame.Sunken);
# self.label_img.setScaledContents(True)
self.grid.addWidget(self.label_img)
# self.label_img.setText()
self.pix = QtGui.QPixmap()
self.pix.load("FileConvert.png")
self.label_img.setPixmap(self.pix)
self.label_text = QtGui.QLabel()
self.grid.addWidget(self.label_text)
self.label_text.setText("" + name + " " + version + u"
\n\nCopyright 2009 Erik Fløisbonn")
self.label_third = QtGui.QLabel()
self.grid.addWidget(self.label_third)
'''self.label_third.setText(
"""
Copyright 2005, Giovanni Bajo
Copyright 1986-1993, 1998, 2004 Thomas Williams, Colin Kelley""")'''
self.label_img.setAlignment(QtCore.Qt.AlignCenter | QtCore.Qt.AlignHCenter ) # Horizontal | Vertical
self.label_text.setAlignment(QtCore.Qt.AlignCenter | QtCore.Qt.AlignHCenter ) # Horizontal | Vertical
self.plot_button = QtGui.QPushButton('Plot')
#self.connect(self.plot_button, QtCore.SIGNAL('pressed()'), self.changeAngle)
self.setLayout(self.grid)
self.show()
self.exec_()
class updateThread(QtCore.QThread):
''' Thread to check for update. To avoid lagging the UI '''
def __init__(self, window):
self.window = window
QtCore.QThread.__init__(self)
def run(self):
self.window.updateSilent()
def show(): # oink
# Look at the formats folder
# and load the file
load_formats()
# Create main window
app = QtGui.QApplication(sys.argv)
qb = window(app)
app.setWindowIcon(QtGui.QIcon("FileConvert.png"))
# Check for updates. This is an own thread, to avoid
# lagging the UI if the computer is not connected
# to the internet.
up = updateThread(qb)
up.start()
qb.show()
app.exec_()
del qb
if __name__ == "__main__":
show()