# -*- coding: utf-8 -*-
# CoordConvert
#
# Created by Erik Fløisbonn
# Email: erif@0x6.org
#
# Latest version can be found at:
# http://www.0x6.org/CoordConvert/
#
name = "CoordConvert"
version = "1.4.7b"
modified = "13/04/09"
author = u"Erik Fløisbonn"
contact = "erif@0x6.org"
url = "http://www.0x6.org/CoordConvert/"
releasenotes = '''What's new?
-----------
    - Changed .kof format to correctly handle blank values of pointcode and themecode.
    - Filename guessing with drag-and-drop.
    - Create graph with Gnuplot (bundled), requires the newest CoordConvert. x_rot, y_rot and other options are not currently implemented.
    - Speed improvements.'''

'''
    TODO:

        1. (Done) Alter .kof format to correctly handle blank values of pointcode and themecode
        2. Add entity TYPE, so that one can transfer different types of data between formats
            - lines between kof/dxf
        3. (Done) Filename guessing.
        4. (Begun) Create graph
            - Must add gnuplot to bundle
            - Delete temporary files after they are used
        5. Check for illegal file in gnuplot
        6. Fix changing gnuplotfile.
'''

import sys
from PyQt4 import QtGui, QtCore
import urllib2
import os

# Globals set by Update.py
'''if not "folder" in globals(): 
    global folder
    folder = "./"
if not "filename" in globals():
    global filename
    filename = "CoordConvert"'''

# Set color of window
# This palette uses the colors of skanska.
global skin
skin = "normal"

def useSkin(name):
    global skin
    skin = name

def setStyle(window):
    if skin == "Skanska":
        window.setStyleSheet('''QMainWindow, QDialog {
background: #E0E0E0;
}
QLineEdit {
     border: 1px solid #293e6b;
     color: #293e6b;
     background: #F4F4F4;
     selection-background-color: #293e6b;
     selection-color: #F0F0F0;
}
QTextEdit {
     border: 1px solid #293e6b;
     color: #293e6b;
     background: #F4F4F4;
     selection-background-color: #293e6b;
     selection-color: #F0F0F0;
}
QCheckBox::indicator {
    border: 0;
}
QCheckBox::indicator:unchecked {
    background-color: transparent;
    border: 1px solid #293e6b;
}
QCheckBox::indicator:checked {
    background-color: #293e6b;
    border: 0;
}
QPushButton {
    border: 1px solid #293e6b;
    background-color: #c8c8c8;
    color: #293e6b;
    padding-left: 10px;
    padding-right: 10px;
}
QPushButton:hover {
    color: #F0F0F0;
    border-style: inset;

}
QPushButton:pressed {
    background-color: #F0F0F0;
    color: #c8c8c8;
}
QMenu {
    background-color: #F0F0F0;
    color: #293e6b;
    border: 1px solid #293e6b;
}

QMenu::item {
    background-color: transparent;
}

QMenu::item:selected {
    background-color: #293e6b;
    color: #F0F0F0;
}
QMenuBar {
    background-color: #F4F4F4;
    color: #293e6b;
    border: 1px solid #293e6b;
    border-right: 0;
    border-top: 0;
    border-left: 1px solid transparent; /* bugfix */
}
QMenuBar::item {
    spacing: 4px; /* spacing between menu bar items */
    padding: 1px 4px;
    background: transparent;
}
QMenuBar::item:selected { /* when selected using mouse or keyboard */
    background: #293e6b;
    color: #F0F0F0;
}
QMenuBar::item:pressed {
    background: #293e6b;
    color: #F0F0F0;
}

QTreeView {
     color: #293e6b;
}

QLabel {
    color: #293e6b;
}

/* Taken from Qt documentation */
QGroupBox {
     background-color: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                                       stop: 0 #E0E0E0, stop: 1 #FFFFFF);
     border: 1px solid #293e6b;
     margin-top: 1ex; /* leave space at the top for the title */
 }

 QGroupBox::title {
     subcontrol-origin: margin;
     subcontrol-position: top center; /* position at the top center */
     padding: 0 3px;
        color: #293e6b;
 }

 QTreeView {
    background-color: #F4F4F4;
    border: 1px solid #293e6b;
}

QHeaderView::section {
     background-color: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                                       stop:0 #E0E0E0, stop: 1 #F4F4F4);
     color: #293e6b;
     padding-left: 4px;
     border-bottom: 1px solid #293e6b;
     border-left: 1px solid #293e6b;
     border-right: 1px solid #293e6b;
     border-top: None;
 }

 /* style the sort indicator */
 QHeaderView::down-arrow {
     background-color: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                                       stop:0 #293e6b, stop: 1 #F4F4F4);
 }

 QHeaderView::up-arrow {
     background-color: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                                       stop:0 #F4F4F4, stop: 1 #293e6b);
 }''')
    elif skin == "LSK":
        window.setStyleSheet('''QMainWindow, QDialog {
    background: #EEEE10;
}
QLineEdit {
     border: 1px solid #000000;
     color: #000000;
     background: #FFFF00;
     selection-background-color: #000000;
     selection-color: #FFFF00;
}
QTextEdit {
     border: 1px solid #000000;
     color: #000000;
     background: #FFFF00;
     selection-background-color: #000000;
     selection-color: #FFFF00;
}
QCheckBox::indicator {
    border: 0;
}
QCheckBox::indicator:unchecked {
    background-color: transparent;
    border: 1px solid #000000;
}
QCheckBox::indicator:checked {
    background-color: #000000;
    border: 0;
}
QPushButton {
    border: 1px solid #000000;
    background-color: #EEEE10;
    color: #000000;
    padding-left: 10px;
    padding-right: 10px;
}
QPushButton:hover {
    color: #EEEE10;
    border-style: inset;
    background-color: #000000;
}
QPushButton:pressed {
    background-color: #FFFF10;
    color: #c8c8c8;
}
QMenu {
    background-color: #FFFF10;
    color: #000000;
    border: 1px solid #000000;
}

QMenu::item {
    background-color: transparent;
}

QMenu::item:selected {
    background-color: #000000;
    color: #FFFF10;
}
QMenuBar {
    background-color: #FFFF00;
    color: #000000;
    border: 1px solid #000000;
    border-right: 0;
    border-top: 0;
    border-left: 1px solid transparent; /* bugfix */
}
QMenuBar::item {
    spacing: 4px; /* spacing between menu bar items */
    padding: 1px 4px;
    background: transparent;
}
QMenuBar::item:selected { /* when selected using mouse or keyboard */
    background: #000000;
    color: #FFFF10;
}
QMenuBar::item:pressed {
    background: #000000;
    color: #FFFF10;
}

QTreeView {
     color: #000000;
}

QLabel {
    color: #000000;
}

/* Taken from Qt documentation */
QGroupBox {
     background-color: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                                       stop: 0 #EEEE10, stop: 1 #AAAA00);
     border: 1px solid #000000;
     margin-top: 1ex; /* leave space at the top for the title */
 }

 QGroupBox::title {
     subcontrol-origin: margin;
     subcontrol-position: top center; /* position at the top center */
     padding: 0 3px;
        color: #000000;
 }

 QTreeView {
    background-color: #FFFF00;
    border: 1px solid #000000;
}

QHeaderView::section {
     background-color: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                                       stop:0 #EEEE10, stop: 1 #FFFF00);
     color: #000000;
     padding-left: 4px;
     border-bottom: 1px solid #000000;
     border-left: 1px solid #000000;
     border-right: 1px solid #000000;
     border-top: None;
 }

 /* style the sort indicator */
 QHeaderView::down-arrow {
     background-color: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                                       stop:0 #000000, stop: 1 #FFFF00);
 }

 QHeaderView::up-arrow {
     background-color: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                                       stop:0 #FFFF00, stop: 1 #000000);
 }"''')
    elif skin == "Forest":
        window.setStyleSheet('''

QMainWindow, QDialog {
    background: #AA0000;
}
QLineEdit {
     border: 1px solid #FFFFFF;
     color: #FFFFFF;
     background: #AA1010;
     selection-background-color: #FFFFFF;
     selection-color: #AA1010;
}
QTextEdit {
     border: 1px solid #FFFFFF;
     color: #FFFFFF;
     background: #AA1010;
     selection-background-color: #FFFFFF;
     selection-color: #AA1010;
}

QCheckBox { color: #FFFFFF; }

QCheckBox::indicator {
    border: 0;
}
QCheckBox::indicator:unchecked {
    background-color: transparent;
    border: 1px solid #FFFFFF;
}
QCheckBox::indicator:checked {
    background-color: #FFFFFF;
    border: 0;
}
QPushButton {
    border: 1px solid #FFFFFF;
    background-color: #EE1010;
    color: #FFFFFF;
    padding-left: 10px;
    padding-right: 10px;
}
QPushButton:hover {
    color: #EE1010;
    border-style: inset;
    background-color: #FFFFFF;
}
QPushButton:pressed {
    background-color: #EE1010;
    color: #AA1010;
}
QMenu {
    background-color: #AA1010;
    color: #FFFFFF;
    border: 1px solid #FFFFFF;
}

QMenu::item {
    background-color: transparent;
}

QMenu::item:selected {
    background-color: #FFFFFF;
    color: #AA1010;
}
QMenuBar {
    background-color: #AA1010;
    color: #FFFFFF;
    border: 1px solid #FFFFFF;
    border-right: 0;
    border-top: 0;
    border-left: 1px solid transparent; /* bugfix */
}
QMenuBar::item {
    spacing: 4px; /* spacing between menu bar items */
    padding: 1px 4px;
    background: transparent;
}
QMenuBar::item:selected { /* when selected using mouse or keyboard */
    background-color: #AA1010;
    color: #FFFFFF;
}
QMenuBar::item:pressed {
    background: #FFFFFF;
    color: #AA1010;
}

QTreeView {
     color: #FFFFFF;
}

QLabel {
    color: #FFFFFF;
}

/* Taken from Qt documentation */
QGroupBox {
     background-color: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                                       stop: 0 #EE1010, stop: 1 #AA0000);
     border: 1px solid #FFFFFF;
     margin-top: 1ex; /*leave space at the top for the title */
 }

 QGroupBox::title {
     subcontrol-origin: margin;
     subcontrol-position: top center; /* position at the top center */
     padding: 0 3px;
        color: #FFFFFF;
    border: 1px solid #FFFFFF;
    background-color: #EE1010;
 }

 QTreeView {
    background-color: #AA1010;
    border: 1px solid #FFFFFF;
}

QHeaderView::section {
     background-color: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                                       stop:0 #EE1010, stop: 1 #AA1010);
     color: #FFFFFF;
     padding-left: 4px;
     border-bottom: 1px solid #FFFFFF;
     border-left: 1px solid #FFFFFF;
     border-right: 1px solid #FFFFFF;
     border-top: None;
 }

 /* style the sort indicator */
 QHeaderView::down-arrow {
     background-color: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                                       stop:0 #FFFFFF, stop: 1 #AA1010);
 }

 QHeaderView::up-arrow {
     background-color: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                                       stop:0 #AA1010, stop: 1 #FFFFFF);
}
"''')
    elif skin == "Lillestrom":
        window.setStyleSheet('''

QMainWindow, QDialog {
    background: #fad603;
}
QLineEdit {
     border: 1px solid #000000;
     color: #000000;
     /*background: #fad603;*/
     selection-background-color: #000000;
     selection-color: #fad603;

     background: qlineargradient(x1:0,y1:0,x2:0,y2:1,
                       stop:0 #000000, stop:0.1 #fad603,
                       stop:0.8 #fad603, stop:1 #fad603);
}
QTextEdit {
     border: 1px solid #000000;
     color: #000000;
     background: #fad603;
     selection-background-color: #000000;
     selection-color: #fad603;
}

QCheckBox { color: #000000; }
QCheckBox { color: #000000; }

QCheckBox::indicator {
    border: 0;
}
QCheckBox::indicator:unchecked {
    background-color: transparent;
    border: 1px solid #000000;
}
QCheckBox::indicator:checked {
    background-color: #000000;
    border: 0;
}

QPushButton {
    border: 1px solid #000000;
    background-color: #fad603;
    color: #000000;
    padding-left: 10px;
    padding-right: 10px;
    background-color: qlineargradient(x1:0,y1:0,x2:0,y2:1,
                       stop:0 white, stop:0.2 #fad603,
                       stop:0.8 #fad603, stop:1 #000000)
}
QPushButton:hover {
    color: #fad603;
    border-style: inset;
    background-color: #000000;
    background-color: qlineargradient(x1:0,y1:0,x2:0,y2:1,
                       stop:0 white, stop:0.2 #000000,
                       stop:0.8 #000000, stop:1 #000000)
}
QPushButton:pressed {
    background-color: #000000;
    color: #fad603;
}
QMenu {
    background-color: #fad603;
    color: #000000;
    border: 1px solid #000000;
}

QMenu::item {
    background-color: transparent;
}

QMenu::item:selected {
    background-color: #000000;
    color: #fad603;
}
QMenuBar {
    background-color: #fad603;
    color: #000000;
    border: 1px solid #000000;
    border-right: 0;
    border-top: 0;
    border-left: 1px solid transparent; /* bugfix */
}
QMenuBar::item {
    spacing: 4px; /* spacing between menu bar items */
    padding: 1px 4px;
    background: transparent;
}
QMenuBar::item:selected { /* when selected using mouse or keyboard */
    background-color: #fad603;
    color: #000000;
}
QMenuBar::item:pressed {
    background: #000000;
    color: #fad603;
}

QTreeView {
     color: #000000;
}

QLabel {
    color: #000000;
}

/* Taken from Qt documentation */
QGroupBox {
     background-color: qlineargradient(x1: 0, y1: 0, x2: 1, y2: 1,
                                       stop: 0 white, stop: 0.5 #fad603, stop: 1 #000000);
     border: 1px solid #000000;
     margin-top: 1ex; /*leave space at the top for the title */

     /*border-radius: 3px;*/
 }

 QGroupBox::title {
     subcontrol-origin: margin;
     subcontrol-position: top center; /* position at the top center */
     /*padding: 0 3px;*/
        color: #000000;
    border: 1px solid #000000;
    background-color: #fad603;

    /*background: qlineargradient(x1:0,y1:0,x2:0,y2:1,
                       stop:0 #000000, stop:0.1 #fad603,
                       stop:0.8 #fad603, stop:1 #fad603);*/

 }

 QTreeView {
    background-color: #fad603;
    border: 1px solid #000000;
}

QHeaderView::section {
     background-color: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                                       stop:0 #fad603, stop: 1 #fad603);
     color: #000000;
     padding-left: 4px;
     border-bottom: 1px solid #000000;
     border-left: 1px solid #000000;
     border-right: 1px solid #000000;
     border-top: None;
 }

 /* style the sort indicator */
 QHeaderView::down-arrow {
     background-color: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                                       stop:0 #000000, stop: 1 #fad603);
 }

 QHeaderView::up-arrow {
     background-color: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                                       stop:0 #fad603, stop: 1 #000000);
}
"''')
    else:
        window.setStyleSheet("")

def setPalette(window):
        return
        if skin == "Skanska":
            palette = QtGui.QPalette(QtGui.QColor(41,62,107))

            palette.setColor(QtGui.QPalette.Window, QtGui.QColor(240,240,240))
            palette.setColor(QtGui.QPalette.Background, QtGui.QColor(240,240,240))

            palette.setColor(QtGui.QPalette.WindowText, QtGui.QColor(41,62,107))
            palette.setColor(QtGui.QPalette.Foreground, QtGui.QColor(41,62,107))

            palette.setColor(QtGui.QPalette.Base, QtGui.QColor(244,244,244))
            palette.setColor(QtGui.QPalette.AlternateBase, QtGui.QColor(244,244,244))

            palette.setColor(QtGui.QPalette.Text, QtGui.QColor(41,62,107))
            palette.setColor(QtGui.QPalette.Button, QtGui.QColor(200,200,200))
            palette.setColor(QtGui.QPalette.ButtonText, QtGui.QColor(41,62,107))
            palette.setColor(QtGui.QPalette.BrightText, QtGui.QColor(41,62,107))

            # 3D
            palette.setColor(QtGui.QPalette.Light, QtGui.QColor(41,62,107))
            palette.setColor(QtGui.QPalette.Midlight, QtGui.QColor(41,62,107))
            palette.setColor(QtGui.QPalette.Dark, QtGui.QColor(41,62,107))
            palette.setColor(QtGui.QPalette.Mid, QtGui.QColor(41,62,107))
            palette.setColor(QtGui.QPalette.Shadow, QtGui.QColor(41,62,107))

            palette.setColor(QtGui.QPalette.ToolTipBase, QtGui.QColor(41,62,107))
            palette.setColor(QtGui.QPalette.ToolTipText, QtGui.QColor(244,244,244))

            # Selected items
            palette.setColor(QtGui.QPalette.Highlight, QtGui.QColor(41,62,107))
            palette.setColor(QtGui.QPalette.HighlightedText, QtGui.QColor(240,240,240))

            # Hyperlinks
            palette.setColor(QtGui.QPalette.Link, QtGui.QColor(41,62,107))
            palette.setColor(QtGui.QPalette.LinkVisited, QtGui.QColor(41,62,107))

            window.setPalette(palette)         

        else:
            window.setPalette(QtGui.QPalette())

# reSmall, subset of reStructuredtext
# A veeeery simple reStructured text interpreter
# This only supports headers h1->h5, unnumbered lists and paragraphs.
def reSmall(text):
    out = []
    tmp = []
    headers = ["-", "+", "/", "*", "%"] # h1->h5
    bullets = ["*", "+", "-"]
    lines = (text + "\n\n").splitlines().__iter__()
    for line in lines:
        if (len(line) > 1 and line[0] == "\t" and line[1] in bullets) or (len(line) > 4 and line[0:4] == " "*4 and line[4] in bullets):
    
            # Remove the bullet
            line = line[0:5].strip("".join(bullets)) + line[5:]
            if "<ul>" not in tmp: 
                if len(tmp) > 0: out.append("<p>%s</p>" % ("".join(tmp)));tmp=[]
                tmp.append("<ul>")
            tmp.append("<li>" + line + "</li>")
        else:
            if "<ul>" in tmp:
                out.append("".join(tmp)); out.append("</ul>");tmp = []
            if len(line) > 1 and line[0] in headers and line[0]*len(line) == line:
                if len(tmp) > 1: 
                    out.append("<p>%s</p>" % ("".join(tmp[:-1])))
                out.append("<h%d>%s</h%d>" % (headers.index(line[0])+1, "".join(tmp[-1]), headers.index(line[0])+1)); tmp =  []
            else:
                if (line == ""): 
                    out.append("<p>%s</p>" % ("".join(tmp)));tmp=[]
                else:
                    tmp.append(line)
    return "\n".join(out)


# Classes defining readers and writers
class Widget():
    ''' Widget class that represents the widgets string, cstring, check '''

    def __init__(self, name, type, value, label=None, checked=None, description=None, priority=99):
        
        self.type = type
        self.name = name
        self.label = label
        self.priority = priority

        if type == "string":
            self.widget = QtGui.QLineEdit(value)
            if label:
                self.label = QtGui.QLabel(self.label)
            else:
                self.label = QtGui.QLabel(self.name)

        if type == "cstring":
            self.widget = QtGui.QLineEdit(value)
            if label:
                self.check = QtGui.QCheckBox(self.label)
            else:
                self.check = QtFGui.QCheckBox(self.name)

        if type == "check":
            if label:
                self.check = QtGui.QCheckBox(self.label)
            else:
                self.check = QtGui.QCheckBox(self.name)

        # Description
        if description:
            self.button = QtGui.QPushButton('?')
            self.description = description

        # Checked
        if checked != None and hasattr(self, "check"):
            if (checked == "True" or checked == True): checked = True
            elif (checked == "False" or checked == False): checked = False
            else: return

            # Change widgets
            self.check.setChecked(checked)
            self.check_action(checked)     

    # Widget actions
    def check_action(self, value):
        if hasattr(self, "widget"):
            if value:
                self.widget.setEnabled(True)
            else:
                self.widget.setEnabled(False)

    def button_action(self):
        if hasattr(self, "description"):
            # QtGui.QMessageBox.information(None, self.name, self.description)
            textedit(title=self.name, text=self.description) 
        

class Variables():
    ''' Variables class, one level above the widgets. Has the responsibility of getting stored
values of the widgets, storing the values, showing the widgets and deleting them. It is also
the interface towards the user when accessing variables, like get_var and is_checked. '''
    
    def __init__(self, config):
        self.config = config
        self.var = {}

        variables = []

        # Add all the variables defined in 'in_variables()'
        if self.job == "reader" and hasattr(self, "reader_variables") and self.reader_variables():
            if type(self.reader_variables()) == list:
                variables.extend(self.reader_variables())

        # Add all the variables defined in 'out_variables()'
        if self.job == "writer" and hasattr(self, "writer_variables") and self.writer_variables():
            if type(self.writer_variables()) == list:
                variables.extend(self.writer_variables())

        # Add widgets
        for var in variables:

            if type(var) != dict:
                continue

            # name, type, value, label, description
            # m,    m,    m,     o,     o
            description = None
            label = None
            priority = 99

            if "name" in var.keys():
                name = var["name"]
            else: 
                QtGui.QMessageBox.warning(None, 'Format error', "One of " + str(self.__class__.__name__) + "'s " +  self.job + " variables does not have a name.")
            if "type" in var.keys():
                typei = var["type"]
            else:
                QtGui.QMessageBox.warning(None, 'Format error', str(self.__class__.__name__) + "'s " +  self.job + " variable " + name + " does not have a type.")
            if "value" in var.keys():
                value = var["value"]
            else:
                QtGui.QMessageBox.warning(None, 'Format error', str(self.__class__.__name__) + "'s " +  self.job + " variable " + name + " does not have a default value.")
            if "label" in var.keys():
                label = var["label"]
            if "description" in var.keys():
                description = var["description"]
            if "priority" in var.keys():
                priority = var["priority"]

            # Add variable
            self.add_var(name, typei, value, label=label, description=description, priority=priority)

    def add_var(self, name, type, default, label=None, description=None, priority=99):

        # Check to see if the value is in the config
        # if so, add it instead of the default

        # Look in config
        if not self.config:
            return None

        # Get widget value
        value = self.config.get(self.__class__.__name__, name + ".widget")
        if not value:
            value = default

        # Get check value, default is None
        checked = self.config.get(self.__class__.__name__, name + ".check")
        if not checked:
            checked = default

        # Add variable
        self.var[name] = Widget(name, type, value, label=label, checked=checked, description=description, priority=priority)
    
    def get_var(self, name):

        if name not in self.var.keys():
            return None

        if self.var[name].type == "check": 
            # Get the value
            return self.var[name].check.isChecked()
        else:
            return self.var[name].widget.text()

    def is_checked(self, name):
        widget = self.var[name]
        if hasattr(widget, "check"):
            return widget.check.isChecked()
        return None

    def addWidgets(self, box, window=None):

        # Sort by variable name
       # keys = self.var.keys()
        #keys.sort()

        # Sort the variables based on their priority
        keys = self.var.keys()
        keys.sort(lambda x,y:cmp(self.var[x].priority,self.var[y].priority))

        x, y = 0, 0
        for name in keys:

            widget = self.var[name]
            y = 0
            if widget.type == "cstring":
                box.addWidget(self.var[name].check, x, y)
                y+=1
                box.addWidget(self.var[name].widget, x, y)
                y+=1

                # Add check action
                box.parentWidget().connect(self.var[name].check, QtCore.SIGNAL('stateChanged(int)'), self.var[name].check_action)

            if widget.type == "string":
                box.addWidget(self.var[name].label, x, y)
                x+=1;
                box.addWidget(self.var[name].widget, x, y)
                y+=1

            if widget.type == "check":
                box.addWidget(self.var[name].check, x, y)
                y+=1

            if hasattr(self.var[name], "button"):

                # Resize button
                if window:
                    
                    # Same size as in_file
                    button = window.out_file_button
                    size = button.width()
                    self.var[name].button.setMaximumWidth(size)

                box.addWidget(self.var[name].button, x, 2)
                box.parentWidget().connect(self.var[name].button, QtCore.SIGNAL('pressed()'), self.var[name].button_action)

            x +=1

    def deleteWidgets(self, box):

        x, y = 0, 0
        for name in self.var:

            widget = self.var[name]

            # Add value to config
            if hasattr(widget, "widget"):
                self.config.set(self.__class__.__name__, name + ".widget", self.get_var(name))
            
            if hasattr(widget, "check"):
                self.config.set(self.__class__.__name__, name + ".check", str(self.is_checked(name)))

            if widget.type == "cstring":
                box.removeWidget(self.var[name].check)
                box.removeWidget(self.var[name].widget)
                self.var[name].check.setParent(None)
                self.var[name].widget.setParent(None)

            if widget.type == "string":
                box.removeWidget(self.var[name].label)
                self.var[name].label.setParent(None)
                box.removeWidget(self.var[name].widget)
                self.var[name].widget.setParent(None)

            if widget.type == "check":
                box.removeWidget(self.var[name].check)
                self.var[name].check.setParent(None)

            if hasattr(self.var[name], "button"):
                box.removeWidget(self.var[name].button)
                self.var[name].button.setParent(None)

            x +=1

        self.var = {}

class io(Variables):
    ''' For each userformat this holds the file, and statistics about io '''
    
    def __init__(self, file, options=None, config=None, job=None):
        self.file = file
        self.options = options
        self.job = job
        self.points = 0
        self.lines = 0

        Variables.__init__(self, config=config)

    # Methods called before and after a conversion
    # self.job holds the job, either reader or writer
    def before(self):
        pass
    def after(self):
        pass

    # Stop the conversion
    def stop(self, message):
        raise Exception(message)

    # Give a warning. Best to do in after() or before()
    # as if used in next() or read() you will get spammed.
    def warning(self, message):
        QtGui.QMessageBox.warning(None, "Warning!", message)

class writer(io):
    ''' Writer class, holds the functions that can be overloaded by usercreated formats

        To create a custom writer, overload write(self, dict) and use self.write_point()
        to write to the output.'''
    
    def write(self, dict):
        return None

    # Write point to the file
    def write_point(self, string):
        if hasattr(self, "points"):
            self.points+=1
        self.file.write(string)

    def writer_variables(self):
        return None
    def writer_report(self):
        return ""

class reader(io):
    ''' Reader class, holds the functions that can be overloaded by usercreated formats

        To create a custom reader, overload next(self) and use self.return_point(self, dict)
        to return point, and read from input wuth self.file.next().'''
    
    def __iter__(self):
        return self
    def next(self):
        self.file.next()
        return None

    # Return point to the writer
    def return_point(self, dict):
        if hasattr(self, "points"):
            self.points+=1
        return dict

    def reader_variables(self):
        return None
    def reader_report(self):
        return ""


# Classes implementing formats
class Parser:
    ''' Parse a string with $(variables) and $functions(arg1,arg2,...). dict holds the variable values. '''
    
    def __init__(self, dict):
               
        # Variables, add whitespace 
        self.var = dict.copy()
        self.var['space'] = " "
        self.var['tab'] = "\t"
        self.var['newline'] = "\n"
        self.var['comma'] = ","

        # Functions
        self.functions = ["+", "-", "*", "/"]

    def parse(self, format):

        # format variables
        for key, item in self.var.iteritems():
            if key and item:
                format = format.replace("$(" + key + ")", str(item))

        # Functions
        functions = self.functions
        pos = format.find("$")
        
        # While there are dollars left
        while pos != -1:
        
            fparan = format.find("(", pos)
            nextDollar = format.find("$", pos+1)
            if nextDollar == -1:
                nextDollar = fparan+1

            # Found a right paranthesis. Does it belong to this dollar?
            if fparan != -1 and fparan < nextDollar:
                
                # Get name
                fname = format[pos+1:fparan]
                if fname in functions:
                
                    # Get end
                    end = format.find(")", fparan)
                    if end != -1:

                        # Get arguments
                        arg_string = format[fparan+1:end].split(",")
                        res = ""
                        if len(arg_string[0]) > 0:
                            try:
                                res = eval(fname.join(arg_string), {}, {})
                            except Exception, e:
                                raise Exception("Interpretation of " + fname.join(arg_string) + ":\n\n" + str(e))
                        
                        # Replace the function call with the result
                        format = format.replace(format[pos:end+1], str(res))

            # Go to next dollar
            pos = format.find("$", pos+1)

        return format

class txt(reader, writer):
    ''' .txt reader/writer. Reads line by line from a file, and tries to match the line to a given format with variables. Writers lines on the usergiven format '''
    
    def before(self):
        self.ignored = 0

    def reader_report(self):
        return "<p>Ignored " + str(self.ignored) + " line(s)</p>"

    def writer_variables(self):
        return [{   "name": "out_format",
                    "type": "string", 
                    "value": "$(x),$(y),$(z)",
                    "label": "Use format:",
                    "description": reSmall('''txt writer
----------
The program supports several file formats which in all cases define x, y and z coordinates of each point. Since some formats also include other information like pointcode, certain formats also define format specific variables. This is a list of the variables and functions one can use with the .txt writer class, which enables the user to specify a custom writer format.

Variables
+++++++++
    - $(pointcode) = pointcode from a .kof file.
    - $(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 + ...
<b>Note:</b> Valid arguments to functions are numbers and variables, as they are evaluated the first pass. Calls to functions are invalid arguments.
Example
+++++++
    - To write "x,y,z" for all points, use the format "$(x), $(y), $(z)".
    - To write "x/2, y-1, z+1" for all points, use the format "$/($(x),2),$-($(y),1),$+($(z),1)"''')}]

    def reader_variables(self):
        return [{   "name": "in_format",
                    "type": "string",
                    "value": "$(x),$(y),$(z)",
                    "label": "Uses format:",
                    "description": reSmall('''txt reader
----------
This reader enables the user to read files with a custom userdefined format. The reader tries to match the format to each line of the infile, by matching and setting the variable values as it goes from left to right. The reader learns as it moves along, so if you are looking for and matching $(x), the next $(x) will only match it's allready set value.

Unknown delimiter
+++++++++++++++++
If you do not know the delimiter, or if it varies from line to line, you can match each delimiter to it's own variable. The reader then looks for numbers, and uses anything inbetween as delimiter. For example:

    - If you have a file with "x,y,z" and "x-y_z", you can use the format "$(x)$(s1)$(y)$(s2)$(z)". This will match both lines and it will set s1,s2 accordingly. If you had used $(s) instead of s1,s2, the second line would not match as "-" does not equal "_".

Example
++++++++
    - If you have a file with points on the format "x,y;z", you can extract the values by using the format "$(x),$(y);$(z)".''')},

            {       "name": "stop_mismatch",
                    "type": "check",
                    "value": True,
                    "label": "Stop on mismatch",
                    "description": reSmall('''txt reader stop on mismatch
-----------------------------
If you check "stop on mismatch" the program will stop when it encounters a line that does not match the format given. If it is not checked, the program will ignore all lines that do not match.''')}]

    def write(self, dict):

        format = str(self.get_var("out_format"))
        parser = Parser(dict)
        self.write_point(parser.parse(format) + "\n")

    def get_next(self):
        
        if len(self.match) > 0:
            if self.match[0:2] == "$(":
                end = self.match[0:].find(")")

                # Could not find an end, it's just text
                if end == -1:
                    tmp = self.match[0]
                    self.match = self.match[1:]
                    return tmp

                tmp = self.match[0:end+1] 
                self.match = self.match[end+1:]

                # Match the variable with constants
                # and variables found so far
                if len(tmp) >=3:
                    var = tmp[2:len(tmp)-1]
                    if var in self.vars.keys():
                        return self.vars[var]
                return tmp

            else:
                tmp = self.match[0]
                self.match = self.match[1:]
                return tmp
        return ""

    def next(self):

        # Match format
        line = self.file.next().strip("\n")
        self.match = str(self.get_var("in_format"))
        self.vars = {}
        self.vars['space'] = " "
        self.vars['tab'] = "\t"
        self.vars['comma'] = ","
        
        while len(self.match) > 0:

            pattern = self.get_next()
            ahead = self.get_next()

            if pattern[0] != "$":
                if pattern[0] == line[0]:
                    line = line[1:]
                    self.match = ahead + self.match
                    continue
                else:
                    if self.is_checked("stop_mismatch"):
                        self.stop("Can not map:\n\n" + pattern + ahead + " to " + line + "\n\nThe character '" + pattern[0] + "' does not match '" + line[0] + "'.")
                    self.ignored +=1
                    return self.return_point(None)

            # Variable pattern
            else:
                      
                # Two variables of unknow size not possible if not looking
                # for something specific
                if len(ahead) > 0 and ahead[0] == "$":

                    # Find number
                    innumber = ["1","2","3","4","5","6","7","8","9","0",".", "-"]
                    number = []
                    while len(line) > 0 and line[0] in innumber:
                        number.append(line[0])
                        line = line[1:]

                    # Did not find a number
                    if number == []:

                        # The left is not a number
                        # Go forward until you encounter a number.
                        nonumber = []
                        while len(line) > 0 and line[0] not in innumber:
                            nonumber.append(line[0])
                            line = line[1:]

                        # Assign the value of the variable to the number.
                        # Is only set on the first encounter of an variable,
                        # as the rest is evaluated to the value.
                        if len(nonumber) > 0:
                            self.vars[pattern[2:len(pattern)-1]] = "".join(nonumber)
                            self.match = ahead + self.match
                            continue

                    else:

                        # Found a number
                        # Assign the value to the variable.
                        self.vars[pattern[2:len(pattern)-1]] = "".join(number)
                        self.match = ahead + self.match
                        continue

                # Find the ahead
                if ahead == "":
                    self.vars[pattern[2:len(pattern)-1]] = line
                    line = ""
                else:
                    pos = line.find(ahead)
                    if pos != -1:
                        self.vars[pattern[2:len(pattern)-1]] = line[:pos]
                        line = line[pos+1:]
                    else:

                        if self.is_checked("stop_mismatch"):
                            self.stop("Can not map:\n\n" + pattern + ahead + " to '" + line + "'\n\nas the character '" + ahead + "' is not in the string '" + line + "'.")
                        self.ignored +=1
                        return self.return_point(None)

        return self.return_point(self.vars)
class pxy(reader):
    ''' Reader class for .pxy files '''         
           
    def __iter__(self):
        return self
        
    def next(self):
            
        line = self.file.next()
        tokens = line.split(" ")
        tokens = [token for token in tokens if token != ""]
        
        # Get token 1, 2, 3
        dict = {'pre': "", "coord": "", "post":""}
        
        # Only interrested in lines on the format:
        # <number> <x> <y> <z>
        try:
            number = [int(tokens[0])]
        except ValueError:
            number = None
            
        if (len(tokens) >= 4 and number):
            dict['x'] = tokens[1]
            dict['y'] = tokens[2]
            dict['z'] = tokens[3]
            return dict
        else:
            return None
class kof(reader, writer):
    ''' Reader class for .kof files, implements the reader protocol '''

    def __iter__(self):
        return self

    def writer_variables(self):
        return [{   "name": "themecode",
                    "type": "cstring",
                    "value": "",
                    "label": "Use themecode:",
                    "priority": 1,
                    "description": reSmall('''Use themecode\n++++\nUse this themecode on all the points. If not checked,  assumes it will get themecode from the reader.''')},
                {   "name": "generate_pointcode",
                    "type": "check",
                    "value": "True",
                    "label": "Generate pointcode",
                    "priority": 2,
                    "description": reSmall('''Generate pointcode\n----\nThe nth point read from file will get pointcode n. Does not rely on having a variabled named pointcode given from a reader. If not checked, assumes that it gets pointcode from reader.''')},
                {   "name": "allow_rounding",
                    "type": "check",
                    "value": "True",
                    "label": "Allow rounding",
                    "priority": 3,
                    "description": reSmall('''Allow rounding\n----\nThe .kof 05 koordinatblokk allows only 3 decimals. If the program encounters a number with more decimals, the program will round the number. If you do not want this, uncheck the box and the program will stop if it encounter such a number.''')},
                {   "name": "allow_trimming",
                    "type": "check",
                    "value": "False",
                    "label": "Allow trimming",
                    "priority": 4,
                    "description": reSmall('''Allow trimming\n----\nThe .kof 05 koordinatblokk allows only 12, 11 and 8 digits for x, y, and h. If the program encounters a number with more digits, the program will remove digits from the left until it has the correct digits. If you do not want this, uncheck the box and the program will stop if it encounter such a number.''')}]

    def before(self):
        if self.job == "writer":
            self.point = 1
            self.caution = []

    def writer_report(self):
        report = []
        if "round" in self.caution:
            report.append(reSmall("Caution!\n////\nThe program has rounded off numbers because the .kof format only allows 3 digits after the decimal point."))
        if "trim" in self.caution:
            report.append(reSmall("Extra caution!\n////\nThe program has trimmed numbers because the .kof format only allows 12, 11, and 8 digits for x, y, and h."))

        return "".join(report)

    def after(self):
        if self.job == "writer":
            if "round" in self.caution:
                self.warning("The program has rounded off numbers because the .kof format only allows 3 digits after the decimal point. \n\nPlease be aware that the point data has lost precision.")
            if "trim" in self.caution:
                self.warning("The program has removed trailing digits off numbers because the .kof format only allows 12, 11 and 8 digits in a 05 koordinatblokk. \n\nPlease be aware that the point data has been altered severly!")
            
    # Pad string to length characters,
    # put space in position (left, right).
    def pad(self, string, position, length, char=" "):
        while (len(string) < length):
            if position == "left":
                string = char + string # ugh
            if position == "right":
                string = string + char # ugh
        if len(string) > length:
            if position == "left":
                return string[len(string)-length:]
            if position == "right":
                return string[:length]
        return string

    # Writer for .kof
    def write(self, dict):

        # KOORDINATBLOKK
        #
        # -05 PPPPPPPPPP KKKKKKKK XXXXXXXX.XXX YYYYYYY.YYY ZZZZ.ZZZ Bk MMMMMMM
        #  05 45         4616        59319.054   58196.831 123.321
        #
        out = [" 05"]

        # Pointcode
        pointcode = "00"
        if self.is_checked("generate_pointcode"):
            pointcode = str(self.point)
            self.point+=1
        else:
            if "pointcode" in dict.keys():
                pointcode = dict["pointcode"]
            else:
                pointcode = ""
        out.append(self.pad(pointcode, "right", 10))
        
        # Themecode
        themecode = "0000"
        if self.is_checked("themecode"):
            themecode = str(self.get_var("themecode"))
        else: # Assume we get themecode
            if "themecode" in dict.keys():
                themecode = dict["themecode"]
            else:
                themecode = ""
        out.append(self.pad(themecode, "right", 8))

        # X, Y, H
        coord = [dict["x"]]
        coord.append(dict["y"])
        coord.append(dict["z"])
        label = ["x", "y", "h"]
        limit = [12, 11, 8] # Number of digits allowed

        # The point must have maximum of 3 digits
        # after the decimal point.
        n = 0
        for n in range(0, len(coord)):
            i = str(float(str(coord[n])))

            # Divide the number into two segments, before
            # and after the decimal point
            declen = len(str(i).split(".")[-1])
            if declen > 3:

                if self.is_checked("allow_rounding"):
                    # Need to round, give a warning to the user.
                    self.caution.append("round")
                    i = str(round(float(i), 3))[:len(str(i).split(".")[0])+len(".")+3]
                else:
                    self.stop("The program has encountered a number it must round to continue: \n\n" + label[n] + " of point " + pointcode + " is " + i + ", but must be rounded to " + str(round(float(i), 3))[:len(str(i).split(".")[0])+len(".")+3] + "\n\nCheck 'allow rounding' to allow the program to round to three decimals.")

            elif declen < 3:
                # Need to add zeros
                i = self.pad(i, "right", len(i)-declen+3, "0")

            # Pad to left
            # 
            # Is it room for the number?
            if len(i) > limit[n]:

                if self.is_checked("allow_trimming"):
                    # Give warning it alters the data severly by removing trailing digits!
                    self.caution.append("trim")
                else:
                    self.stop("The program has encountered a number it must trim to continue: \n\n" + label[n] + " of point " + pointcode + " is " + str(i) + ", but it can only have " + str(limit[n]) + " digits.\n\nCheck 'allow trimming' to allow the program to trim the number to the needed digits.")

            # Pad and append
            i = self.pad(i, "left", limit[n])
            out.append(i)

        # Write point
        self.write_point(" ".join(out) + "\n")

    def next(self):
            
        line = self.file.next()
        type = line[1:3]

        # Only interested in blocks with type 05 called 
        # KOORDINATBLOKK and it's three values X, Y, H,
        # pointcode(name/id) and themecode (the value which is not a real after 
        # pointcode).
        #
        #   DB   Pkt   Tk   X       Y       H      Bk Merk
        # ^ I2 ^ A10 ^ A8 ^ F12.3 ^ F11.3 ^ F8.3 ^ I2 ^ A7
        # -05 PPPPPPPPPP KKKKKKKK XXXXXXXX.XXX YYYYYYY.YYY ZZZZ.ZZZ Bk MMMMMMM
        #  05 45         4616        59319.054   58196.831  123.321

        # -05 PPPPPPPPPP KKKKKKKK XXXXXXXX.XXX YYYYYYY.YYY ZZZZ.ZZZ Bk MMMMMMM
        #
       
        # New: Handle Pkt and/or Tk set to blank
        if (type == '05'):

            field = [
                ("type", 3), 
                ("pointcode", 10),
                ("themecode", 8),
                ("x", 12),
                ("y", 11), 
                ("z", 8)]
        
            dict = {}
            line = line.strip("\r\n")
            
            i = 0
            for name, length in field:
                val = line[i:i+length].strip(" ")
                if len(val) > 0: dict[name] = val
                i += length+1

            """
            tokens = line.split(" ")
            tokens = [token for token in tokens if token != ""]
            tokens.reverse()
            
            # Type
            dict['type'] = tokens.pop()
            
            # Pointcode
            dict['pointcode'] = tokens.pop()
            
            tmp = tokens.pop()
            
            # Themecode
            real = (not tmp.find(".") == -1)
            if not real:
                dict['themecode'] = tmp
            else:
                tokens.append(tmp)
                
            # x, y, z
            dict['x'] = tokens.pop()
            dict['y'] = tokens.pop()
            dict['z'] = tokens.pop()"""
            
            return dict
                            
        else:
            return None
class dxf(reader, writer):
    ''' Reader, writer class for .dxf files. Highly experimental as I do not actually have autoCAD :)'''

    def writer_variables(self):
        return [{   "name" : "writer_switch_xy",
                    "type": "check", 
                    "value": True, 
                    "label": "Switch x/y"}]

    def reader_variables(self):
        return [{   "name" : "reader_switch_xy",
                    "type": "check", 
                    "value": True, 
                    "label": "Switch x/y"}]

    def __iter__(self):
        return self

    def before(self):
        if self.job == "writer":
            self.file.write("999\nCoordConvert " + version + "\n0\nSECTION\n2\nHEADER\n0\nENDSEC\n0\nSECTION\n2\nENTITIES\n")

    def after(self):
        if self.job == "writer":
            self.file.write("0\nENDSEC\n0\nEOF")

    def write(self, dict):
        if self.is_checked("writer_switch_xy"):
            self.file.write( "0\nPOINT\n100\nAcDbPoint\n10\n%s\n20\n%s\n30\n%s\n" % (dict['y'], dict['x'], dict['z']))
        else:             
            self.file.write( "0\nPOINT\n100\nAcDbPoint\n10\n%s\n20\n%s\n30\n%s\n" % (dict['x'], dict['y'], dict['z']))

    def nextLine(self):
        return self.file.next().strip("\r\n\t ")

    def next(self):
        
        ''' The dxf autoCAD format specification states that
            a POINT is defined as:

                100    Subclass marker (AcDbPoint)
                10     Point location (in WCS)
                       DXF: X value; APP: 3D point
                20, 30 DXF: Y and Z values of point location (in WCS)

            Meaning that a POINT starts with groupcode 100
            followed by a marker, and then 10 followed by x,
            followed by 20 and y, and 30 and z. z is mandatory, 
            and is usually 0 for 2d.

        '''

        # Get groupcode
        line = self.nextLine()
        if (line == "100"):

            # Get marker
            marker = self.nextLine()
            if marker == "AcDbPoint":

                dict = {}
                while len(dict) < 3:
                    
                    # Get code
                    code = self.nextLine()
                    if code == "10": 
                        if self.is_checked("reader_switch_xy"):
                            dict['y'] = self.nextLine()
                        else:
                            dict['x'] = self.nextLine()

                    if code == "20": 
                        if self.is_checked("reader_switch_xy"):
                            dict['x'] = self.nextLine()
                        else:
                            dict['y'] = self.nextLine()

                    if code == "30": dict['z'] = self.nextLine()

                return dict

        # Groupcode indicating POINT
        elif (line == "0"):

            # Get marker
            marker = self.nextLine()
            if marker == "POINT":

                dict = {}
                while len(dict) < 3:
                    
                    # Get code
                    code = self.nextLine()
                    if code == "10": 
                        if self.is_checked("reader_switch_xy"):
                            dict['y'] = self.nextLine()
                        else:
                            dict['x'] = self.nextLine()

                    if code == "20": 
                        if self.is_checked("reader_switch_xy"):
                            dict['x'] = self.nextLine()
                        else:
                            dict['y'] = self.nextLine()

                    if code == "30": dict['z'] = self.nextLine()
                    if code == "38": dict['z'] = self.nextLine()

                return dict

        else:
            return None
class csv(reader, writer):
    ''' Reader and writer class for .csv files '''

    def writer_variables(self):
        return [{
                    "name": "pointcode", 
                    "type": "check", 
                    "value": True, 
                    "label": "Keep pointcodes"}]

    def next(self):

        # Reader for CSV, x, y, z
        # Does not handle pointcodes
        # as the writer does.
        dict = {}
        xyz = self.file.next().split(",")

        dict['x'] = xyz[0]
        dict['y'] = xyz[1]
        dict['z'] = xyz[2].strip("\r\n\t ")

        return dict

    def write(self, dict):
    
        # CSV is comma seperated values
        # Pointcode will be the first value
        # then x, y, z
        out = []
        if self.is_checked("pointcode") and "pointcode" in dict.keys():
            out.append(dict['pointcode'])

        out.extend([dict['x'],dict['y'],dict['z']])
        format = ",".join(out)
        self.file.write(format + "\n")

# Code handling the exchange of data between the reader and writer
class coords ():
    ''' Class for organizing read and write between different file formats '''            
        
    def __init__(self, filename, out, options=None, readers=None, 
                 writers=None, reader=None, writer=None, window=None):
    
        # Check if out exist, and if so, ask if the user wants to overwrite it
        if not isinstance(out, Dummy) and os.path.exists(out) and window:
            reply = QtGui.QMessageBox.question(window, 'The file exists', "The file\n\n" + out + "\n\nalready exists.\n\nAre you sure you want to overwrite the file?", QtGui.QMessageBox.No, QtGui.QMessageBox.Yes)
            if reply == QtGui.QMessageBox.No:
                raise Exception("The conversion was cancelled.")
            
        # Don't erase the content of the file
        if filename == out:
            raise IOError("In and outfile is the same. This would erase your data.")
            return

        self.filename = filename
        self.filenameout = out
        self.file = open(self.filename)
        self.out = None
        if not isinstance(self.filenameout, Dummy):
            self.out = open(self.filenameout, "w")
        self.writer, self.reader = None, None

        # Use the reader provided
        if reader:
            self.reader = reader
            reader.file = self.file
        else:
            # Find correct reader
            ext = self.filename.split(".")[-1]
            if (readers and readers.has_key(ext)):
                self.reader = eval(ext + "(self.file, options)")
            
        if (self.reader == None):
            raise IOError("Reader for format ." + ext + " does not exist")
        
        # Use the writer provided
        if writer:
            self.writer = writer
            self.writer.file = self.out
        else:
            ext = self.filenameout.split(".")[-1]
            if (writers and writers.has_key(ext)):
                self.writer = eval(ext + "(self.out, options)")
            
        if (self.writer == None):
            raise IOError("Writer for format ." + ext + " does not exist")
          
    def convert(self, window=None, title=["Converting", "The conversion was cancelled."], eventMod=10, progMod=10):
        
        if ((not self.writer) or (not self.reader)):
            raise Exception("Does not support file extensions")
            return
        
        # Get size of infile in bytes
        self.reader.file.seek(0, os.SEEK_END)
        size = self.reader.file.tell()
        self.reader.file.seek(0)
        
        # Setup progressbar
        if (window):
            progress = QtGui.QProgressDialog(title[0], 'Cancel', 0, size, window)
            progress.setMinimumDuration(0)
            progress.setValue(0)
            
        # Tell writer to initialize
        # Write header for instance
        self.writer.before()
        self.reader.before()
        old = False
        
        # Catch exceptions from the reader and writer.
        try:

            # Convert data
            num = 0; # percent = 0
            for line in self.reader:
                
                pos = self.reader.file.tell()
                if (pos*100/size)%eventMod == 0:
                    window.parent.processEvents()
                    
                    # Was cancelled?
                    if (progress.wasCanceled()):
                        raise Exception(title[1])
                    
                if (line):  
                    self.writer.write(line)
                    num += 1
                    
                    if (window):
                        
                        # Only update 100 times :\
                        if (not old):
                            # pos = self.reader.file.tell()
                            # newPercent = (pos*100)/size
                            if (pos*100/size)%progMod == 0:
                                progress.setValue(pos)
                            # percent = newPercent
                        else:
                            progress.setValue(self.reader.file.tell())
                                
        except Exception, e:
            if (window): 
                progress.setValue(size) # Hide progressbar
            raise e
                    
        if (window):
            progress.setValue(size)

        # Tell writer to end
        # Write tail for instance
        self.writer.after()
        self.reader.after()
        
        return num
                                   
    def __del__(self):
    
        if (hasattr(self, "file")):
            self.file.close()
        if (hasattr(self, "out") and self.out):
            self.out.close()

''' Listing the readers and writers available, and options '''           
options = { "pointcode" : False, "format" : [False, "$(x),$(y),$(z)"], "separator" : "$(comma)" }
readers = { "csv" : "csv", "pxy" : "pxy", "kof" : "kof", "dxf" : "dxf" , "txt":"txt" }
writers = { "csv" : "csv", "dxf" : "dxf", "txt":"txt", "kof":"kof"}
        
# ConfigParser and window editing it
class ConfigParser():
    ''' ConfigParser to parse configfiles 
        
        Created a custom one so that it works on
        old programs compiled with pyinstall. 
        
    '''

    def __init__(self):
        self.sections = {}
        
    def add_section(self, name):
        self.sections[name] = {}
    
    def set(self, section, key, value):
        if section not in self.sections.keys(): 
            self.add_section(section)
        section = self.sections[section]
        section[key] = value
        
    def get(self, section, key):
        
        if section in self.sections.keys():
            section = self.sections[section]
            if key in section.keys():
                return section[key]
        
        return None
        
    def write(self, file):
        
        for section in self.sections:
            file.write("[" + section + "]\n")
            for key, value in self.sections[section].iteritems():
                file.write(str(key) + " = \"" + str(value) + "\"\n")
        
    def read(self, filename):
        
        file = open(filename, "r")
        section = ""
        
        for line in file:
            
            line = line.strip("\n")
            if len(line) > 0 and (line[0] == "[" and line[-1] == "]"):
            
                # Remove section decoration
                section = line[1:-1]
                self.add_section(section)
                
            elif section != "":
                
                line = line.split("=")
                if len(line) >= 2:
                
                    # Get val in " <val> "
                    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, [str(k), str(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, [str(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(str(section), str(item.text(0)), str(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(str(section), str(key), str(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 before(self):
        self.write_point("""set term png
set output '%s'
set pm3d
set dgrid3d
set view 060,030
splot "-" using 1:2:3 with lines 
\n""" % self.bitmap)
        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("Points")
        
        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="CoordConvert")
        file_ = os.fdopen(fd)
        file_.close()

        try:
            k = coords(str(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] + [str(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()
        
        # 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):
        return
        #print x, y
        # Change line in file about view
        file_ = open(file, "r+")
        
        # 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
        

        choice = self.draw_box.currentIndex()
        drawMethod = self.with_box.currentIndex()
        
        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=" + str(self.urlencode(self.name_edit.text().toAscii())))
        get.append("email=" + str(self.urlencode(self.contact_edit.text().toAscii())))
        get.append("version="+version)
        get.append("text="+ str(self.urlencode(self.text_edit.toPlainText().toAscii())))

        url = "http://www.0x6.org/CoordConvert/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()
        self.text.setHtml("<body style='background: #fefefe; color: #000;'><table><tr><td>" + text + "</td></tr></table></body>")
        # 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 psyco
#psyco.full()

# 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("CoordConvert", "started")
        if started:
            started = int(started)+1
        else:
            started = 1
        config.set("CoordConvert", "started", str(started))

        # Skin
        self.refresh_style()

        self.parent = parent
        self.setWindowTitle('CoordConvert ' + 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 = str(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 = str(data.text())
                    text = text.replace("file://", "") # Linux stuff
                    text = text.strip("\r\n")
                elif data.hasUrls():
                    text = str(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("CoordConvert", "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("CoordConvert", "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("CoordConvert", "releasenotes")
        if not notes or notes != version:
            self.show_releasenotes()

            # Set to shown
            self.config.set("CoordConvert", "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("CoordConvert", "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("CoordConvert", "infile")
        if not inn:
            inn = self.in_file_edit.text()
        out = self.config.get("CoordConvert", "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("<h1>Supported formats</h1><h2>Readers</h2>" + str(readers.keys()) + "<h2>Writers</h2>" + str(writers.keys()), title="Supported formats", parent=self)

        textedit(reSmall('''
Supported formats
-----------------
Readers
++++++
''' + str(readers.keys()) + '''
Writers
+++++++
''' + str(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 CoordConvert.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("CoordConvert", "infile", self.in_file_edit.text())
        if hasattr(self, "in_file_edit"):
            config.set("CoordConvert", "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',
        '''CoordConvert %s (%s) </br>
<br/>
%s<br/>
%s<br/>
<br/>
%s''' % (version, modified, author, contact, url))"""
        about_window(self)
        #a = plot_window(self)
        #file_stats_window(self)
        """a.setText('''<html>CoordConvert %s (%s)<br/>
<br/>
%s<br/>
%s<br/>
<br/>
%s</html>''' % (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 = str(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 = str(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"):
        outfile = ".".join(str(filename).split(".")[:-1]) + "." + ext
        if not (outfile == "." + ext):
            self.out_file_edit.setText(outfile)
            
    # Convert between fileformats
    def convert(self, noask=False):
    
        if (str(self.in_file_edit.text()) == "" or str(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(str(self.in_file_edit.text()), str(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 = ["<h1>Report</h1>", "<h2>Reader</h2>",

                            "<p>Read " + str(k.reader.file.tell()) + " byte(s) from " + k.reader.file.name + "</p>",
                            str(k.reader.reader_report()),
                            "<h2>Writer</h2>",  
                            "<p>Wrote " + str(k.writer.file.tell()) + " byte(s) to " + k.writer.file.name + "</p>",
                            str(k.writer.writer_report()),
                            "<h2>Result</h2>Converted " + str(lines) + " points."]

                # Show report
                textedit("".join(report), title="Report")

            # Save number of points converted
            if self.config:
                converted = self.config.get("CoordConvert", "converted")
                if converted:
                    converted = int(converted) + lines
                else:
                    converted = lines
                self.config.set("CoordConvert", "converted", str(converted))
            
        except Exception, msg:
            QtGui.QMessageBox.critical(self, 'Error', str(msg))
            
    # 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/CoordConvert/" + 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(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 = ["<html>" + name, " %s (%s) <br/><br/>Erik ", "<font style='color:", "#000000", u"'>Solhaug </font>Fløisbonn<br/>%s<br/><br/>%s<html>"""]
        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("<hr/>")

            # Get value from config
            started = parent.config.get("CoordConvert", "started")
            if started:
                self.stats.append("Started " + started + " time(s)<br/>")
            else: self.stats.append("")

            self.converted = parent.config.get("CoordConvert", "converted")
            if self.converted:
                self.stats.append("Converted " + self.converted + u" point(s)<br/>")
                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:)<br/>")
            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)<br/>"

        # 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 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)
   
    # 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()