def __init__(self):
     super(TerminalExporter, self).__init__()
     self.config = Config()
     self.plugin_config = parse_plugin_config(self.config)
     self.logging_terminals = {}
     self.scrollback_lines = self.config['scrollback_lines']
     dbg('using config: %s' % self.plugin_config)

 def __init__(self):
     plugin.MenuItem.__init__(self)
     self.config = Config()
     self.pluginConfig = parsePluginConfig(self.config)
     self.loggingTerminals = {}
     self.scrollbackLines = self.config['scrollback_lines']
     dbg("using config: %s" % self.pluginConfig)

    def get_last_line(self, terminal):
        """Retrieve last line of terminal (contains '[email protected]')"""
        ret=None
        vte = terminal.get_vte()

        cursor = vte.get_cursor_position()
        column_count = vte.get_column_count()
        row_position = cursor[1]
        
        start_row = row_position
        start_col = 0
        end_row = row_position
        end_col = column_count
        is_interesting_char = lambda a, b, c, d: True

        """ manage text wrapping :
        usecases :
        - PS1 too long
        - componant of PS1 forcing display on several lines (e.g working directory)
        - window resizing
        - ...
        So, very ugly algorithm
        if current line too short, we assume prompt is wrapped
        we the search for 1st line of prompt, that is : first line following the
        last line containing LF
        we iterate back until LF found (means : end of output of last command), 
        then forward one line
        """
        lines= vte.get_text_range(start_row, start_col, end_row, end_col, is_interesting_char)

        if lines and lines[0]:
            # line too short, iterate back
            if len(lines)<=self.prompt_minlen:
                dbg("line below prompt min size of "+str(self.prompt_minlen)+ " chars : must iterate back '"+lines+"'")
                start_row=start_row-1
                end_row=start_row
                lines = vte.get_text_range(start_row, start_col, end_row, end_col, is_interesting_char)
                prev_lines=lines
                # we iterate back to first line of terminal, including history...
                while lines != None and start_row>=0:
                    # LF found, PS1 first line is next line... eeeer previous pushed line
                    if lines[len(lines)-1] == '\n':
                        lines=prev_lines
                        break
                    
                    lines = vte.get_text_range(start_row, start_col, end_row, end_col, is_interesting_char)
                    start_row=start_row-1
                    end_row=start_row                        
                    prev_lines=lines
                    
        lines=lines.splitlines()
        if lines and lines[0]:
            if len(lines[0])>=self.line_minlen:
                ret=lines[0]
            else:
                # should never happen since we browse back in history
                dbg("line '"+lines[0]+"' too short, won't use : "+str(len(lines[0])))
        
        return ret

 def set_cwd(self, cwd=None):
     if cwd is None:
         cwd = self.terminal.get_cwd()
     if cwd == self.cwd:
         return
     self.cwd = cwd
     cwd = self.clisnips.SetWorkingDirectory(cwd)
     dbg('clisnips.SetWorkingDirectory "%s"' % cwd)

 def watch(self, _widget, terminal):
     """Watch a terminal"""
     vte = terminal.get_vte()
     self.watches[terminal] = vte.connect('contents-changed',
                                          self.reset_timer, terminal)
     timeout_id = gobject.timeout_add(5000, self.check_times, terminal)
     self.timers[terminal] = timeout_id
     dbg('timer %s added for %s' %(timeout_id, terminal))

def spawn(env):
  PythonConsoleServer.env = env
  tcpserver = SocketServer.TCPServer(('127.0.0.1', 0), PythonConsoleServer)
  dbg("debugserver: listening on %s" % str(tcpserver.server_address))
  debugserver = threading.Thread(target=tcpserver.serve_forever, name="DebugServer")
  debugserver.setDaemon(True)
  debugserver.start()
  return(debugserver, tcpserver)

 def on_resize(self, widget, allocation):
     # current = self.term.vte.get_font()
     config = pango.FontDescription(self.term.config['font'])
     # dbg(current.get_size())
     dbg(config.get_size())
     dbg(allocation)
     if allocation.width < 600 or allocation.height < 400:
         config.set_size(int(config.get_size() * 0.85))
     self.term.set_font(config)

 def on_terminal_key_pressed(self, vt, event):
     kv = event.keyval
     if kv in (gtk.keysyms.Return, gtk.keysyms.KP_Enter):
         # Although we registered the emission hook on vte.Terminal,
         # the event is also fired by terminatorlib.window.Window ...
         if isinstance(vt, vte.Terminal):
             dbg('CliSnipsMenu :: Enter pressed %s' % vt)
             self.on_keypress_enter()
     return True

 def callback(self, menuitems, menu, terminal):
     """Add our menu item to the menu"""
     item = gtk.CheckMenuItem(_("Watch for _silence"))
     item.set_active(self.watches.has_key(terminal))
     if item.get_active():
         item.connect("activate", self.unwatch, terminal)
     else:
         item.connect("activate", self.watch, terminal)
     menuitems.append(item)
     dbg('Menu items appended')

 def callback(self, menuitems, menu, terminal):
     """Add our menu items to the menu"""
     if not self.watches.has_key(terminal):
         item = gtk.MenuItem(_("Watch for silence"))
         item.connect("activate", self.watch, terminal)
     else:
         item = gtk.MenuItem(_("Stop watching for silence"))
         item.connect("activate", self.unwatch, terminal)
     menuitems.append(item)
     dbg('Menu items appended')

 def callback(self, menuitems, menu, terminal):
     """Add our menu item to the menu"""
     item = Gtk.CheckMenuItem.new_with_mnemonic(_('Watch for _activity'))
     item.set_active(self.watches.has_key(terminal))
     if item.get_active():
         item.connect("activate", self.unwatch, terminal)
     else:
         item.connect("activate", self.watch, terminal)
     menuitems.append(item)
     dbg('Menu item appended')

 def tryAddLayoutMenuItem(self, name, terminal, menu):
     (isLayout, shortname) = self.tryGetLayoutShortName(name)
     if isLayout:
         layoutItem = gtk.MenuItem(_(shortname))
         layoutItem.connect(EVENT_ACTIVATE, self.loadCallback, terminal)
         menu.append(layoutItem)
         return True
     else:
         dbg("ignoring [%s] : %s" % (name, shortname))
         return False               

 def writeXmlToFile (self, element, filename = None):
     if filename is None:
         newFilename = inputBox(title=SAVE_BOX_TITLE, message=SAVE_BOX_MESSAGE, default_text="")
         if not (newFilename is None or newFilename == ""):
             self.writeXmlToFile(element, newFilename)
         else:
             dbg("no filename provided; abort saving")
     else:           
         targetFileName = join(self.configDir,filename)
         targetFileName = targetFileName + LAYOUT_EXTENSION
         ET.ElementTree(element).write(targetFileName)

    def write_xml_to_file(self, element, filename=None):
        if filename is None:
            new_filename = input_box(title=SAVE_BOX_TITLE,
                                     message=SAVE_BOX_MESSAGE, default_text="")
            if not (new_filename is None or new_filename == ""):
                return self.write_xml_to_file(element, new_filename)
            else:
                dbg('no filename provided; abort saving')
                return

        target_filename = join(self.config_dir, filename)
        target_filename += LAYOUT_EXTENSION
        ElementTree.ElementTree(element).write(target_filename)

 def try_add_layout_menu_item(self, name, terminal, menu):
     """
     Checks if given file is a layout and add a context menu item if so.
     @param name: The file name of the possible layout.
     @param terminal: The terminal this context menu item belongs to.
     @param menu: Full gtk menu instance; not used here.
     """
     is_layout, short_name = self.try_get_layout_short_name(name)
     if is_layout:
         layout_item = gtk.MenuItem(short_name)
         layout_item.connect(EVENT_ACTIVATE, self.load_callback, terminal)
         menu.append(layout_item)
         return True
     dbg('ignoring [%s] : %s' % (name, short_name))
     return False

    def check_times(self, terminal):
        """Check if this terminal has gone silent"""
        time_now = time.mktime(time.gmtime())
        if not self.last_activities.has_key(terminal):
            dbg('Terminal %s has no last activity' % terminal)
            return True

        dbg('seconds since last activity: %f (%s)' % (time_now - self.last_activities[terminal], terminal))
        if time_now - self.last_activities[terminal] >= 10.0:
            del(self.last_activities[terminal])
            note = pynotify.Notification('Terminator', 'Silence in: %s' % 
                                         terminal.get_window_title(), 'terminator')
            note.show()

        return True

 def doExport(self, widget, terminal):
     """
     Export complete terminal content into file.
     """
     vte = terminal.get_vte()
     (startRow, endRow, endColumn) = self.getVteBufferRange(vte)
     content = vte.get_text_range(startRow, 0, endRow, endColumn, 
                                 lambda widget, col, row, junk: True)
     filename = self.getFilename()
     with open(filename, "w") as outputFile: 
         outputFile.writelines(content)
         outputFile.close()
     dbg("terminal content written to [%s]" % filename)
     if self.pluginConfig[SETTING_EXPORT_ENV] != "":
         terminal.feed('%s="%s"\n' % (self.pluginConfig[SETTING_EXPORT_ENV] ,filename))
     return filename

 def tryAddLayoutMenuItem(self, name, terminal, menu):
     """
     Checks if given file is a layout and add a context menu item if so.
     @param name: The file name of the possible layout.
     @param terminal: The terminal this context menu item belongs to.
     @param menu: Full gtk menu instance; not used here.
     """
     isLayout, shortname = self.tryGetLayoutShortName(name)
     if isLayout:
         layoutItem = gtk.MenuItem(_(shortname))
         layoutItem.connect(EVENT_ACTIVATE, self.loadCallback, terminal)
         menu.append(layoutItem)
         return True
     else:
         dbg("ignoring [%s] : %s" % (name, shortname))
         return False

    def check_host(self, _vte, terminal):
        """Our host might have changed..."""
        self.update_watches()

        last_line = self.get_last_line(terminal)
        

        if last_line:
            patterns = self.get_patterns()
            for profile, pattern in patterns.iteritems():
                match = re.match(pattern, last_line)
                if match:
                    if profile in self.profiles and profile != terminal.get_profile():
                        dbg("switching to profile : "+profile)
                        terminal.set_profile(None, profile, False)
        return True

 def do_export(self, _, terminal):
     """
     Export complete terminal content into file.
     """
     vte = terminal.get_vte()
     (start_row, end_row, end_column) = self.get_vte_buffer_range(vte)
     content = vte.get_text_range(start_row, 0, end_row, end_column,
                                  lambda widget, col, row, junk: True)
     filename = self.get_filename()
     with open(filename, "w") as output_file:
         output_file.writelines(content)
         output_file.close()
     dbg('terminal content written to [%s]' % filename)
     if self.plugin_config[SETTING_EXPORT_ENV] != '':
         terminal.feed('%s="%s"\n' % (self.plugin_config[SETTING_EXPORT_ENV], filename))
     return filename