# -*- coding: UTF-8 -*-
# -*- python -*-
# Copyright (C) 2005 by Sebastien Estienne
#
# This file may be distributed and/or modified under the terms of
# the GNU General Public License version 2 as published by
# the Free Software Foundation.
# This file is distributed without any warranty; without even the implied
# warranty of merchantability or fitness for a particular purpose.
# See "COPYING" in the source distribution for more information.
#
# $id$
#

from sdapplet.pluginutils import *

try:
    import gettext
    gettext.bindtextdomain("service-discovery-applet", "/usr/share/locale")
    gettext.textdomain("service-discovery-applet")
    _ = gettext.gettext
    import pygtk
    pygtk.require('2.0')
    import gtk
    import os
    import pwd
    import subprocess
    import gnome
except ImportError, e:
    error_msg(_("A required python module is missing!\n%s") % (e))
    sys.exit()

class plugin_gnometerminal:
    def __init__(self):
        self.service_type = ["_ssh._tcp", "_sftp-ssh._tcp" ]
        self.author = "Sébastien Estienne"

    def enter_callback(self, widget, win):
        win.response(gtk.RESPONSE_OK)

    def SshLogin(self, hostname, username = None):
        self.win = gtk.Dialog(_("SSH Connection"), None,
                              gtk.DIALOG_MODAL,
                              (gtk.STOCK_OK, gtk.RESPONSE_OK,
                               gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL))

        vbox = gtk.VBox(False, 5)
        self.win.vbox.pack_start(vbox, True, True, 0)
        vbox.set_border_width(5)
    
        label = gtk.Label()
        label.set_markup(_("Connecting to <b>%s</b>.\nPlease enter your <b>login</b>:") % (hostname))
        
        vbox.pack_start(label, False, False, 0)
    
        # Create our entry
        entry = gtk.Entry()
        if username!= None:
            entry.set_text(username)
        entry.connect("activate", self.enter_callback, self.win)
        vbox.pack_start(entry, False, False, 0)
    
        # Create the completion object
        completion = gtk.EntryCompletion()
    
        # Assign the completion to the entry
        entry.set_completion(completion)
    
        # Create a tree model and use it as the completion model
        completion_model = self.__create_completion_model()
        completion.set_model(completion_model)
    
        # Use model column 0 as the text column
        completion.set_text_column(0)
    
        self.win.show_all()
        if self.win.run() == gtk.RESPONSE_OK:
            self.win.destroy()
            return entry.get_text()
        else:
            self.win.destroy()
            return None
    
    def __create_completion_model(self):
        ''' Creates a tree model containing the completions.
        '''
        store = gtk.ListStore(str)
        
        iter = store.append()
        store.set(iter, 0, "root")
    
        current_user = pwd.getpwuid(os.getuid())[0]
        iter = store.append()
        store.set(iter, 0, current_user)
    
        return store

    def connect(self, use_host_names, name, stype, hostname, address, port, txts):
        if use_host_names == True:
            address = hostname
        print "connecting using gnometerminal"
        if txts.has_key("u"):
            username = self.SshLogin(name, txts["u"])
        else:
            username = self.SshLogin(name)


        if stype == "_ssh._tcp":
            scheme = "ssh"
        else:
            scheme = "sftp"
        if username == None:
            return
        elif username != "":
            sshline = "%s -p %i %s@%s" % (scheme, port, username, address)
        else:
            sshline = "%s -p %i %s " % (scheme, port, address)

        cmdline = []
        cmdline.append("gnome-terminal")
        cmdline.append("--tab")
        cmdline.append("-t %s" % name)
        cmdline.append("-e %s" % sshline)
        print cmdline
        pid = subprocess.Popen(cmdline).pid
        
def load():
    return plugin_gnometerminal()