def reparent(window, parent):
""" Forced reparent. When reparenting Gtk applications into Tk
some extra protocol calls are needed.
"""
from Xlib import display
from Xlib.xobject import drawable
if not parent:
return window
plug = gtk.Plug(int(parent))
plug.show()
d = display.Display()
w = drawable.Window(d.display, plug.window.xid, 0)
# Honor XEmbed spec
atom = d.get_atom('_XEMBED_INFO')
w.change_property(atom, atom, 32, [0, 1])
w.reparent(parent, 0, 0)
w.map()
d.sync()
for c in window.get_children():
window.remove(c)
plug.add(c)
# Hide window if it's displayed
window.unmap()
return plug
def prepare(self):
'''
Prepare a widget for embedding. If it is already embeded this will break the widget free.
'''
newplug = gtk.Plug(0)
if None == self.widget:
self.widget = self.prepare_new_widget()
newplug.add(self.widget)
else:
if None != self.widget.get_parent():
self.widget.reparent(newplug)
else:
newplug.add(self.widget)
if None != self.plug:
del self.plug
self.plug = newplug
self.plug.show_all()
Components.Client.logger.info(
"Prepare plug for insertion, ID={0}".format(self.plug.get_id()))
return self.plug.get_id()
def __init__(self):
usage = "usage: %prog [options]"
parser = OptionParser(usage=usage)
parser.disable_interspersed_args()
parser.add_options(options)
self.set_theme_font()
(opts, args) = parser.parse_args()
self.window = gtk.Window()
self.window.set_default_size(1024, 600)
xid = None
if opts.parent:
xid = int(opts.parent)
plug = gtk.Plug(xid)
for c in self.window.get_children():
self.window.remove(c)
plug.add(c)
self.window = plug
self.window.connect('destroy', self.quit)
self.table = gtk.Table(10, 5)
self.btn_hal = gtk.Button(label="HAL Configuration")
self.btn_hal.set_border_width(4)
self.btn_hal.connect("clicked", self.halshow_action)
self.btn_halscope = gtk.Button(label="HAL Scope")
self.btn_halscope.set_border_width(4)
self.btn_halscope.connect("clicked", self.halscope_action)
self.btn_ladder = gtk.Button(label="Ladder Logic")
self.btn_ladder.set_border_width(4)
self.btn_ladder.connect("clicked", self.ladder_action)
self.btn_teamviewer = gtk.Button(label="Teamviewer")
self.btn_teamviewer.set_border_width(4)
self.btn_teamviewer.connect("clicked", self.teamviewer_action)
self.btn_nautilus = gtk.Button(label="File Manager")
self.btn_nautilus.set_border_width(4)
self.btn_nautilus.connect("clicked", self.nautilus_action)
self.btn_linuxcncop = gtk.Button(label="Linuxcnc Status")
self.btn_linuxcncop.set_border_width(4)
self.btn_linuxcncop.connect("clicked", self.linuxcnc_status)
self.table.attach(self.btn_hal, 0, 1, 0, 1)
self.table.attach(self.btn_ladder, 0, 1, 1, 2)
self.table.attach(self.btn_linuxcncop, 0, 1, 2, 3)
self.table.attach(self.btn_halscope, 1, 2, 0, 1)
self.table.attach(self.btn_teamviewer, 1, 2, 1, 2)
self.table.attach(self.btn_nautilus, 1, 2, 2, 3)
self.window.add(self.table)
def __init__(self, xid, path):
self.conn = None
self.cursor = None
self.store = None
self.isopen = False
self.tables = gtk.combo_box_new_text()
self.table = gtk.TreeView()
self.dialog = gtk.Dialog()
self.table.set_enable_search(True)
self.table.set_grid_lines(grid_lines)
self.table.set_hover_selection(hover_selection)
if query_is_entry:
self.query = gtk.Entry()
self.query.set_editable(query_editable)
self.query.connect("activate", self.entry_activate)
else:
self.query = gtk.Label()
self.query.set_selectable(query_editable)
self.query.set_alignment(0, 0.5)
button = gtk.Button("Query", None, False)
button.connect("pressed", self.kostyl_dialog)
hbox = gtk.HBox(homogeneous=False, spacing=5)
hbox.pack_start(gtk.Label("Tables:"), False)
hbox.pack_start(self.tables, False)
hbox.add(self.query)
hbox.pack_end(button, False)
hbox.set_border_width(5)
self.sw = gtk.ScrolledWindow()
self.sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.sw.add(self.table)
self.container = gtk.VBox(homogeneous=False, spacing=5)
self.container.pack_start(hbox, expand=False)
self.container.add(self.sw)
self.open_db(path)
query = "SELECT * FROM {0};".format(self.tables.get_active_text())
self.query.set_text(query)
if self.isopen:
gobject.idle_add(self.execute, query)
self.plug = gtk.Plug(xid)
self.plug.add(self.container)
self.plug.connect("destroy", self.exit)
self.plug.show_all()
def add_plug(window):
"""Replace top level with a plug so it can be reparented.
This doesn't actually reparent the widget
"""
plug = gtk.Plug(0)
plug.show()
for c in window.get_children():
window.remove(c)
plug.add(c)
# Hide window if it's displayed
window.unmap()
return plug
def __init__(self, session_bus, appid, dbus_name, dbus_path):
dbus.service.Object.__init__(self, session_bus, dbus_path)
self.appid = appid
self.dbus_name = dbus_name
self.dbus_path = dbus_path
# WARING: only use once in one process
DBusGMainLoop(set_as_default=True)
self.plug = gtk.Plug(0)
self.webview = WebView(COOKIE_FILE)
self.webview.connect('title-changed', self.webview_message_handler)
self.webview.connect('script-alert', self.webview_message_handler)
#self.webview.enable_inspector()
self.paned_box = PanedBox(2, True, 2, True)
self.paned_box.enter_bottom_win_callback = self.enter_bottom_notify
self.paned_box.enter_top_win_callback = self.enter_top_notify
self.paned_box.add_content_widget(self.webview)
self.plug.add(self.paned_box)
self.plug.connect('delete-event', self.plug_delete_event)
# Handle signals.
self.plug.connect("realize", self.flash_frame_realize)
self.plug.connect("destroy", self.flash_frame_exit)
glib.timeout_add(1000, self.is_exist)
glib.timeout_add(200, self.connect_signal)
def message_receiver(self, *message):
message_type, contents = message
if message_type == 'exit':
self.exit()
elif message_type == 'load_uri':
self.load_flash(contents)
elif message_type == 'load_loading_uri':
self.webview.load_uri(contents)
self.send_message('loading_uri_finish', '')
elif message_type == 'load_string':
self.webview.load_string(contents)
elif message_type == 'get_plug_id':
self.send_flash_info()
elif message_type == 'app_info_download_finish':
self.webview.execute_script("app_info=%s" %
json.dumps(str(contents), encoding="UTF-8", ensure_ascii=False))
setattr(FlashFrame,
'message_receiver',
dbus.service.method(dbus_name)(message_receiver))
def __init__(self, socket_id, profile):
""" PlugBrowser(socket_id, profile) -> Basic initialization and
setup of a gtk.Plug to hold this browser view.
"""
super(
PlugBrowser,
self,
).__init__(profile)
self._socket_id = socket_id
self._pid = os.getpid()
plug = gtk.Plug(socket_id)
plug.add(self)
plug.show_all()
def __init__(self):
xdot.DotWidget.__init__(self)
self.connect('clicked', self.on_url_clicked)
self.connect('activate', self.on_url_activate)
self.connect('select', self.on_url_select)
self.connect('unselect-all', self.on_url_unselect_all)
self.connect('key-press-event', self.on_url_key_press)
self.flows = {}
self.current_flow = None
Wid = 0L
if len(sys.argv) == 3:
Wid = long(sys.argv[1])
locale_dir = str(sys.argv[2])
self.plug = gtk.Plug(Wid)
self.plug.add(self)
self.plug.show_all()
gettext.install("gebr", locale_dir)
def main(args=None):
translations.init()
gtk_options = (_('gtk-specific options'),
_("Options specific to bpython's Gtk+ front end"), [
optparse.Option('--socket-id',
dest='socket_id',
type='int',
help=_('Embed bpython'))
])
config, options, exec_args = bpython.args.parse(args, gtk_options, True)
interpreter = repl.Interpreter(None, getpreferredencoding())
repl_widget = ReplWidget(interpreter, config)
repl_widget.connect('exit-event', gtk.main_quit)
gobject.idle_add(init_import_completion)
if not exec_args:
sys.path.insert(0, '')
gobject.idle_add(repl_widget.startup)
else:
if options.interactive:
gobject.idle_add(bpython.args.exec_code, interpreter, exec_args)
else:
bpython.args.exec_code(interpreter, exec_args)
return 0
sys.stderr = repl_widget
sys.stdout = repl_widget
if not options.socket_id:
parent = gtk.Window()
parent.connect('delete-event', lambda widget, event: gtk.main_quit())
# branding
# fix icon to be distributed and loaded from the correct path
icon = gtk.gdk.pixbuf_new_from_file(
os.path.join(os.path.dirname(__file__), 'logo.png'))
parent.set_title('bpython')
parent.set_icon(icon)
parent.resize(600, 300)
else:
parent = gtk.Plug(options.socket_id)
parent.connect('destroy', gtk.main_quit)
container = gtk.VBox()
parent.add(container)
mb = gtk.MenuBar()
filemenu = gtk.Menu()
filem = gtk.MenuItem("File")
filem.set_submenu(filemenu)
save = gtk.ImageMenuItem(gtk.STOCK_SAVE)
save.connect("activate", repl_widget.do_write2file)
filemenu.append(save)
pastebin = gtk.MenuItem("Pastebin")
pastebin.connect("activate", repl_widget.do_paste)
filemenu.append(pastebin)
pastebin_partial = gtk.MenuItem(_("Pastebin selection"))
pastebin_partial.connect("activate", repl_widget.do_partial_paste)
filemenu.append(pastebin_partial)
exit = gtk.ImageMenuItem(gtk.STOCK_QUIT)
exit.connect("activate", gtk.main_quit)
filemenu.append(exit)
mb.append(filem)
vbox = gtk.VBox(False, 2)
vbox.pack_start(mb, False, False, 0)
container.pack_start(vbox, expand=False)
# read from config
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
sw.add(repl_widget)
container.add(sw)
sb = repl_widget.interact.statusbar
container.pack_end(sb, expand=False)
parent.set_focus(repl_widget)
parent.show_all()
parent.connect('delete-event', lambda widget, event: gtk.main_quit())
try:
gtk.main()
except KeyboardInterrupt:
pass
return 0
#!/usr/bin/python
import pygtk
pygtk.require('2.0')
import gtk, sys
Wid = 0L
if len(sys.argv) == 2:
Wid = long(sys.argv[1])
plug = gtk.Plug(Wid)
print "Plug ID=", plug.get_id()
def embed_event(widget):
print "I (", widget, ") have just been embedded!"
plug.connect("embedded", embed_event)
entry2 = gtk.Entry()
entry2.set_text("Munghi")
entry = gtk.Entry()
entry.set_text("hello")
def entry_point(widget):
print "You've changed my text to '%s'" % widget.get_text()
def __init__(self, policy, exceptions, embed=None, execution_path="/usr/share/tomoyo-mdv"):
"""Initializes main window and GUI"""
if embed:
self.window = gtk.Plug(embed)
else:
self.window = gtk.Window()
self.window.set_title(_("Tomoyo GUI"))
self.window.set_default_size(640, 440)
self.window.connect('delete-event', lambda *w: gtk.main_quit())
self.policy = policy
self.exceptions = exceptions
self.execution_path = execution_path
# main vbox
self.main_vbox = gtk.VBox()
self.window.add(self.main_vbox)
# toolbar
toolbar = gtk.Toolbar()
toolbar.set_style(gtk.TOOLBAR_ICONS)
toolbar_item = gtk.ToolButton("Refresh")
toolbar_item.set_stock_id(gtk.STOCK_REFRESH)
toolbar_item.connect("clicked", lambda *w: self.refresh_domains(self.all_domains, self.active_domains, reload=True))
toolbar_item.set_tooltip_text(_("Refresh policy"))
toolbar.insert(toolbar_item, -1)
toolbar_item = gtk.ToolButton("Save")
toolbar_item.set_stock_id(gtk.STOCK_SAVE)
toolbar_item.connect("clicked", lambda *w: self.save_domains())
toolbar_item.set_tooltip_text(_("Save policy"))
toolbar.insert(toolbar_item, -1)
toolbar_item = gtk.ToolButton(label="Save and apply")
toolbar_item.set_stock_id(gtk.STOCK_APPLY)
toolbar_item.connect("clicked", lambda *w: self.save_domains(reload=True))
toolbar_item.set_tooltip_text(_("Save and apply policy"))
toolbar.insert(toolbar_item, -1)
toolbar.insert(gtk.SeparatorToolItem(), -1)
# policy exporting
self.export_domains = gtk.ToolButton("Export")
self.export_domains.set_stock_id(gtk.STOCK_SAVE_AS)
self.export_domains.connect("clicked", self.export_policy)
self.export_domains.set_tooltip_text(_("Export selected policy"))
self.export_domains.set_sensitive(False)
self.selected_domains = None
toolbar.insert(self.export_domains, -1)
# policy importing
self.import_domains = gtk.ToolButton("Import")
self.import_domains.set_stock_id(gtk.STOCK_OPEN)
self.import_domains.connect("clicked", self.import_policy)
self.import_domains.set_tooltip_text(_("Import selected policy"))
self.import_domains.set_sensitive(True)
self.selected_domains = None
toolbar.insert(self.import_domains, -1)
toolbar.insert(gtk.SeparatorToolItem(), -1)
# policy initializing
self.initialize_domains = gtk.ToolButton("Initialize")
self.initialize_domains.set_stock_id(gtk.STOCK_REVERT_TO_SAVED)
self.initialize_domains.connect("clicked", self.install_policy)
self.initialize_domains.set_tooltip_text(_("Initialize policy"))
self.selected_domains = None
toolbar.insert(self.initialize_domains, -1)
toolbar.insert(gtk.SeparatorToolItem(), -1)
toolbar_item = gtk.ToolButton("Quit")
toolbar_item.set_stock_id(gtk.STOCK_QUIT)
toolbar_item.connect("clicked", lambda *w: gtk.main_quit())
toolbar_item.set_tooltip_text(_("Quit without saving"))
toolbar.insert(toolbar_item, -1)
self.main_vbox.pack_start(toolbar, False, False)
# tabs
self.notebook = gtk.Notebook()
self.main_vbox.pack_start(self.notebook)
self.notebook.connect('switch-page', self.show_help_for_page)
# domains
sw_all, self.all_domains = self.build_list_of_domains()
sw_active, self.active_domains = self.build_list_of_domains()
# help text for switching pages
self.num_pages = 0
self.page_help = {}
self.notebook.append_page(sw_all, gtk.Label(_("All domains")))
self.add_page_help("All domains")
self.notebook.append_page(sw_active, gtk.Label(_("Active domains")))
self.add_page_help("Active domains")
# contents
sw2 = gtk.ScrolledWindow()
sw2.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw2.set_shadow_type(gtk.SHADOW_ETCHED_IN)
frame = gtk.Frame(_("Details"))
self.domain_details = gtk.VBox(False, 5)
frame.add(self.domain_details)
sw2.add_with_viewport(frame)
self.main_vbox.pack_start(sw2)
# size group
self.size_group = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
# show initial help
self.show_help(0)
self.window.show_all()
self.refresh_domains(self.all_domains, self.active_domains)
# now building exceptions
sw_exceptions, self.ls_exceptions = self.build_list_of_exceptions()
self.update_exceptions()
self.notebook.append_page(sw_exceptions, gtk.Label(_("Exceptions")))
self.add_page_help("Exceptions")
# help
self.notebook.append_page(self.build_help(), gtk.Label(_("Help")))
self.add_page_help("Help")
