def lyriczilla_applet_factory(applet, iid):
socket = gtk.Socket()
applet.add(socket)
subprocess.Popen(['lyriczilla-nest', str(socket.get_id())])
socket.set_size_request(400, 20)
applet.show_all()
return gtk.TRUE
def call_gparted(main_window):
'''call_autoparted() -> dict {'mount point' : 'dev'}
-> None
'''
import gtk
mountpoints = {'/': '/dev/hda1', 'swap': '/dev/hda2', '/home': '/dev/hda3'}
# plug/socket implementation (Gparted integration)
socket = gtk.Socket()
socket.show()
main_window.get_widget('embedded').add(socket)
Wid = str(socket.get_id())
# TODO: rewrite next block.
try:
subprocess.Popen(['/usr/bin/gparted', '-i', Wid],
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
close_fds=True)
except:
try:
subprocess.Popen(['/usr/local/bin/gparted', '-i', Wid],
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
close_fds=True)
except:
main_window.get_widget('embedded').destroy()
if (stdin is not ''):
mountpoints = stdin
return mountpoints
def _add_socket(self, w):
#must create an new socket, because socket will be destroyed when it reparent!!!
if self.socket:
self.socket.destroy()
self.socket = gtk.Socket()
self.pack_start(self.socket, True, True)
self.socket.realize()
def start(self):
"""
Start the Vim instance if it is not already running.
This command forks in a pseudoterminal, and starts Vim, if Vim is not
already running. The pid is stored for later use.
"""
if not self.pid:
# Get the console vim executable path
#command = self.prop_main_registry.commands.vim.value()
command = 'gvim'
# Fork using pty.fork to prevent Vim taking the terminal
sock = gtk.Socket()
w = gtk.Window()
w.realize()
w.add(sock)
xid = sock.get_id()
pid, fd = pty.fork()
if pid == 0:
# Child, execute Vim with the correct servername argument
os.execvp(command, ['gvim', '-f', '--servername', self.name,
'--socketid', '%s' % xid])
#'-v'])
# os.system('%s -v --servername %s' % (command, self.name))
else:
# Parent, store the pid, and file descriptor for later.
self.pid = pid
self.childfd = fd
def __init__(self, width, height):
# Build the main widget
super(PyGameCanvas,self).__init__()
# Build the sub-widgets
self._align = gtk.Alignment(0.5, 0.5)
self._inner_evb = gtk.EventBox()
self._socket = gtk.Socket()
# Add internal widgets
self._inner_evb.set_size_request(width, height)
self._inner_evb.add(self._socket)
self._socket.show()
self._align.add(self._inner_evb)
self._inner_evb.show()
self._align.show()
self.add(self._align)
# Construct a gtkEvent.Translator
self._translator = gtkEvent.Translator(self, self._inner_evb)
# <Cue Thus Spract Zarathustra>
self.set_flags(gtk.CAN_FOCUS)
self.show()
def add_wnck_window_to_tab(self, wnck_window):
'''将窗口添加到标签
'''
notebook = self.notebook
drawingarea = gtk.Socket()
drawingarea.show()
drawingarea.connect('realize', self._on_add_wnck_window_to_drawingarea, wnck_window, drawingarea)
drawingarea.connect('plug-removed', self._tab_remove)
tabimage = gtk.Image()
tabimage.set_from_pixbuf(wnck_window.get_icon())
tabimage.set_padding(0, 0)
tabimage.show()
tabmenu = gtk.Label(wnck_window.get_name())
box = gtk.Viewport()
box.add(drawingarea)
box.show()
box.set_flags(gtk.CAN_FOCUS)
drawingarea.box = box
drawingarea.tabimage = tabimage
drawingarea.tabmenu = tabmenu
drawingarea.wnck_window = wnck_window
notebook.append_page_menu(box, tabimage, tabmenu)
notebook.set_current_page( notebook.page_num(box) )
notebook.set_tab_reorderable(drawingarea, 1)
self.tabs[wnck_window] = drawingarea
pass
def __init__(self, handle):
activity.Activity.__init__(self, handle)
toolbox = activity.ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.show()
try:
view = gnash.View()
view.props.uri = os.path.join(activity.get_bundle_path(), SWFNAME)
self.set_canvas(view)
view.show()
except NameError:
socket = gtk.Socket()
self.set_canvas(socket)
self.show_all()
args = [
'gnash', '-x',
str(socket.get_id()),
os.path.join(activity.get_bundle_path(), SWFNAME)
]
logging.debug(args)
self._process = subprocess.Popen(args)
def __init__(self, handle):
# fork pygame before we initialize the activity.
import os
import pygame
import sys
pygame.init()
windowid = pygame.display.get_wm_info()['wmwindow']
self.child_pid = os.fork()
if self.child_pid == 0:
bp = activity.get_bundle_path()
library_path = os.path.join(bp, 'library')
pippy_app_path = os.path.join(bp, 'pippy_app.py')
sys.path[0:0] = [library_path]
g = globals()
g['__name__'] = '__main__'
execfile(pippy_app_path, g, g) # start pygame
sys.exit(0)
super(PyGameActivity, self).__init__(handle)
import gobject
import gtk
toolbox = activity.ActivityToolbox(self)
toolbar = toolbox.get_activity_toolbar()
self.set_toolbox(toolbox)
toolbox.show()
socket = gtk.Socket()
socket.set_flags(socket.flags() | gtk.CAN_FOCUS)
socket.show()
self.set_canvas(socket)
socket.add_id(windowid)
self.show_all()
socket.grab_focus()
gobject.child_watch_add(self.child_pid, lambda pid, cond: self.close())
# hide the buttons we don't use.
toolbar.share.hide() # this should share bundle.
toolbar.keep.hide()
def _add_socket(self, w):
#must create an new socket, because socket will be destroyed when it reparent!!!
if self.socket:
self.socket.destroy()
self.socket = gtk.Socket()
self.socket_box.add(self.socket)
self.socket.realize()
def __init__(self, create = True, accel_group = None, tooltips = None):
'''建立主窗口和布局
'''
self.mainwindow = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.mainwindow.set_icon_name("gimp")
self.mainwindow.set_default_size(700, 500)
self.mainwindow.maximize()
self.mainwindow.set_title(_("GimpBox"))
#self.mainwindow.set_position(gtk.WIN_POS_CENTER)
self.mainwindow.show()
self.mainwindow.connect("delete_event", self.quit)
self.screen = wnck.screen_get_default()
self.hpaned1 = gtk.HPaned()
self.hpaned1.set_position(180)
self.hpaned1.show()
self.toolboxarea = gtk.Socket()
self.toolboxarea.show()
self.hpaned1.pack1(self.toolboxarea, False, True)
self.hpaned2 = gtk.HPaned()
self.hpaned2.show()
self.notebook = gtk.Notebook()
self.notebook.set_tab_pos(gtk.POS_BOTTOM)
self.notebook.popup_enable()
self.notebook.set_scrollable(True)
self.notebook.show()
self.hpaned2.pack1(self.notebook, False, True)
self.miscboxarea = gtk.Socket()
self.miscboxarea.show()
self.hpaned2.pack2(self.miscboxarea, False, False)
self.hpaned1.pack2(self.hpaned2, True, True)
self.mainwindow.add(self.hpaned1)
gobject.idle_add(self.start)
#self.toolboxarea.connect('realize', self.start)
self.mainwindow.show_all()
pass
def __init__(self):
gtk.EventBox.__init__(self)
self.set_flags(gtk.CAN_FOCUS)
self.setup_events()
self.socket = gtk.Socket()
self.add(self.socket)
self.button_state = [0, 0, 0]
self.mouse_pos = (0, 0)
def __pack(self):
socket = gtk.Socket()
eb = gtk.EventBox()
self.widget.pack_start(eb)
eb.add_events(gtk.gdk.KEY_PRESS_MASK)
eb.add(socket)
self.show_all()
self.__eb = eb
return socket.get_id()
def _create_ui(self):
"""Instantiate the GTK socket.
Called by the run method before the widget is realized.
"""
socket = gtk.Socket()
self.add_events(gtk.gdk.KEY_PRESS_MASK)
self.add(socket)
self.show_all()
return socket.get_id()
def __init__(self, handle):
activity.Activity.__init__(self, handle, False)
self.set_title("Derecho A Transitar")
self.socket = gtk.Socket()
self.set_canvas(self.socket)
self.gtkplug = gtkplug()
self.socket.add_id(self.gtkplug.get_id())
self.add_events(gtk.gdk.ALL_EVENTS_MASK)
self.connect("destroy", self.salir)
self.connect("set-focus-child", self.refresh)
self.show_all()
def __pack(self):
socket = gtk.Socket()
socket.connect('plug-removed', self.cb_unplugged)
eb = gtk.EventBox()
self.widget.pack_start(eb)
eb.add_events(gtk.gdk.KEY_PRESS_MASK)
eb.add(socket)
self.show_all()
self.__eb = eb
self.__socket = socket
return socket.get_id()
def _popup(self, *p):
"""Open a popup window for temporary anchoring the player video.
"""
if self.player is None:
return None
w = gtk.Window()
d = gtk.Socket()
w.add(d)
w.show_all()
self.player.set_visual(d.get_id())
return w
def __init__(self, handle):
Activity.__init__(self, handle, False)
self.socket = gtk.Socket()
self.set_canvas(self.socket)
self.interfaz = Interfaz()
self.socket.add_id(self.interfaz.get_id())
self.show_all()
self.connect("key-press-event", self.interfaz.key_press_even)
self.connect("key-release-event", self.interfaz.key_release_even)
def __init__(self, command, args):
self.win = gtk.EventBox()
self.socket = gtk.Socket()
self.socket.connect('plug-added', self.cb_plugged)
self.socket.connect('plug-removed', self.cb_unplugged)
self.win.add(self.socket)
self.pid = None
self.command = command
self.args = args
self.r_cb_plugged = None
self.r_cb_unplugged = None
def __init__(self, handle):
activity.Activity.__init__(self, handle)
self.set_title(_('SimCity Activity'))
self.connect('destroy', self._destroy_cb)
self.connect('focus-in-event', self._focus_in_cb)
self.connect('focus-out-event', self._focus_out_cb)
signal.signal(signal.SIGCHLD, self._sigchild_handler)
self._bundle_path = get_bundle_path()
if False:
# FIXME: Plug SimCity's window into a gtk socket.
# Doesn't work yet, but it would be cool if it did.
socket = gtk.Socket()
try:
self.set_canvas(socket)
except AttributeError:
self.add(socket)
socket.show()
socket.connect('plug-added', self._plug_added_cb)
socket.connect('plug-removed', self._plug_removed_cb)
win = socket.get_id()
command = os.path.join(self._bundle_path, 'SimCity')
args = [
command,
#'-R', str(win), # Set root window to socket window id
'-t', # Interactive tty mode, so we can send it commands.
]
logging.debug("CWD: " + self._bundle_path)
logging.debug("SIMCITY ARGS: " + repr(args))
self._process = subprocess.Popen(
args,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
close_fds=True,
cwd=self._bundle_path,
preexec_fn=lambda: os.chdir(self._bundle_path))
logging.debug("STARTING THREAD... " +
str(self._stdout_thread_function))
t = None
try:
t = thread.start_new(self._stdout_thread_function, ())
except Exception, e:
logging.debug("EXCEPTION " + str(e))
def __init__(self):
gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
self.set_title("Derecho A Transitar")
self.fullscreen()
self.socket = gtk.Socket()
self.add(self.socket)
self.gtkplug = gtkplug()
self.socket.add_id(self.gtkplug.get_id())
self.add_events(gtk.gdk.ALL_EVENTS_MASK)
self.connect("destroy", self.salir)
self.connect("set-focus-child", self.refresh)
self.show_all()
def __init__(self, handle):
Activity.__init__(self, handle)
self.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("#ffeeaa"))
self.socket = gtk.Socket()
self.set_canvas(self.socket)
self.interfaz = Interfaz()
self.socket.add_id(self.interfaz.get_id())
self.show_all()
self.connect("key-press-event", self.interfaz.key_press_event)
self.connect("key-release-event", self.interfaz.key_release_event)
def __init__(self, mainwindow):
gtk.EventBox.__init__(self)
global CANVAS
assert CANVAS == None, "Only one PygameCanvas can be created, ever."
CANVAS = self
self._mainwindow = mainwindow
self.set_flags(gtk.CAN_FOCUS)
self._socket = gtk.Socket()
self.add(self._socket)
self.show_all()
def _add_uisocket(self, box):
# add Hatari parent container to given box
socket = gtk.Socket()
# without this, closing Hatari would remove the socket widget
socket.connect("plug-removed", lambda obj: True)
socket.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("black"))
socket.set_events(gtk.gdk.ALL_EVENTS_MASK)
socket.set_flags(gtk.CAN_FOCUS)
# set initial embedded hatari size
width, height = self.config.get_window_size()
socket.set_size_request(width, height)
# no resizing for the Hatari window
box.pack_start(socket, False, False)
self.hatariwin = socket
def create_ui(self):
self.holder = gtk.EventBox()
self.holder.add_events(gtk.gdk.KEY_PRESS_MASK)
self.widget.add(self.holder)
# NOTE: Setting a size request on self.widget prevents vim from propagating
# its own size requests up when gvim adds UI elements and resizes
self.socket = gtk.Socket()
self.holder.add(self.socket)
self.widget.show_all()
self.vim_command = 'gvim'
self.vim = None
self.vim_proc = None
self.vim_pid = None
self.vim_running = False # to prevent accessing vim after close
def pytest_funcarg__vim_process(request):
w = gtk.Window()
w.set_title(request.function.__name__)
s = gtk.Socket()
w.add(s)
w.set_size_request(600, 600)
w.show_all()
refresh_ui()
process = _start_vim(
s.get_id(),
request.function.__name__)
process._win_ = w
request.addfinalizer(w.destroy)
return process
def __init__(self, parent):
ViewerExtension.__init__(self, parent)
self._process = None
# create container
self._container = gtk.Viewport()
self._container.set_shadow_type(gtk.SHADOW_IN)
# create socket for embeding GVim window
self._socket = gtk.Socket()
self._socket.connect('realize', self.__socket_realized)
# pack interface
self._container.add(self._socket)
def __init__(self, url, title="new"):
super(SessionTab, self).__init__()
self.socket = gtk.Socket()
self.socket.connect("plug-removed", self.close)
self.label = TabLabel(title)
self.label.connect("close", self.close)
self.proc = None
self.source_id = None
self.status = ""
self.title = ""
self.location = url
self.wid = -1
self.close_emitted = False
def __init__(self):
gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
self.set_title("CantaBichos")
self.fullscreen()
#self.set_size_request(800,600)
self.socket = gtk.Socket()
self.add(self.socket)
self.gtkplug = gtkplug()
self.socket.add_id(self.gtkplug.get_id())
self.add_events(gtk.gdk.ALL_EVENTS_MASK)
self.connect("destroy", self.salir)
self.connect("set-focus-child", self.refresh)
self.show_all()
def __init__(self, handle):
"""Set up the Pilas activity."""
activity.Activity.__init__(self, handle)
# we do not have collaboration features,
# make the share option insensitive
self.max_participants = 1
# toolbar with the new toolbar redesign
toolbar_box = ToolbarBox()
activity_button = ActivityButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
title_entry = TitleEntry(self)
toolbar_box.toolbar.insert(title_entry, -1)
title_entry.show()
share_button = ShareButton(self)
toolbar_box.toolbar.insert(share_button, -1)
share_button.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
socket = gtk.Socket()
socket.connect("plug-added", self._on_plugged_event)
socket.set_flags(gtk.CAN_FOCUS)
self.set_canvas(socket)
self.set_focus(socket)
socket.show()
screen_width = gtk.gdk.screen_width()
screen_height = gtk.gdk.screen_height()
Popen(["python", "pilas_plug.py", str(socket.get_id()),
str(screen_width), str(screen_height)], env=new_env)
def install_featured(widget, wTree, treeview_featured, window):
vbox = wTree.get_widget("vbox1")
socket = gtk.Socket()
vbox.pack_start(socket)
socket.show()
window_id = repr(socket.get_id())
command = "gksu mint-synaptic-install " + window_id
model = treeview_featured.get_model()
iter = model.get_iter_first()
while iter != None:
if (model.get_value(iter, 1) == "true"):
pkg = model.get_value(iter, 0)
command = command + " " + pkg
iter = model.iter_next(iter)
os.system(command)
close_window(widget, window)
