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

# Jordi Ivars Oller
# 2005
# Licensed under GPL <http://www.gnu.org>
#
# Copyright (c) 2005, 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 implied 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.5.2

#TODO:
#Menu entry in terminal to change color, font, etc.
#Take path from terminal ssh session to pass nautilus when open sftp session
#New window warning if you are closing session with opened tabs
#Timeout window (in sshauth pexpect)

#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

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):
	
#Try with arguments. If exists args (a path to file), pass the args. If not, args are empty (None)
	
		try:

			port = 22
	
			
			if sys.argv[1]:
			

				if sys.argv[1] == "--about":
			
					acercax=Acerca()
					acercax.run()
										

				else:
					
					start(sys.argv[1],port)
				
							
		except:
			
				port=22
				ip=None
				start(ip,port)										


class start:

	def __init__(self,conection,port):
					
				
		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)
		

#If exists args, open the file passed in args

		if conection != None:
			lee=open(conection,'r')
			ip=lee.read()
			lee.close()
			host=ip.split("\n")[0]
			
#By default, the session_name=filename withouth .ssh. To separe file and directories, split / 

			index=len(conection.split("/"))
			session_name=conection.split("/")[index-1]
			
			session_name=session_name.split(".ssh")[0]
			
#Separe file content with split @. If list have 1 valor, only have IP. If have 2, user+ip
#and if is different from 1 or 2, error.

			if len(host.split("@")) == 1:
			
				username=None
				host=host.split("@")[0]
				self.conectar(host,username,port,session_name)
			
			elif len(host.split("@")) == 2:
		
				
				username=host.split("@")[0]
				host=host.split("@")[1]				
				self.conectar(host,username,port,session_name)
			else:
		
				
				IpErrorMsg()
				
		
		else:
			
			host = None
			username = None
			session_name = None			
			self.conectar(host,username,port,session_name)

#Pass all the needed vars, the ip, username, the port and the session name.

		
	def conectar(self,ip,username,port,session_name):
			
		
		if ip != None:		
	
#Find if exists a previous registered session name in saved sessions directory.

			home=os.path.expanduser("~")
			regster=home+"/.gnome-sshman/"+session_name+".ssh"

			if exists (regster):

#If exists register, open, read it and pass ip and user

				a=open(regster,'r')
				data=a.read()
				username = data.split('@')[0]
				ip = data.split('@')[1]
				host = ip.split('/n')[0]
			
				GsshMain(username,ip,port,session_name)
				gtk.main()
				
						
			else:

#If not exists register, username is empty
				GsshMain(username,ip,port,session_name)
				gtk.main()
					
		else:

#If no arguments in main, username and ip are empty (None)

			username=None
			ip=None
			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,
			'sessions_folder_button/clicked'  :self.on_sessions_folder_button_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']
		
		#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.save_log="yes"
	
		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()
		
#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 gtk.FALSE
		#If tabs, session opened and then cancel button not closes main window.
		else:
			self.main_widget.hide()
			return gtk.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 menu. If user+ip entries are empty, open connection with nautilus
		#in menu is insensitive		
		
		if self.ip==None or self.ip=="" or self.username==None or self.username=="":		
			
			menu1=gtk.Menu()
	
			menu_string = """<ui>
            <popup name='Popup'>
                <menuitem action='Open'/>
                <menuitem action='About'/>
            </popup>
            </ui>"""

		
			actg = gtk.ActionGroup('WindowActions')
			try:	
				actions = [('Open', gtk.STOCK_OPEN, _("Open current connection with Nautilus"), '<control>O','Create a new file', self.menu_response),

			('About', gtk.STOCK_ABOUT, _("About Gnome-Sshman"), '<control>O','Open a file', self.go_about),]
			except:
			
				actions = [('Open', gtk.STOCK_OPEN, _("Open current connection with Nautilus"), '<control>O','Create a new file', self.menu_response),

			('About', None, _("About Gnome-Sshman"), '<control>O','Open a file', self.go_about),]
			

			actg.add_actions(actions)
			#menuui = gtk.UIManager(gtk.UI_MANAGER_POPUP)
			menuui = gtk.UIManager()
			menuui.insert_action_group(actg, 0)
			menuui.add_ui_from_string(menu_string)
			menu1 = menuui.get_widget("/Popup")

	#Nautilus menu option is insensitive
			menuui.get_widget("/Popup/Open").set_sensitive(gtk.FALSE)
			

		else:
		
			menu1=gtk.Menu()
			
			menu_string = """<ui>
            <popup name='Popup'>
                <menuitem action='Open'/>
                <menuitem action='About'/>
            </popup>
            </ui>"""

			actg = gtk.ActionGroup('WindowActions')
			
			try:
				actions = [('Open', gtk.STOCK_OPEN, _("Open current connection with Nautilus"), '<control>O','Create a new file', self.menu_response),
           		('About', gtk.STOCK_ABOUT, _("About Gnome-Sshman"), '<control>O','Open a file', self.go_about),]
			except:
				actions = [('Open', gtk.STOCK_OPEN, _("Open current connection with Nautilus"), '<control>O','Create a new file', self.menu_response),
           		('About', None, _("About Gnome-Sshman"), '<control>O','Open a file', self.go_about),]

			actg.add_actions(actions)
			#menuui = gtk.UIManager(gtk.UI_MANAGER_POPUP)
			menuui = gtk.UIManager()
			menuui.insert_action_group(actg, 0)
			menuui.add_ui_from_string(menu_string)
			menu1 = menuui.get_widget("/Popup")

		#Nautilus menu options turns sensitive

			menuui.get_widget("/Popup/Open").set_sensitive(gtk.TRUE)
	
	#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
			
					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
					server_save=self.username+"@"+self.ip+"@"+self.port
					
					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)
				
				
		
	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


	def on_comboboxentry1_changed(self, widget, *args):
	
		#By default, save_session is activated with a new session
		self.save_session.set_active(gtk.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)
			
		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)
			
		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)		
			
					
	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(gtk.FALSE)
		
		else:
		
			self.button_ok.set_sensitive(gtk.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(gtk.FALSE)
		
		else:
		
			self.button_ok.set_sensitive(gtk.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"
		else:
		
			self.save_log="no"
	
	#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_sessions_folder_button_clicked(self, widget, *args):
		
		#Button to open nautilus in sessions folder.

		home=os.path.expanduser("~")
		session_folder=home+"/.gnome-sshman/"
		
		os.system("nautilus "+session_folder)
		
	def open_session(self):
	
		#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"
						
		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()
								
				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
				
				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()
								
				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=gtk.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,
			'about1/activate'   : self.on_about1_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']
		
		#Creating menu and adding sessions menu
		
		self.file_menu = gtk.Menu()   
		self.get_files_for_menu()
		
#Set window to full screen	
	def on_full_screen1_activate(self,data):
		if data.get_active():
			self.menuwindow.fullscreen()
						
		else:
			self.menuwindow.unfullscreen()
			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):
		
		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):
			
		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):
	
		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)
		
	#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.menuitem4.set_submenu(self.file_menu)
			c=c+1
				
#Called from sessions menu, give session name to create menu Sessions		
	def sessions_menu(self,data):
		
		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()	
			
	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(gtk.FALSE, 0)
		equis = gtk.Image()
		equis.set_from_stock(gtk.STOCK_CLOSE,gtk.ICON_SIZE_MENU)
		box1.pack_start(equis, gtk.FALSE, gtk.FALSE, 0)
		self.closebutton.add(box1)
		box2 = gtk.HBox(gtk.FALSE, 0)
		box2.pack_start(self.label, gtk.FALSE, gtk.FALSE, 0)
		box2.pack_start(self.closebutton, gtk.FALSE, gtk.FALSE, 0)
	
#Establish default values for terminal , colors, fonts, etc:

		self.font_size=10


	#Terminal creation
		
		t = vte.Terminal()
		t.set_scrollback_lines(60000)
		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)
		
		#Set default terminal colors		
		white =  gtk.gdk.color_parse("white")
		black =  gtk.gdk.color_parse("black")
		
		self.term[0].set_cursor_blinks(True)
		self.term[0].set_default_colors()
		self.term[0].set_color_background(white)
		self.term[0].set_color_foreground(black)
		self.term[0].set_color_bold(black)
		self.term[0].set_scroll_on_output(True)
		
		#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
		
		
		self.term[0].fork_command('python')
						
		#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 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=gtk.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(gtk.FALSE, 0)
		equis = gtk.Image()
		equis.set_from_stock(gtk.STOCK_CLOSE,gtk.ICON_SIZE_MENU)
		box1.pack_start(equis, gtk.FALSE, gtk.FALSE, 0)
		self.closebutton.add(box1)
		box2 = gtk.HBox(gtk.FALSE, 0)
		box2.pack_start(self.label, gtk.FALSE, gtk.FALSE, 0)
		box2.pack_start(self.closebutton, gtk.FALSE, gtk.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(white)
		self.term[ultima].set_color_foreground(black)
		self.term[ultima].set_color_bold(black)
		self.term[ultima].fork_command('python')
	
		#Set default font managed by pango
		font=pango.FontDescription()
		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
		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=gtk.TRUE)
						
		#Charge self.server to global again (nautilus can need it)
	
	
	def close_vte(self,widget,ultima):
		
	#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=gtk.FALSE)
			self.tabs = self.tabs-1
						
			#Remove data from tabs list
			del self.data_tabs[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 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:

			self.popmenu2=gtk.Menu()
	
#	<menuitem action='Copy'/>
#	<menuitem action='Paste'/>	
			menu_string = """<ui>
            <popup name='Popup'>
                <menuitem action='Open'/>
				<menuitem action='About'/>
            </popup>
            </ui>"""

		
			actg = gtk.ActionGroup('WindowActions')
				
			actions = [('Open', gtk.STOCK_OPEN, _("Open with Nautilus"), '<control>O','Create a new file', self.on_open_with_nautilus1_activate),
			('About', gtk.STOCK_ABOUT, _("About Gnome-Sshman"), '<control>O','Open a file', self.go_about),
			('Copy', gtk.STOCK_COPY, _("Copy"), '<control>c','Copy', self.term_copy),
			('Paste', gtk.STOCK_PASTE, _("Paste"), '<control>v','Paste', self.term_paste),
			]
			
			self.terminal=terminal
			actg.add_actions(actions)
			menuui = gtk.UIManager()
			menuui.insert_action_group(actg, 0)
			menuui.add_ui_from_string(menu_string)
			self.popmenu2 = menuui.get_widget("/Popup")

	#Nautilus menu option is insensitive
			self.popmenu2.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=gtk.FALSE)
			self.tabs = self.tabs-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()
			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+"/root")
			else:
				os.system("nautilus sftp://"+user+"@"+server+"/home/"+user)
		
		else:
			pass

	def on_salir1_activate(self, widget):
		
		#First, destroy main widget (for correct communication with main window) 
		#and then, quit
		self.main_widget.destroy()
		gtk.main_quit()
		

	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(gtk.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(gtk.TRUE)
		elif self.keyring_pass == "":
			self.key_okbutton.set_sensitive(gtk.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(gtk.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(gtk.FALSE)
		
		#If save session = yes, the password can be saved

		if self.save_log =="yes":
	
			self.checkbutton3.set_sensitive(gtk.TRUE)
	
#If not exists keyring master file, can not save passwords
				
		if not exists (self.master_key_file):
			self.checkbutton3.set_sensitive(gtk.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(gtk.TRUE)
		elif self.password == "":
			self.ask_okbutton.set_sensitive(gtk.FALSE)	

#Change save password status when keyring created
		if self.save_log =="yes":
			if exists (self.master_key_file):
				self.checkbutton3.set_sensitive(gtk.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"
				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"
				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"
				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(gtk.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(gtk.TRUE)
		elif self.keyring_pass == "":
			self.okbutton.set_sensitive(gtk.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()

main()
