#!/usr/bin/env python

import sys
import os
import subprocess
import string
import socket
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from gui import GuiWidget
from db import PgConn
from Gdata import Data
from GpsData import GpsClass
from vrt import VrtG
from query import QueryGrass
from Savekml import KmlView
from epsg import SearchEpsg
from grass.script.core import *
from joyt import *

from episg import *
from pysqlite2 import dbapi2 as sqlite3

clon = 0
clat = 0
item = 'LookAt'
head = '0'

grassenv = gisenv()
rasterpath = grassenv['GISDBASE']+'/'+grassenv['LOCATION_NAME']+'/'+ \
           grassenv['MAPSET']+'/cellhd/'
vectorpath = grassenv['GISDBASE']+'/'+grassenv['LOCATION_NAME']+'/'+ \
           grassenv['MAPSET']+'/vector/'
apppath = os.path.abspath(os.path.dirname(sys.argv[0]))

sqlitedb = apppath+'/geonames.sqlite'


class MyClass(QObject):
    def init(self):
        self.Value=0
        self.ZoomValue = 0
        self.w = GuiWidget()
        self.queryvalue = 0
        self.query = QueryGrass()
        self.vrt = VrtG()
        self.gps = GpsClass()
        self.kmlview = KmlView()
        self.SearchEpsg = SearchEpsg()
        self.slvallon = self.setcenter()[0]
        self.slvallat = self.setcenter()[1]
        self.w.Lon.setText("0")
        self.w.Lat.setText("0")
        self.fxvallon = self.SetPosition()[0]
        self.fxvallat = self.SetPosition()[1]
        self.slstep = 1
        tables = self.gettablelist()
        self.w.Place.clear()
        self.w.Place.addItems(tables)
        self.w.GrassType.hide()
        self.w.InputType.hide()
        self.connect(self.w.GrassType, SIGNAL("currentIndexChanged(int)"),
                     self.GetType)
        self.connect(self.w.ZoomSlider, SIGNAL("valueChanged(int)"), 
                     self.setValueZoomSpinBox)
        self.connect(self.w.ZoomSlider, SIGNAL("valueChanged(int)"), 
                     self.sendFunction)
        self.connect(self.w.ZoomSpinBox, SIGNAL("valueChanged(double)"), 
                     self.setValueZoomSlider)
        self.connect(self.w.ZoomSpinBox, SIGNAL("valueChanged(double)"), 
                     self.sendFunction)
        self.connect(self.w.ZoomSlider, SIGNAL("valueChanged()"), 
                     self.setValue)
        self.connect(self.w.ZoomSpinBox, SIGNAL("valueChanged()"), 
                     self.setValue)
        self.connect(self.w.RangeSlider, SIGNAL("valueChanged(int)"), 
                     self.setValueRangeSpinBox)
        self.connect(self.w.RangeSlider, SIGNAL("valueChanged(int)"), 
                     self.sendFunction)
        self.connect(self.w.RangeSpinBox, SIGNAL("valueChanged(double)"), 
                     self.setValueRangeSlider)
        self.connect(self.w.RangeSpinBox, SIGNAL("valueChanged(double)"), 
                     self.sendFunction)
        self.connect(self.w.RangeSlider, SIGNAL("valueChanged()"), 
                     self.setValue)
        self.connect(self.w.RangeSpinBox, SIGNAL("valueChanged()"), 
                     self.setValue)
        self.connect(self.w.RollSlider, SIGNAL("valueChanged(int)"), 
                     self.setValueRollSpinBox)
        self.connect(self.w.RollSlider, SIGNAL("valueChanged(int)"), 
                     self.sendFunction)
        self.connect(self.w.RollSpinBox, SIGNAL("valueChanged(double)"), 
                     self.setValueRollSlider)
        self.connect(self.w.RollSpinBox, SIGNAL("valueChanged(double)"), 
                     self.sendFunction)
        self.connect(self.w.RollSlider, SIGNAL("valueChanged()"), 
                     self.setValue)
        self.connect(self.w.RollSpinBox, SIGNAL("valueChanged()"), 
                     self.setValue)
        self.connect(self.w.PitchSlider, SIGNAL("valueChanged(int)"), 
                     self.setValuePitchSpinBox)
        self.connect(self.w.PitchSlider, SIGNAL("valueChanged(int)"), 
                     self.sendFunction)
        self.connect(self.w.PitchSpinBox, SIGNAL("valueChanged(double)"), 
                     self.setValuePitchSlider)
        self.connect(self.w.PitchSpinBox, SIGNAL("valueChanged(double)"), 
                     self.sendFunction)
        self.connect(self.w.PitchSlider, SIGNAL("valueChanged()"), 
                     self.setValue)
        self.connect(self.w.PitchSpinBox, SIGNAL("valueChanged()"), 
                     self.setValue)
        self.connect(self.w.HandlingSlider, SIGNAL("valueChanged(int)"), 
                     self.setValueHandlingSpinBox)
        self.connect(self.w.HandlingSlider, SIGNAL("valueChanged(int)"), 
                     self.sendFunction)
        self.connect(self.w.HandlingSpinBox, SIGNAL("valueChanged(double)"), 
                     self.setValueHandlingSlider)
        self.connect(self.w.HandlingSpinBox, SIGNAL("valueChanged(double)"), 
                     self.sendFunction)
        self.connect(self.w.HandlingSlider, SIGNAL("valueChanged()"), 
                     self.setValue)
        self.connect(self.w.HandlingSpinBox, SIGNAL("valueChanged()"), 
                     self.setValue)
        self.connect(self.w.SpeedSpinBox, SIGNAL("valueChanged(double)"), 
                     self.setValueSpeedSpinBox)
        self.connect(self.w.SpeedSpinBox, SIGNAL("valueChanged()"), 
                     self.setValue)
        self.connect(self.w.SpeedMultipler, SIGNAL("valueChanged(double)"), 
                     self.setValueSpeedMultipler)
        self.connect(self.w.SpeedMultipler, SIGNAL("valueChanged()"), 
                     self.setValueM)
        self.connect(self.w.ZoomStepSpinBox, SIGNAL("valueChanged()"), 
                     self.setValueZM)
        self.connect(self.w.ZoomMultipler, SIGNAL("valueChanged(double)"), 
                     self.setValueZoomMultipler)
        self.connect(self.w.ZoomMultipler, SIGNAL("valueChanged()"), 
                     self.setValueZ)
        self.w.north.setAutoRepeat(True)
        self.w.northeast.setAutoRepeat(True)
        self.w.south.setAutoRepeat(True)
        self.w.east.setAutoRepeat(True)
        self.w.west.setAutoRepeat(True)
        self.w.southwest.setAutoRepeat(True)
        self.w.northwest.setAutoRepeat(True)
        self.w.southeast.setAutoRepeat(True)
        self.connect(self.w.center, SIGNAL("clicked()"),
                     self.ResetPosition)
        self.connect(self.w.actionGPS, SIGNAL("triggered()"),
                     self.GPSunceckbuttons)
        self.connect(self.w.actionGPS, SIGNAL("triggered()"),
                     self.GpsHandling)
        self.connect(self.w.actionLonLat, SIGNAL("triggered()"),
                     self.LonLatunceckbuttons)
        self.connect(self.w.actionGrass, SIGNAL("triggered()"),
                     self.Grassunceckbuttons)
        self.connect(self.w.actionJoystick, SIGNAL("triggered()"),
			                     self.Joyunceckbuttons)
        self.connect(self.w.actionJoystick, SIGNAL("triggered()"), 
                                 self.startstopjoy)	
        self.connect(self.w.actionJoystick, SIGNAL("triggered()"), 
                                 self.stopstartjoy)
        self.connect(self.w.actionExit, SIGNAL("triggered()"), qApp, SLOT("quit()"))
        self.connect(self.w.actionDB_setting, SIGNAL("triggered()"),
                     self.pgsetting)
        self.connect(self.w.actionDataexp, SIGNAL("triggered()"),
                     self.processdata)
        self.connect(self.w.actionData_2, SIGNAL("triggered()"),
                     self.processdata)
        self.connect(self.w.actionQuery, SIGNAL("triggered()"),
                     self.querydata)
        self.connect(self.w.actionQuery_2, SIGNAL("triggered()"),
                     self.querydata)
        self.connect(self.w.actionNMEA, SIGNAL("triggered()"),
                     self.GpsHandling)
        self.connect(self.w.north, SIGNAL("clicked()"),
                     self.inclat)
        self.connect(self.w.northeast, SIGNAL("clicked()"),
                     self.inclatlon)
        self.connect(self.w.south, SIGNAL("clicked()"),
                     self.declat)
        self.connect(self.w.east, SIGNAL("clicked()"),
                     self.inclon)
        self.connect(self.w.west, SIGNAL("clicked()"),
                     self.declon)
        self.connect(self.w.southwest, SIGNAL("clicked()"),
                     self.declatlon)
        self.connect(self.w.northwest, SIGNAL("clicked()"),
                     self.inclatdeclon)
        self.connect(self.w.southeast, SIGNAL("clicked()"),
                     self.declatinclon)
        self.connect(self.w.center, SIGNAL("clicked()"),
                     self.setcenter)
        self.connect(self.w.Head, SIGNAL("currentIndexChanged(int)"),
                     self.GetHead)
        self.connect(self.w.View, SIGNAL("currentIndexChanged(int)"),
                     self.GetViewType)
        self.connect(self.w.SendPosition, SIGNAL("clicked()"),
                     self.SetLonLat)
        self.connect(self.w.SendPosition, SIGNAL("clicked()"),
                     self.ResetPosition)
        self.w.actionHideSlider.setChecked(True)
        self.w.actionHideSpinbox.setChecked(True)
        self.w.actionHideStepTool.setChecked(True)
        self.w.actionHide_place_position.setChecked(True)
        self.connect(self.w.Lon, SIGNAL("textChanged(QString)"), self.query.setLonValue)
        self.connect(self.w.Lat, SIGNAL("textChanged(QString)"), self.query.setLatValue)
        self.connect(self.w.RollSpinBox, SIGNAL("valueChanged(double)"), self.gps.setChangeRoll)
        self.connect(self.w.PitchSpinBox, SIGNAL("valueChanged(double)"), self.gps.setChangePitch)
        self.connect(self.w.HandlingSpinBox, SIGNAL("valueChanged(double)"), self.gps.setChangeHead)
        self.connect(self.w.ZoomSpinBox, SIGNAL("valueChanged(double)"), self.gps.setChangeZoom)
        self.connect(self.w.RangeSpinBox, SIGNAL("valueChanged(double)"), self.gps.setChangeRange)
        self.connect(self.w.View, SIGNAL("currentIndexChanged(QString) "), self.gps.setChangeVtype)
        self.connect(self.w.actionSavekml, SIGNAL("triggered()"), self.kmldialog)
        #self.connect(self.w.actionSavekml, SIGNAL("triggered()"), self.addearth)
        self.connect(self.w.actionVrt, SIGNAL("triggered()"), self.vrtdata)
        #self.connect(self.w.QueryEpsg, SIGNAL("clicked()"), self.SEpsg)
        self.connect(self.w.actionEpsg, SIGNAL("triggered()"), self.SEpsg)
        self.connect(self.w.actionHideSlider, SIGNAL("triggered()"), self.hideSlider)
        self.connect(self.w.actionHideSpinbox, SIGNAL("triggered()"), self.hideSpin)
        self.connect(self.w.actionHideStepTool, SIGNAL("triggered()"), self.hideStep)
        self.connect(self.w.actionHide_place_position, SIGNAL("triggered()"), self.hidePos)
        self.connect(self.w.Place, SIGNAL("currentIndexChanged(int)"),
                     self.itemlist)
        self.connect(self.w.placezone, SIGNAL("currentIndexChanged(int)"), self.setplacezonecoords)
        self.connect(self.w.InputType, SIGNAL("currentIndexChanged(int)"), self.regioncoords)
        #self.connect(self.w.SendPosition, SIGNAL("clicked()"), self.itemlist)  
        self.joy = joy()
        self.w.show()


    def hideSlider(self):
        if self.w.actionHideSlider.isChecked():
            self.w.HandlingSlider.show()
            self.w.ZoomSlider.show()
            self.w.RollSlider.show()
            self.w.PitchSlider.show()
            self.w.RangeSlider.show()
            self.w.Zoomlabel.show()
            self.w.Rangelabel.show()
            self.w.Rolllabel.show()
            self.w.Pitchlabel.show()
            self.w.Headinglabel.show()
            self.w.line1.show()
            self.w.line2.show()
            self.w.line3.show()
            self.w.line4.show()
            self.w.line5.show()
        else :
            self.w.HandlingSlider.hide()
            self.w.ZoomSlider.hide()
            self.w.RollSlider.hide()
            self.w.PitchSlider.hide()
            self.w.RangeSlider.hide()
            self.w.Zoomlabel.hide()
            self.w.Rangelabel.hide()
            self.w.Rolllabel.hide()
            self.w.Pitchlabel.hide()
            self.w.Headinglabel.hide()
            self.w.line1.hide()
            self.w.line2.hide()
            self.w.line3.hide()
            self.w.line4.hide()
            self.w.line5.hide()
            
    def hideSpin(self):
        if self.w.actionHideSpinbox.isChecked():
            self.w.ZoomSpinBox.show()
            self.w.RangeSpinBox.show()
            self.w.RollSpinBox.show()
            self.w.PitchSpinBox.show()
            self.w.HandlingSpinBox.show()
        else :
            self.w.ZoomSpinBox.hide()
            self.w.RangeSpinBox.hide()
            self.w.RollSpinBox.hide()
            self.w.PitchSpinBox.hide()
            self.w.HandlingSpinBox.hide()

    def hideStep(self):
        if self.w.actionHideStepTool.isChecked():
            self.w.movinggroup.show()
        else :
            self.w.movinggroup.hide()
            
    def hidePos(self):
        if self.w.actionHide_place_position.isChecked():
            self.w.Place.show()
            self.w.placezone.show()
            #self.w.GrassType.show()
            #self.w.InputType.show()
            #self.w.View.show()
        else :
            self.w.Place.hide()
            self.w.placezone.hide()
            #self.w.GrassType.hide()
            #self.w.InputType.hide()
            #self.w.View.hide()

    def setValueZoomSpinBox(self, z):
        self.ZoomValue = float(z)
        self.w.ZoomSpinBox.setRange(-100, 27536977)
        zstep = float(self.w.ZoomStepSpinBox.value())
        zmult = float(self.w.ZoomMultipler.value())
        zstep = zstep * (10 ** zmult)
        self.w.ZoomSpinBox.setSingleStep(zstep)
        self.w.ZoomSpinBox.setValue(self.ZoomValue)
        
    def setValueZoomSlider(self, z):
        self.ZoomValue = int(z)
        self.w.ZoomSlider.setMinimum(-100)
        self.w.ZoomSlider.setMaximum(27536977)
        self.w.ZoomSlider.setValue(self.ZoomValue)

    def setValueRangeSpinBox(self, r):
        self.RangeValue = float(r)
        self.w.RangeSpinBox.setRange(-100, 27536977)
        zstep = float(self.w.ZoomStepSpinBox.value())
        zmult = float(self.w.ZoomMultipler.value())
        zstep = zstep * (10 ** zmult)
        self.w.RangeSpinBox.setSingleStep(zstep)
        self.w.RangeSpinBox.setValue(self.RangeValue)

    def setValueRangeSlider(self, r):
        self.RangeValue = int(r)
        self.w.RangeSlider.setMinimum(-100)
        self.w.RangeSlider.setMaximum(27536977)
        self.w.RangeSlider.setValue(self.RangeValue)

    def setValueRollSpinBox(self, rl):
        self.RollValue = float(rl)
        self.w.RollSpinBox.setRange(-90, 90)
        self.w.RollSpinBox.setSingleStep(1)
        self.w.RollSpinBox.setValue(self.RollValue)

    def setValueRollSlider(self, rl):
        self.RollValue = int(rl)
        self.w.RollSlider.setMinimum(-90)
        self.w.RollSlider.setMaximum(90)
        self.w.RollSlider.setValue(self.RollValue)

    def setValuePitchSpinBox(self, p):
        self.PitchValue = float(p)
        self.w.PitchSpinBox.setRange(-90, 90)
        self.w.PitchSpinBox.setSingleStep(1)
        self.w.PitchSpinBox.setValue(self.PitchValue)

    def setValuePitchSlider(self, p):
        self.PitchValue = int(p)
        self.w.PitchSlider.setMinimum(-90)
        self.w.PitchSlider.setMaximum(90)
        self.w.PitchSlider.setValue(self.PitchValue)

    def setValueHandlingSpinBox(self, h):
        self.HandlingValue = float(h)
        self.w.HandlingSpinBox.setRange(-360, 360)
        self.w.HandlingSpinBox.setSingleStep(1)
        self.w.HandlingSpinBox.setValue(self.HandlingValue)

    def setValueHandlingSlider(self, h):
        self.HandlingValue = int(h)
        self.w.HandlingSlider.setMinimum(-360)
        self.w.HandlingSlider.setMaximum(360)
        self.w.HandlingSlider.setValue(self.HandlingValue)

    def setValueSpeedSpinBox(self, s):
        self.SpeedValue = float(s)
        self.w.SpeedSpinBox.setRange(0.01, 1)
        self.w.SpeedSpinBox.setSingleStep(0.01)
        self.w.SpeedSpinBox.setValue(self.SpeedValue)

    def setValueSpeedMultipler(self, s):
        self.SpeedM = float(s)
        self.w.SpeedMultipler.setRange(1, 10)
        self.w.SpeedMultipler.setSingleStep(1)
        self.w.SpeedMultipler.setValue(self.SpeedM)

    def setValueZoomMSpinBox(self, s):
        self.ZoomValue = float(s)
        self.w.ZoomSpinBox.setRange(0.01, 1)
        self.w.ZoomSpinBox.setSingleStep(0.01)
        self.w.ZoomSpinBox.setValue(self.ZoomValue)

    def setValueZoomMultipler(self, s):
        self.ZoomStepValue = float(s)
        self.w.ZoomMultipler.setRange(1, 10)
        self.w.ZoomMultipler.setSingleStep(1)
        self.w.ZoomMultipler.setValue(self.ZoomStepValue)

    def GetHead(self,index):
        global head
        head = self.w.Head.itemText(index)
        if head == 'N':
            head = '0'
        if head == 'NE':
            head = '45' 
        if head == 'E':
            head = '90'
        if head == 'SE':
            head = '135'
        if head == 'S':
            head = '180'
        if head == 'SW':
            head = '-135'
        if head == 'W':
            head = '-90'
        if head == 'NW':
            head = '-45'
        if head == 'Auto':
            head = 'angle'
        if head == 'Manual':
            head = 'Manual'
        return head

    def GetViewType(self,index):
        ViewT = self.w.View.itemText(index)
        return ViewT

    def sendFunction(self):
        heads = head
        if head == str('Manual'):
            heads = self.w.HandlingSlider.value()
        if self.w.actionLonLat.isChecked():
            ossimxml = '<Set target=":navigator" vref="wgs84">\
            <%s><longitude>%s</longitude><latitude>%s</latitude>\
            <altitude>%s</altitude><heading>%s</heading><pitch>%s</pitch>\
            <roll>%s</roll><altitudeMode>absolute</altitudeMode>\
            <range>%s</range></%s></Set>' % (item, unicode(self.fxvallon), 
                                             unicode(self.fxvallat), 
                                             self.w.ZoomSlider.value(), heads, 
                                             self.w.PitchSlider.value() , 
                                             self.w.RollSlider.value(),
                                             self.w.RangeSlider.value(), item)
        if self.w.actionGrass.isChecked():
            ossimxml = '<Set target=":navigator" vref="wgs84"><%s>\
            <longitude>%s</longitude><latitude>%s</latitude>\
            <altitude>%s</altitude><heading>%s</heading>\
            <pitch>%s</pitch><roll>%s</roll>\
            <altitudeMode>absolute</altitudeMode>\
            <range>%s</range></%s></Set>' % (item, unicode(self.slvallon), 
                                             unicode(self.slvallat), 
                                             self.w.ZoomSlider.value(), heads, 
                                             self.w.PitchSlider.value(), 
                                             self.w.RollSlider.value(),
                                             self.w.RangeSlider.value(), item)
        if self.w.actionGPS.isChecked():
            #self.CrossClassLon = float(self.CrossClassLon)
            #self.CrossClassLat = float(self.CrossClassLat)
            #self.CrossClassLon = 0 
            #self.CrossClassLat = 0
            coordsfile = apppath+'/lonlatfile'
            f = open(coordsfile, "r")
            lonlat = f.readline()
            lonlat = lonlat.split(' ')
            lon = lonlat[0]
            lat = lonlat[1]
            ossimxml = '<Set target=":navigator" vref="wgs84"><%s>\
            <longitude>%s</longitude><latitude>%s</latitude>\
            <altitude>%s</altitude><heading>%s</heading>\
            <pitch>%s</pitch><roll>%s</roll>\
            <altitudeMode>absolute</altitudeMode>\
            <range>%s</range></%s></Set>' % (item, lon, 
                                             lat, 
                                             self.w.ZoomSlider.value(), heads, 
                                             self.w.PitchSlider.value(), 
                                             self.w.RollSlider.value(),
                                             self.w.RangeSlider.value(), item)
        ossim = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        ossim.connect(("127.0.0.1", 7000))
        ossim.send(ossimxml)
        ossim.close()

    def ResetPosition(self):
        heads = head
        if self.w.actionLonLat.isChecked():
            self.fxvallon = self.SetPosition()[0]
            self.fxvallat = self.SetPosition()[1]
            ossimxml = '<Set target=":navigator" vref="wgs84"><%s>\
            <longitude>%s</longitude><latitude>%s</latitude>\
            <altitude>%s</altitude><heading>%s</heading><pitch>%s</pitch>\
            <roll>%s</roll><altitudeMode>absolute</altitudeMode>\
            <range>%s</range></%s></Set>' % (item, unicode(self.fxvallon), 
                                             unicode(self.fxvallat), 
                                             self.w.ZoomSlider.value(), heads, 
                                             self.w.PitchSlider.value(), 
                                             self.w.RollSlider.value(),
                                             self.w.RangeSlider.value(), item)
            self.w.Lat.setText(unicode(self.fxvallat))
            self.w.Lon.setText(unicode(self.fxvallon))

        if self.w.actionGrass.isChecked():
            self.slvallon = self.setcenter()[0]
            self.slvallat = self.setcenter()[1]
            ossimxml = '<Set target=":navigator" vref="wgs84"><%s>\
            <longitude>%s</longitude><latitude>%s</latitude>\
            <altitude>%s</altitude><heading>%s</heading><pitch>%s</pitch>\
            <roll>%s</roll><altitudeMode>absolute</altitudeMode>\
            <range>%s</range></%s></Set>' % (item, unicode(self.slvallon), 
                                             unicode(self.slvallat), 
                                             self.w.ZoomSlider.value(), heads, 
                                             self.w.PitchSlider.value(), 
                                             self.w.RollSlider.value(),
                                             self.w.RangeSlider.value(), item)
            self.w.Lat.setText(unicode(self.slvallat))
            self.w.Lon.setText(unicode(self.slvallon))


        if self.w.actionGPS.isChecked():
            #self.CrossClassLon = float(self.CrossClassLon)
            #self.CrossClassLat = float(self.CrossClassLat)
            coordsfile = apppath+'/lonlatfile'
            f = open(coordsfile, "r")
            lonlat = f.readline()
            lonlat = lonlat.split(' ')
            lon = lonlat[0]
            lat = lonlat[1]
            ossimxml = '<Set target=":navigator" vref="wgs84"><%s>\
            <longitude>%s</longitude><latitude>%s</latitude>\
            <altitude>%s</altitude><heading>%s</heading>\
            <pitch>%s</pitch><roll>%s</roll><altitudeMode>absolute</altitudeMode>\
            <range>%s</range></%s></Set>' % (item, lon, 
                                             lat, 
                                             self.w.ZoomSlider.value(), heads, 
                                             self.w.PitchSlider.value(), 
                                             self.w.RollSlider.value(),
                                             self.w.RangeSlider.value(), item)
            self.w.Lat.setText(unicode(self.CrossClassLat))
            self.w.Lon.setText(unicode(self.CrossClassLon))
        ossim = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        ossim.connect(("127.0.0.1", 7000))
        ossim.send(ossimxml)
        ossim.close()


    def inclat(self):
        step = float(self.w.SpeedSpinBox.value())
        mult = float(self.w.SpeedMultipler.value())
        step = step * (10 ** -mult)
        heads = head
        if head == str('Manual'):
            heads = self.w.HandlingSlider.value()
        if self.w.actionLonLat.isChecked():
            self.fxvallat += step
            ossimxml = '<Set target=":navigator" vref="wgs84"><%s>\
            <longitude>%s</longitude><latitude>%s</latitude>\
            <altitude>%s</altitude><heading>%s</heading><pitch>%s</pitch>\
            <roll>%s</roll><altitudeMode>absolute</altitudeMode>\
            <range>%s</range></%s></Set>' % (item, unicode(self.fxvallon), 
                                             unicode(self.fxvallat), 
                                             self.w.ZoomSlider.value(), heads, 
                                             self.w.PitchSlider.value(), 
                                             self.w.RollSlider.value(),
                                             self.w.RangeSlider.value(), item)
            self.w.Lat.setText(unicode(self.fxvallat))
            self.w.Lon.setText(unicode(self.fxvallon))
        if self.w.actionGrass.isChecked():
            self.slvallat += step
            ossimxml = '<Set target=":navigator" vref="wgs84"><%s>\
            <longitude>%s</longitude><latitude>%s</latitude>\
            <altitude>%s</altitude><heading>%s</heading><pitch>%s</pitch>\
            <roll>%s</roll><altitudeMode>absolute</altitudeMode>\
            <range>%s</range></%s></Set>' % (item, unicode(self.slvallon), 
                                             unicode(self.slvallat), 
                                             self.w.ZoomSlider.value(), heads, 
                                             self.w.PitchSlider.value(), 
                                             self.w.RollSlider.value(),
                                             self.w.RangeSlider.value(), item)
            self.w.Lat.setText(unicode(self.slvallat))
            self.w.Lon.setText(unicode(self.slvallon))
        if self.w.actionGPS.isChecked():
            self.CrossClassLat = float(self.CrossClassLat)
            self.CrossClassLat += step
            ossimxml = '<Set target=":navigator" vref="wgs84"><%s>\
            <longitude>%s</longitude><latitude>%s</latitude>\
            <altitude>%s</altitude><heading>%s</heading><pitch>%s</pitch>\
            <roll>%s</roll><altitudeMode>absolute</altitudeMode>\
            <range>%s</range></%s></Set>' % (item, unicode(self.CrossClassLon), 
                                             unicode(self.CrossClassLat), 
                                             self.w.ZoomSlider.value(), heads, 
                                             self.w.PitchSlider.value(), 
                                             self.w.RollSlider.value(),
                                             self.w.RangeSlider.value(), item)
            self.w.Lat.setText(unicode(self.CrossClassLat))
            self.w.Lon.setText(unicode(self.CrossClassLon))
        ossim = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        ossim.connect(("127.0.0.1", 7000))
        ossim.send(ossimxml)
        ossim.close()

    def declat(self):
        step = float(self.w.SpeedSpinBox.value())
        mult = float(self.w.SpeedMultipler.value())
        heads = head
        step = step * (10 ** -mult)
        if head == str('Manual'):
            heads = self.w.HandlingSlider.value()
        if self.w.actionLonLat.isChecked():
            self.fxvallat -= step
            ossimxml = '<Set target=":navigator" vref="wgs84"><%s>\
            <longitude>%s</longitude><latitude>%s</latitude>\
            <altitude>%s</altitude><heading>%s</heading>\
            <pitch>%s</pitch><roll>%s</roll><altitudeMode>absolute</altitudeMode>\
            <range>%s</range></%s></Set>' % (item, unicode(self.fxvallon), 
                                             unicode(self.fxvallat), 
                                             self.w.ZoomSlider.value(), heads, 
                                             self.w.PitchSlider.value(), 
                                             self.w.RollSlider.value(),
                                             self.w.RangeSlider.value(), item)
            self.w.Lat.setText(unicode(self.fxvallat))
            self.w.Lon.setText(unicode(self.fxvallon))
        if self.w.actionGrass.isChecked():
            self.slvallat -= step
            ossimxml = '<Set target=":navigator" vref="wgs84"><%s>\
            <longitude>%s</longitude><latitude>%s</latitude>\
            <altitude>%s</altitude><heading>%s</heading><pitch>%s</pitch>\
            <roll>%s</roll><altitudeMode>absolute</altitudeMode>\
            <range>%s</range></%s></Set>' % (item, unicode(self.slvallon), 
                                             unicode(self.slvallat), 
                                             self.w.ZoomSlider.value(), heads, 
                                             self.w.PitchSlider.value(), 
                                             self.w.RollSlider.value(),
                                             self.w.RangeSlider.value(), item)
            self.w.Lat.setText(unicode(self.slvallat))
            self.w.Lon.setText(unicode(self.slvallon))
        if self.w.actionGPS.isChecked():
            self.CrossClassLat = float(self.CrossClassLat)
            self.CrossClassLat -= step
            ossimxml = '<Set target=":navigator" vref="wgs84"><%s>\
            <longitude>%s</longitude><latitude>%s</latitude>\
            <altitude>%s</altitude><heading>%s</heading>\
            <pitch>%s</pitch><roll>%s</roll><altitudeMode>absolute</altitudeMode>\
            <range>%s</range></%s></Set>' % (item, unicode(self.CrossClassLon), 
                                             unicode(self.CrossClassLat), 
                                             self.w.ZoomSlider.value(), heads, 
                                             self.w.PitchSlider.value(), 
                                             self.w.RollSlider.value(),
                                             self.w.RangeSlider.value(), item)
            self.w.Lat.setText(unicode(self.CrossClassLat))
            self.w.Lon.setText(unicode(self.CrossClassLon))
        ossim = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        ossim.connect(("127.0.0.1", 7000))
        ossim.send(ossimxml)
        ossim.close()

    def inclon(self):
        step = float(self.w.SpeedSpinBox.value())
        mult = float(self.w.SpeedMultipler.value())
        #self.fxvallon += step
        heads = head
        step = step * (10 ** -mult)
        if head == str('Manual'):
            heads = self.w.HandlingSlider.value()
        if self.w.actionLonLat.isChecked():
            self.fxvallon += step
            ossimxml = '<Set target=":navigator" vref="wgs84"><%s>\
            <longitude>%s</longitude><latitude>%s</latitude>\
            <altitude>%s</altitude><heading>%s</heading><pitch>%s</pitch>\
            <roll>%s</roll><altitudeMode>absolute</altitudeMode>\
            <range>%s</range></%s></Set>' % (item, unicode(self.fxvallon), 
                                             unicode(self.fxvallat), 
                                             self.w.ZoomSlider.value(), heads, 
                                             self.w.PitchSlider.value(), 
                                             self.w.RollSlider.value(),
                                             self.w.RangeSlider.value(), item)
            self.w.Lat.setText(unicode(self.fxvallat))
            self.w.Lon.setText(unicode(self.fxvallon))
        if self.w.actionGrass.isChecked():
            self.slvallon += step
            ossimxml = '<Set target=":navigator" vref="wgs84"><%s>\
            <longitude>%s</longitude><latitude>%s</latitude>\
            <altitude>%s</altitude><heading>%s</heading><pitch>%s</pitch>\
            <roll>%s</roll><altitudeMode>absolute</altitudeMode>\
            <range>%s</range></%s></Set>' % (item, unicode(self.slvallon), 
                                             unicode(self.slvallat), 
                                             self.w.ZoomSlider.value(), heads, 
                                             self.w.PitchSlider.value(), 
                                             self.w.RollSlider.value(),
                                             self.w.RangeSlider.value(), item)
            self.w.Lat.setText(unicode(self.slvallat))
            self.w.Lon.setText(unicode(self.slvallon))
        if self.w.actionGPS.isChecked():
            self.CrossClassLon = float(self.CrossClassLon)
            self.CrossClassLon += step
            ossimxml = '<Set target=":navigator" vref="wgs84"><%s>\
            <longitude>%s</longitude><latitude>%s</latitude>\
            <altitude>%s</altitude><heading>%s</heading><pitch>%s</pitch>\
            <roll>%s</roll><altitudeMode>absolute</altitudeMode>\
            <range>%s</range></%s></Set>' % (item, unicode(self.CrossClassLon), 
                                             unicode(self.CrossClassLat), 
                                             self.w.ZoomSlider.value(), heads, 
                                             self.w.PitchSlider.value(), 
                                             self.w.RollSlider.value(),
                                             self.w.RangeSlider.value(), item)
            self.w.Lat.setText(unicode(self.CrossClassLat))
            self.w.Lon.setText(unicode(self.CrossClassLon))
        ossim = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        ossim.connect(("127.0.0.1", 7000))
        ossim.send(ossimxml)
        ossim.close()

    def declon(self):
        step = float(self.w.SpeedSpinBox.value())
        mult = float(self.w.SpeedMultipler.value())
        heads = head
        step = step * (10 ** -mult)
        if head == str('Manual'):
            heads = self.w.HandlingSlider.value()
        if self.w.actionLonLat.isChecked():
            self.fxvallon -= step
            ossimxml = '<Set target=":navigator" vref="wgs84"><%s>\
            <longitude>%s</longitude><latitude>%s</latitude>\
            <altitude>%s</altitude><heading>%s</heading><pitch>%s</pitch>\
            <roll>%s</roll><altitudeMode>absolute</altitudeMode>\
            <range>%s</range></%s></Set>' % (item, unicode(self.fxvallon), 
                                             unicode(self.fxvallat), 
                                             self.w.ZoomSlider.value(), heads, 
                                             self.w.PitchSlider.value(), 
                                             self.w.RollSlider.value(),
                                             self.w.RangeSlider.value(), item)
            self.w.Lat.setText(unicode(self.fxvallat))
            self.w.Lon.setText(unicode(self.fxvallon))
        if self.w.actionGrass.isChecked():
            self.slvallon -= step
            ossimxml = '<Set target=":navigator" vref="wgs84"><%s>\
            <longitude>%s</longitude><latitude>%s</latitude>\
            <altitude>%s</altitude><heading>%s</heading><pitch>%s</pitch>\
            <roll>%s</roll><altitudeMode>absolute</altitudeMode>\
            <range>%s</range></%s></Set>' % (item, unicode(self.slvallon), 
                                             unicode(self.slvallat), 
                                             self.w.ZoomSlider.value(), heads, 
                                             self.w.PitchSlider.value(), 
                                             self.w.RollSlider.value(),
                                             self.w.RangeSlider.value(), item)
            self.w.Lat.setText(unicode(self.slvallat))
            self.w.Lon.setText(unicode(self.slvallon))
        if self.w.actionGPS.isChecked():
            self.CrossClassLon = float(self.CrossClassLon)
            self.CrossClassLon -= step
            ossimxml = '<Set target=":navigator" vref="wgs84"><%s>\
            <longitude>%s</longitude><latitude>%s</latitude>\
            <altitude>%s</altitude><heading>%s</heading><pitch>%s</pitch>\
            <roll>%s</roll><altitudeMode>absolute</altitudeMode>\
            <range>%s</range></%s></Set>' % (item, unicode(self.CrossClassLon), 
                                             unicode(self.CrossClassLat), 
                                             self.w.ZoomSlider.value(), heads, 
                                             self.w.PitchSlider.value(), 
                                             self.w.RollSlider.value(), 
                                             self.w.RangeSlider.value(), item)
            self.w.Lat.setText(unicode(self.CrossClassLat))
            self.w.Lon.setText(unicode(self.CrossClassLon))
        ossim = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        ossim.connect(("127.0.0.1", 7000))
        ossim.send(ossimxml)
        ossim.close()

    def inclatlon(self):
        step = float(self.w.SpeedSpinBox.value())
        mult = float(self.w.SpeedMultipler.value())
        heads = head
        step = step * (10 ** -mult)
        if head == str('Manual'):
            heads = self.w.HandlingSlider.value()
        if self.w.actionLonLat.isChecked():
            self.fxvallat += step
            self.fxvallon += step
            ossimxml = '<Set target=":navigator" vref="wgs84"><%s>\
            <longitude>%s</longitude><latitude>%s</latitude>\
            <altitude>%s</altitude><heading>%s</heading><pitch>%s</pitch>\
            <roll>%s</roll><altitudeMode>absolute</altitudeMode>\
            <range>%s</range></%s></Set>' % (item, unicode(self.fxvallon), 
                                             unicode(self.fxvallat), 
                                             self.w.ZoomSlider.value(), heads, 
                                             self.w.PitchSlider.value(), 
                                             self.w.RollSlider.value(), 
                                             self.w.RangeSlider.value(), item)
            self.w.Lat.setText(unicode(self.fxvallat))
            self.w.Lon.setText(unicode(self.fxvallon))
        if self.w.actionGrass.isChecked():
            self.slvallat += step
            self.slvallon += step
            ossimxml = '<Set target=":navigator" vref="wgs84"><%s>\
            <longitude>%s</longitude><latitude>%s</latitude>\
            <altitude>%s</altitude><heading>%s</heading><pitch>%s</pitch>\
            <roll>%s</roll><altitudeMode>absolute</altitudeMode>\
            <range>%s</range></%s></Set>' % (item, unicode(self.slvallon), 
                                             unicode(self.slvallat), 
                                             self.w.ZoomSlider.value(), heads, 
                                             self.w.PitchSlider.value(), 
                                             self.w.RollSlider.value(), 
                                             self.w.RangeSlider.value(), item)
            self.w.Lat.setText(unicode(self.slvallat))
            self.w.Lon.setText(unicode(self.slvallon))
        if self.w.actionGPS.isChecked():
            self.CrossClassLon = float(self.CrossClassLon)
            self.CrossClassLat = float(self.CrossClassLat)
            self.CrossClassLon += step
            self.CrossClassLat += step
            ossimxml = '<Set target=":navigator" vref="wgs84"><%s>\
            <longitude>%s</longitude><latitude>%s</latitude>\
            <altitude>%s</altitude><heading>%s</heading><pitch>%s</pitch>\
            <roll>%s</roll><altitudeMode>absolute</altitudeMode>\
            <range>%s</range></%s></Set>' % (item, unicode(self.CrossClassLon), 
                                             unicode(self.CrossClassLat), 
                                             self.w.ZoomSlider.value(), heads, 
                                             self.w.PitchSlider.value(), 
                                             self.w.RollSlider.value(), 
                                             self.w.RangeSlider.value(), item)
            self.w.Lat.setText(unicode(self.CrossClassLat))
            self.w.Lon.setText(unicode(self.CrossClassLon))
        ossim = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        ossim.connect(("127.0.0.1", 7000))
        ossim.send(ossimxml)
        ossim.close()

    def declatlon(self):
        step = float(self.w.SpeedSpinBox.value())
        mult = float(self.w.SpeedMultipler.value())
        heads = head
        step = step * (10 ** -mult)
        if head == str('Manual'):
            heads = self.w.HandlingSlider.value()
        if self.w.actionLonLat.isChecked():
            self.fxvallat -= step
            self.fxvallon -= step
            ossimxml = '<Set target=":navigator" vref="wgs84"><%s>\
            <longitude>%s</longitude><latitude>%s</latitude>\
            <altitude>%s</altitude><heading>%s</heading><pitch>%s</pitch>\
            <roll>%s</roll><altitudeMode>absolute</altitudeMode>\
            <range>%s</range></%s></Set>' % (item, unicode(self.fxvallon), 
                                             unicode(self.fxvallat), 
                                             self.w.ZoomSlider.value(), heads, 
                                             self.w.PitchSlider.value() , 
                                             self.w.RollSlider.value(), 
                                             self.w.RangeSlider.value(), item)
            self.w.Lat.setText(unicode(self.fxvallat))
            self.w.Lon.setText(unicode(self.fxvallon))
        if self.w.actionGrass.isChecked():
            self.slvallat -= step
            self.slvallon -= step
            ossimxml = '<Set target=":navigator" vref="wgs84"><%s>\
            <longitude>%s</longitude><latitude>%s</latitude>\
            <altitude>%s</altitude><heading>%s</heading><pitch>%s</pitch>\
            <roll>%s</roll><altitudeMode>absolute</altitudeMode>\
            <range>%s</range></%s></Set>' % (item, unicode(self.slvallon), 
                                             unicode(self.slvallat), 
                                             self.w.ZoomSlider.value(), heads, 
                                             self.w.PitchSlider.value(), 
                                             self.w.RollSlider.value(), 
                                             self.w.RangeSlider.value(), item)
            self.w.Lat.setText(unicode(self.slvallat))
            self.w.Lon.setText(unicode(self.slvallon))
        if self.w.actionGPS.isChecked():
            self.CrossClassLon = float(self.CrossClassLon)
            self.CrossClassLat = float(self.CrossClassLat)
            self.CrossClassLon -= step
            self.CrossClassLat -= step
            ossimxml = '<Set target=":navigator" vref="wgs84"><%s>\
            <longitude>%s</longitude><latitude>%s</latitude>\
            <altitude>%s</altitude><heading>%s</heading><pitch>%s</pitch>\
            <roll>%s</roll><altitudeMode>absolute</altitudeMode>\
            <range>%s</range></%s></Set>' % (item, unicode(self.CrossClassLon), 
                                             unicode(self.CrossClassLat), 
                                             self.w.ZoomSlider.value(), heads, 
                                             self.w.PitchSlider.value(), 
                                             self.w.RollSlider.value(), 
                                             self.w.RangeSlider.value(), item)
            self.w.Lat.setText(unicode(self.CrossClassLat))
            self.w.Lon.setText(unicode(self.CrossClassLon))
        ossim = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        ossim.connect(("127.0.0.1", 7000))
        ossim.send(ossimxml)
        ossim.close()

    def inclatdeclon(self):
        step = float(self.w.SpeedSpinBox.value())
        mult = float(self.w.SpeedMultipler.value())
        step = step * (10 ** -mult)
        heads = head
        if head == str('Manual'):
            heads = self.w.HandlingSlider.value()
        if self.w.actionLonLat.isChecked():
            self.fxvallat += step
            self.fxvallon -= step
            ossimxml = '<Set target=":navigator" vref="wgs84"><%s>\
            <longitude>%s</longitude><latitude>%s</latitude>\
            <altitude>%s</altitude><heading>%s</heading><pitch>%s</pitch>\
            <roll>%s</roll><altitudeMode>absolute</altitudeMode>\
            <range>%s</range></%s></Set>' % (item, unicode(self.fxvallon), 
                                             unicode(self.fxvallat), 
                                             self.w.ZoomSlider.value(), heads, 
                                             self.w.PitchSlider.value(), 
                                             self.w.RollSlider.value(), 
                                             self.w.RangeSlider.value(), item)
            self.w.Lat.setText(unicode(self.fxvallat))
            self.w.Lon.setText(unicode(self.fxvallon))
        if self.w.actionGrass.isChecked():
            self.slvallat += step
            self.slvallon -= step
            ossimxml = '<Set target=":navigator" vref="wgs84"><%s>\
            <longitude>%s</longitude><latitude>%s</latitude>\
            <altitude>%s</altitude><heading>%s</heading><pitch>%s</pitch>\
            <roll>%s</roll><altitudeMode>absolute</altitudeMode>\
            <range>%s</range></%s></Set>' % (item, unicode(self.slvallon), 
                                             unicode(self.slvallat), 
                                             self.w.ZoomSlider.value(), heads, 
                                             self.w.PitchSlider.value() , 
                                             self.w.RollSlider.value(), 
                                             self.w.RangeSlider.value(), item)
            self.w.Lat.setText(unicode(self.slvallat))
            self.w.Lon.setText(unicode(self.slvallon))
        if self.w.actionGPS.isChecked():
            self.CrossClassLon = float(self.CrossClassLon)
            self.CrossClassLat = float(self.CrossClassLat)
            self.CrossClassLon -= step
            self.CrossClassLat += step
            ossimxml = '<Set target=":navigator" vref="wgs84"><%s>\
            <longitude>%s</longitude><latitude>%s</latitude>\
            <altitude>%s</altitude><heading>%s</heading><pitch>%s</pitch>\
            <roll>%s</roll><altitudeMode>absolute</altitudeMode>\
            <range>%s</range></%s></Set>' % (item, unicode(self.CrossClassLon), 
                                             unicode(self.CrossClassLat), 
                                             self.w.ZoomSlider.value(), heads, 
                                             self.w.PitchSlider.value(), 
                                             self.w.RollSlider.value(), 
                                             self.w.RangeSlider.value(), item)
            self.w.Lat.setText(unicode(self.CrossClassLat))
            self.w.Lon.setText(unicode(self.CrossClassLon))
        ossim = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        ossim.connect(("127.0.0.1", 7000))
        ossim.send(ossimxml)
        ossim.close()

    def declatinclon(self):
        step = float(self.w.SpeedSpinBox.value())
        mult = float(self.w.SpeedMultipler.value())
        step = step * (10 ** -mult)
        heads = head
        if head == str('Manual'):
            heads = self.w.HandlingSlider.value()
        if self.w.actionLonLat.isChecked():
            self.fxvallat -= step
            self.fxvallon += step
            ossimxml = '<Set target=":navigator" vref="wgs84"><%s>\
            <longitude>%s</longitude><latitude>%s</latitude>\
            <altitude>%s</altitude><heading>%s</heading><pitch>%s</pitch>\
            <roll>%s</roll><altitudeMode>absolute</altitudeMode>\
            <range>%s</range></%s></Set>' % (item, unicode(self.fxvallon), 
                                             unicode(self.fxvallat), 
                                             self.w.ZoomSlider.value(), heads, 
                                             self.w.PitchSlider.value(), 
                                             self.w.RollSlider.value(), 
                                             self.w.RangeSlider.value(), item)
            self.w.Lat.setText(unicode(self.fxvallat))
            self.w.Lon.setText(unicode(self.fxvallon))
        if self.w.actionGrass.isChecked():
            self.slvallat -= step
            self.slvallon += step
            ossimxml = '<Set target=":navigator" vref="wgs84"><%s>\
            <longitude>%s</longitude><latitude>%s</latitude>\
            <altitude>%s</altitude><heading>%s</heading><pitch>%s</pitch>\
            <roll>%s</roll><altitudeMode>absolute</altitudeMode>\
            <range>%s</range></%s></Set>' % (item, unicode(self.slvallon), 
                                             unicode(self.slvallat), 
                                             self.w.ZoomSlider.value(), heads, 
                                             self.w.PitchSlider.value(), 
                                             self.w.RollSlider.value(), 
                                             self.w.RangeSlider.value(), item)
            self.w.Lat.setText(unicode(self.slvallat))
            self.w.Lon.setText(unicode(self.slvallon))
        if self.w.actionGPS.isChecked():
            self.CrossClassLon = float(self.CrossClassLon)
            self.CrossClassLat = float(self.CrossClassLat)
            self.CrossClassLon += step
            self.CrossClassLat -= step
            ossimxml = '<Set target=":navigator" vref="wgs84"><%s>\
            <longitude>%s</longitude><latitude>%s</latitude>\
            <altitude>%s</altitude><heading>%s</heading><pitch>%s</pitch>\
            <roll>%s</roll><altitudeMode>absolute</altitudeMode>\
            <range>%s</range></%s></Set>' % (item, unicode(self.CrossClassLon), 
                                             unicode(self.CrossClassLat), 
                                             self.w.ZoomSlider.value(), heads, 
                                             self.w.PitchSlider.value(), 
                                             self.w.RollSlider.value(), 
                                             self.w.RangeSlider.value(), item)
            self.w.Lat.setText(unicode(self.CrossClassLat))
            self.w.Lon.setText(unicode(self.CrossClassLon))
        ossim = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        ossim.connect(("127.0.0.1", 7000))
        ossim.send(ossimxml)
        ossim.close()

    def SetLonLat(self):
        heads = head
        if head == str('Manual'):
            heads = self.w.HandlingSlider.value()
        ossimxml = '<Set target=":navigator" vref="wgs84"><%s>\
        <longitude>%s</longitude><latitude>%s</latitude>\
        <altitude>%s</altitude><heading>%s</heading><pitch>%s</pitch>\
        <roll>%s</roll><altitudeMode>absolute</altitudeMode>\
        <range>%s</range></%s></Set>' % (item, unicode(self.w.Lon.text()), 
                                         unicode(self.w.Lat.text()), 
                                         self.w.ZoomSlider.value(), heads, 
                                         self.w.PitchSlider.value(), 
                                         self.w.RollSlider.value(), 
                                         self.w.RangeSlider.value(), item)
        ossim = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        ossim.connect(("127.0.0.1", 7000))
        ossim.send(ossimxml)
        ossim.close()

    def setValue(self, v):
        self.Value = v

    def setValueM(self, v):
        self.Value = v

    def setValueZ(self, v):
        self.Value = v

    def setValueZM(self, v):
        self.Value = v

    def setcenter(self):
        global centro
        clon = 0
        clat = 0
        s = read_command("g.region", flags='l')
        if s == '':
            s = read_command("g.region", flags='c')
            region = parse_key_val(s, ':')
            clon = region['east-west center']
            clat = region['north-south center']
        else:
            region = parse_key_val(s, ':')
            clon = region['center longitude']
            clat = region['center latitude']
        clon = str(clon)
        clat = str(clat)
        clon = clon.replace(':', " ")
        clat = clat.replace(':', " ")
        if clat[-1] == 'N':
            signlat = 1
        if clat[-1] == 'S':
            signlat = -1
        if clon[-1] == 'E':
            signlon = 1
        if clon[-1] == 'W':
            signlon = -1
        clat = clat[:-1] 
        clon = clon[:-1]
        clat = [float(i) for i in clat.split()]
        clon = [float(i) for i in clon.split()]
        clat = (clat[0] + (clat[1] / 60) + clat[2] / 3600) * float(signlat)
        clon = (clon[0] + (clon[1] / 60) + clon[2] / 3600) * float(signlon)
        slvallon = clon 
        slvallat = clat
        centro = (clon,clat)
        return centro

    def SetPosition(self):
        global centro
        lon = float(self.w.Lon.text())
        lat = float(self.w.Lat.text())
        centro = (lon,lat)
        return centro

    def PrintPosition(self, lon, lat, zoom, roll, pitch, heading, range):
        testo = '''Longitude : %s 
Latitude : %s 
Altitude : %s
Heading : %s
Roll : %s
Pitch : %s
Range : %s
''' % (lon, lat, zoom, roll, pitch, heading, range)

    def GetType(self,index):
        global Gtype
        Gtype = self.w.GrassType.itemText(index)
        if Gtype == 'region':
            rg = list_strings('region')
            region = []
            for i in rg:
                rgname = i.split('@', 2)[0]
                region.append(rgname)
            region.sort()
            self.w.InputType.clear()
            self.w.InputType.addItems(region)
        if Gtype == 'vect':
            vc = list_strings('vect')
            vector = []
            for i in vc:
                vecname = i.split('@', 2)[0]
                vector.append(vecname)
            vector.sort()
            self.w.InputType.clear()
            self.w.InputType.addItems(vector)
        if Gtype == 'rast':
            rs = list_strings('rast')
            raster = []
            for i in rs:
                rasname = i.split('@', 2)[0]
                raster.append(rasname)
            raster.sort()
            self.w.InputType.clear()
            self.w.InputType.addItems(raster)
        #return GType

    def GPSunceckbuttons(self):
        self.w.actionLonLat.setChecked(False)
        self.w.actionGrass.setChecked(False)
        self.w.actionJoystick.setChecked(False)

    def LonLatunceckbuttons(self):
        self.w.actionGPS.setChecked(False)
        self.w.actionGrass.setChecked(False)
        self.w.actionJoystick.setChecked(False)

    def Grassunceckbuttons(self):
        self.w.actionGPS.setChecked(False)
        self.w.actionLonLat.setChecked(False)
        self.w.actionJoystick.setChecked(False)

    def Joyunceckbuttons(self):
        self.w.actionGPS.setChecked(False)
        self.w.actionLonLat.setChecked(False)
        self.w.actionGrass.setChecked(False)

    def startstopjoy(self):
        if self.w.actionJoystick.isChecked():
            self.joy.togglej()

    def stopstartjoy(self):
        if not self.w.actionJoystick.isChecked():
            self.joy.stop()

    def pgsetting(self):
        self.pgconn = PgConn()
        self.pgconn.show()

    def processdata(self):
        self.pdata = Data()
        self.pdata.show()

    def querydata(self):
        print self.slvallon, self.slvallat
        #self.query = QueryGrass(self.slvallon, self.slvallat)
        self.query.show()

    def vrtdata(self):
        self.vrt.show()

    def GpsHandling(self):
        print item,self.w.ZoomSlider.value(),head,self.w.PitchSlider.value(),self.w.RollSlider.value(),self.w.RangeSlider.value()
        #self.gps = GpsClass(item,self.w.ZoomSlider.value(),head,self.w.PitchSlider.value(),self.w.RollSlider.value(),self.w.RangeSlider.value())
        self.gps.show()

    def kmldialog(self):
        print 'pressed'
        self.kmlview.show()

    def SEpsg(self):
        self.searchepsg = SearchEpsg()
        self.searchepsg.show()

    def GeomTr(self):
        self.Geom = Geom()
        self.Geom.show()


    def addearth(self):
        ossimxml = '<ossimPlanetQtLegend><ossimPlanetOssimImageLayer>\
        <name>earth.jpg</name><description>ossimPlanetTextureLayer</description>\
        <id/><enableFlag>1</enableFlag><transparentColor>\
        <enableFlag>0</enableFlag><color>0 0 0</color>\
        </transparentColor><filterType>nearest neighbor</filterType>\
        <ossimPlanetExtents><minLat>-90.000000000000000</minLat>\
        <maxLat>89.933333333333337</maxLat>\
        <minLon>-179.933333333333337</minLon>\
        <maxLon>180.000000000000000</maxLon>\
        <minScale>0.000000000000000</minScale>\
        <maxScale>1897728.887088264338672</maxScale>\
        <minHeight>-4503599627370495.000000000000000</minHeight>\
        <maxHeight>4503599627370496.000000000000000</maxHeight>\
        <minDate><ossimDate version="1"><month>1</month><day>1</day>\
        <year>1</year><hour>0</hour><minutes>0</minutes>\
        <seconds>0</seconds><fractionalSecond>0.000000000000000</fractionalSecond>\
        <ossimDate></minDate><maxDate><ossimDate version="1"><month>12</month>\
        <day>31</day><year>9999</year><hour>0</hour><minutes>0</minutes>\
        <seconds>0</seconds><fractionalSecond>0.000000000000000</fractionalSecond>\
        </ossimDate></maxDate></ossimPlanetExtents><ossimPlanetLookAt>\
        <latitude>-0.066666666666649</latitude><longitude>0.066666666666634</longitude>\
        <altitude>0.000000000000000</altitude><range>44755145.097128249704838</range>\
        <roll>0.000000000000000</roll><tilt>0.000000000000000</tilt>\
        <heading>0.000000000000000</heading><altitudeMode>clampToGround</altitudeMode>\
        </ossimPlanetLookAt><filename>/Library/Application Support/ossim/images/reference/earth.jpg</filename>\
        <entry>0</entry></ossimPlanetOssimImageLayer></ossimPlanetQtLegend>'
        ossim = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        ossim.bind(("127.0.0.1", 9000))
        ossim.listen(1)
        conn, addr = ossim.accept()
        while 1:
             #data = conn.recv(1025)
             #if not data: break
             ossim.send(ossimxml)        

    def itemlist(self,index):
        Zone = self.w.Place.itemText(index)
        database_name = sqlitedb
        db_connection = sqlite3.connect(database_name)
        db_cursor = db_connection.cursor()
        listatabelle = db_cursor.execute("SELECT name,latitude,longitude FROM %s ;" % (Zone))
        tabelle = listatabelle.fetchall()
        tablelist = []
        allist = []
        for i in tabelle:
            tablelist.append(i[0])
            allist.append(i[0]+' '+str(i[1])+' '+str(i[2]))
        allist.sort()
        tablelist.sort()
        self.w.placezone.clear()
        self.w.placezone.addItems(allist)
        db_connection.commit()

    def setplacezonecoords(self,index):
        Placename = self.w.placezone.itemText(index)
        st = unicode(Placename)
        st = st.split(' ')
        lat = st[-2]
        lon = st[-1]
        self.w.Lon.setText(lon)
        self.w.Lat.setText(lat)

    def regioncoords(self,index):
        regiontype = self.w.GrassType.itemText(index)
        regioncenter = self.w.InputType.itemText(index)
        print self.w.GrassType.itemText(index),regioncenter, self.w.GrassType.itemText(index)
        if regiontype == 'region':
            sr = run_command('g.region', region=regioncenter)
            print self.w.GrassType.itemText(index),regioncenter, self.w.GrassType.itemText(index)
        if regiontype == 'rast':
            sr = run_command('g.region', rast=regioncenter) 
            print self.w.GrassType.itemText(index),regioncenter,self.w.GrassType.itemText(index)
        if regiontype == 'vect':
            sr = run_command('g.region', vect=regioncenter)
            print self.w.GrassType.itemText(index),regioncenter, self.w.GrassType.itemText(index)
        s = read_command('g.region', flags='l')
        if s == '':
            s = read_command("g.region", flags='c')
            region = parse_key_val(ss, ':')
            clon = region['east-west center']
            clat = region['north-south center']
        else:
            region = parse_key_val(s, ':')
            clon = region['center longitude']
            clat = region['center latitude']
        clon = str(clon)
        clat = str(clat)
        clon = clon.replace(':', " ")
        clat = clat.replace(':', " ")
        if clat[-1] == 'N':
            signlat = 1
        if clat[-1] == 'S':
            signlat = -1
        if clon[-1] == 'E':
            signlon = 1
        if clon[-1] == 'W':
            signlon = -1
        clat = clat[:-1] 
        clon = clon[:-1]
        clat = [float(i) for i in clat.split()]
        clon = [float(i) for i in clon.split()]
        lat = (clat[0] + (clat[1] / 60) + clat[2] / 3600) * float(signlat)
        lon = (clon[0] + (clon[1] / 60) + clon[2] / 3600) * float(signlon)
        self.w.placezone.clear()
        self.w.Lon.setText(str(lon))
        self.w.Lat.setText(str(lat))

    def gettablelist(self):
        database_name = sqlitedb
        db_connection = sqlite3.connect(database_name)
        db_cursor = db_connection.cursor()
        listatabelle = db_cursor.execute("SELECT name FROM sqlite_master where type = 'table';")
        tabelle = listatabelle.fetchall()
        tablelist = []
        for i in tabelle:
            tablelist.append(i[0])
        db_connection.commit()
        tablelist.sort()
        return tablelist

if __name__ == "__main__":
    app = QApplication(sys.argv)
    p = MyClass()
    p.init()
    sys.exit(app.exec_())