#!/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 pref import PreferenceSetting
from msgworn import worn
from msgworntcp import worntcp
from Gdata import Data
from GpsData import GpsClass
from GrassShell import GrShell
#from query import QueryGrass
#from vrt import VrtG
from datatools import DataWork
from Savekml import KmlView
from model import PlaceModel
from modelite import PlaceModelite
from epsg import SearchEpsg
from grass.script.core import *

from LatLongUTMconversion import LLtoUTM
from VectorOp import VectorOperation
from joyt import *
from episg import *
from pysqlite2 import dbapi2 as sqlite3

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

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]))

dbconf = '%s/db.conf' % (apppath)

tcpparam = '%s/conf/tcp.conf' % (apppath)

sqliteconf = '%s/conf/spatilite.conf' % (apppath)

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 = DataWork()
        self.DataW = DataWork()
        self.Gshell = GrShell()
        self.gps = GpsClass()
        self.vectoroperation = VectorOperation()
        self.kmlview = KmlView()
        self.Data = Data()
        self.placemodel = PlaceModel()
        self.placemodelite = PlaceModelite()
        self.SearchEpsg = SearchEpsg()
        self.slvallon = self.setcenter()[0]
        self.slvallat = self.setcenter()[1]
        #self.slvallon = 0
        #self.slvallat = 0
        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.RangeStepSpinBox, SIGNAL("valueChanged()"),
                     self.setValueRM)
        self.connect(self.w.ZoomMultipler, SIGNAL("valueChanged(double)"), 
                     self.setValueZoomMultipler)
        self.connect(self.w.ZoomMultipler, SIGNAL("valueChanged()"), 
                     self.setValueZ)
        self.connect(self.w.RangeMultipler, SIGNAL("valueChanged()"), 
                     self.setValueR)
        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.actionPref, SIGNAL("triggered()"), self.preference)
        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.dataprocess)
        #self.connect(self.w.actionQuery_2, SIGNAL("triggered()"),
        #             self.dataprocess)
        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.ellipse, SIGNAL("currentIndexChanged(int)"),
                     self.ellipsesettings)
        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.DataW.setLonValue)
        self.connect(self.w.Lat, SIGNAL("textChanged(QString)"), 
                     self.DataW.setLatValue)
        self.connect(self.w.Lon, SIGNAL("textChanged(QString)"), 
                     self.kmlview.setLonValue)
        self.connect(self.w.Lat, SIGNAL("textChanged(QString)"), 
                     self.kmlview.setLatValue)
        self.connect(self.w.Lon, SIGNAL("textChanged(QString)"), 
                     self.Data.setLonValue)
        self.connect(self.w.Lat, SIGNAL("textChanged(QString)"), 
                     self.Data.setLatValue)
        #
        self.connect(self.w.RollSpinBox, SIGNAL("valueChanged(double)"), 
                     self.kmlview.setChangeRoll)
        self.connect(self.w.PitchSpinBox, SIGNAL("valueChanged(double)"), 
                     self.kmlview.setChangePitch)
        self.connect(self.w.HandlingSpinBox, SIGNAL("valueChanged(double)"), 
                     self.kmlview.setChangeHead)
        self.connect(self.w.ZoomSpinBox, SIGNAL("valueChanged(double)"), 
                     self.kmlview.setChangeZoom)
        self.connect(self.w.RangeSpinBox, SIGNAL("valueChanged(double)"), 
                     self.kmlview.setChangeRange)
        #
        self.connect(self.w.Lon, SIGNAL("textChanged(QString)"), 
                     self.placemodel.setLonValue)
        self.connect(self.w.Lat, SIGNAL("textChanged(QString)"), 
                     self.placemodel.setLatValue)
        self.connect(self.w.RollSpinBox, SIGNAL("valueChanged(double)"), 
                     self.placemodel.setChangeRoll)
        self.connect(self.w.PitchSpinBox, SIGNAL("valueChanged(double)"), 
                     self.placemodel.setChangePitch)
        self.connect(self.w.HandlingSpinBox, SIGNAL("valueChanged(double)"), 
                     self.placemodel.setChangeHead)
        self.connect(self.w.ZoomSpinBox, SIGNAL("valueChanged(double)"), 
                     self.placemodel.setChangeZoom)
        self.connect(self.w.RangeSpinBox, SIGNAL("valueChanged(double)"), 
                     self.placemodel.setChangeRange)
        #
        self.connect(self.w.Lon, SIGNAL("textChanged(QString)"), 
                     self.placemodelite.setLonValue)
        self.connect(self.w.Lat, SIGNAL("textChanged(QString)"), 
                     self.placemodelite.setLatValue)
        self.connect(self.w.RollSpinBox, SIGNAL("valueChanged(double)"), 
                     self.placemodelite.setChangeRoll)
        self.connect(self.w.PitchSpinBox, SIGNAL("valueChanged(double)"), 
                     self.placemodelite.setChangePitch)
        self.connect(self.w.HandlingSpinBox, SIGNAL("valueChanged(double)"), 
                     self.placemodelite.setChangeHead)
        self.connect(self.w.ZoomSpinBox, SIGNAL("valueChanged(double)"), 
                     self.placemodelite.setChangeZoom)
        self.connect(self.w.RangeSpinBox, SIGNAL("valueChanged(double)"), 
                     self.placemodelite.setChangeRange)
        #
        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.actionModel, SIGNAL("triggered()"), 
                     self.modeldialog)
        #self.connect(self.w.actionSavekml, SIGNAL("triggered()"), self.addearth)
        self.connect(self.w.actionVrt, SIGNAL("triggered()"), 
                     self.dataprocess)
        self.connect(self.w.actionGVrt, SIGNAL("triggered()"), 
                     self.dataprocess)
        self.connect(self.w.actionGrassshell, SIGNAL("triggered()"), 
                     self.GrassShell)
        #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.actionVectorOp, SIGNAL("triggered()"), self.Geom)
        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 lonlat2nordest(self):
        lonlat = str(self.slvallon)+' '+str(self.slvallat)
        coordsfile = apppath+'/lonlatfile2'
        f = open(coordsfile, "w")
        f.write(lonlat)
        f.flush()
        f.close
        c = read_command('m.proj', input=coordsfile, flags='i') 
        lonlat = parse_key_val(c,'\t')
        lonlat = str(lonlat)
        lonlat = lonlat.replace('{','')
        lonlat = lonlat.replace('}','')
        lonlat = lonlat.replace("'",'')
        lonlat = lonlat.replace(':','')
        lonlat = lonlat.replace('|',' ')
        lonlat = lonlat.split(' ')
        #lonlat = str(lonlat[0])+','+str(lonlat[1])
        self.w.Nord.setText(str(lonlat[1]))
        self.w.East.setText(str(lonlat[0]))
        
    def ellipsesettings(self,index):
        global ell
        #self.ellipsecode = ''
        ell = self.w.ellipse.itemText(index)
        if ell == 'Airy':
            ell = 1
        if ell == 'Australian National':
            ell = 2
        if ell == 'Bessel 1841':
            ell = 3
        if ell == 'Bessel 1841 (Nambia)':
            ell = 4
        if ell == 'Clarke 1866':
            ell = 5
        if ell == 'Clarke 1880':
            ell = 6
        if ell == 'Everest':
            ell = 7
        if ell == 'Fischer 1960 (Mercury)':
            ell = 8
        if ell == 'Fischer 1968':
            ell = 9
        if ell == 'GRS 1967':
            ell = 10
        if ell == 'GRS 1980':
            ell = 11
        if ell == 'Helmert 1906':
            ell = 12
        if ell == 'Hough':
            ell = 13
        if ell == 'International':
            ell = 14
        if ell == 'Krassovsky':
            ell = 15
        if ell == 'Modified Airy':
            ell = 16
        if ell == 'Modified Everest':
            ell = 17
        if ell == 'Modified Fischer 1960':
            ell = 18
        if ell == 'South American 1969':
            ell = 19
        if ell == 'WGS 60':
            ell = 20
        if ell == 'WGS 66':
            ell = 21
        if ell == 'WGS-72':
            ell = 22
        if ell == 'WGS-84':
            ell = 23
        return ell

    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)
        rstep = float(self.w.RangeStepSpinBox.value())
        rmult = float(self.w.RangeMultipler.value())
        rstep = rstep * (10 ** rmult)
        self.w.RangeSpinBox.setSingleStep(rstep)
        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 CeckViewTypeState(self):
        if not self.w.actionLonLat.isChecked():
            self.worningmessage()
            

    def setparamconnection(self):
        try:
            TCP = open(tcpparam, "r")
            K = TCP.read()
            Y = K.rsplit(',')
            host = str(Y[0])
            nav = str(Y[1])
            data = str(Y[2])
            return host, nav, data
        except :
            print 'Use preference Panel to set preference'
            self.worningmessagetcp()

    def sendFunction(self):
        heads = head
        host = self.setparamconnection()[0]
        nav = self.setparamconnection()[1]
        if head == str('Manual'):
            heads = self.w.HandlingSlider.value()
        if self.w.actionLonLat.isChecked():
            (z, e, n) = LLtoUTM(ell, self.fxvallat, self.fxvallon)
            self.w.Nord.setText(str(n))
            self.w.East.setText(str(e))
            self.w.utmcode.setText(str(z))
            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():
            #self.lonlat2nordest()
            #ek = self.ellipsesettings()
            (z, e, n) = LLtoUTM(ell, self.slvallat, self.slvallon)
            #print z , e , n
            self.w.Nord.setText(str(n))
            self.w.East.setText(str(e))
            self.w.utmcode.setText(str(z))
            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)
            print ossimxml
        ossim = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        ossim.connect((host, int(nav))) 
        try:
            ossim.send(ossimxml)
            ossim.close()
        except:
            self.CeckViewTypeState()

    def ResetPosition(self):
        heads = head
        host = self.setparamconnection()[0]
        nav = self.setparamconnection()[1]
        if self.w.actionLonLat.isChecked():
            self.fxvallon = self.SetPosition()[0]
            self.fxvallat = self.SetPosition()[1]
            (z, e, n) = LLtoUTM(ell, self.fxvallat, self.fxvallon)
            self.w.Nord.setText(str(n))
            self.w.East.setText(str(e))
            self.w.utmcode.setText(str(z))
            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]
            (z, e, n) = LLtoUTM(ell, self.slvallat, self.slvallon)
            self.w.Nord.setText(str(n))
            self.w.East.setText(str(e))
            self.w.utmcode.setText(str(z))
            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((host, int(nav)))  
        try:
            ossim.send(ossimxml)
            ossim.close()
        except:
            self.CeckViewTypeState()


    def inclat(self):
        host = self.setparamconnection()[0]
        nav = self.setparamconnection()[1]
        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
            (z, e, n) = LLtoUTM(ell, self.fxvallat, self.fxvallon)
            self.w.Nord.setText(str(n))
            self.w.East.setText(str(e))
            self.w.utmcode.setText(str(z))
            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
            (z, e, n) = LLtoUTM(ell, self.slvallat, self.slvallon)
            self.w.Nord.setText(str(n))
            self.w.East.setText(str(e))
            self.w.utmcode.setText(str(z))
            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((host, int(nav)))  
        try:
            ossim.send(ossimxml)
            ossim.close()
        except:
            self.CeckViewTypeState()

    def declat(self):
        host = self.setparamconnection()[0]
        nav = self.setparamconnection()[1]
        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
            (z, e, n) = LLtoUTM(ell, self.fxvallat, self.fxvallon)
            self.w.Nord.setText(str(n))
            self.w.East.setText(str(e))
            self.w.utmcode.setText(str(z))
            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
            (z, e, n) = LLtoUTM(ell, self.slvallat, self.slvallon)
            self.w.Nord.setText(str(n))
            self.w.East.setText(str(e))
            self.w.utmcode.setText(str(z))
            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((host, int(nav)))  
        try:
            ossim.send(ossimxml)
            ossim.close()
        except:
            self.CeckViewTypeState()

    def inclon(self):
        host = self.setparamconnection()[0]
        nav = self.setparamconnection()[1]
        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
            (z, e, n) = LLtoUTM(ell, self.fxvallat, self.fxvallon)
            self.w.Nord.setText(str(n))
            self.w.East.setText(str(e))
            self.w.utmcode.setText(str(z))
            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
            (z, e, n) = LLtoUTM(ell, self.slvallat, self.slvallon)
            self.w.Nord.setText(str(n))
            self.w.East.setText(str(e))
            self.w.utmcode.setText(str(z))
            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((host, int(nav)))  
        try:
            ossim.send(ossimxml)
            ossim.close()
        except:
            self.CeckViewTypeState()

    def declon(self):
        host = self.setparamconnection()[0]
        nav = self.setparamconnection()[1]
        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
            (z, e, n) = LLtoUTM(ell, self.fxvallat, self.fxvallon)
            self.w.Nord.setText(str(n))
            self.w.East.setText(str(e))
            self.w.utmcode.setText(str(z))
            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
            (z, e, n) = LLtoUTM(ell, self.slvallat, self.slvallon)
            self.w.Nord.setText(str(n))
            self.w.East.setText(str(e))
            self.w.utmcode.setText(str(z))
            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((host, int(nav)))  
        try:
            ossim.send(ossimxml)
            ossim.close()
        except:
            self.CeckViewTypeState()

    def inclatlon(self):
        host = self.setparamconnection()[0]
        nav = self.setparamconnection()[1]
        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
            (z, e, n) = LLtoUTM(ell, self.fxvallat, self.fxvallon)
            self.w.Nord.setText(str(n))
            self.w.East.setText(str(e))
            self.w.utmcode.setText(str(z))
            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
            (z, e, n) = LLtoUTM(ell, self.slvallat, self.slvallon)
            self.w.Nord.setText(str(n))
            self.w.East.setText(str(e))
            self.w.utmcode.setText(str(z))
            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((host, int(nav)))  
        try:
            ossim.send(ossimxml)
            ossim.close()
        except:
            self.CeckViewTypeState()

    def declatlon(self):
        host = self.setparamconnection()[0]
        nav = self.setparamconnection()[1]
        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
            (z, e, n) = LLtoUTM(ell, self.fxvallat, self.fxvallon)
            self.w.Nord.setText(str(n))
            self.w.East.setText(str(e))
            self.w.utmcode.setText(str(z))
            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
            (z, e, n) = LLtoUTM(ell, self.slvallat, self.slvallon)
            self.w.Nord.setText(str(n))
            self.w.East.setText(str(e))
            self.w.utmcode.setText(str(z))
            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((host, int(nav)))  
        try:
            ossim.send(ossimxml)
            ossim.close()
        except:
            self.CeckViewTypeState()

    def inclatdeclon(self):
        host = self.setparamconnection()[0]
        nav = self.setparamconnection()[1]
        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
            (z, e, n) = LLtoUTM(ell, self.fxvallat, self.fxvallon)
            self.w.Nord.setText(str(n))
            self.w.East.setText(str(e))
            self.w.utmcode.setText(str(z))
            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
            (z, e, n) = LLtoUTM(ell, self.slvallat, self.slvallon)
            self.w.Nord.setText(str(n))
            self.w.East.setText(str(e))
            self.w.utmcode.setText(str(z))
            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((host, int(nav)))  
        try:
            ossim.send(ossimxml)
            ossim.close()
        except:
            self.CeckViewTypeState()

    def declatinclon(self):
        host = self.setparamconnection()[0]
        nav = self.setparamconnection()[1]
        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
            (z, e, n) = LLtoUTM(ell, self.fxvallat, self.fxvallon)
            self.w.Nord.setText(str(n))
            self.w.East.setText(str(e))
            self.w.utmcode.setText(str(z))
            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
            (z, e, n) = LLtoUTM(ell, self.slvallat, self.slvallon)
            self.w.Nord.setText(str(n))
            self.w.East.setText(str(e))
            self.w.utmcode.setText(str(z))
            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((host, int(nav)))  
        try:
            ossim.send(ossimxml)
            ossim.close()
        except:
            self.CeckViewTypeState()

    def SetLonLat(self):
        host = self.setparamconnection()[0]
        nav = self.setparamconnection()[1]
        heads = head
        if head == str('Manual'):
            heads = self.w.HandlingSlider.value()
        (z, e, n) = LLtoUTM(ell, float(self.w.Lat.text()), float(self.w.Lon.text()))
        self.w.Nord.setText(str(n))
        self.w.East.setText(str(e))
        self.w.utmcode.setText(str(z))
        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((host, int(nav)))  
        try:
            ossim.send(ossimxml)
            ossim.close()
        except:
            self.CeckViewTypeState()

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

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

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

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

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

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

    def setCLL(self):
        s = read_command("g.region", flags='c')
        region = parse_key_val(s, ':')
        clon_deg = region['east-west center']
        clat_deg = region['north-south center']
        centro_deg = (clon_deg,clat_deg)
        return centro_deg
        
    def setCPRJ(self):
        s = read_command("g.region", flags='l')
        region = parse_key_val(s, ':')
        clon_deg = region['center longitude']
        clat_deg = region['center latitude']
        centro_deg = (clon_deg,clat_deg)
        return centro_deg
  
    def projinfo(self):
        units = read_command("g.proj", flags='p')
        units = units.replace('-','')
        #units = units.replace('\n','')
        units = parse_key_val(units, ':')
        units_key = units.keys()
        for i in units_key :
            key_value = str(units[i]).strip()
            units[i] =  key_value
        return units


    def setcenter(self):
        global centro
        clon = 0
        clat = 0
        proj_info = self.projinfo()
        unit = proj_info['units']
        if unit == 'meters':
            clon = self.setCPRJ()[0]
            clat = self.setCPRJ()[1]
        if unit == 'degrees':
            clon = self.setCLL()[0]
            clat = self.setCLL()[1]
        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()]
        #print 'Starting at coordinates :'
        #print 'Lat :', clat,' Lon :', clon
        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 preference(self):
        self.preferencesetting = PreferenceSetting()
        self.preferencesetting.show()

    def worningmessage(self):
        self.worn = worn()
        self.worn.show()

    def worningmessagetcp(self):
        self.worntcp = worntcp()
        self.worntcp.show()

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

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

    def dataprocess(self):
        self.DataW.show()

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

    def GrassShell(self):
        self.Gshell.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):
        self.kmlview.show()

    def modeldialog(self):
        self.placemodel.show()

    def modeldialog(self):
        self.placemodelite.show()

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

    def Geom(self):
        #self.Geom = Geom()
        self.vectoroperation.show()


      

    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__":
    import sys
    import time
    app = QApplication(sys.argv)
    splash_pix = QPixmap('/Users/Shared/Development/gsoc/OssimPlanetSasha/spl.png')
    splash_pix_mask = QPixmap('/Users/Shared/Development/gsoc/OssimPlanetSasha/spl.png')
    splash = QSplashScreen(splash_pix, Qt.WindowStaysOnTopHint)
    splash.setMask(splash_pix_mask.mask())
    splash.show()
    time.sleep(3)
    app.processEvents()
    p = MyClass()
    p.init()
    splash.close()
    sys.exit(app.exec_())