Ubuntu-fr

Gilou_

Screenlet terminal en python

Bonjour à tous

J'ai installé récemment un screenlet en python sous ubuntu qui permet d'afficher un terminal (sur le bureau).

Je voudrais juste ajouter une ligne de commande qui s'execute au démarrage de celui-ci.
Le but étant de me connecter à mon serveur en ssh au démarrage de celui-ci. Donc soit de mettre directement la commande, soit d'executer un petit script.

J'ai teste de rajouter un self.terminal.write("ma commande") mais ça ne fonctionne pas.
J'ai aussi essaye de passer la commande en paramètres dnas le command_fork()

Je n'ai jamais fait de python (:cry:) et j'ai un peu de mal.

Merci de votre aide

Voici le code du screenlet :

#!/usr/bin/env python

import screenlets
from screenlets.options import BoolOption, StringOption, FloatOption, IntOption, ColorOption, FileOption
import gobject
import gtk
import cairo
import vte
import gconf


class TerminalScreenlet (screenlets.Screenlet):
   """A Terminal Screenlet"""
   __name__ = 'TerminalScreenlet'
   __version__ = '0.1.7'
   __author__ = 'spdf'
   __desc__ = __doc__
   __timeout__ = None 


   # GConf Profile dir for gnome-terminal
   GCONF_PROFILE_DIR = "/apps/gnome-terminal/profiles/Default"
   gconf_client = gconf.client_get_default() 

   transparent = True
   vte_transparent = True
   background = '' 
   use_back = False
   trans_value = 0.5 
   vte_trans_value = 0.5
   border_width = 1 
   border_color = [1.0, 1.0, 1.0, 1.0]
   foreground_color = [1.0, 1.0, 1.0, 1.0]
   background_color = [0, 0, 0, 1.0]
   font_name = ''
   term_width = 640
   term_height = 300 
   use_gconf_cols = False

   def __init__ (self, **keyword_args):
      # Create screenlet
      screenlets.Screenlet.__init__(self, is_widget=False, width=640, height=300, uses_theme=False, **keyword_args)

      # prep gconf
      self.gconf_client.add_dir(self.GCONF_PROFILE_DIR, gconf.CLIENT_PRELOAD_RECURSIVE) 
      self.gconf_client.notify_add(self.GCONF_PROFILE_DIR, self.on_gconf_notification)

      # Options
      self.add_options_group('Options', 'Terminal Options')
      self.add_option(BoolOption('Options','transparent', self.transparent, 'Transparent Screenlet', '')) 
      self.add_option(FloatOption('Options','trans_value', self.trans_value,'Amount', '', min=0.1, max=1.0, increment=0.1,digits=2))
      self.add_option(BoolOption('Options','vte_transparent', self.vte_transparent, 'Transparent Terminal', ''))
      self.add_option(FloatOption('Options','vte_trans_value', self.vte_trans_value,'Amount', '', min=0, max=1.0, increment=0.1,digits=2))
      self.add_option(BoolOption('Options','use_back', self.use_back, 'Use Background', '')) 
      self.add_option(StringOption('Options','background',self.background,'Path to Image','Full path to image file'))

      # Colours
      self.add_options_group('Colours', 'Terminal Colours')
      self.add_option(ColorOption('Colours','border_color', self.border_color, 'Border Colour',''))
      self.add_option(ColorOption('Colours','foreground_color', self.foreground_color, 'Foreground Colour',''))
      self.add_option(ColorOption('Colours','background_color', self.background_color, 'Background Colour',''))
      self.add_option(BoolOption('Colours','use_gconf_cols', self.use_gconf_cols, 'Use gconf palette settings','Uses palette from default gnome-terminal profile')) 

      # Sizing
      self.add_options_group('Sizing', 'Sizing/Border Options')
      self.add_option(IntOption('Sizing','term_width', self.term_width,'Width','',min=20, max=2000,increment=10))
      self.add_option(IntOption('Sizing','term_height', self.term_height,'Height','',min=20, max=2000,increment=10)) 
      self.add_option(IntOption('Sizing','border_width', self.border_width, 'Border Width','',min=0,max=25))

      # Fonts 
      self.add_options_group('Fonts', 'Font Options')
      self.add_option(StringOption('Fonts','font_name',self.font_name,'Font String',''))

      # Terminal
      self.vbox = gtk.VBox()
      self.terminal = vte.Terminal()
      self.vbox.add(self.terminal)
      self.vbox.set_size_request(self.width,self.height)
      self.window.add (self.vbox)
      self.vbox.show_all()
      self.vbox.set_border_width(self.border_width)

      # Signal connect
      self.terminal.connect ("child-exited", lambda term: term.fork_command())
      self.terminal.connect ("popup-menu", self.on_vte_popup_menu)
      self.terminal.connect ("button-press-event", self.on_vte_button_press) 


      # Start the terminal
      self.terminal.fork_command()

   def on_gconf_notification(self, client, conn_id, entry, value):
      self.vte_set_colours()

   def gconf_get_str(self, key, default = ""):
      val = self.gconf_client.get(key)
      if val is not None and val.type == gconf.VALUE_STRING:
         return val.get_string()
      else:
         return default 

   def show_font_dialog (self):
      font_sel = gtk.FontSelectionDialog("Select a Font - Cancel sets default system font")
      font_sel.set_font_name(self.font_name)
      resp = font_sel.run()
      if (resp == gtk.RESPONSE_OK):
         # Apply
         self.font_name = font_sel.get_font_name()
      elif (resp == gtk.RESPONSE_CANCEL):
         # Defaults to system specified font
         self.font_name = ''
      font_sel.destroy() 

   def vte_set_background_image (self):
      if (self.use_back):
         try: self.terminal.set_background_image_file(self.background)
         except: pass
      else:
         try: self.terminal.set_background_image_file("")
         except: pass 

   def vte_set_opacity (self, value):
      opacity = int(value * 65535)
      self.terminal.set_opacity(opacity) 

      # background colour has to change (even slightly) for this to have any effect without restart, this is the workaround. 
      self.terminal.set_colors(gtk.gdk.color_parse ("#ABCDEF"), gtk.gdk.color_parse ("#ABCDEF"), [])
      self.vte_set_colours()

   def vte_set_font (self, value):
      try: self.terminal.set_font_from_string(value)
      except: pass

   def vte_set_colours (self):
      if (self.use_gconf_cols):
         # Get palette from gconf, create list of gdk.Colors
         palette = self.gconf_get_str(self.GCONF_PROFILE_DIR + "/palette", "")
         gdk_palette = [] 
         for col in palette.split(':'):
            newcol = gtk.gdk.color_parse(col)
            gdk_palette.append(newcol)
         fg_colour = self.gconf_get_str(self.GCONF_PROFILE_DIR + "/foreground_color", "#FFFFFF")
         bg_colour = self.gconf_get_str(self.GCONF_PROFILE_DIR + "/background_color", "#000000")
         self.terminal.set_colors(gtk.gdk.color_parse (fg_colour), gtk.gdk.color_parse (bg_colour), gdk_palette)
      else:
         fg_colour = gtk.gdk.Color(int(self.foreground_color[0] * 65535), int(self.foreground_color[1] * 65535), int(self.foreground_color[2] * 65535))
         bg_colour = gtk.gdk.Color(int(self.background_color[0] * 65535), int(self.background_color[1] * 65535), int(self.background_color[2] * 65535))
         self.terminal.set_colors(fg_colour, bg_colour, [])

   def on_init(self):
      self.add_default_menuitems()
      if (self.use_back):
         self.vte_set_background_image()
      if (self.transparent):
         self.window.set_opacity(self.trans_value)
      if (self.vte_transparent):
         self.vte_set_opacity(self.vte_trans_value)

   def on_draw (self, ctx):
      ctx.scale(self.scale, self.scale)
      ctx.save()
      ctx.rectangle(0,0,self.width,self.height)
      ctx.set_source_rgba(self.border_color[0], self.border_color[1], self.border_color[2], 1.0)
      ctx.fill()
      ctx.restore()

   def on_draw_shape (self, ctx):
      self.on_draw(ctx)

   def on_vte_popup_menu(self, term):
      self.do_popup()

   def on_vte_button_press(self, term, event):
      if event.button == 3:
         self.do_popup(event)
         return True 

   def do_popup(self, event = None):
      menu = self.create_popup_menu()
      if event is not None:
         menu.popup(None, None, None, event.button, event.time)
      else:
         menu.popup(None, None, None, 0, gtk.get_current_event_time())
         menu.select_first(False)        

   def create_popup_menu(self):
      menu = gtk.Menu()

      item = gtk.ImageMenuItem(gtk.STOCK_COPY)
      item.connect("activate", lambda menu_item: self.terminal.copy_clipboard())
      item.set_sensitive(self.terminal.get_has_selection())
      menu.append(item)

      item = gtk.ImageMenuItem(gtk.STOCK_PASTE)
      item.connect("activate", lambda menu_item: self.terminal.paste_clipboard())
      menu.append(item)

      item = gtk.SeparatorMenuItem()
      menu.append(item)
 
      item = gtk.ImageMenuItem(gtk.STOCK_PROPERTIES)
      item.connect("activate", lambda menu_item: self.show_settings_dialog())
      menu.append(item)
        
      item = gtk.SeparatorMenuItem()
      menu.append(item)
      
      item = gtk.ImageMenuItem(gtk.STOCK_SELECT_FONT)
      item.connect("activate", lambda menu_item: self.show_font_dialog())
      menu.append(item)

      menu.show_all()
      return menu

   def __setattr__ (self, name, value):
      screenlets.Screenlet.__setattr__ (self, name, value)
      if name == 'transparent':
         if (value):
            self.window.set_opacity(self.trans_value)
         else:
            self.window.set_opacity(1)
      if name == 'vte_transparent':
         if (value):
            self.vte_set_opacity(self.vte_trans_value)
         else:
            self.vte_set_opacity(1)
      elif name == 'use_back':
         self.vte_set_background_image()
      elif name == 'background':
         self.vte_set_background_image()
      elif name == 'trans_value':
         if (self.transparent):
            self.window.set_opacity(self.trans_value)
      elif name == 'vte_trans_value':
         if (self.vte_transparent):
            self.vte_set_opacity(self.vte_trans_value)
      elif name == 'scale':
         self.window.set_size_request(int(self.term_width*value),int(self.term_height*value))
      elif name == 'border_width':
         self.vbox.set_border_width(value)
      elif (name == 'term_width'):
         self.width = value 
         self.window.set_size_request(int(self.width*self.scale),int(self.height*self.scale))
      elif (name == 'term_height'):
         self.height = value 
         self.window.set_size_request(int(self.width*self.scale),int(self.height*self.scale))
      elif name == 'border_color':
         self.redraw_canvas()
      elif name == 'background_color':
         self.vte_set_colours()
      elif name == 'foreground_color':
         self.vte_set_colours()
      elif name == 'font_name':
         self.vte_set_font(value)
      elif name == 'use_gconf_cols':
         self.vte_set_colours()
           

if __name__ == "__main__":
   #Create screenlet session
   import screenlets.session
   screenlets.session.create_session(TerminalScreenlet)