terminator/terminator

1378 lines
45 KiB
Plaintext
Raw Normal View History

#!/usr/bin/python
2007-07-28 01:33:48 +00:00
# Terminator - multiple gnome terminals in one window
2008-02-08 10:20:48 +00:00
# Copyright (C) 2006-2008 cmsj@tenshu.net
2007-07-28 01:33:48 +00:00
#
# 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, version 2 only.
#
# 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
"""Terminator by Chris Jones <cmsj@tenshu.net>"""
2008-03-29 01:36:23 +00:00
# Global defines
APP_NAME = 'terminator'
APP_VERSION = '0.9'
# import standard python libs
import os, platform, sys, string, time, math
from optparse import OptionParser
try:
import gettext
gettext.install (APP_NAME)
except:
def _ (text):
return text
# import unix-lib
2007-08-26 23:24:32 +00:00
import pwd
2008-03-06 20:00:08 +00:00
TARGET_TYPE_VTE = 8
2008-04-02 21:10:32 +00:00
# import our configuration loader
from terminatorlib import config
from terminatorlib.config import dbg
#import encoding list
from terminatorlib.encoding import TerminatorEncoding
# Sort out cwd detection code, if available
pid_get_cwd = lambda pid: None
if platform.system() == 'FreeBSD':
try:
from terminatorlib import freebsd
pid_get_cwd = lambda pid: freebsd.get_process_cwd(pid)
except:
pass
elif platform.system == 'Linux':
pid_get_cwd = lambda pid: os.path.realpath ('/proc/%s/cwd' % pid)
# import gtk libs
# check just in case anyone runs it on a non-gnome system.
try:
import gobject, gtk, pango
except:
print >> sys.stderr, _("You need to install the python bindings for " \
"gobject, gtk and pango to run Terminator.")
sys.exit(1)
# import a library for viewing URLs
try:
# gnome.url_show() is really useful
import gnome
url_show = gnome.url_show
except:
# webbrowser.open() is not really useful, but will do as a fallback
import webbrowser
url_show = webbrowser.open
# import vte-bindings
try:
import vte
except:
error = gtk.MessageDialog (None, gtk.DIALOG_MODAL, gtk.MESSAGE_ERROR, gtk.BUTTONS_OK,
_('You need to install python bindings for libvte ("python-vte" in debian/ubuntu)'))
error.run()
sys.exit (1)
def openurl (url):
try:
url_show (url)
except:
pass
class TerminatorTerm (gtk.VBox):
matches = {}
def __init__ (self, terminator, profile = None, command = None, cwd = None):
gtk.VBox.__init__ (self)
self.terminator = terminator
2008-04-02 21:10:32 +00:00
self.conf = terminator.conf
self.command = command
self.cwd = cwd or os.getcwd();
if not os.path.exists(self.cwd) or not os.path.isdir(self.cwd):
self.cwd = pwd.getpwuid(os.getuid ())[5]
self.clipboard = gtk.clipboard_get (gtk.gdk.SELECTION_CLIPBOARD)
2008-04-02 21:10:32 +00:00
self.scrollbar_position = self.conf.scrollbar_position
self._vte = vte.Terminal ()
self._vte.set_size (80, 24)
self.reconfigure_vte ()
self._vte.show ()
self._termbox = gtk.HBox ()
self._termbox.show()
self._title = gtk.Label()
2008-03-02 12:44:08 +00:00
self._title.show()
self._titlebox = gtk.EventBox()
self._titlebox.add(self._title)
self.show()
self.pack_start(self._titlebox, False)
self.pack_start(self._termbox)
if len(self.terminator.term_list) > 0 and self.conf.titlebars:
if len(self.terminator.term_list) == 1:
self.terminator.term_list[0]._titlebox.show()
self._titlebox.show()
else:
self._titlebox.hide()
2008-04-02 21:10:32 +00:00
self._scrollbar = gtk.VScrollbar (self._vte.get_adjustment ())
if self.scrollbar_position != "hidden" and self.scrollbar_position != "disabled":
self._scrollbar.show ()
if self.scrollbar_position == 'right':
packfunc = self._termbox.pack_start
else:
packfunc = self._termbox.pack_end
packfunc (self._vte)
packfunc (self._scrollbar, False)
2008-03-02 13:17:56 +00:00
self._vte.connect ("key-press-event", self.on_vte_key_press)
self._vte.connect ("button-press-event", self.on_vte_button_press)
self._vte.connect ("popup-menu", self.on_vte_popup_menu)
2008-02-24 20:42:08 +00:00
"""drag and drop"""
2008-03-07 12:09:59 +00:00
srcvtetargets = [ ( "vte", gtk.TARGET_SAME_APP, TARGET_TYPE_VTE ) ]
dsttargets = [ ( "vte", gtk.TARGET_SAME_APP, TARGET_TYPE_VTE ), ('text/plain', 0, 0) , ("STRING", 0, 0), ("COMPOUND_TEXT", 0, 0)]
self._vte.drag_source_set( gtk.gdk.CONTROL_MASK | gtk.gdk.BUTTON3_MASK, srcvtetargets, gtk.gdk.ACTION_MOVE)
self._titlebox.drag_source_set( gtk.gdk.BUTTON1_MASK, srcvtetargets, gtk.gdk.ACTION_MOVE)
#self._vte.drag_dest_set(gtk.DEST_DEFAULT_MOTION | gtk.DEST_DEFAULT_HIGHLIGHT |gtk.DEST_DEFAULT_DROP ,dsttargets, gtk.gdk.ACTION_MOVE)
self._vte.drag_dest_set(gtk.DEST_DEFAULT_MOTION | gtk.DEST_DEFAULT_HIGHLIGHT |gtk.DEST_DEFAULT_DROP ,dsttargets, gtk.gdk.ACTION_MOVE)
2008-03-06 20:00:08 +00:00
self._vte.connect("drag-begin", self.on_drag_begin, self)
self._titlebox.connect("drag-begin", self.on_drag_begin, self)
2008-02-24 20:42:08 +00:00
self._vte.connect("drag-data-get", self.on_drag_data_get, self)
self._titlebox.connect("drag-data-get", self.on_drag_data_get, self)
#for testing purpose: drag-motion
self._vte.connect("drag-motion", self.on_drag_motion, self)
2008-02-24 20:42:08 +00:00
self._vte.connect("drag-data-received", self.on_drag_data_received, self)
2008-02-26 18:30:21 +00:00
self._vte.connect ("composited-changed", self.on_composited_changed)
self._vte.connect ("window-title-changed", self.on_vte_title_change)
self._vte.connect ("grab-focus", self.on_vte_focus)
2008-03-02 12:44:08 +00:00
self._vte.connect ("focus-out-event", self.on_vte_focus_out)
self._vte.connect ("focus-in-event", self.on_vte_focus_in)
2008-04-02 21:10:32 +00:00
exit_action = self.conf.exit_action
2007-11-09 05:58:47 +00:00
if exit_action == "restart":
self._vte.connect ("child-exited", self.spawn_child)
# We need to support "left" because some buggy versions of gnome-terminal
# set it in some situations
elif exit_action in ("close", "left"):
self._vte.connect ("child-exited", lambda close_term: self.terminator.closeterm (self))
self._vte.add_events (gtk.gdk.ENTER_NOTIFY_MASK)
self._vte.connect ("enter_notify_event", self.on_vte_notify_enter)
self.add_matches()
env_proxy = os.getenv ('http_proxy')
2008-05-19 22:05:10 +00:00
if not env_proxy and self.conf.http_proxy:
os.putenv ('http_proxy', self.conf.http_proxy)
os.putenv ('COLORTERM', 'gnome-terminal')
2008-03-06 20:00:08 +00:00
def on_drag_begin(self, widget, drag_context, data):
if os.path.exists("/usr/share/icons/hicolor/48x48/apps/terminator.png"):
widget.drag_source_set_icon_pixbuf( gtk.gdk.pixbuf_new_from_file("/usr/share/icons/hicolor/48x48/apps/terminator.png"))
2008-02-24 20:42:08 +00:00
def on_drag_data_get(self,widget, drag_context, selection_data, info, time, data):
print "Drag data get"
selection_data.set("vte",info, str(data.terminator.term_list.index (self)))
2008-03-06 20:00:08 +00:00
def on_drag_motion(self, widget, drag_context, x, y, time, data):
#print "Drag Motion on ",
2008-03-06 14:54:31 +00:00
"""
x-special/gnome-icon-list
text/uri-list
UTF8_STRING
COMPOUND_TEXT
TEXT
STRING
text/plain;charset=utf-8
text/plain;charset=UTF-8
text/plain
"""
#print "motion"
2008-03-06 14:54:31 +00:00
if 'text/plain' in drag_context.targets:
#copy text from another widget
return
2008-03-04 20:25:51 +00:00
srcwidget = drag_context.get_source_widget()
if (isinstance(srcwidget, gtk.EventBox) and srcwidget == self._titlebox) or widget == srcwidget:
2008-03-04 20:25:51 +00:00
#on self
return
2008-03-05 16:28:20 +00:00
2008-03-04 20:25:51 +00:00
alloc = widget.allocation
rect = gtk.gdk.Rectangle(0, 0, alloc.width, alloc.height)
widget.window.invalidate_rect(rect, True)
widget.window.process_updates(True)
2008-03-04 20:25:51 +00:00
context = widget.window.cairo_create()
if self.conf.use_theme_colors:
2008-03-04 20:25:51 +00:00
color = self._vte.get_style ().text[gtk.STATE_NORMAL]
else:
color = gtk.gdk.color_parse (self.conf.foreground_color)
2008-02-24 20:42:08 +00:00
2008-03-07 12:09:59 +00:00
context.set_source_rgba(color.red, color.green, color.blue, 0.5)
pos = self.get_location(widget, x, y)
2008-03-04 20:25:51 +00:00
topleft = (0,0)
topright = (alloc.width,0)
2008-03-05 16:28:20 +00:00
topmiddle = (alloc.width/2,0)
2008-03-04 20:25:51 +00:00
bottomleft = (0, alloc.height)
bottomright = (alloc.width,alloc.height)
2008-03-05 16:28:20 +00:00
bottommiddle = (alloc.width/2, alloc.height)
2008-03-04 20:25:51 +00:00
middle = (alloc.width/2, alloc.height/2)
2008-03-05 16:28:20 +00:00
middleleft = (0, alloc.height/2)
middleright = (alloc.width, alloc.height/2)
#print "%f %f %d %d" %(coef1, coef2, b1,b2)
2008-03-04 20:25:51 +00:00
coord = ()
2008-03-07 12:09:59 +00:00
if pos == "right":
2008-05-22 00:39:01 +00:00
coord = (topright, topmiddle, bottommiddle, bottomright)
2008-03-07 12:09:59 +00:00
if pos == "top":
2008-05-22 00:39:01 +00:00
coord = (topleft, topright, middleright , middleleft)
2008-03-07 12:09:59 +00:00
if pos == "left":
2008-05-22 00:39:01 +00:00
coord = (topleft, topmiddle, bottommiddle, bottomleft)
2008-03-07 12:09:59 +00:00
if pos == "bottom":
2008-05-22 00:39:01 +00:00
coord = (bottomleft, bottomright, middleright , middleleft)
2008-03-04 20:25:51 +00:00
if len(coord) > 0 :
2008-03-05 16:28:20 +00:00
context.move_to(coord[len(coord)-1][0],coord[len(coord)-1][1])
2008-03-04 20:25:51 +00:00
for i in coord:
context.line_to(i[0],i[1])
2008-03-04 20:25:51 +00:00
context.fill()
2008-02-24 20:42:08 +00:00
def on_drag_drop(self, widget, drag_context, x, y, time):
print "Drag Drop on",
parent = widget.get_parent()
print parent,
def on_drag_data_received(self, widget, drag_context, x, y, selection_data, info, time, data):
print "Drag Data Received on "
2008-03-06 14:54:31 +00:00
if selection_data.type == 'text/plain':
#copy text to destination
2008-03-06 20:00:08 +00:00
#print "%s %s" % (selection_data.type, selection_data.target)
2008-03-06 14:54:31 +00:00
txt = selection_data.data.strip()
if txt[0:7] == "file://":
2008-03-06 20:00:08 +00:00
txt = "'%s'" % txt[7:]
self._vte.feed_child(txt)
2008-03-06 14:54:31 +00:00
return
2008-03-06 20:00:08 +00:00
2008-02-24 20:42:08 +00:00
widgetsrc = data.terminator.term_list[int(selection_data.data)]
2008-03-04 20:25:51 +00:00
srcvte = drag_context.get_source_widget()
#check if computation requireds
2008-03-06 19:13:10 +00:00
if (isinstance(srcvte, gtk.EventBox) and srcvte == self._titlebox) or srcvte == widget:
print "on itself"
return
srchbox = widgetsrc
2008-03-04 20:25:51 +00:00
dsthbox = widget.get_parent().get_parent()
dstpaned = dsthbox.get_parent()
srcpaned = srchbox.get_parent()
if isinstance(dstpaned, gtk.Window) and isinstance(srcpaned, gtk.Window):
print "Only one terminal"
return
2008-03-07 12:09:59 +00:00
pos = self.get_location(widget, x, y)
data.terminator.remove(widgetsrc)
data.terminator.add(self, widgetsrc,pos)
return
def get_location(self, vte, x, y):
pos = ""
#get the diagonales function for the receiving widget
2008-03-07 12:09:59 +00:00
coef1 = float(vte.allocation.height)/float(vte.allocation.width)
coef2 = -float(vte.allocation.height)/float(vte.allocation.width)
2008-02-24 20:42:08 +00:00
b1 = 0
2008-03-07 12:09:59 +00:00
b2 = vte.allocation.height
#determine position in rectangle
"""
--------
|\ /|
| \ / |
| \/ |
| /\ |
| / \ |
|/ \|
--------
"""
2008-02-24 20:42:08 +00:00
if (x*coef1 + b1 > y ) and (x*coef2 + b2 < y ):
pos = "right"
if (x*coef1 + b1 > y ) and (x*coef2 + b2 > y ):
pos = "top"
if (x*coef1 + b1 < y ) and (x*coef2 + b2 > y ):
pos = "left"
if (x*coef1 + b1 < y ) and (x*coef2 + b2 < y ):
pos = "bottom"
2008-03-07 12:09:59 +00:00
return pos
def add_matches (self, lboundry="[[:<:]]", rboundry="[[:>:]]"):
userchars = "-A-Za-z0-9"
passchars = "-A-Za-z0-9,?;.:/!%$^*&~\"#'"
hostchars = "-A-Za-z0-9"
pathchars = "-A-Za-z0-9_$.+!*(),;:@&=?/~#%"
schemes = "(news:|telnet:|nntp:|file:/|https?:|ftps?:|webcal:)"
user = "[" + userchars + "]+(:[" + passchars + "]+)?"
urlpath = "/[" + pathchars + "]*[^]'.}>) \t\r\n,\\\"]"
2008-03-07 12:09:59 +00:00
self.matches['full_uri'] = self._vte.match_add(lboundry + schemes + "//(" + user + "@)?[" + hostchars +".]+(:[0-9]+)?(" + urlpath + ")?" + rboundry + "/?")
# FreeBSD works with [[:<:]], Linux works with \<
if self.matches['full_uri'] == -1:
if lboundry != "\\<":
self.add_matches(lboundry = "\\<", rboundry = "\\>")
else:
self.matches['addr_only'] = self._vte.match_add (lboundry + "(www|ftp)[" + hostchars + "]*\.[" + hostchars + ".]+(:[0-9]+)?(" + urlpath + ")?" + rboundry + "/?")
self.matches['email'] = self._vte.match_add (lboundry + "(mailto:)?[a-z0-9][a-z0-9.-]*@[a-z0-9][a-z0-9-]*(\.[a-z0-9][a-z0-9-]*)+" + rboundry)
self.matches['nntp'] = self._vte.match_add (lboundry + '''news:[-A-Z\^_a-z{|}~!"#$%&'()*+,./0-9;:=?`]+@[-A-Za-z0-9.]+(:[0-9]+)?''' + rboundry)
def spawn_child (self, event=None):
2008-04-02 21:10:32 +00:00
update_records = self.conf.update_records
login = self.conf.login_shell
args = []
shell = ''
if self.command:
args = self.command
shell = self.command[0]
2008-04-02 21:10:32 +00:00
elif self.conf.use_custom_command:
args = self.conf.custom_command.split ()
shell = args[0]
if not os.path.exists (shell):
shell = os.getenv ('SHELL') or ''
if not os.path.exists (shell):
shell = pwd.getpwuid (os.getuid ())[6] or ''
if not os.path.exists (shell):
for i in ['bash','zsh','tcsh','ksh','csh','sh']:
shell = '/usr/bin/%s'%i
if not os.path.exists (shell):
shell = '/bin/%s'%i
if not os.path.exists (shell):
continue
else:
break
else:
break;
if not os.path.exists (shell):
# Give up, we're completely stuck
print >> sys.stderr, _('Unable to find a shell')
gobject.timeout_add (100, self.terminator.closeterm, self)
return (-1)
if not args:
args.append (shell)
os.putenv ('WINDOWID', '%s'%self._vte.get_parent_window().xid)
self._pid = self._vte.fork_command (command = shell, argv = args, envv = [], directory=self.cwd, loglastlog = login, logwtmp = update_records, logutmp = update_records)
if self._pid == -1:
print >>sys.stderr, _('Unable to start shell: ') + shell
return (-1)
def get_cwd (self):
""" Return the current working directory of the subprocess.
This function requires OS specific behaviours
"""
return (pid_get_cwd(self._pid))
def reconfigure_vte (self):
# Set our emulation
2008-04-02 21:10:32 +00:00
self._vte.set_emulation (self.conf.emulation)
# Set our wordchars
2008-04-02 21:10:32 +00:00
self._vte.set_word_chars (self.conf.word_chars)
# Set our mouselation
2008-04-02 21:10:32 +00:00
self._vte.set_mouse_autohide (self.conf.mouse_autohide)
# Set our compatibility
2008-04-02 21:10:32 +00:00
backspace = self.conf.backspace_binding
delete = self.conf.delete_binding
# Note, each of the 4 following comments should replace the line beneath it, but the python-vte bindings don't appear to support this constant, so the magic values are being assumed from the C enum :/
if backspace == "ascii-del":
# backbind = vte.ERASE_ASCII_BACKSPACE
backbind = 2
else:
# backbind = vte.ERASE_AUTO_BACKSPACE
backbind = 1
if delete == "escape-sequence":
# delbind = vte.ERASE_DELETE_SEQUENCE
delbind = 3
else:
# delbind = vte.ERASE_AUTO
delbind = 0
self._vte.set_backspace_binding (backbind)
self._vte.set_delete_binding (delbind)
2008-04-02 21:10:32 +00:00
# Set our font
try:
2008-04-02 21:10:32 +00:00
self._vte.set_font (pango.FontDescription (self.conf.font))
except:
pass
# Set our boldness
2008-04-02 21:10:32 +00:00
self._vte.set_allow_bold (self.conf.allow_bold)
2008-04-02 21:10:32 +00:00
# Set our color scheme
palette = self.conf.palette
if self.conf.use_theme_colors:
fg_color = self._vte.get_style ().text[gtk.STATE_NORMAL]
bg_color = self._vte.get_style ().base[gtk.STATE_NORMAL]
2007-07-27 23:33:43 +00:00
else:
2008-04-02 21:10:32 +00:00
fg_color = gtk.gdk.color_parse (self.conf.foreground_color)
bg_color = gtk.gdk.color_parse (self.conf.background_color)
colors = palette.split (':')
palette = []
for color in colors:
if color:
palette.append (gtk.gdk.color_parse (color))
2007-07-27 23:33:43 +00:00
self._vte.set_colors (fg_color, bg_color, palette)
# Set our background image, transparency and type
# Many thanks to the authors of gnome-terminal, on which this code is based.
2008-04-02 21:10:32 +00:00
background_type = self.conf.background_type
# set background image settings
if background_type == "image":
2008-04-02 21:10:32 +00:00
self._vte.set_background_image_file (self.conf.background_image)
self._vte.set_scroll_background (self.conf.scroll_background)
else:
self._vte.set_background_image_file('')
self._vte.set_scroll_background(False)
# set transparency for the background (image)
if background_type in ("image", "transparent"):
self._vte.set_background_tint_color (bg_color)
2008-04-02 21:10:32 +00:00
self._vte.set_background_saturation(1 - (self.conf.background_darkness))
self._vte.set_opacity(int(self.conf.background_darkness * 65535))
else:
self._vte.set_background_saturation(1)
self._vte.set_opacity(65535)
if not self._vte.is_composited():
self._vte.set_background_transparent (background_type == "transparent")
else:
self._vte.set_background_transparent (False)
# Set our cursor blinkiness
2008-04-02 21:10:32 +00:00
self._vte.set_cursor_blinks = (self.conf.cursor_blink)
# Set our audible belliness
2008-04-02 21:10:32 +00:00
silent_bell = self.conf.silent_bell
self._vte.set_audible_bell = not silent_bell
self._vte.set_visible_bell = silent_bell
# Set our scrolliness
2008-04-02 21:10:32 +00:00
self._vte.set_scrollback_lines (self.conf.scrollback_lines)
self._vte.set_scroll_on_keystroke (self.conf.scroll_on_keystroke)
self._vte.set_scroll_on_output (self.conf.scroll_on_output)
2008-04-02 21:10:32 +00:00
if self.scrollbar_position != self.conf.scrollbar_position:
self.scrollbar_position = self.conf.scrollbar_position
2008-04-02 21:10:32 +00:00
if self.scrollbar_position == 'hidden' or self.scrollbar_position == 'disabled':
self._scrollbar.hide ()
else:
self._scrollbar.show ()
2008-04-07 22:50:01 +00:00
if self.scrollbar_position == 'right':
self._termbox.reorder_child (self._vte, 0)
elif self.scrollbar_position == 'left':
self._termbox.reorder_child (self._scrollbar, 0)
# Set our sloppiness
2008-04-02 21:10:32 +00:00
self.focus = self.conf.focus
def on_composited_changed (self, widget):
self.reconfigure_vte ()
def on_vte_button_press (self, term, event):
# Left mouse button + Ctrl while over a link should open it
mask = gtk.gdk.CONTROL_MASK
if (event.state & mask) == mask:
if event.button == 1:
url = self._vte.match_check (int (event.x / self._vte.get_char_width ()), int (event.y / self._vte.get_char_height ()))
if url:
if (url[0][0:7] != "mailto:") & (url[1] == self.matches['email']):
address = "mailto:" + url[0]
else:
address = url[0]
openurl ( address )
return False
# Left mouse button should transfer focus to this vte widget
if event.button == 1:
self._vte.grab_focus ()
return False
2008-02-24 20:42:08 +00:00
# Right mouse button should display a context menu if ctrl not pressed
if event.button == 3 and event.state & gtk.gdk.CONTROL_MASK == 0:
self.do_popup (event)
return True
def on_vte_notify_enter (self, term, event):
if (self.focus == "sloppy" or self.focus == "mouse"):
term.grab_focus ()
return False
def do_scrollbar_toggle (self):
self.toggle_widget_visibility (self._scrollbar)
def do_title_toggle (self):
self.toggle_widget_visibility (self._titlebox)
def toggle_widget_visibility (self, widget):
if not isinstance (widget, gtk.Widget):
raise TypeError
if widget.get_property ('visible'):
widget.hide ()
else:
widget.show ()
#keybindings for the individual splited terminals (affects only the
#the selected terminal)
def on_vte_key_press (self, term, event):
keyname = gtk.gdk.keyval_name (event.keyval)
mask = gtk.gdk.CONTROL_MASK
if (event.state & mask) == mask:
if keyname == 'plus':
self.zoom (True)
return (True)
elif keyname == 'minus':
self.zoom (False)
return (True)
# bindings that should be moved to Terminator as they all just call
# a function of Terminator. It would be cleaner is TerminatorTerm
# has absolutely no reference to Terminator.
# N (next) - P (previous) - O (horizontal) - E (vertical) - W (close)
mask = gtk.gdk.CONTROL_MASK | gtk.gdk.SHIFT_MASK
if (event.state & mask) == mask:
if keyname == 'N':
self.terminator.go_next (self)
return (True)
elif keyname == "P":
self.terminator.go_prev (self)
return (True)
elif keyname == 'O':
self.terminator.splitaxis (self, False)
return (True)
elif keyname == 'E':
self.terminator.splitaxis (self, True)
return (True)
elif keyname == 'W':
self.terminator.closeterm (self)
return (True)
elif keyname == 'C':
self._vte.copy_clipboard ()
return (True)
elif keyname == 'V':
self._vte.paste_clipboard ()
return (True)
elif keyname == 'S':
self.do_scrollbar_toggle ()
return (True)
2008-03-08 20:13:22 +00:00
elif keyname == 'T':
self.terminator.newtab(self)
return (True)
elif keyname in ('Up', 'Down', 'Left', 'Right'):
self.terminator.resizeterm (self, keyname)
return (True)
mask = gtk.gdk.CONTROL_MASK
if (event.state & mask) == mask:
if keyname == 'Page_Down':
self.terminator.next_tab(self)
return (True)
elif keyname == 'Page_Up':
self.terminator.previous_tab(self)
return (True)
if keyname and (keyname == 'Tab' or keyname.endswith('_Tab')):
if event.state == gtk.gdk.CONTROL_MASK:
self.terminator.go_next (self)
return (True)
if (event.state & mask) == mask:
self.terminator.go_prev (self)
return (True)
return (False)
def zoom (self, zoom_in):
pangodesc = self._vte.get_font ()
fontsize = pangodesc.get_size ()
if fontsize > pango.SCALE and not zoom_in:
fontsize -= pango.SCALE
elif zoom_in:
fontsize += pango.SCALE
pangodesc.set_size (fontsize)
self._vte.set_font (pangodesc)
def on_vte_popup_menu (self, term, event):
self.do_popup (event)
def do_popup (self, event = None):
menu = self.create_popup_menu (event)
menu.popup (None, None, None, event.button, event.time)
def create_popup_menu (self, event):
menu = gtk.Menu ()
url = None
if event:
url = self._vte.match_check (int (event.x / self._vte.get_char_width ()), int (event.y / self._vte.get_char_height ()))
if url:
if url[1] != self.matches['email']:
address = url[0]
2007-12-29 03:01:28 +00:00
nameopen = _("_Open Link")
namecopy = _("_Copy Link Address")
else:
2007-11-09 04:36:01 +00:00
if url[0][0:7] != "mailto:":
address = "mailto:" + url[0]
else:
address = url[0]
2007-12-29 03:01:28 +00:00
nameopen = _("_Send Mail To...")
namecopy = _("_Copy Email Address")
item = gtk.MenuItem (nameopen)
item.connect ("activate", lambda menu_item: openurl (address))
menu.append (item)
item = gtk.MenuItem (namecopy)
item.connect ("activate", lambda menu_item: self.clipboard.set_text (url[0]))
menu.append (item)
item = gtk.MenuItem ()
menu.append (item)
item = gtk.ImageMenuItem (gtk.STOCK_COPY)
item.connect ("activate", lambda menu_item: self._vte.copy_clipboard ())
item.set_sensitive (self._vte.get_has_selection ())
menu.append (item)
item = gtk.ImageMenuItem (gtk.STOCK_PASTE)
item.connect ("activate", lambda menu_item: self._vte.paste_clipboard ())
menu.append (item)
item = gtk.MenuItem ()
menu.append (item)
item = gtk.CheckMenuItem (_("Show _scrollbar"))
item.set_active (self._scrollbar.get_property ('visible'))
item.connect ("toggled", lambda menu_item: self.do_scrollbar_toggle ())
menu.append (item)
item = gtk.CheckMenuItem (_("Show _titlebar"))
item.set_active (self._titlebox.get_property ('visible'))
item.connect ("toggled", lambda menu_item: self.do_title_toggle ())
menu.append (item)
2008-05-20 23:37:04 +00:00
self._do_encoding_items (menu)
item = gtk.MenuItem ()
menu.append (item)
item = gtk.MenuItem (_("Split H_orizontally"))
item.connect ("activate", lambda menu_item: self.terminator.splitaxis (self, False))
menu.append (item)
item = gtk.MenuItem (_("Split V_ertically"))
item.connect ("activate", lambda menu_item: self.terminator.splitaxis (self, True))
menu.append (item)
2008-03-08 20:13:22 +00:00
item = gtk.MenuItem (_("Open _Tab"))
item.connect ("activate", lambda menu_item: self.terminator.newtab (self))
menu.append (item)
item = gtk.MenuItem ()
menu.append (item)
item = gtk.ImageMenuItem (gtk.STOCK_CLOSE)
item.connect ("activate", lambda menu_item: self.terminator.closeterm (self))
menu.append (item)
menu.show_all ()
return menu
def on_encoding_change (self, widget, encoding):
2008-05-20 23:37:04 +00:00
current = self._vte.get_encoding ()
if current != encoding:
2008-05-20 23:37:04 +00:00
dbg ('Setting Encoding to: %s'%encoding)
self._vte.set_encoding (encoding)
2008-05-20 23:37:04 +00:00
def _do_encoding_items (self, menu):
active_encodings = self.conf.active_encodings
item = gtk.MenuItem (_("Encodings"))
2008-05-20 23:37:04 +00:00
menu.append (item)
submenu = gtk.Menu ()
item.set_submenu (submenu)
2008-05-15 06:41:00 +00:00
current_encoding = self._vte.get_encoding ()
group = None
2008-05-20 23:37:04 +00:00
for encoding in active_encodings:
radioitem = gtk.RadioMenuItem (group, _(encoding))
2008-05-15 06:41:00 +00:00
if group is None:
group = radioitem
if encoding == current_encoding:
2008-05-20 23:37:04 +00:00
radioitem.set_active (True)
2008-05-15 06:41:00 +00:00
2008-05-20 23:37:04 +00:00
radioitem.connect ('activate', self.on_encoding_change, encoding)
submenu.append (radioitem)
item = gtk.MenuItem (_("Other Encodings"))
2008-05-20 23:37:04 +00:00
submenu.append (item)
#second level
2008-05-20 23:37:04 +00:00
submenu = gtk.Menu ()
item.set_submenu (submenu)
encodings = TerminatorEncoding ().get_list ()
encodings.sort (lambda x, y: cmp (x[2].lower (), y[2].lower ()))
group = None
2008-05-20 23:37:04 +00:00
for encoding in encodings:
2008-05-20 23:37:04 +00:00
if encoding[1] in active_encodings:
continue
2008-05-20 23:42:43 +00:00
if encoding[1] is None:
2008-05-20 23:37:04 +00:00
label = "%s %s"%(encoding[2], self._vte.get_encoding ())
else:
2008-05-20 23:37:04 +00:00
label = "%s %s"%(encoding[2], encoding[1])
2008-05-20 23:37:04 +00:00
radioitem = gtk.RadioMenuItem (group, label)
if group is None:
group = radioitem
if encoding[1] == current_encoding:
2008-05-20 23:37:04 +00:00
radioitem.set_active (True)
2008-05-20 23:37:04 +00:00
radioitem.connect ('activate', self.on_encoding_change, encoding[1])
submenu.append (radioitem)
2008-05-15 06:41:00 +00:00
def on_vte_title_change(self, vte):
2008-04-02 21:10:32 +00:00
if self.conf.titletips:
vte.set_property ("has-tooltip", True)
vte.set_property ("tooltip-text", vte.get_window_title ())
#set the title anyhow, titlebars setting only show/hide the label
self._title.set_text(vte.get_window_title ())
2008-03-29 01:36:23 +00:00
self.terminator.set_window_title("%s: %s" %(APP_NAME.capitalize(), vte.get_window_title ()))
2008-03-08 20:13:22 +00:00
notebookpage = self.terminator.get_first_notebook_page(vte)
while notebookpage != None:
notebookpage[0].set_tab_label_text(notebookpage[1], vte.get_window_title ())
notebookpage = self.terminator.get_first_notebook_page(notebookpage[0])
2008-03-02 12:44:08 +00:00
def on_vte_focus_in(self, vte, event):
self._titlebox.modify_bg(gtk.STATE_NORMAL,self.terminator.window.get_style().bg[gtk.STATE_SELECTED])
self._title.modify_fg(gtk.STATE_NORMAL, self.terminator.window.get_style().fg[gtk.STATE_SELECTED])
return
def on_vte_focus_out(self, vte, event):
self._titlebox.modify_bg(gtk.STATE_NORMAL, self.terminator.window.get_style().bg[gtk.STATE_NORMAL])
self._title.modify_fg(gtk.STATE_NORMAL, self.terminator.window.get_style().fg[gtk.STATE_NORMAL])
return
def on_vte_focus(self, vte):
if vte.get_window_title ():
2008-03-29 01:36:23 +00:00
self.terminator.set_window_title("%s: %s" %(APP_NAME.capitalize(), vte.get_window_title ()))
2008-03-08 20:13:22 +00:00
notebookpage = self.terminator.get_first_notebook_page(vte)
while notebookpage != None:
notebookpage[0].set_tab_label_text(notebookpage[1], vte.get_window_title ())
notebookpage = self.terminator.get_first_notebook_page(notebookpage[0])
def destroy(self):
self._vte.destroy()
class Terminator:
2008-03-01 00:09:49 +00:00
def __init__ (self, profile, command = None, fullscreen = False, maximise = False, borderless = False):
self.profile = profile
self.command = command
self._fullscreen = False
self.term_list = []
2008-04-02 21:10:32 +00:00
stores = []
stores.append (config.TerminatorConfValuestoreRC ())
2008-04-02 21:10:32 +00:00
try:
import gconf
store = config.TerminatorConfValuestoreGConf ()
store.set_reconfigure_callback (self.reconfigure_vtes)
stores.append (store)
except:
pass
2008-04-02 21:10:32 +00:00
self.conf = config.TerminatorConfig (stores)
self.window = gtk.Window ()
2008-03-29 01:36:23 +00:00
self.window.set_title (APP_NAME.capitalize())
2008-02-08 11:05:19 +00:00
# FIXME: This really shouldn't be a hardcoded path
try:
2008-03-29 01:36:23 +00:00
self.window.set_icon_from_file ("/usr/share/icons/hicolor/48x48/apps/" + APP_NAME + ".png")
2008-02-08 11:05:19 +00:00
except:
self.icon = self.window.render_icon (gtk.STOCK_DIALOG_INFO, gtk.ICON_SIZE_BUTTON)
self.window.set_icon (self.icon)
self.window.connect ("key-press-event", self.on_key_press)
self.window.connect ("delete_event", self.on_delete_event)
self.window.connect ("destroy", self.on_destroy_event)
2007-11-09 03:19:25 +00:00
self.window.set_property ('allow-shrink', True)
2008-03-01 00:09:49 +00:00
if fullscreen:
self.fullscreen_toggle ()
if maximise:
self.maximize ()
if borderless:
self.window.set_decorated (False)
# Set RGBA colormap if possible so VTE can use real alpha
# channels for transparency.
screen = self.window.get_screen()
colormap = screen.get_rgba_colormap()
if colormap:
self.window.set_colormap(colormap)
# Start out with just one terminal
# FIXME: This should be really be decided from some kind of profile
term = (TerminatorTerm (self, self.profile, self.command))
self.term_list = [term]
self.window.add (term)
self.window.show ()
term.spawn_child ()
def maximize (self):
2008-03-29 01:36:23 +00:00
""" Maximize the Terminator window."""
self.window.maximize ()
2008-05-14 23:44:05 +00:00
def fullscreen_toggle (self):
""" Toggle the fullscreen state of the window. If it is in
fullscreen state, it will be unfullscreened. If it is not, it
will be set to fullscreen state.
"""
if self._fullscreen:
self.window.unfullscreen ()
else:
self.window.fullscreen ()
self._fullscreen = not self._fullscreen
def on_delete_event (self, window, event, data=None):
if len (self.term_list) == 1:
return False
# show dialog
2007-12-29 03:01:28 +00:00
dialog = gtk.Dialog (_("Close?"), window, gtk.DIALOG_MODAL,
(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT, gtk.STOCK_CLOSE, gtk.RESPONSE_ACCEPT))
dialog.set_has_separator (False)
dialog.set_resizable (False)
2007-12-29 03:01:28 +00:00
primairy = gtk.Label (_('<big><b>Close all terminals?</b></big>'))
primairy.set_use_markup (True)
primairy.set_alignment (0, 0.5)
2007-12-29 03:01:28 +00:00
secundairy = gtk.Label (_("This window has %s terminals open. Closing the window will also close all terminals.") % len(self.term_list))
secundairy.set_line_wrap(True)
primairy.set_alignment (0, 0.5)
labels = gtk.VBox ()
labels.pack_start (primairy, False, False, 6)
labels.pack_start (secundairy, False, False, 6)
image = gtk.image_new_from_stock(gtk.STOCK_DIALOG_WARNING, gtk.ICON_SIZE_DIALOG)
image.set_alignment (0.5, 0)
box = gtk.HBox()
box.pack_start (image, False, False, 6)
box.pack_start (labels, False, False, 6)
dialog.vbox.pack_start (box, False, False, 12)
dialog.show_all ()
result = dialog.run ()
dialog.destroy ()
return not (result == gtk.RESPONSE_ACCEPT)
def on_destroy_event (self, widget, data=None):
gtk.main_quit ()
# keybindings for the whole terminal window (affects the main
# windows containing the splited terminals)
def on_key_press (self, window, event):
""" Callback for the window to determine what to do with special
keys. Currently handled key-combo's:
* F11: toggle fullscreen state of the window.
* CTRL - SHIFT - Q: close all terminals
"""
keyname = gtk.gdk.keyval_name (event.keyval)
mask = gtk.gdk.CONTROL_MASK | gtk.gdk.SHIFT_MASK
if (keyname == 'F11'):
2008-05-14 23:44:05 +00:00
self.fullscreen_toggle ()
return (True)
if (event.state & mask) == mask:
if keyname == 'Q':
if not self.on_delete_event (window, gtk.gdk.Event (gtk.gdk.DELETE)):
self.on_destroy_event (window, gtk.gdk.Event (gtk.gdk.DESTROY))
def set_window_title(self, title):
2008-03-02 13:17:56 +00:00
"""
Modifies Terminator window title
"""
self.window.set_title(title)
2008-02-27 20:27:29 +00:00
def add(self, widget, terminal, pos = "bottom"):
"""
Add a term to another at position pos
"""
vertical = pos in ("top", "bottom")
pane = (vertical) and gtk.VPaned () or gtk.HPaned ()
# get the parent of the provided terminal
parent = widget.get_parent ()
if isinstance (parent, gtk.Window):
# We have just one term
widget.reparent (pane)
if pos in ("top", "left"):
pane.remove(widget)
pane.pack1 (terminal, True, True)
pane.pack2 (widget, True, True)
else:
pane.pack1 (widget, True, True)
pane.pack2 (terminal, True, True)
parent.add (pane)
position = (vertical) and parent.allocation.height \
or parent.allocation.width
2008-03-08 20:13:22 +00:00
if isinstance (parent, gtk.Notebook):
page = -1
for i in range(0, parent.get_n_pages()):
if parent.get_nth_page(i) == widget:
2008-03-08 20:13:22 +00:00
page = i
break
widget.reparent (pane)
2008-03-08 20:13:22 +00:00
if pos in ("top", "left"):
pane.remove(widget)
pane.pack1 (terminal, True, True)
pane.pack2 (widget, True, True)
2008-03-08 20:13:22 +00:00
else:
pane.pack1 (widget, True, True)
pane.pack2 (terminal, True, True)
2008-03-08 20:13:22 +00:00
#parent.remove_page(page)
pane.show()
parent.insert_page(pane, None, page)
parent.set_tab_label_text(pane, widget._vte.get_window_title())
parent.set_tab_label_packing(pane, True, True, gtk.PACK_START)
parent.set_current_page(page)
position = (vertical) and parent.allocation.height \
or parent.allocation.width
if isinstance (parent, gtk.Paned):
# We are inside a split term
position = (vertical) and widget.allocation.height \
or widget.allocation.width
if (widget == parent.get_child1 ()):
widget.reparent (pane)
parent.pack1 (pane, True, True)
else:
widget.reparent (pane)
parent.pack2 (pane, True, True)
if pos in ("top", "left"):
pane.remove(widget)
pane.pack1 (terminal, True, True)
pane.pack2 (widget, True, True)
else:
pane.pack1 (widget, True, True)
pane.pack2 (terminal, True, True)
pane.pack1 (widget, True, True)
pane.pack2 (terminal, True, True)
# show all, set position of the divider
pane.show ()
pane.set_position (position / 2)
terminal.show ()
terminal.spawn_child ()
# insert the term reference into the list
index = self.term_list.index (widget)
self.term_list.insert (index + 1, terminal)
# make the new terminal grab the focus
terminal._vte.grab_focus ()
return (terminal)
def on_page_reordered(self, notebook, child, page_num):
print page_num
2008-03-08 20:13:22 +00:00
def newtab(self,widget):
terminal = TerminatorTerm (self, self.profile, None, widget.get_cwd())
widgetbox = widget
2008-03-08 20:13:22 +00:00
parent = widgetbox.get_parent ()
if isinstance(parent, gtk.Paned) or isinstance(parent, gtk.Window):
2008-03-08 20:13:22 +00:00
#no notebook yet.
notebook = gtk.Notebook()
notebook.connect('page-reordered',self.on_page_reordered)
2008-03-08 20:13:22 +00:00
notebook.set_property('homogeneous', True)
notebook.set_tab_reorderable(widgetbox, True)
2008-04-08 19:35:48 +00:00
if isinstance(parent, gtk.Paned):
if parent.get_child1() == widgetbox:
widgetbox.reparent(notebook)
parent.pack1(notebook)
else:
widgetbox.reparent(notebook)
parent.pack2(notebook)
elif isinstance(parent, gtk.Window):
widgetbox.reparent(notebook)
parent.add(notebook)
notebook.set_tab_reorderable(widgetbox,True)
2008-04-08 19:35:48 +00:00
notebooklabel = ""
if widget._vte.get_window_title() is not None:
notebooklabel = widget._vte.get_window_title()
notebook.set_tab_label_text(widgetbox, notebooklabel)
2008-03-08 20:13:22 +00:00
notebook. set_tab_label_packing(widgetbox, True, True, gtk.PACK_START)
notebook.show()
2008-03-08 20:13:22 +00:00
elif isinstance(parent, gtk.Notebook):
notebook = parent
else:
return (False)
notebook.append_page(terminal,terminal._vte.get_window_title())
notebook. set_tab_label_packing(terminal, True, True, gtk.PACK_START)
notebook.set_tab_reorderable(terminal,True)
2008-03-08 20:13:22 +00:00
notebook.set_current_page(-1)
index = self.term_list.index(widget)
self.term_list.insert (index + 1, terminal)
terminal.show ()
terminal.spawn_child ()
2008-03-08 20:13:22 +00:00
terminal._vte.grab_focus ()
return (True)
2008-03-08 20:13:22 +00:00
return terminal
def splitaxis (self, widget, vertical=True):
""" Split the provided widget on the horizontal or vertical axis. """
# create a new terminal and parent pane.
terminal = TerminatorTerm (self, self.profile, None, widget.get_cwd())
pos = vertical and "bottom" or "right"
self.add(widget, terminal, pos)
terminal.show ()
terminal.spawn_child ()
return terminal
def remove(self, widget):
2008-02-27 20:27:29 +00:00
"""Remove a TerminatorTerm from the Terminator view and terms list
Returns True on success, False on failure"""
parent = widget.get_parent ()
sibling = None
if isinstance (parent, gtk.Window):
# We are the only term
if not self.on_delete_event (parent, gtk.gdk.Event (gtk.gdk.DELETE)):
self.on_destroy_event (parent, gtk.gdk.Event (gtk.gdk.DESTROY))
return
if isinstance (parent, gtk.Paned):
index = self.term_list.index (widget)
grandparent = parent.get_parent ()
# Discover sibling while all objects exist
if widget == parent.get_child1 ():
sibling = parent.get_child2 ()
if widget == parent.get_child2 ():
sibling = parent.get_child1 ()
if not sibling:
# something is wrong, give up
print >> sys.stderr, "Error: %s is not a child of %s"%(widget, parent)
return False
parent.remove(widget)
2008-03-08 20:13:22 +00:00
if isinstance(grandparent, gtk.Notebook):
page = -1
for i in range(0, grandparent.get_n_pages()):
if grandparent.get_nth_page(i) == parent:
page = i
break
parent.remove(sibling)
grandparent.remove_page(page)
grandparent.insert_page(sibling, None,page)
grandparent.set_tab_label_packing(sibling, True, True, gtk.PACK_START)
else:
grandparent.remove (parent)
sibling.reparent (grandparent)
grandparent.resize_children()
parent.destroy ()
self.term_list.remove (widget)
if not isinstance (sibling, gtk.Paned):
for term in self.term_list:
if term == sibling:
term._vte.grab_focus ()
break
else:
if index == 0: index = 1
self.term_list[index - 1]._vte.grab_focus ()
2008-03-08 20:13:22 +00:00
elif isinstance (parent, gtk.Notebook):
parent.remove(widget)
2008-03-08 20:13:22 +00:00
nbpages = parent.get_n_pages()
index = self.term_list.index (widget)
self.term_list.remove (widget)
if nbpages == 1:
sibling = parent.get_nth_page(0)
parent.remove(sibling)
gdparent = parent.get_parent()
if isinstance(gdparent, gtk.Window):
gdparent.remove(parent)
gdparent.add(sibling)
elif isinstance(gdparent, gtk.Paned):
if gdparent.get_child1() == parent:
gdparent.remove(parent)
gdparent.pack1(sibling)
else:
gdparent.remove(parent)
gdparent.pack2(sibling)
parent.destroy()
if index == 0: index = 1
self.term_list[index - 1]._vte.grab_focus ()
if len(self.term_list) == 1:
self.term_list[0]._titlebox.hide()
return True
def closeterm (self, widget):
if self.remove(widget):
widget.destroy ()
return True
return False
def go_next (self, term):
current = self.term_list.index (term)
next = current
if current == len (self.term_list) - 1:
next = 0
else:
next += 1
2008-03-08 20:13:22 +00:00
nextterm = self.term_list[next]
if isinstance(nextterm.get_parent(), gtk.Notebook):
box = nextterm
2008-03-08 20:13:22 +00:00
parent = box.get_parent()
for i in range(0, parent.get_n_pages()):
if box == parent.get_nth_page(i):
parent.set_current_page(i)
break
notebookpage = self.get_first_notebook_page(nextterm)
2008-03-08 20:13:22 +00:00
if notebookpage:
child = None
for i in range(0, notebookpage[0].get_n_pages()):
if notebookpage[0].get_nth_page(i) == notebookpage[1]:
notebookpage[0].set_current_page(i)
break
nextterm._vte.grab_focus ()
def go_prev (self, term):
current = self.term_list.index (term)
previous = current
if current == 0:
previous = len (self.term_list) - 1
else:
previous -= 1
#self.window.set_title(self.term_list[previous]._vte.get_window_title())
2008-03-08 20:13:22 +00:00
previousterm = self.term_list[previous]
if isinstance(previousterm.get_parent(), gtk.Notebook):
box = previousterm
2008-03-08 20:13:22 +00:00
parent = box.get_parent()
for i in range(0, parent.get_n_pages()):
if box == parent.get_nth_page(i):
parent.set_current_page(i)
break
notebookpage = self.get_first_notebook_page(previousterm)
2008-03-08 20:13:22 +00:00
if notebookpage:
child = None
for i in range(0, notebookpage[0].get_n_pages()):
if notebookpage[0].get_nth_page(i) == notebookpage[1]:
notebookpage[0].set_current_page(i)
break
previousterm._vte.grab_focus ()
def resizeterm (self, widget, keyname):
vertical = False
if keyname in ('Up', 'Down'):
vertical = True
elif keyname in ('Left', 'Right'):
vertical = False
else:
return
parent = self.get_first_parent_paned(widget,vertical)
if parent == None:
return
#We have a corresponding parent pane
#
#allocation = parent.get_allocation()
2008-04-02 21:10:32 +00:00
if keyname in ('Up', 'Down'):
maxi = parent.get_child1().get_allocation().height + parent.get_child2().get_allocation().height - 1
2008-04-02 21:10:32 +00:00
else:
maxi = parent.get_child1().get_allocation().width + parent.get_child2().get_allocation().width - 1
move = 10
if keyname in ('Up', 'Left'):
move = -10
2008-04-02 21:10:32 +00:00
move = max(2, parent.get_position() + move)
move = min(maxi, move)
2008-04-02 21:10:32 +00:00
parent.set_position(move)
2008-04-02 21:10:32 +00:00
def previous_tab(self, term):
notebook = self.get_first_parent_notebook(term)
notebook.prev_page()
return
def next_tab(self, term):
notebook = self.get_first_parent_notebook(term)
notebook.next_page()
return
def get_first_parent_notebook(self, widget):
if isinstance (widget, gtk.Window):
return None
parent = widget.get_parent()
if isinstance (parent, gtk.Notebook):
return parent
return self.get_first_parent_notebook(parent)
def get_first_parent_paned (self, widget, vertical = None):
"""This method returns the first parent pane of a widget.
if vertical is True returns the first VPaned
if vertical is False return the first Hpaned
if is None return the First Paned"""
if isinstance (widget, gtk.Window):
return None
parent = widget.get_parent()
if isinstance (parent, gtk.Paned) and vertical is None:
return parent
if isinstance (parent, gtk.VPaned) and vertical:
return parent
elif isinstance (parent, gtk.HPaned) and not vertical:
return parent
return self.get_first_parent_paned(parent, vertical)
2008-04-02 21:10:32 +00:00
2008-03-08 20:13:22 +00:00
def get_first_notebook_page(self, widget):
if isinstance (widget, gtk.Window):
return None
parent = widget.get_parent()
if isinstance (parent, gtk.Notebook):
page = -1
for i in range(0, parent.get_n_pages()):
if parent.get_nth_page(i) == widget:
return (parent, widget)
return self.get_first_notebook_page(parent)
2008-04-02 21:10:32 +00:00
def reconfigure_vtes (self):
for term in self.term_list:
term.reconfigure_vte ()
if __name__ == '__main__':
def execute_cb (option, opt, value, parser):
2008-02-26 18:30:21 +00:00
assert value is None
value = []
while parser.rargs:
arg = parser.rargs[0]
value.append (arg)
del (parser.rargs[0])
setattr(parser.values, option.dest, value)
def execute_cb (option, opt, value, parser):
assert value is None
value = []
while parser.rargs:
arg = parser.rargs[0]
value.append (arg)
del (parser.rargs[0])
setattr(parser.values, option.dest, value)
usage = "usage: %prog [options]"
parser = OptionParser (usage)
2008-03-29 01:40:49 +00:00
parser.add_option ("-v", "--version", action="store_true", dest="version", help="Display program version")
parser.add_option ("-d", "--debug", action="store_true", dest="debug", help="Enable debugging information")
2008-03-29 01:36:23 +00:00
parser.add_option ("-m", "--maximise", action="store_true", dest="maximise", help="Open the %s window maximised"%APP_NAME.capitalize())
parser.add_option ("-f", "--fullscreen", action="store_true", dest="fullscreen", help="Set the window into fullscreen mode")
parser.add_option ("-b", "--borderless", action="store_true", dest="borderless", help="Turn off the window's borders")
parser.add_option ("-p", "--profile", dest="profile", help="Specify a GNOME Terminal profile to emulate")
parser.add_option ("-e", "--command", dest="command", help="Execute the argument to this option inside the terminal")
parser.add_option ("-x", "--execute", dest="execute", action="callback", callback=execute_cb, help="Execute the remainder of the command line inside the terminal")
(options, args) = parser.parse_args ()
if len (args) != 0:
parser.error("Expecting zero additional arguments, found: %d"%len (args))
2008-03-29 01:40:49 +00:00
if options.version:
print "%s %s"%(APP_NAME, APP_VERSION)
sys.exit (0)
command = []
if (options.command):
command.append (options.command)
if (options.execute):
command = options.execute
2008-03-01 00:09:49 +00:00
term = Terminator (options.profile, command, options.fullscreen, options.maximise, options.borderless)
gtk.main ()