#!/usr/bin/env python
# -*- coding: UTF8 -*-

# Jordi Ivars Oller
# 2005-2007
# Licensed under GPL <http://www.gnu.org>
#
# Copyright (c) 2005-2007, Jordi Ivars Oller <ear@oronetes.net>                    
#                                                                                    
# This program is free software; you can redistribute it and/or               
# modify it under the terms of the GNU General Public License                 
# as published by the Free Software Foundation; either version 2              
# of the License, or (at your option) any later version.                      
#                                                               
# This program is distributed in the hope that it will be useful,             
# but WITHOUT ANY WARRANTY; without even the impliedf warranty of              
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               
# GNU General Public License for more details.                                
#                                                                                     
# You should have received a copy of the GNU General Public License           
# along with this program; if not, write to the Free Software                 
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA. 
#####################################################################


#version 0.6

#TODO:

#Take path from terminal ssh session to pass nautilus when open sftp session
#Timeout window (in sshauth pexpect)


#CHANGELOG (version 0.6)
#Removed open sessions folder button (now, nautilus is an optional dependency)
#Added a session info tool to view session data and attach notes to ssh session
#Code clean
#Added telnet support
#New window warning if you are closing session with opened tabs
#Added preferences window to change colors, fonts and set other default options.
#Added gconf support
#Corrected cypher module bug with hwrandom module
#Corrected bug with gnome 2.20 nautilus in background mode

#CHANGELOG (version 0.5.2)
#Corrected port saving bug. Ssh port selected now is saved.
#Corrected bug with bold fonts, now bold text is visible.
#Better ssh errors information
#Added close button to tabs
#Added new "view" menu with zoom and full screen options
#Changed keybindings from ctrl+ to ctrl+shift+
#Enabled cursor blink

#CHANGELOG (version 0.5.1)
#Changed terminal font management from xft to pango. Now fonts looks better.
#Changed background to white by default.
#Added 30 seconds timeout when checking if connection is available.
#Corrected terminal focus.
#Added press return key to validate text entries
#Ignored all warnings when run from console

#CHANGELOG (version 0.5)
#Ssh terminal with python-vte (removed gnome-terminal as ssh console) with tabs support,
#sessions menu to fast access to new session and open with nautilus current opened session.
#Keyring to store all ssh passwords encrypted with AES (using python-crypto) using only
#a passphrase.
#Python-pexpect used to send or receive data from "ssh" to Gnome-Sshman.
#New setup.py installer to check all gnome-sshman needed dependencies.



#Import modules and set path to glade and python modules

import os, gtk, sys, os.path, gnome, dircache, gtk.glade, getpass, vte, pango, gconf

sys.path.append('/usr/share/gnome-sshman')

from os.path import exists

#i18n support
#Try to import locale, if exists

try:

	import locale, gettext
	
	APP='gnome-sshman'
	DIR='/usr/share/locale/'

	#For glade
	locale.setlocale (locale.LC_ALL, '')
	gettext.bindtextdomain (APP, DIR)
	gettext.textdomain (APP)
	gettext.install (APP, DIR, unicode=1)
	gtk.glade.bindtextdomain (APP, DIR)
	gtk.glade.textdomain (APP)
	
	#For python
	t = gettext.translation(APP,DIR)
	_ = t.ugettext
	
	
except:
	
	pass


#Globals		

import gssh_globals as gglobals
glade_dir=gglobals.glade_dir
version=gglobals.version


class Widgets:

	def __init__(self,file):
		self.widgets = gtk.glade.XML(file)
	def __getitem__(self,key):
		return self.widgets.get_widget(key)

class main:

	def __init__(self):
					
				
		home=os.path.expanduser("~")
		session_folder=home+"/.gnome-sshman"
		
		#If not exists ssh session directories, create
			
		if not exists (session_folder):
			
			os.system("mkdir "+session_folder)
		

		ip = None
		username = None
		session_name = None		
		port = "22"	
		#self.conectar(host,username,port,session_name)
		GsshMain(username,ip,port,session_name)
		gtk.main()


#Main window class
class GsshMain:

	def __init__(self,username,ip,port,session_name):
	
		
		main_widgets = Widgets(glade_dir+'ssh_manager.glade')
		main_widgets['gssh-main'].connect("destroy", self.on_gssh_main_destroy)
		main_widgets['gssh-main'].connect("delete_event", self.delete_event)
		main_widgets['gssh-main'].connect("key_press_event", self.on_gssh_main_press_event)

		connections = {
			'eventbox1/button_press_event' : self.on_eventbox1_button_press_event,
			'comboboxentry1/changed' : self.on_comboboxentry1_changed,
			'entry_user/changed'     : self.on_entry_user_changed,
			'entry_host/changed'	: self.on_entry_host_changed,
			'entry_save/changed'    : self.on_entry_save_changed,
			'entry_port/changed'   : self.on_entry_port_changed,
			'save_session/toggled' : self.on_save_session_toggled,
			'button_cancel/clicked'     : self.on_button3_clicked,
			'button_ok/clicked'     : self.on_button4_clicked,
			'comboboxentry1/set_focus_child'    :self.on_comboboxentry1_set_focus_child,
			'protocol_entry/changed'	:self.on_protocol_entry_changed,
			'viewinfo/clicked'  :self.on_viewinfo_clicked
			}
	
		for wid_con, func in connections.iteritems():
			wid,con = wid_con.split('/')
			main_widgets[wid].connect(con,func)
		
	
		#Easy values:)
		
		self.main_widget=main_widgets['gssh-main']
		self.comboboxentry1=main_widgets['comboboxentry1']
		self.entry_user=main_widgets['entry_user']
		self.entry_host=main_widgets['entry_host']
		self.button_ok=main_widgets['button_ok']
		self.entry_port=main_widgets['entry_port']
		self.save_session=main_widgets['save_session']
		self.entry_save=main_widgets['entry_save']
		self.viewinfo=main_widgets['viewinfo']
		self.protocol_entry=main_widgets['protocol_entry']
	
		#Set protocols in protocol combobox and activate ssh by default
		self.protocol_entry.append_text("ssh")
		self.protocol_entry.append_text("sftp")
		self.protocol_entry.append_text("telnet")
		self.protocol_entry.set_active(0)
		self.protocol = "ssh"
		###
		
		#emulation types global
		
		self.term_types=["xterm","ansi","vt100"]
		
		
		#Create a session names list and add data to use to view current session info
		self.sessionnames_list=[]
		
		#Set the site when preferences window is called.
		#By default is called from terminal
		self.preferences_called="terminal"
		
		#By default, keyring is closed
		
		self.key_pass="no"
		
		#First init, 0 tabs and first tab				
		self.tabs=-1	
		self.first_tab="yes"
		
		self.username = username
		self.ip = ip
		self.port = port
		
	
		self.entry_session_changed="no"
		
		#Var used to execute menu only 1 time
		self.menu_control="1"

		if session_name == None:
		
			session_name = ""
			
		self.session_name=session_name
		

		#If exists previous data, write to text entries

		if self.username != None:
			self.entry_user.set_text(self.username)

		if self.ip != None:
			self.entry_host.set_text(self.ip)
			
		self.entry_save.set_text(self.session_name)
		self.entry_port.set_text(str(self.port))
		
		#Get a list of all session files
		self.get_files()
		
		
		#Get gconf values
		self.cgconf = gconf.client_get_default ();

		#gconf colors

		if not self.cgconf.dir_exists("/apps/gnome-sshman"):
			
			self.cgconf.set_string("/apps/gnome-sshman/version","0.6")
						
			self.cgconf.set_string("/apps/gnome-sshman/background_color","white")
				
			self.cgconf.set_string("/apps/gnome-sshman/text_color","black")
			
			self.cgconf.set_string("/apps/gnome-sshman/default_colors","yes")
			
			self.cgconf.set_string("/apps/gnome-sshman/save_sessions","yes")
			self.cgconf.set_string("/apps/gnome-sshman/different_windows","no")
		
			self.cgconf.set_string("/apps/gnome-sshman/default_fonts","yes")
			
			self.cgconf.set_int("/apps/gnome-sshman/term_emulation", 0)
			
			self.cgconf.set_string("/apps/gnome-sshman/font", "Sans 12")
			
		#gconf save sessions by default
		if self.cgconf.get_string("/apps/gnome-sshman/save_sessions") == "no":
			
			self.save_session.set_active(False)
			self.save_log="no"
			self.entry_save.set_sensitive(False)
			
		else:
			self.save_log="yes"
		
				
	def on_protocol_entry_changed(self,widget):
		
		if widget.get_active() == 0:
		
			self.protocol = "ssh"
			self.entry_port.set_text("22")
			
		elif widget.get_active() == 1:
		
			self.protocol = "sftp"
			self.entry_port.set_text("22")
			
		elif widget.get_active() == 2:
		
			self.protocol = "telnet"
			self.entry_port.set_text("23")
			
#Capture return key		
	def on_gssh_main_press_event(self,widget,event):
		keyname = gtk.gdk.keyval_name(event.keyval)
		
		if keyname == "Return" and self.username != "" and self.username != None and self.ip != "" and self.ip != None:
			self.entry_user.grab_focus()
			self.on_button4_clicked(self,widget, event)
			
#Delete event to control quit window button, when tabs are > 0, only hide
#window 

	def delete_event(self, widget, event, data=None):

		if self.tabs < 0:
			#self.main_widget.destroy()
			#gtk.main_quit()
			return False
		#If tabs, session opened and then cancel button not closes main window.
		else:
			self.main_widget.hide()
			return True
			

		
	def on_eventbox1_button_press_event(self,widget,event):
		
		#Paint menu
		self.menu(widget,event)
		
		#Only connect menu 1 time, in def menu menu_control changes to 2
		if self.menu_control=="1":
			widget.connect('button-press-event', self.menu)
			
		
	def menu(self,widget, event):
	
		#Creating popupmenu. 
						
		popup1_widgets = Widgets(glade_dir+'popmenu1.glade')
			
		connections = {
			'about_gnomesshman/activate' : self.go_about,
			'open_current_connection_with_nautilus/activate' : self.menu_response,
			'edit_preferences/activate' : self.on_preferences_activate
			}
			
		
		for wid_con, func in connections.iteritems():
			wid,con = wid_con.split('/')
			popup1_widgets[wid].connect(con,func)
			
			
		menu1=popup1_widgets['menu1']
		
		
		#Set the site when preferences window is called.
		#Here is called from main
		self.preferences_called="main"
	
	#Defining menu as popup
	
		if event.type == gtk.gdk.BUTTON_PRESS:
			
			menu1.popup(None, None, None, event.button, event.time)
			#Change menu_control to 2. 
			self.menu_control="2"
	
	
	def go_about(self,data_enter):
		
		Acerca()		
		
	def menu_response(self,data_enter):
	
		import os			
					
		if self.ip == None or self.username == None:
							
			ConectErrorMsg()	
		else:
		
#The nautilus connection is the same that terminal connection		
###Starts nautilus connection

			try:
				import socket
				s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
				s.connect((self.ip, int(self.port)))
				s.close()
			
				conexion = "yes"
		
			except:
	
				conexion = "no"
		
		
			if conexion == "yes":
		
									
				if self.save_log == "no":
				
					import os
					server=self.username+"@"+self.ip+":"+self.port
			
					os.system("nautilus sftp://"+server+ " &") 
		
		
				elif self.save_log == "yes":
		
			
					import os.path
					from os.path import exists
					import time
				
					server=self.username+"@"+self.ip+":"+self.port
					server_save=self.username+"@"+self.ip+"@"+self.port+"@"+self.protocol
					
					home=os.path.expanduser("~")
		
					if self.session_name=="":
				
						regster=home+"/.gnome-sshman/"+self.ip+".ssh"
					
					else:
		
						regster=home+"/.gnome-sshman/"+self.session_name+".ssh"
				
						a=open(regster,'wr')
						a.write(server_save)
						a.close()
				
						os.system("nautilus sftp://"+server+ " &")
		
			elif conexion == "no":
	
				ConectErrorMsg()
			
#####Ends nautilus connection
								
			#os.system("nautilus sftp://"+self.username+"@"+self.ip+":"+self.port)
				
				
		
	def get_files(self):
	
		#From our sessions folder, get all files withouth .ssh to put in comboboxentry1
		
		home=os.path.expanduser("~")
		session_folder=home+"/.gnome-sshman"
		
		a=dircache.listdir(session_folder)
		
		#Get only .ssh files
				
		z=0
			
		#The list is splitted 2 times to delete al.key files (with 1 time show a .key file)
		
		for x in a:
			
			if len(x.split(".ss")) != 2:
				del a[z]
				
			z=z+1
		
		z=0
		for x in a:
			
			if len(x.split(".ss")) != 2:
				del a[z]
				
			z=z+1
			
		b=len(a)
		c=0
	
		while c < b:
			x=a[c]
			self.comboboxentry1.append_text(x.split(".ssh")[0])
			c=c+1
			
		self.removecombo=c			
	
	
#When comobobox is touched, servers list is rebuilded

	def on_comboboxentry1_set_focus_child(self, widget, *args):
	
	
	#Rebuild servers list in combobox to view if any was deleted
		
		x=self.removecombo
		y=0
		while x >= y:
			
			self.comboboxentry1.remove_text(x)
			x=x-1
			
						
		self.get_files()
		
		
	def on_comboboxentry1_changed(self, widget, *args):
	
		
		#By default, save_session is activated with a new session if gconf permits
		
		
	#	if self.cgconf.get_string("/apps/gnome-sshman/save_sessions") == "no":
			
	#		self.save_session.set_active(False)
	#		self.save_log="no"
			
	#	else:
	#		self.save_log="yes"
		
		#self.save_session.set_active(True)
		
		#Get text from combobox
	
		entrada = self.comboboxentry1.get_model()
		activo = self.comboboxentry1.get_active()
		if activo < 0:
			return None
		filename=entrada[activo][0]+".ssh"
		home=os.path.expanduser("~")
		session_folder=home+"/.gnome-sshman/"
		filename=session_folder+filename
		
					
		lee=open(filename,'r')
		filedata=lee.read()
		lee.close()
		filedata=filedata.split("\n")[0]
				
		index=len(filename.split("/"))
		session_name=filename.split("/")[index-1]
			
		session_name=session_name.split(".ssh")[0]
						
		if len(filedata.split("@")) == 1:
				
			username=None
			host=filedata.split("@")[0]
			self.entry_host.set_text(host)
			self.entry_user.set_text("")
			self.entry_save.set_text(session_name)
			port="22"
			self.entry_port.set_text(port)
			protocol="ssh"
			self.protocol_entry.set_active(0)		
		
		elif len(filedata.split("@")) == 2:
			
			username=filedata.split("@")[0]
			host=filedata.split("@")[1]				
						
			self.entry_user.set_text(username)
			self.entry_host.set_text(host)
			self.entry_save.set_text(session_name)
			port="22"
			self.entry_port.set_text(port)
			protocol="ssh"
			self.protocol_entry.set_active(0)		
		
		elif len(filedata.split("@")) == 3:
			
			username=filedata.split("@")[0]
			host=filedata.split("@")[1]				
						
			self.entry_user.set_text(username)
			self.entry_host.set_text(host)
			self.entry_save.set_text(session_name)
			port=filedata.split("@")[2]
			self.entry_port.set_text(port)		
			self.protocol_entry.set_active(0)

#TELNET READ DATA

		elif len(filedata.split("@")) == 4:
			
			username=filedata.split("@")[0]
			host=filedata.split("@")[1]				
						
			self.entry_user.set_text(username)
			self.entry_host.set_text(host)
			self.entry_save.set_text(session_name)
			port=filedata.split("@")[2]
			self.entry_port.set_text(port)		
			
			protocol=filedata.split("@")[3]
			
			if protocol == "ssh":
				self.protocol_entry.set_active(0)
				self.entry_port.set_text(port)
			elif protocol == "sftp":
				self.protocol_entry.set_active(1)
				self.entry_port.set_text(port)
			elif protocol == "telnet":
				self.protocol_entry.set_active(2)
				self.entry_port.set_text(port)
			else:
				self.protocol_entry.set_active(0)
				self.entry_port.set_text(port)
		
		
					
	def on_entry_user_changed(self, widget, *args):
	
		self.username=self.entry_user.get_text()
	
#If username or host entries are empty, ok button is insensible

		if self.username == None or self.username == "" or self.ip == None or self.ip=="":
			
			self.button_ok.set_sensitive(False)
			#self.viewinfo.set_sensitive(False)
		
		else:
		
			self.button_ok.set_sensitive(True)
			self.viewinfo.set_sensitive(True)

	

	def on_entry_host_changed(self, widget, *args):
	
		#Hostname or Ip entry
	
		self.ip=self.entry_host.get_text()
	
#If username or host entries are empty, ok button is insensible	
		if self.username == None or self.username == "" or self.ip == None or self.ip=="":
			
			self.button_ok.set_sensitive(False)
			#self.viewinfo.set_sensitive(False)
		
		else:
		
			self.button_ok.set_sensitive(True)
			self.viewinfo.set_sensitive(True)
			
	def on_entry_save_changed(self, widget, *args):
	
		#Save session name entry


			self.session_name=self.entry_save.get_text()
			self.entry_session_changed="yes"
	

	def on_entry_port_changed(self, widget, *args):
	
		#Port entry

		self.port=self.entry_port.get_text()


	def on_save_session_toggled(self, widget, *args):
	
		#Save session checkbutton. If is or not active, save_log is advised
				
		if self.save_session.get_active():
	
			self.save_log="yes"
			self.entry_save.set_sensitive(True)
			
		else:
		
			self.save_log="no"
			self.entry_save.set_sensitive(False)
	
	#Controls quit from window quit button (yea, the cross)
	
	def on_gssh_main_destroy(self, widget, *args):
				
		if self.tabs < 0:
			self.main_widget.destroy()
			gtk.main_quit()
		
		#If tabs, session opened and then cancel button not closes main window.
		else:
		
			self.main_widget.hide()
	
	def on_button3_clicked(self, widget, *args):
	
		#Cancel button. First destroy main widget and then quit. Used for
		#correct vte window communication
		
		#If no tabs, no session opened, then close with cancel button
		if self.tabs < 0:
			self.main_widget.destroy()
			gtk.main_quit()
		
		#If tabs, session opened and then cancel button not closes main window.
		else:
		
			self.main_widget.hide()
			
	def on_button4_clicked(self, widget, *args):
	
		#Ok button. 
		
		#Check session name changes.
		if self.entry_session_changed == "no":
			self.session_name = self.session_name
		
				
		self.open_session()
		
	def on_viewinfo_clicked(self, widget, *args):
		
			
		infowindow(self.username,self.port,self.ip,self.session_name)
	
			
	
	def open_session(self):
	
		
		
		#Set combobox empty DONT WORK!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
		#text="--"
		#a=self.removecombo+1
		#elf.comboboxentry1.append_text(text)
		#print a
		self.comboboxentry1.set_active(-1)
		
		#Check if passed host/port is available opening a connection. If not, error
		
				
		try:
			import socket
			s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

			s.settimeout(30)
			s.connect((self.ip, int(self.port)))
			
			s.close()
			
			conexion = "yes"
			self.sessionnames_list.append(self.session_name)
						
		except:
	
			conexion = "no"
			
		
		#Check if exists session name. If not, assign as session name ip address
		if self.session_name==None or self.session_name=="":
			self.session_name=self.ip
		
		if conexion == "yes":
			
			if self.save_log == "no":
				
				import os
				server=self.username+"@"+self.ip
			
		#Send data to passwd()
				if self.protocol=="sftp":
						
						if self.username == "root":
							ruta = "/root"
						
						else:
					
							ruta="/home/"+self.username	
						
						
						os.system("nautilus sftp://"+server+":"+ruta+ " &") 
				
				else:
										
						self.passwd(server)
					
		
			elif self.save_log == "yes":
					
				import os.path
				from os.path import exists
				import time
				
		#In register .ssh file, adds username@ip		
				server=self.username+"@"+self.ip
				server_save=self.username+"@"+self.ip+"@"+self.port+"@"+self.protocol
				
				home=os.path.expanduser("~")
		
				regster=home+"/.gnome-sshman/"+self.session_name+".ssh"
					
		
		#!!Future!! Save session logs?
				#logster=home+"/.gnome-sshman/"+self.ip+".log"			
			
				a=open(regster,'wr')
				a.write(server_save)
				a.close()
				
				if self.protocol=="sftp":
					if self.username == "root":
						ruta = "/root"
						
					else:
					
						ruta="/home/"+self.username	
							
					os.system("nautilus sftp://"+server+":"+ruta+ " &")
				
				else:
										
					self.passwd(server)				
				
															
		
		elif conexion == "no":
	
		#Call error window when connection is not available
			
			ConectErrorMsg()
			

##############################################################################
#########################TERMINAL#############################################
##############################################################################

#Ssh terminal with menus

	def MenuWindow(self,server,tabs):
				
		
		self.server=server
		self.tabs = tabs
		self.wintabs=gtk.Notebook()
		self.wintabs.set_scrollable(scrollable=True)
		#self.scrollwin=gtk.ScrolledWindow()
		
		term_widgets = Widgets(glade_dir+'terminal.glade')
	
		term_widgets['menu-window'].connect("destroy", self.destroy)


		connections = {
			'open_ssh_manager1/activate' : self.on_open_ssh_manager1_activate,
			'open_with_nautilus1/activate' : self.on_open_with_nautilus1_activate,
			'close_tab1/activate'  : self.on_close_tab1_activate,
			'salir1/activate'     : self.on_salir1_activate,
			'normal_view1/activate'	: self.on_normal_view1_activate,
			'zoom_in1/activate' : self.on_zoom_in1_activate,
			'zoom_out1/activate' : self.on_zoom_out1_activate,
			'full_screen1/activate' : self.on_full_screen1_activate,
			'current_session1/activate' : self.on_current_session1_activate,
			'open_new_current1/activate':self.on_open_new_current1_activate,
			'about1/activate'   : self.on_about1_activate,
			'preferen/activate' : self.on_preferences_activate
				}
	
		for wid_con, func in connections.iteritems():
			wid,con = wid_con.split('/')
			term_widgets[wid].connect(con,func)
		
		self.vbox4=term_widgets['vbox4']
		
			
		self.open_vte_first(server)
			

		self.menuwindow=term_widgets['menu-window']
		self.menuterminal=term_widgets['menu-terminal']
		self.menuitem4=term_widgets['menuitem4']
		self.open_new1=term_widgets['open_new1']
		self.current_session1=term_widgets['current_session1']
		
		#Creating menu and adding sessions menu
		
		self.file_menu = gtk.Menu()   
		self.get_files_for_menu()

	
	def on_open_new_current1_activate(self,data):
		
		tabpage = self.wintabs.get_current_page()
		session_name=self.sessionnames_list[tabpage]
		
		home=os.path.expanduser("~")
		regster=home+"/.gnome-sshman/"+session_name+".ssh"

		if exists (regster):

			a=open(regster,'r')
			data=a.read()
			username = data.split('@')[0]
			ip = data.split('@')[1]
			port = data.split('@')[2]
			
		else:
		
			username = None
			ip = None
			port = None
			
		self.username=username
		self.ip=ip	
		self.port=port
		self.session_name=session_name		
		
	
		self.open_session()
		
####COLORS#####
	def on_preferences_activate(self,data):
			
		preferen = Widgets(glade_dir+'preferences.glade')
		
		#colorsel['colorselector'].connect("destroy", self.destroy_win)
		
		self.preferen=preferen['prefs']

		connections = {
			'close/clicked' : self.on_close_clicked,
		   'colorpicker2/color_set' : self.on_colorpicker2_color_set,
			'colorpicker3/color_set' : self.on_colorpicker3_color_set,
			'colors_default_check/toggled' : self.on_colors_default_check_toggled,
			'save_sess_check/toggled' : self.on_save_sess_check_toggled,
			'diff_win_check/toggled' : self.on_diff_win_check_toggled,
			'fontbutton1/font_set' : self.on_fontbutton1_font_set,
			'defaultfonts_check/toggled' : self.on_defaultfonts_check_toggled,
			'term_emu_combo/changed'  : self.on_term_emu_combo_changed
			}
	
		for wid_con, func in connections.iteritems():
			wid,con = wid_con.split('/')
			preferen[wid].connect(con,func)

		self.colorpick2=preferen['colorpicker2']
		self.colorpick3=preferen['colorpicker3']
		self.colors_default_check=preferen['colors_default_check']	
		self.save_sess_check=preferen['save_sess_check']
		self.diff_win_check=preferen['diff_win_check']
		self.fontbutton=preferen['fontbutton1']
		self.font_checkbutton=preferen['defaultfonts_check']
		self.term_emu_combo=preferen['term_emu_combo']
	

	
#Read colors from gconf and apply to color buttons

		colorbg=self.cgconf.get_string("/apps/gnome-sshman/background_color")
		colortxt=self.cgconf.get_string("/apps/gnome-sshman/text_color")
		colorbg=gtk.gdk.color_parse(colorbg)
		colortxt=gtk.gdk.color_parse(colortxt)
		
		self.colorpick2.set_color(colorbg)
		self.colorpick3.set_color(colortxt)	
		
	
#Read use default colors check and applies

		default_colors=self.cgconf.get_string("/apps/gnome-sshman/default_colors")

	
		if default_colors == "yes":
		
			self.colors_default_check.set_active(True)
			self.colorpick2.set_sensitive(False)
			self.colorpick3.set_sensitive(False)
			
		elif default_colors == "no":
		
			self.colors_default_check.set_active(False)
			self.colorpick2.set_sensitive(True)
			self.colorpick3.set_sensitive(True)

#Read save sessions check button and apply
	
		if self.cgconf.get_string("/apps/gnome-sshman/save_sessions") == "yes":
	
			self.save_sess_check.set_active(True)
	
		else:
			self.save_sess_check.set_active(False)

#Read open in different windows check button and apply
		
		if self.cgconf.get_string("/apps/gnome-sshman/different_windows") == "yes":
		
			self.diff_win_check.set_active(True)
			
		else:
			self.diff_win_check.set_active(False)
	
#Set fonts preferences
		if self.cgconf.get_string("/apps/gnome-sshman/default_fonts") == "yes":
		
			self.fontbutton.set_sensitive(False)
			try:
				self.fontbutton.set_font_name(self.cgconf.get_string("/apps/gnome-sshman/font"))
			except:
				pass
			
		else:
		
			self.font_checkbutton.set_active(False)
			self.fontbutton.set_font_name(self.cgconf.get_string("/apps/gnome-sshman/font"))
			
		
		#Set terminal types and select gconf	
	
		for x in self.term_types:
			self.term_emu_combo.append_text(x)
		
		self.term_emu_combo.set_active(self.cgconf.get_int("/apps/gnome-sshman/term_emulation"))
		
	def on_close_clicked(self,data):
		
		
		#colorbg=self.default_background_color
		#colortext=self.default_text_color
		#Set the site when preferences window is called.
		#Here is called from terminal
		self.preferences_called="terminal"
		self.preferen.destroy()

#Change background color
	def on_colorpicker2_color_set(self,color):
			
		
		colorbg = gtk.color_selection_palette_to_string([color.get_color()])
		color = color.get_color()
	
		if self.preferences_called =="terminal":
			a=0
			for x in self.term:
		
				self.term[a].set_color_background(color)
				a=a+1
		
		self.default_background_color=color
		self.cgconf.set_string("/apps/gnome-sshman/background_color",colorbg)
		
#Change text color

	def on_colorpicker3_color_set(self,color):
	
				
		colortxt = gtk.color_selection_palette_to_string([color.get_color()])
		color = color.get_color()
		
		if self.preferences_called =="terminal":
			a=0
			for x in self.term:
		
				self.term[a].set_color_foreground(color)
				self.term[a].set_color_bold(color)
				a=a+1
	
		self.default_text_color=color
		self.default_bold_color=color
		self.cgconf.set_string("/apps/gnome-sshman/text_color",colortxt)
		
		
	def on_colors_default_check_toggled(self,widget):
	
		
		if self.colors_default_check.get_active():
	
			self.cgconf.set_string("/apps/gnome-sshman/default_colors","yes")
			
			#Color selector inactive
			self.colorpick2.set_sensitive(False)
			self.colorpick3.set_sensitive(False)
			
			#set default colors
			colorbg = gtk.gdk.color_parse("white")
			colortxt = gtk.gdk.color_parse("black")
			
			if self.preferences_called =="terminal":
				a = 0
				for x in self.term:
		
					self.term[a].set_color_background(colorbg)
					self.term[a].set_color_foreground(colortxt)
					self.term[a].set_color_bold(colortxt)
					a=a+1
			
			
		else:
			self.cgconf.set_string("/apps/gnome-sshman/default_colors","no")
			
			#color selector active
			self.colorpick2.set_sensitive(True)
			self.colorpick3.set_sensitive(True)
			
			#set selected colors
			
			colorbg = self.cgconf.get_string("/apps/gnome-sshman/background_color")
			colorbg = gtk.gdk.color_parse(colorbg)
				
			colortxt = self.cgconf.get_string("/apps/gnome-sshman/text_color")
			colortxt = gtk.gdk.color_parse(colortxt)
		
			if self.preferences_called =="terminal":		
				a = 0	
				for x in self.term:
		
					self.term[a].set_color_background(colorbg)
					self.term[a].set_color_foreground(colortxt)
					self.term[a].set_color_bold(colortxt)
					a=a+1
		
	
	
	def on_save_sess_check_toggled(self,widget):
		
		if self.save_sess_check.get_active():
		
			self.save_log="yes"
			self.save_session.set_active(True)
			self.cgconf.set_string("/apps/gnome-sshman/save_sessions","yes")
			
			
		else:
			
			self.save_session.set_active(False)
			self.cgconf.set_string("/apps/gnome-sshman/save_sessions","no")
			self.save_log="no"
	
	
	def on_diff_win_check_toggled(self,widget):
	
		if widget.get_active():
			self.cgconf.set_string("/apps/gnome-sshman/different_windows","yes")
					
		else:
			self.cgconf.set_string("/apps/gnome-sshman/different_windows","no")
	
	
	def on_defaultfonts_check_toggled(self,widget):
		
		if widget.get_active():
			
			
			self.cgconf.set_string("/apps/gnome-sshman/default_fonts","yes")
	
			if self.preferences_called =="terminal":
				
				font_size=10
				font=pango.FontDescription()
				font.set_size( font_size * pango.SCALE)
				self.menuwindow.resize(200,200)
				a = 0	
		
				for x in self.term:			
					self.term[a].set_font(font)
				
			self.fontbutton.set_sensitive(False)
			
		else:
			
			self.cgconf.set_string("/apps/gnome-sshman/default_fonts","no")
			self.fontbutton.set_sensitive(True)
			
			if self.preferences_called =="terminal":
				try:
					font=pango.FontDescription(self.cgconf.get_string("/apps/gnome-sshman/font"))
					a = 0
					for x in self.term:		
						self.term[a].set_font(font)
				except:
				
					pass
				
				self.menuwindow.resize(200,200)
				
				
	def on_fontbutton1_font_set(self,widget):
	
		self.cgconf.set_string("/apps/gnome-sshman/font", widget.get_font_name())
		
		
		
		#print widget.get_font_name()
		
		if self.preferences_called =="terminal":
			fd = pango.FontDescription(widget.get_font_name())
			
			a = 0	
			for x in self.term:		
				self.term[a].set_font(fd)
			
			self.menuwindow.resize(200,200)
		
	
	def on_term_emu_combo_changed(self,widget):
		
		self.cgconf.set_int("/apps/gnome-sshman/term_emulation", widget.get_active())
		
		if self.preferences_called =="terminal":
			
			for x in self.term:
		
				x.set_emulation(self.term_types[self.cgconf.get_int("/apps/gnome-sshman/term_emulation")])
		
		
################
#Set window to full screen	
	def on_full_screen1_activate(self,data):
		if data.get_active():
			
			self.menuwindow.fullscreen()
			
						
		else:
		
			self.menuwindow.unfullscreen()
			
			if self.cgconf.get_string("/apps/gnome-sshman/default_fonts") == "no":
				getfont=self.cgconf.get_string("/apps/gnome-sshman/font")
			
				font=pango.FontDescription(getfont)
					
				for x in self.term:
		
					x.set_font(font)
					self.menuwindow.resize(200,200)
			
			else:
				self.font_size=10
				font=pango.FontDescription()
				font.set_size( self.font_size * pango.SCALE)
		
				for x in self.term:
					x.set_font(font)
					self.menuwindow.resize(200,200)



#Zoom in fonts				
	def on_zoom_in1_activate(self,data):
		
		
		if self.cgconf.get_string("/apps/gnome-sshman/default_fonts") == "no":
					
			getfont=self.cgconf.get_string("/apps/gnome-sshman/font")
			
			font=pango.FontDescription(getfont)
			a=font.get_size()
			original_font_size=a/1024
			
			try:
				if original_font_size == self.font_size	:		
					self.font_size=original_self.font_size+1
				else:
					self.font_size=self.font_size+1
			except:
				self.font_size=original_font_size+1
			
			font.set_size( self.font_size * pango.SCALE)
			
			
			
			for x in self.term:
		
				x.set_font(font)
				self.menuwindow.resize(200,200)

			
		
		else:
			self.font_size=self.font_size+1
			font=pango.FontDescription()
			font.set_size( self.font_size * pango.SCALE)
		
			for x in self.term:
		
				x.set_font(font)
			
#Zoom out fonts		
	def on_zoom_out1_activate(self,data):
			
			
			
		if self.cgconf.get_string("/apps/gnome-sshman/default_fonts") == "no":
			
			getfont=self.cgconf.get_string("/apps/gnome-sshman/font")
			
			font=pango.FontDescription(getfont)
			a=font.get_size()			
			original_font_size=a/1024
			
			
			try:
				if original_font_size == self.font_size	:		
					self.font_size=original_self.font_size-1
				else:
					self.font_size=self.font_size-1
			except:
				self.font_size=original_font_size-1
			
			
			font.set_size( self.font_size * pango.SCALE)
			
			
			for x in self.term:
		
				x.set_font(font)
				self.menuwindow.resize(200,200)

		else:
			self.font_size=self.font_size-1
			font=pango.FontDescription()
			font.set_size( self.font_size * pango.SCALE)
				
			for x in self.term:
				x.set_font(font)
				self.menuwindow.resize(200,200)
			

#Return to default size	
	def on_normal_view1_activate(self,data):
	
		if self.cgconf.get_string("/apps/gnome-sshman/default_fonts") == "no":
			
			getfont=self.cgconf.get_string("/apps/gnome-sshman/font")
			
			font=pango.FontDescription(getfont)
					
			for x in self.term:
		
				x.set_font(font)
				self.menuwindow.resize(200,200)

		else:
			self.font_size=10
			font=pango.FontDescription()
			font.set_size( self.font_size * pango.SCALE)
		
			for x in self.term:
				x.set_font(font)
				self.menuwindow.resize(200,200)

#View current session information
	def on_current_session1_activate(self,data):
	
		tabpage = self.wintabs.get_current_page()
		session_name=self.sessionnames_list[tabpage]
		
		home=os.path.expanduser("~")
		regster=home+"/.gnome-sshman/"+session_name+".ssh"

		if exists (regster):

			a=open(regster,'r')
			data=a.read()
			username = data.split('@')[0]
			ip = data.split('@')[1]
			port = data.split('@')[2]
			
		else:
		
			username = None
			ip = None
			port = None
			
								
		infowindow(username,port,ip,session_name)
		
#Create a list from save all data (user+ip) from every tab 
	def save_tabs(self):
	
		data=self.server
		self.data_tabs.append(data)
		
		
#Writing all sessions to sessions menu	
	def get_files_for_menu(self):
	
		#From our sessions folder, get all files withouth .ssh to put in comboboxentry1
		
		home=os.path.expanduser("~")
		session_folder=home+"/.gnome-sshman"
		
		a=dircache.listdir(session_folder)
		
		#Get only .ssh files, splits list 2 times
				
		z=0
		
		for x in a:
			
			if len(x.split(".ss")) != 2:
				del a[z]
			z=z+1
		
		z=0
		
		for x in a:
			
			if len(x.split(".ss")) != 2:
				del a[z]
				
			z=z+1
		
				
		b=len(a)
		c=0
	
		while c < b:
			x=a[c]
			
			name=x.split(".ssh")[0]
			self.open_item = gtk.MenuItem(name)
			self.file_menu.append(self.open_item)
			self.open_item.connect_object("activate", self.sessions_menu, name)
			self.open_item.show()
			self.open_new1.set_submenu(self.file_menu)
			c=c+1
				
#Called from sessions menu, give session name to create menu Sessions		
	def sessions_menu(self,data):
		import os
		filename=data+".ssh"
		home=os.path.expanduser("~")
		session_folder=home+"/.gnome-sshman/"
		filename=session_folder+filename
		
		port = "22"
				
		lee=open(filename,'r')
		filedata=lee.read()
		lee.close()
		filedata=filedata.split("\n")[0]
				
		index=len(filename.split("/"))
		session_name=filename.split("/")[index-1]
			
		session_name=session_name.split(".ssh")[0]
						
		if len(filedata.split("@")) == 1:
				
			self.username=getpass.getuser()
			self.ip=filedata.split("@")[0]
			self.port="22"
			self.session_name=data
						
			self.open_session()	
			
					
		elif len(filedata.split("@")) == 2:
			
			self.username=filedata.split("@")[0]
			self.ip=filedata.split("@")[1]
			self.port="22"
			self.session_name=data			
						
			self.open_session()
				
			
		elif len(filedata.split("@")) == 3:
			
			self.username=filedata.split("@")[0]
			self.ip=filedata.split("@")[1]
			self.port=filedata.split("@")[2]
			self.session_name=data			
						
			self.open_session()	
		
		elif len(filedata.split("@")) == 4:
			
			self.username=filedata.split("@")[0]
			self.ip=filedata.split("@")[1]				
			self.port=filedata.split("@")[2]
			self.session_name=data	
			
			protocol=filedata.split("@")[3]
			
			if protocol == "ssh":
				self.protocol="ssh"
				
				self.open_session()	
				
	#Open sftp session from main
				
			elif protocol == "sftp":
				
				try:
					import socket
					s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
					s.connect((self.ip, int(self.port)))
					s.close()
			
					conexion = "yes"
		
				except:
	
					conexion = "no"
		
		
				if conexion == "yes":
		
									
					if self.save_log == "no":
				
						import os
						server=self.username+"@"+self.ip+":"+self.port
			
						os.system("nautilus sftp://"+server+ " &") 
		
		
					elif self.save_log == "yes":
		
			
						import os.path
						from os.path import exists
						import time
				
						server=self.username+"@"+self.ip+":"+self.port
						server_save=self.username+"@"+self.ip+"@"+self.port+"@"+self.protocol
					
						home=os.path.expanduser("~")
		
						if self.session_name=="":
				
							regster=home+"/.gnome-sshman/"+self.ip+".ssh"
					
						else:
		
							regster=home+"/.gnome-sshman/"+self.session_name+".ssh"
				
							a=open(regster,'wr')
							a.write(server_save)
							a.close()
				
							os.system("nautilus sftp://"+server+ " &")
		
				elif conexion == "no":
	
					ConectErrorMsg()
			
	#Open telnet session from main			
				
			elif protocol == "telnet":
				
				self.protocol="telnet"
				self.open_session()	
			else:
				self.protocol="ssh"
			
				self.open_session()	
		
		
	def destroy(self,widget):
		gtk.main_quit()

#Open terminal for first time only. Initialize tabs list and save data tabs, etc.

	
	def open_vte_first(self,server):
		
		
		#Add new tab to tabs count and hide ssh manager
		self.tabs=self.tabs+1
		self.main_widget.hide()
									
		#Need save data (server and user) for every tab.
	
		self.data_tabs=[]
		self.save_tabs()		
		
		self.label=gtk.Label(self.session_name+"")		
		self.closebutton=gtk.Button()
		self.closebutton.set_relief(gtk.RELIEF_NONE)
		
		#self.closebutton.connect("clicked", self.on_close_tab1_activate)
		
		box1 = gtk.HBox(False, 0)
		equis = gtk.Image()
		equis.set_from_stock(gtk.STOCK_CLOSE,gtk.ICON_SIZE_MENU)
		box1.pack_start(equis, False, False, 0)
		self.closebutton.add(box1)
		box2 = gtk.HBox(False, 0)
		box2.pack_start(self.label, False, False, 0)
		box2.pack_start(self.closebutton, False, False, 0)
	
#Establish default values for terminal , colors, fonts, etc:

#Terminal creation
		
		t = vte.Terminal()
		t.set_scrollback_lines(50000)
		t.set_scroll_on_output(True)
#To store all terminals with their connected signals, create a list and store
#every terminal in it (all called as "t", but every "t" in a different position)

		self.term=[]
		self.term.append(t)
	
#Import preferences from gconf
		
		confirm=self.cgconf.get_string("/apps/gnome-sshman/default_colors")
		
		
		if confirm == "yes":
		
			uno = "white"
			dos = "black"
		
		else:
			uno=self.cgconf.get_string("/apps/gnome-sshman/background_color")
			dos=self.cgconf.get_string("/apps/gnome-sshman/text_color")


					

		colorbg = gtk.gdk.color_parse(uno)
		colortxt = gtk.gdk.color_parse(dos)
		
		#Set default terminal colors		
		#white =  gtk.gdk.color_parse("white")
		#black =  gtk.gdk.color_parse("black")
		#print gtk.gdk.Color(white)
		
		
		#Export default colors
		self.default_background_color=colorbg
		self.default_text_color=colortxt
		self.default_bold_color=self.default_text_color
	

		self.term[0].set_cursor_blinks(True)
		self.term[0].set_default_colors()
		self.term[0].set_color_background(self.default_background_color)
		self.term[0].set_color_foreground(self.default_text_color)
		self.term[0].set_color_bold(self.default_bold_color)
		self.term[0].set_scroll_on_output(True)
		
		#self.term[0].set_background_transparent(True)
		
#Set fonts	
		if self.cgconf.get_string("/apps/gnome-sshman/default_fonts") == "no":
					
			getfont=self.cgconf.get_string("/apps/gnome-sshman/font")
			font=pango.FontDescription(getfont)
			self.term[0].set_font(font)
		
		else:
		
			self.font_size=10
		#Set default font managed by pango
			font=pango.FontDescription()
		#font.set_size( self.font_size * pango.SCALE)
			font.set_size( self.font_size * pango.SCALE)
			self.term[0].set_font(font)
		
		
		#t.set_scroll_on_keystroke(True)
		#To adjust vte to window changes (!!!!!Think this not works!!!!)
		#self.term[0].get_adjustment
		
				
		#Set terminal emulation type	
		self.term[0].set_emulation(self.term_types[self.cgconf.get_int("/apps/gnome-sshman/term_emulation")])
		
		#tipos de emulacin
		#xterm
		#ansi
		#vt100
		self.term[0].fork_command('python')
		
		if self.protocol == "telnet":		
		#With warnings module ignore all warning messages, aren't showed
			self.term[0].feed_child('import warnings,sys,os ;sys.path.append("/usr/share/gnome-sshman");import telnetauth\n' )
		else:
			self.term[0].feed_child('import warnings,sys,os ;sys.path.append("/usr/share/gnome-sshman");import sshauth\n' )
		
		#Event to terminal. If exit...
		#Send to exit signal a terminal position. With open_vte_first is first position.
		self.term[0].connect("child-exited", self.close_vte,self.data_tabs[0])
		self.closebutton.connect("clicked", self.close_vte, self.data_tabs[0])
		self.term[0].connect("button-press-event", self.popupmenu, self.term[0])
	
		#t.set_color_foreground(black)
		
	
#ScrolledWindow
		#self.scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_ALWAYS)
		#self.scrollwin.add_with_viewport(self.term[0])
		#self.wintabs.append_page(self.scrollwin,self.label)


	#Add tab
		self.wintabs.append_page(self.term[0],box2)
		self.vbox4.add(self.wintabs)
		
		box2.show()
		box1.show()		
		equis.show()
		self.label.show()
		self.closebutton.show()
		self.term[0].show()
		
		#self.scrollwin.show()
		self.wintabs.show()
		

#Set focus to terminal
		self.term[0].grab_focus()

#Signal to scroll
	#	self.term[0].connect("cursor-moved", self.text_scroll,self.scrollwin,self.term[0])
		

		
		#First session, no show tabs
		self.wintabs.set_show_tabs(show_tabs=False)
	
	#def text_scroll(self,widget,adj,terminal):
		
		#print terminal.get_size_request()
	#	print terminal.get_column_count()
	#	terminal.set_size(600,600)
	#	terminal.set_scroll_adjustments(600,600)
		#print terminal.get_text_range()
		#print terminal.get_char_width()
	#	print "AAAAAAAAAAAAAAAAAAA"
		#terminal.get_vadjustment().step_increment = 50
		#alloc = widget.get_allocation()     
		#if alloc.y < adj2.value or alloc.y > adj2.value + adj2.page_size:
		#adj2.set_value(400)
		
		#scroll.get_vadjustment()
	
			
	def open_vte(self,server):
	
		#Add new to to tabs count	
		self.tabs=self.tabs+1
		
		self.main_widget.hide()
					
		#Save data tab to list
		self.server=server
		self.save_tabs()
		
		self.label=gtk.Label(self.session_name+"")			
		
		self.closebutton=gtk.Button()
		self.closebutton.set_relief(gtk.RELIEF_NONE)
	
		box1 = gtk.HBox(False, 0)
		equis = gtk.Image()
		equis.set_from_stock(gtk.STOCK_CLOSE,gtk.ICON_SIZE_MENU)
		box1.pack_start(equis, False, False, 0)
		self.closebutton.add(box1)
		box2 = gtk.HBox(False, 0)
		box2.pack_start(self.label, False, False, 0)
		box2.pack_start(self.closebutton, False, False, 1)
			
		
		t = vte.Terminal()

#Add terminal to terminal list

		self.term.append(t)

#ultima is the last terminal added (current terminal)		
		ultima=len(self.term)-1
		self.ultima=ultima

#Set default terminal colors		
		white =  gtk.gdk.color_parse("white")
		black =  gtk.gdk.color_parse("black")
		self.term[ultima].set_cursor_blinks(True)
		self.term[ultima].set_default_colors()
		self.term[ultima].set_color_background(self.default_background_color)
		self.term[ultima].set_color_foreground(self.default_text_color)
		self.term[ultima].set_color_bold(self.default_bold_color)

#Set terminal emulation type	
		
		self.term[ultima].set_emulation(self.term_types[self.cgconf.get_int("/apps/gnome-sshman/term_emulation")])
		
		self.term[ultima].fork_command('python')

#Set fonts	
		if self.cgconf.get_string("/apps/gnome-sshman/default_fonts") == "no":
					
			getfont=self.cgconf.get_string("/apps/gnome-sshman/font")
			font=pango.FontDescription(getfont)
			self.term[ultima].set_font(font)
		
		else:
		
		#Set default font managed by pango
			font=pango.FontDescription()
		#font.set_size( self.font_size * pango.SCALE)
			font.set_size( self.font_size * pango.SCALE)
			self.term[ultima].set_font(font)

	
		#To adjust vte to window changes:
		#t.get_adjustment
		#With warnings module ignore all warning messages, aren't showed
		
		if self.protocol == "telnet":		
	
			self.term[ultima].feed_child('import warnings,sys,os ;sys.path.append("/usr/share/gnome-sshman");import telnetauth\n' )
		else:
			self.term[ultima].feed_child('import warnings,sys,os ;warnings.defaultaction = "ignore";sys.path.append("/usr/share/gnome-sshman");import sshauth\n' )

#Send to exit signal a terminal position for all terminals. Here is sending 
#the data stored in data_tabs list in the same position that terminal (stored in ultima)
		self.term[ultima].connect("child-exited", self.close_vte, self.data_tabs[ultima])
		self.closebutton.connect("clicked", self.close_vte, self.data_tabs[ultima])
		self.term[ultima].connect("button-press-event", self.popupmenu, self.term[ultima])
		self.wintabs.append_page(self.term[ultima], box2)
		
		self.wintabs.next_page()
			
			
		box2.show()
		box1.show()		
		equis.show()
		self.label.show()
		self.closebutton.show()
		
		self.term[ultima].show()
		#Activate last tab opened
		self.wintabs.set_current_page(self.tabs)
		#Show tabs
		self.wintabs.set_show_tabs(show_tabs=True)
						
		#Charge self.server to global again (nautilus can need it)
	
	
	def close_vte(self,widget,ultima):
	
	#Take server name to notify send
		server_notify=ultima.split("@")[1]
	
	#ultima has the value for ever term. term+ultima = self.data_tabs
		
		a=0
		c=0
	
	#Search value position in tabs data list. ultima is a value stored in data_tabs
	#Their position in data_tabs[] give us terminal position
	
		for x in self.data_tabs:
		
			if x == ultima:
				b=a
				c=c+1
			a=a+1				
	
	#If a value is repeated (two positions), delete tab in use (ultima=current tab)
	
		if c > 1:
			ultima = self.wintabs.get_current_page()
		else:
			ultima = b


		#With 1 tab, close tab and no show last tab, with 0, close app and with
		#more of 1 tab, close tab
		if self.tabs==1:
			
			#Remove tab and hide tabs
			
			self.wintabs.remove_page(ultima)
			self.wintabs.set_show_tabs(show_tabs=False)
			self.tabs = self.tabs-1
						
			#Remove data from tabs list
			del self.data_tabs[ultima]
			
			#Remove session name
			del self.sessionnames_list[ultima]
		
			#Remove terminal from terminal list
			del self.term[ultima]
			
		#If only 1 tab, close window
		elif self.tabs == 0:

			gtk.main_quit()
	
		#And for the others....
		else:
			
			#Get current tab and remove it
			self.wintabs.remove_page(ultima)
			
			self.tabs=self.tabs-1
				
			#Remove data from tabs list
			del self.data_tabs[ultima]
			#Remove session name
			del self.sessionnames_list[ultima]
			#Remove terminal from terminal list
		
			del self.term[ultima]
	
	

	
	
	#Open terminal ssh session other times (first time open with open_vte_first)
	
	def popupmenu(self,widget,event,terminal):
		
		if event.button == 3:
		
			popup2_widgets = Widgets(glade_dir+'popmenu2.glade')
			
			connections = {
			'open_with_nautilus1/activate' : self.on_open_with_nautilus1_activate,
			'about_gnomesshman/activate' : self.go_about
			
				}
			
		
			for wid_con, func in connections.iteritems():
				wid,con = wid_con.split('/')
				popup2_widgets[wid].connect(con,func)
			
			
			menu2=popup2_widgets['menu2']
			menu2.popup(None, None, None, event.button, event.time)
	
			
		else:
			pass
		
	def term_copy(self,widget):
	
		b=self.terminal.copy_primary()
		print b
		print "a"
	
	def term_paste(self,widget):
		print "b"


#Close tab menu entry
	def on_close_tab1_activate(self,widget):
	
		
		#If 2 tabs, remove 1 and hide the last
		if self.tabs==1:
		
			
			#Get current tab, remove it and hide tabs
			tabpage = self.wintabs.get_current_page()
			self.wintabs.remove_page(tabpage)
			self.wintabs.set_show_tabs(show_tabs=False)
			self.tabs = self.tabs-1
			
			server_notify=self.data_tabs[tabpage]
			server_notify=server_notify.split("@")[1]
			#Remove data from tabs list
			del self.data_tabs[tabpage]
			#Remove terminal from terminal list
			del self.term[tabpage]
					
		
	
		#If only 1 tab, no remove it
		elif self.tabs == 0:

			pass
	
		#And for the others....
		else:
					
			
			#Get current tab and remove it
			tabpage = self.wintabs.get_current_page()
			
			server_notify=self.data_tabs[tabpage]
			server_notify=server_notify.split("@")[1]
			
			self.wintabs.remove_page(tabpage)
			
			self.tabs=self.tabs-1
					
					
			#Remove data from tabs list
			del self.data_tabs[tabpage]
			#Remove terminal from terminal list
			del self.term[tabpage]
		
			
#Open new ssh manager from terminal

	def on_open_ssh_manager1_activate(self, widget):

		#To call session manager we need empty text entries to do a new session
		#selection
			
		self.entry_user.set_text("")
		self.entry_host.set_text("")
		self.entry_save.set_text("")
		self.entry_port.set_text("22")
		self.username=None
		self.ip=None
		#port="22"
		self.session_name=None
		self.main_widget.show()
		
#Open current ssh connection with nautilus. Need to get path, now nautilus opens user path
	def on_open_with_nautilus1_activate(self, widget):
		
		#Get current tab to get data from tab
						
		tabpage = self.wintabs.get_current_page()
		
		#Separe user and servername from data tab.
		
		#If tab only have server (no user). Strange.
		
		if len(self.data_tabs[tabpage].split("@")) == 1:
			
			os.system("nautilus sftp://"+self.data_tabs[tabpage]+ " &")
		
		#For data tab with user and servername
		
		elif len(self.data_tabs[tabpage].split("@")) == 2:
			
			user=self.data_tabs[tabpage].split("@")[0]
			server=self.data_tabs[tabpage].split("@")[1]
		
			if user == "root":
				os.system("nautilus sftp://"+user+"@"+server+":"+self.port+"/root &")
			else:
				os.system("nautilus sftp://"+user+"@"+server+":"+self.port+"/home/"+user+ " &")
		
		else:
			pass

	def on_salir1_activate(self, widget):
		
		if self.tabs != 0:
			
			quit_dialog_widgets = Widgets(glade_dir+'quit_dialog.glade')
						
			connections = {
				'quit_dialog_ok/clicked' : self.on_quit_dialog_ok_clicked,  
				'quit_dialog_cancel/clicked' : self.on_quit_dialog_cancel_clicked  
			}
		
			for wid_con, func in connections.iteritems():
				wid,con = wid_con.split('/')
				quit_dialog_widgets[wid].connect(con,func)
			
			self.quit_dialog=quit_dialog_widgets['Quit_dialog']
			
		#First, destroy main widget (for correct communication with main window) 
		#and then, quit
		else:
		
			server_notify=self.data_tabs[0]
			server_notify=server_notify.split("@")[1]
			
			
			self.main_widget.destroy()
			
			gtk.main_quit()
		

		
	def on_quit_dialog_ok_clicked(self,widget):
		
		self.main_widget.destroy()
		gtk.main_quit()
		
	def on_quit_dialog_cancel_clicked(self,widget):
		self.quit_dialog.destroy()
		
		
	def on_about1_activate(self, widget):
	
		Acerca()
		
###############################################################################
#######################PASSWORD DIALOG#########################################
###############################################################################

#Passwords dialog, to set session password, keyring, etc.

	def passwd(self,username):

		#Path to files
		home=os.path.expanduser("~")
		self.files=home+"/.gnome-sshman/"
		self.keys=home+"/.gnome-sshman/"	
		files=home+"/.gnome-sshman/"+"Master.key"
		self.master_key_file=files
		
		#If session has no name, then sessionname=ip
	
		if self.session_name==None: 
			
			self.session_name=self.ip
			
		#Set file names
		self.session_file=self.files+self.session_name+".ssh"
		self.key_file=self.keys+self.session_name+".key"
		
		self.server=username
		
		#If not exist session file, open password dialog
		if not exists(self.session_file):
		
			self.session_file_exists="no"
			self.askpass(username)
				
		#Check if exists master keyring file
		if not exists(files):
		
			keyring_first_time()		


		#If exists session file, check if exists key file
		if exists(self.session_file):
			
			if exists(self.key_file):
				
				#With keyring previous opened
				if self.key_pass=="yes":
				
				#With keyring, no save password
				
					self.save_passwd="no"
					self.keyringwin.destroy()
					
					self.check_pass()
		
				#With keyring not opened, open keyring dialog
				else:
			
					self.askpassring(username)
					
			#If not exists key file, open password dialog
			else:
					
				self.askpass(username)
						
		#Set password to blank (used by askpass dialog)		
		self.password=""
				
		
####Keyring dialog######

	def askpassring(self,server):

		
		keyring_widgets = Widgets(glade_dir+'keyring.glade')
		self.server=server
		keyring_widgets['keyring'].connect("destroy", self.on_button1_clicked)
		keyring_widgets['keyring'].connect("key_press_event", self.on_keyring_press_event)


		connections = {
			'button2/clicked' : self.on_button2_clicked,  
			'button1/clicked' : self.on_button1_clicked,  
			'entry_keyring/changed'  : self.on_entry_keyring_changed
			}
	
					
		for wid_con, func in connections.iteritems():
			wid,con = wid_con.split('/')
			keyring_widgets[wid].connect(con,func)
		
						
		self.keyringwin=keyring_widgets['keyring']
		self.key_password=keyring_widgets['entry_keyring']
		self.key_okbutton=keyring_widgets['button2']
	
	#By default, ok button deactivated
		self.key_okbutton.set_sensitive(False)
	#Control keyring password tries
		self.exec_times=0

#Set keyring password to blank
		self.keyring_pass = ""

#Capture return key		
	def on_keyring_press_event(self,widget,event):
		keyname = gtk.gdk.keyval_name(event.keyval)
		#print "Key %s (%d) was pressed" % (keyname, event.keyval)
		if keyname == "Return" and self.keyring_pass != "":
			self.on_button2_clicked(self,widget, event)
				
	def on_button1_clicked(self,widget, *args):
	
		self.keyringwin.destroy()
	
	def on_entry_keyring_changed(self,widget, *args):
		
		#Get keyring password from entry
		self.keyring_pass=self.key_password.get_text()
		
		if self.keyring_pass != "":
			self.key_okbutton.set_sensitive(True)
		elif self.keyring_pass == "":
			self.key_okbutton.set_sensitive(False)	
			
	def on_button2_clicked(self,widget, *args):
		
		#Add 1 execution pressed ok button
		self.exec_times=self.exec_times+1
		
		#Set key file
		self.key_file=self.keys+self.session_name+".key"
		
		#If exists, no save password
		if exists (self.key_file):
			self.save_passwd="no"
		
		file=self.master_key_file
		key=self.keyring_pass
			
#Decrypt master file, try to open it and remove
		
		import cipher
		cipher.Decipher(file,key)
				
		file_opened=self.keys+"Master"
		
		#Try 3 times to open keyring, is not open, use askpassword withouth keyring
		
		try:
			o=open(file_opened, "r")
			self.key_pass="yes"
			self.keyring_pass=key			
			o.close()		
			os.system("rm "+file_opened)
			self.check_pass()	
			self.keyringwin.destroy()

		except:
		
			if self.exec_times == 3:
				self.key_pass="no"
				self.save_log="no"
				
				#When pass save_log to no by 3 intents, uncheck
				#save session
				self.save_session.set_active(False)
				self.keyringwin.destroy()
				self.askpass(self.server)	
			else:
				self.keyringwin.hide()
				self.keyringwin.show()
				self.key_password.set_text("")
		
				
####Password dialog######

	def askpass(self,server):

		askpass_widgets = Widgets(glade_dir+'auth-dialog.glade')
				
		self.server=server
		askpass_widgets['authdialog'].connect("destroy", self.on_cancelbutton1_clicked)
		askpass_widgets['authdialog'].connect("key_press_event", self.on_authdialog_key_press_event)
		
		connections = {
			'okbutton1/clicked' : self.on_okbutton1_clicked,
			'cancelbutton1/clicked' : self.on_cancelbutton1_clicked,
			'entry1/changed'  :  self.on_entry1_changed,
			'checkbutton3/toggled' : self.on_checkbutton3_toggled
				}
	
					
		for wid_con, func in connections.iteritems():
			wid,con = wid_con.split('/')
			askpass_widgets[wid].connect(con,func)
		
		self.passwin=askpass_widgets['authdialog']
		self.checkbutton3=askpass_widgets['checkbutton3']
		self.entry_passwd=askpass_widgets['entry1']
		self.ask_okbutton=askpass_widgets['okbutton1']
		
		self.save_passwd="no"
		
		#By default, ok button deactivated
		self.ask_okbutton.set_sensitive(False)
		
		#If save session = yes, the password can be saved

		if self.save_log =="yes":
	
			self.checkbutton3.set_sensitive(True)
	
#If not exists keyring master file, can not save passwords
				
		if not exists (self.master_key_file):
			self.checkbutton3.set_sensitive(False)
		
		
		
#Capture return key		
	def on_authdialog_key_press_event(self,widget,event):
		keyname = gtk.gdk.keyval_name(event.keyval)
		#print "Key %s (%d) was pressed" % (keyname, event.keyval)
		if keyname == "Return" and self.password != "":
			self.on_okbutton1_clicked(self,widget, event)
			
	def on_cancelbutton1_clicked(self,widget, *args):
	
		self.passwin.destroy()
			
		
	def on_okbutton1_clicked(self,widget,*args):
		
		self.passwin.destroy()
	
		#Saving password with keyring closed, opens keyring dialog	
		if self.save_passwd=="yes" and self.key_pass=="no":
		
			self.askpassring(self.server)
					
		else:
			
			self.check_pass()
		
							
	def on_checkbutton3_toggled(self,widget, *args):
		
		if self.checkbutton3.get_active():
						
			self.save_passwd="yes"
		else:
			self.save_passwd="no"
		

	def on_entry1_changed(self,widget,*args):
			
		self.password=self.entry_passwd.get_text()
		
		if self.password != "":
			self.ask_okbutton.set_sensitive(True)
		elif self.password == "":
			self.ask_okbutton.set_sensitive(False)	

#Change save password status when keyring created
		if self.save_log =="yes":
			if exists (self.master_key_file):
				self.checkbutton3.set_sensitive(True)
			
#Check passwords, sended by password dialog

	def check_pass(self):
				
			
		home=os.path.expanduser("~")
		self.files=home+"/.gnome-sshman/"
		self.keys=home+"/.gnome-sshman/"
		
		self.session_file=self.files+self.session_name+".ssh"
		self.key_file=self.keys+self.session_name+".key"
		
#In this file is writed data needed by sshauth module, when readed then is deleted
#here and when sshauth is called

		pass_file=self.keys+".pass"
									
		if self.save_passwd=="yes":
	
	#Save key
			file_opened=self.keys+self.session_name
			a=open(file_opened, 'w')
			a.write(self.password)
			a.close()
					
	#If keyring opened, continue. If not, open it			
	
			if self.key_pass=="yes":
						
				file=file_opened
				key=self.keyring_pass
					
				import cipher
				cipher.Encipher(file,key)
				os.system("rm "+file_opened)
			
				f=open(pass_file, "w")
				f.write(self.server+"#"+self.password+"#"+self.keyring_pass+"#"+self.session_name+"#"+self.port)
				f.close()
				
				#If number of tabs is -1, then open open_vte_first
				if self.tabs < 0 and self.first_tab=="yes":
					self.MenuWindow(self.server,self.tabs)
					self.first_tab="no"
				
				elif self.cgconf.get_string("/apps/gnome-sshman/different_windows") == "yes":
					self.MenuWindow(self.server,self.tabs)
				
				else:
					self.open_vte(self.server)
				
				#os.system("rm "+pass_file)
				
			else:
				
				os.system("rm "+file_opened)
				self.askpassring(self.server)
					
		else:
						
			if self.key_pass=="yes" and exists (self.key_file) and exists (self.master_key_file):
						
				key_file=self.key_file
				key=self.keyring_pass
				opened_file=self.files+self.session_name
				
				import cipher
				cipher.Decipher(key_file,key)
												
				aa=open(opened_file, 'r')
				self.password=aa.read()
				aa.close()			
								
				os.system("rm "+opened_file)
				
				#Pass passwd file to sshauth.py
						
				f=open(pass_file, "w")
				f.write(self.server+"#"+self.password+"#"+self.keyring_pass+"#"+self.session_name+"#"+self.port)
				f.close()

				if self.tabs < 0 and self.first_tab=="yes":
					self.MenuWindow(self.server,self.tabs)
					self.first_tab="no"
				
				elif self.cgconf.get_string("/apps/gnome-sshman/different_windows") == "yes":
					self.MenuWindow(self.server,self.tabs)
					
				else:
					self.open_vte(self.server)
		
				#os.system("rm "+pass_file)
				
			else:
			
				send="no"
				f=open(pass_file, "w")
				f.write(self.server+"#"+self.password+"#"+send+"#"+self.session_name+"#"+self.port)
				f.close()
			
				if self.tabs < 0 and self.first_tab=="yes":
					self.MenuWindow(self.server,self.tabs)
					self.first_tab="no"
					
				elif self.cgconf.get_string("/apps/gnome-sshman/different_windows") == "yes":
					self.MenuWindow(self.server,self.tabs)
					
				else:
					self.open_vte(self.server)
				
				#os.system("rm "+pass_file)	
				
					
#Window for invalid ip error
class IpErrorMsg:
	
	def __init__(self):
	
		error1_widgets = Widgets(glade_dir+'ip_error.glade')
			
		self.mainerr1=error1_widgets['ip_error']

		connections = {
			'okbutton1/clicked' : self.on_okbutton1_clicked
			}
	
		
	def on_okbutton1_clicked(self, widget, *args):
		self.mainerr1.destroy()
		
		
#Window for invalid connection error
class ConectErrorMsg:
		
	def __init__(self):
	
		error2_widgets = Widgets(glade_dir+'connect_error.glade')
			
		self.mainerr2=error2_widgets['conect_error']

		connections = {
			'okbutton2/clicked' : self.on_okbutton2_clicked
			}
	
		for wid_con, func in connections.iteritems():
			wid,con = wid_con.split('/')
			error2_widgets[wid].connect(con,func)

	
	def on_okbutton2_clicked(self, widget, *args):
		self.mainerr2.destroy()
		

#Dialog to show keyring initialization dialog. Only showed when Master.key not exists

class keyring_first_time:

	def __init__(self):
	
		keyring_first_widgets = Widgets(glade_dir+'keyring_first.glade')
			
			
		keyring_first_widgets['keyring_first'].connect("destroy", self.on_button1_clicked)
		keyring_first_widgets['keyring_first'].connect("key_press_event", self.on_keyring_first_press_event)		
		
		connections = {
			'button2/clicked' : self.on_button2_clicked,  
			'button1/clicked' : self.on_button1_clicked,  
			'entry_keyring_first/changed'  : self.on_entry_keyring_first_changed
			}
	
					
		for wid_con, func in connections.iteritems():
			wid,con = wid_con.split('/')
			keyring_first_widgets[wid].connect(con,func)
			
						
		self.keyring_first_win=keyring_first_widgets['keyring_first']
		self.keyring_first_pass=keyring_first_widgets['entry_keyring_first']
		self.okbutton=keyring_first_widgets['button2']
		
		#Deactivate ok button by default
		self.okbutton.set_sensitive(False)
		self.keyring_first_win.grab_focus()
	#Capture return key		
	def on_keyring_first_press_event(self,widget,event):
		keyname = gtk.gdk.keyval_name(event.keyval)
		
		if keyname == "Return" and self.keyring_pass != "":
			self.on_button2_clicked(self,widget, event)

	def on_button1_clicked(self,widget, *args):
	
		self.keyring_first_win.destroy()
	
	def on_entry_keyring_first_changed(self,widget, *args):
		
		self.keyring_pass=self.keyring_first_pass.get_text()
		
		if self.keyring_pass != "":
			self.okbutton.set_sensitive(True)
		elif self.keyring_pass == "":
			self.okbutton.set_sensitive(False)		
			
	def on_button2_clicked(self,widget, *args):

		home=os.path.expanduser("~")
		files=home+"/.gnome-sshman/"
		master_file=files+"Master"

		f=open(master_file, "w")
		f.write("opened")
		f.close()
		
		import cipher
		cipher.Encipher(master_file,self.keyring_pass)
		os.system("rm "+master_file)
		
		self.keyring_first_win.destroy()
		
def Acerca():


	import gnome.ui
	about = gnome.ui.About('Gnome-Sshman\n',version,_('Published under GPL license'),_('The ssh manager for Gnome'),['Jordi Ivars <ear@oronetes.net>'],None,_('Jordi Ivars <ear@oronetes.net>'))
	about.show()

class infowindow:
		
		
	def __init__(self,username,port,ip,session_name):
	
	
		self.session_name = session_name
		
		
		import time
		home=os.path.expanduser("~")
		session_folder=home+"/.gnome-sshman/"
		notes_file=session_folder+session_name+".notes"
		key_file=session_folder+session_name+".key"
		ssh_file=session_folder+session_name+".ssh"
		
		if not exists (ssh_file):
			
			fecha=" "
		else:
		
			fecha=os.path.getmtime(ssh_file)
			fecha=time.ctime(fecha)
				
	
		
		infowidgets = Widgets(glade_dir+'info.glade')
		
		infowidgets['infowin'].connect("destroy", self.destroy_win)
		
		self.info=infowidgets['infowin']

		connections = {
			'info_button/clicked' : self.on_infobutton_clicked,
			'delete/clicked': self.on_delete_clicked
					
			}
	
		for wid_con, func in connections.iteritems():
			wid,con = wid_con.split('/')
			infowidgets[wid].connect(con,func)

		
		self.text_entry_info=infowidgets['text_entry_info']
		
		self.infowin=infowidgets['infowin']
		self.label1=infowidgets['label1']
		self.label2=infowidgets['label2']
		self.label3=infowidgets['label3']
		self.label4=infowidgets['label4']
		self.label5=infowidgets['label5']
		self.label6=infowidgets['label6']


#set info text
		
				
		one=_('The session name is ')+session_name
		two=_('The default user is ')+username
		three=_('The ip to connect is ')+ip
		

		if session_name==" " or session_name == None or session_name=="":
		
			self.label1.set_text(_("This session hasn't previously saved"))
			
		else:
			
			self.label1.set_text(one)
			
		
		self.label2.set_text(two)
		text=three+", port "+port
		self.label3.set_text(text)

		
		if exists (ssh_file):
			
			self.label4.set_text(_('Last saved session in ')+fecha)
			
		else:
					
			self.label4.set_text(_("This session has never been saved"))

		
		if exists (key_file):
		
			self.label5.set_text(_("This session has a password key file saved"))

		else:
			self.label5.set_text(_("This sessions hasn't a password key file saved"))
			
			
		try:
			import socket
			s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

			s.settimeout(5)
			s.connect((ip, int(port)))
			
			s.close()
			
			conexion = "yes"
						
		except:
	
			conexion = "no"
		
		
		if conexion == "yes":
		
			self.label6.set_text(_("This connection seems available"))
			
			
		else:
		
			self.label6.set_text(_("This connection seems not available"))
			
			
	#Read existing notes file
	
		if exists (notes_file):
		
			a=open(notes_file,'r')
			text=a.read()
			
			
			buffer=self.text_entry_info.get_buffer()
			buffer.set_text(text)
			
			a.close()
		
	def on_infobutton_clicked(self,widget):
	
		buffer=self.text_entry_info.get_buffer()
		start, end = buffer.get_bounds()
		
		
		notes=buffer.get_text(start,end)
		
		home=os.path.expanduser("~")
		session_folder=home+"/.gnome-sshman/"
		notes_file=session_folder+self.session_name+".notes"
		
		
		a=open(notes_file,'wr')
		a.write(notes)
		a.close()
		
		self.infowin.destroy()
		 

	def on_delete_clicked(self,widget):
	
				
		removesession_widgets = Widgets(glade_dir+'remove_session.glade')
			
		self.removesession=removesession_widgets['remove_session']

		connections = {
			'okbutton2/clicked' : self.continue_removing,
			'cancel/clicked' : self.cancel_removing
			}
	
		for wid_con, func in connections.iteritems():
			wid,con = wid_con.split('/')
			removesession_widgets[wid].connect(con,func)
		
		
					
	def continue_removing(self,widget):
		
		home=os.path.expanduser("~")
		session_folder=home+"/.gnome-sshman/"
		notes_file=session_folder+self.session_name+".notes"
		key_file=session_folder+self.session_name+".key"
		ssh_file=session_folder+self.session_name+".ssh"
	
		if exists (ssh_file):
		
			os.system("rm "+ssh_file)
			
		if exists (notes_file):
			
			os.system("rm "+notes_file)
			
		if exists (key_file):
		
			os.system("rm "+key_file)
			
		self.removesession.destroy()
		self.infowin.destroy()
	
	def cancel_removing(self,widget):
		
		self.removesession.destroy()
		
	def destroy_win(self,widget, *args):
	
		self.infowin.destroy()

		
main()
