def show_changes(self):
self.new_version = float(self.changelog.split(' ')[0][1:])
if float(self.current_version) < self.new_version:
self.button_cancel.set_label('gtk-cancel')
self.button_cancel.set_use_stock(True)
self.button_cancel.set_label("Ignore")
self.set_title("There's a new version of Reaper available")
self.add_button("Go to download page", gtk.RESPONSE_OK)
self.add_button("Update", gtk.RESPONSE_YES)
self.button_update = self.action_area.get_children()[0]
self.button_web = self.action_area.get_children()[1]
gtk.settings_get_default().set_property('gtk-alternative-button-order', True)
self.set_alternative_button_order([
gtk.RESPONSE_OK, gtk.RESPONSE_YES, gtk.RESPONSE_CANCEL
])
self.scrolledwindow.set_size_request(
widget_get_char_width(self.scrolledwindow)*120,
widget_get_char_height(self.scrolledwindow)*min(len(self.changelog.split('\n')), 10)
)
self.textview.get_buffer().set_text(self.changelog)
self.button_update.connect('clicked', self.update_clicked)
self.button_web.connect('clicked', self.web_clicked)
else:
self.destroy()
exit(0)
def __init__(self, halcomp, builder, useropts):
get_ini_info = getiniinfo.GetIniInfo()
prefs = preferences.preferences(get_ini_info.get_preference_file_path())
theme_name = prefs.getpref("gtk_theme", "Follow System Theme", str)
if theme_name == "Follow System Theme":
theme_name = gtk.settings_get_default().get_property("gtk-theme-name")
gtk.settings_get_default().set_string_property("gtk-theme-name", theme_name, "")
def debug():
gtk.settings_get_default().set_long_property('gtk-button-images', True, 'True')
mainWindow = gtk.Window(gtk.WINDOW_TOPLEVEL)
mainWindow.set_title(APPNAME)
mainWindow.connect("destroy", quit)
applet = gnomeapplet.Applet()
gui = Gui(applet, None)
applet.reparent(mainWindow)
mainWindow.show_all()
gtk.main()
sys.exit()
def __config_load_custom_font(self):
use_custom_font = self.__config.get_value("panel", "use_custom_font", False)
font_name = gtk.settings_get_default().get_property("gtk-font-name")
font_name = unicode(font_name, "utf-8")
custom_font = self.__config.get_value("panel", "custom_font", font_name)
style_string = 'style "custom-font" { font_name="%s" }\n' 'class "IBusCandidateLabel" style "custom-font"\n'
if use_custom_font:
style_string = style_string % custom_font
gtk.rc_parse_string(style_string)
else:
style_string = style_string % ""
gtk.rc_parse_string(style_string)
settings = gtk.settings_get_default()
gtk.rc_reset_styles(settings)
def parse_config(self):
self.config = ConfigParser.RawConfigParser()
self.config.readfp(StringIO.StringIO(self.default_config))
self.config.read([
'/etc/marchobmenu/menu.conf',
os.path.expanduser('~/.config/marchobmenu/menu.conf')
])
self.show_icons = self.config.getboolean('Icons', 'show')
if self.show_icons:
self.default_icon = self.config.get('Icons', 'default')
self.icon_size = self.config.getint('Icons', 'size')
self.use_gtk_theme = self.config.getboolean('Icons', 'use_gtk_theme')
if self.use_gtk_theme:
try:
import pygtk
pygtk.require('2.0')
import gtk
gtk_settings = gtk.settings_get_default()
self.theme = gtk_settings.get_property('gtk-icon-theme-name')
except:
self.use_gtk_theme = False
self.theme = self.config.get('Icons','theme')
else:
self.theme = self.config.get('Icons','theme')
def launch_panel(replace):
settings = gtk.settings_get_default()
if settings.get_property('gtk-fallback-icon-theme') == None:
settings.set_property('gtk-fallback-icon-theme', 'gnome')
# gtk.settings_get_default().props.gtk_theme_name = "/home/phuang/.themes/aud-Default/gtk-2.0/gtkrc"
# gtk.rc_parse("./themes/default/gtkrc")
UIApplication(replace).run()
def reconfigure(self):
"""Update configuration for the whole application"""
if self.config['handle_size'] in xrange(0, 6):
gtk.rc_parse_string("""
style "terminator-paned-style" {
GtkPaned::handle_size = %s
}
class "GtkPaned" style "terminator-paned-style"
""" % self.config['handle_size'])
gtk.rc_reset_styles(gtk.settings_get_default())
# Cause all the terminals to reconfigure
for terminal in self.terminals:
terminal.reconfigure()
# Reparse our keybindings
self.keybindings.configure(self.config['keybindings'])
# Update tab position if appropriate
maker = Factory()
for window in self.windows:
child = window.get_child()
if maker.isinstance(child, 'Notebook'):
child.configure()
def on_theme_combobox_changed(self, widget):
model = widget.get_model()
active = widget.get_active()
self.theme = model[active][0].decode('utf-8')
settings = gtk.settings_get_default()
settings.set_property('gtk-theme-name', self.theme)
self.plugin.config['THEME'] = self.theme
def init(self):
self.config_dialog = ThemeSwitcherPluginConfigDialog(self)
settings = gtk.settings_get_default()
default_theme = settings.get_property('gtk-theme-name')
self.config['DEFAULT_THEME'] = default_theme
self.theme = default_theme
self.config_default_values = {'THEME': (default_theme, '')}
def _show_dialog_program_error_question(self, offer_info=True):
dialog = gtk.MessageDialog(parent=common.get_main_window(),
flags=gtk.DIALOG_DESTROY_WITH_PARENT,
type=gtk.MESSAGE_ERROR,
buttons=gtk.BUTTONS_OK)
dialog.set_icon_name('vineyard-preferences')
dialog.set_markup('<span weight="bold" size="larger">%s</span>' % \
_("The program exited with an error"))
if self.name == 'winetricks':
dialog.format_secondary_markup(unicode('The installation program did ' + \
'not exit cleanly. You may have success with simply running it again.'))
else:
dialog.format_secondary_markup(unicode('The program <b>%(program)s</b> did ' + \
'not exit cleanly and any work or progress you may have ' + \
'done in the program may have been lost.') % \
{'program': common.escape_xml(self.name)})
settings = gtk.settings_get_default()
settings.set_property('gtk-alternative-button-order', True)
if offer_info:
button_info = gtk.Button(_("More info"))
dialog.add_action_widget(button_info, 10)
dialog.set_alternative_button_order([10, gtk.RESPONSE_OK])
dialog.set_default_response(gtk.RESPONSE_OK)
dialog.connect("response", self._on_dialog_main_response)
dialog.show_all()
def __init__(self):
"Initialize the PresFilter."
gtk.Entry.__init__(self)
self._handler_changed = self.connect_after("changed", self._on_changed)
self.connect("key-press-event", self._on_key_pressed)
self.connect("focus-in-event", exposong.main.main.disable_shortcuts)
self.connect("focus-out-event", exposong.main.main.enable_shortcuts)
self.connect("terms-changed", self.filter)
# Make sure icons are supported by GTK version
self.use_icons = gtk.gtk_version[0] >= 2 and gtk.gtk_version[1] > 16
if self.use_icons:
self.set_icon_from_stock(gtk.ENTRY_ICON_PRIMARY, gtk.STOCK_FIND)
self.connect("icon-press", self._on_icon_pressed)
# Do not draw a yellow bg if an a11y theme is used
settings = gtk.settings_get_default()
theme = settings.get_property("gtk-theme-name")
self._a11y = theme.startswith("HighContrast") or theme.startswith("LowContrast")
# set sensible atk name
atk_desc = self.get_accessible()
atk_desc.set_name(_("Search"))
# data
self._timeout_id = 0
self.__fmodel = None
def __init__(self, icon_theme):
"""
Creates an enhanced IconEntry that supports a time out when typing
and uses a different background colour when the search is active
"""
sexy.IconEntry.__init__(self)
self.__gobject_init__()
self._handler_changed = self.connect_after("changed",
self._on_changed)
self.connect("icon-pressed", self._on_icon_pressed)
# Does not work - known bug in libsexy
# image = gtk.image_new_from_icon_name(gtk.STOCK_CLEAR,
# gtk.ICON_SIZE_MENU)
image = gtk.Image()
pixbuf = icon_theme.load_icon(gtk.STOCK_CLEAR,
gtk.ICON_SIZE_MENU,
0)
image.set_from_pixbuf(pixbuf)
self.set_icon(sexy.ICON_ENTRY_SECONDARY, image)
self.set_icon_highlight(sexy.ICON_ENTRY_PRIMARY, True)
# Do not draw a yellow bg if an a11y theme is used
settings = gtk.settings_get_default()
theme = settings.get_property("gtk-theme-name")
self._a11y = theme.startswith("HighContrast") or\
theme.startswith("LowContrast")
self._timeout_id = 0
def init_main_window(self):
main_window = self.widgets['window']
settings = gtk.settings_get_default()
settings.props.gtk_menu_bar_accel = None
self.keymap = gtk.gdk.keymap_get_default()
accel_group = gtk.AccelGroup()
main_window.add_accel_group(accel_group)
self.widgets['accel_group'] = accel_group
self.assign_key_binding(constants.hide_connections_keys, self.hide_unhide_tree)
self.assign_key_binding(constants.terminal_home_keys, self.do_localhost)
self.assign_key_binding('F10', self.f10_event)
self.assign_key_binding(constants.tab_close_keys, self.close_tab_event)
main_window.connect("delete-event", self.x_event)
# Grab the default color
self.default_color = DefaultColorSettings().base_color
# Until I figure if I want this I'll disable it
mb_http_server = self.widgets['mb_http_server']
mb_http_server.hide()
#Remove the first tab from the notebook
self.terminals = self.widgets["terminals"]
self.terminals.remove_page(0)
main_window.show()
self.hide_unhide_cluster_box(self.widgets['mb_cluster'])
def __init__(self, projects, toplevel=None):
BaseDialog.__init__(self, parent=toplevel)
self.add_buttons(_("Close _without Saving"), gtk.RESPONSE_NO,
gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_SAVE, gtk.RESPONSE_YES)
save, cancel, close = self.action_area.get_children()
if gtk.settings_get_default().get_property(
"gtk-alternative-button-order"):
save, close = close, save
save.set_name("save")
cancel.set_name("cancel")
close.set_name("close")
self.set_default_response(gtk.RESPONSE_YES)
self.set_border_width(6)
self.set_resizable(False)
self.set_has_separator(False)
self.vbox.set_spacing(12)
# Add the warning image to the dialog
warning_image = gtk.image_new_from_stock(gtk.STOCK_DIALOG_WARNING,
gtk.ICON_SIZE_DIALOG)
warning_image.set_alignment(0.5, 0)
self._hbox = gtk.HBox(False, 12)
self._hbox.set_border_width(6)
self._hbox.pack_start(warning_image, False, False, 0)
self.vbox.pack_start(self._hbox)
def change_theme(self,b):
theme = self.wTree.get_widget("theme_choice").get_active_text()
self.prefs.putpref('gtk_theme', theme, str)
if theme == "Follow System Theme":
theme = self.system_theme
settings = gtk.settings_get_default()
settings.set_string_property("gtk-theme-name", theme, "")
def _setup_gtk(self):
import gtk
from kiwi.environ import environ
gtk.gdk.threads_init()
# Total madness to make sure we can draw treeview lines,
# this affects the GtkTreeView::grid-line-pattern style property
#
# Two bytes are sent in, see gtk_tree_view_set_grid_lines in gtktreeview.c
# Byte 1 should be as high as possible, gtk+ 0x7F appears to be
# the highest allowed for Gtk+ 2.22 while 0xFF worked in
# earlier versions
# Byte 2 should ideally be allowed to be 0, but neither C nor Python
# allows that.
#
data = environ.get_resource_string("stoq", "misc", "stoq.gtkrc")
data = data.replace('\\x7f\\x01', '\x7f\x01')
gtk.rc_parse_string(data)
# Creating a button as a temporary workaround for bug
# https://bugzilla.gnome.org/show_bug.cgi?id=632538, until gtk 3.0
gtk.Button()
settings = gtk.settings_get_default()
settings.props.gtk_button_images = True
def __init__(self):
gtk.settings_get_default().props.gtk_button_images = True
self.builder = gtk.Builder()
self.builder.add_from_file(get_resource_path("gui.glade"))
self.builder.connect_signals(self)
self.builder.get_object("sgf_file_filter").add_pattern("*.sgf")
self.builder.get_object("forward").set_sensitive(False)
self.builder.get_object("back").set_sensitive(False)
canvas = self.builder.get_object("canvas")
os.putenv('SDL_WINDOWID', str(canvas.window.xid))
gtk.gdk.flush()
pygame.init()
pygame.display.set_mode((400, 400), 0, 0)
self.screen = pygame.display.get_surface()
self.size = None
self.last = None
self.font = pygame.font.Font(get_resource_path("DroidSansMono.ttf"), 16)
gobject.idle_add(self.draw)
if len(sys.argv) == 2:
self.set_file(sys.argv[1])
else:
self.set_size(7)
self.pb = "None"
self.pw = "None"
def main():
import logging
import gtk
settings = gtk.settings_get_default()
# Use a button ordering more consistent with Windows
print 'Use a button ordering more consistent with Windows'
settings.set_property('gtk-alternative-button-order', True)
logging.basicConfig(format='%(asctime)s [%(levelname)s:%(name)s]: '
'%(message)s', datefmt=r'%Y-%m-%d %H:%M:%S',
level=logging.INFO)
initialize_core_plugins()
from app import App
from app_context import get_app
gtk.threads_init()
gtk.gdk.threads_init()
gtk.gdk.threads_enter()
my_app = get_app()
sys.excepthook = except_handler
my_app.run()
gtk.gdk.threads_leave()
def __init__(self, icon_theme=None):
"""
Creates an enhanced IconEntry that supports a time out when typing
and uses a different background colour when the search is active
"""
sexy.IconEntry.__init__(self)
if not icon_theme:
icon_theme = gtk.icon_theme_get_default()
self._handler_changed = self.connect_after("changed",
self._on_changed)
self.connect("icon-pressed", self._on_icon_pressed)
image_find = gtk.image_new_from_stock(gtk.STOCK_FIND,
gtk.ICON_SIZE_MENU)
self.set_icon(sexy.ICON_ENTRY_PRIMARY, image_find)
self.empty_image = gtk.Image()
self.clear_image = gtk.image_new_from_stock(gtk.STOCK_CLEAR,
gtk.ICON_SIZE_MENU)
self.set_icon(sexy.ICON_ENTRY_SECONDARY, self.clear_image)
self.set_icon_highlight(sexy.ICON_ENTRY_PRIMARY, True)
# Do not draw a yellow bg if an a11y theme is used
settings = gtk.settings_get_default()
theme = settings.get_property("gtk-theme-name")
self._a11y = (theme.startswith("HighContrast") or
theme.startswith("LowContrast"))
# data
self._timeout_id = 0
self._undo_stack = [""]
self._redo_stack = []
def init():
"""Shared SCBdo program initialisation."""
print ("\n\
SCBdo(" + VERSION + ") Copyright (C) 2010,2011 Nathan Fraser\n\
This program comes with ABSOLUTELY NO WARRANTY.\n\
This is free software, and you are welcome to redistribute it\n\
under certain conditions.\n\n")
# prepare for type 1 threads
gobject.threads_init()
# fix the menubar accel mapping
mset = gtk.settings_get_default()
mset.set_string_property('gtk-menu-bar-accel', 'F24', 'override')
# set the global default window icon
try:
gtk.window_set_default_icon_from_file(SCB_LOGOFILE)
except:
SCB_LOGOFILE = os.path.join(UI_PATH, 'scbdo_icon.png')
gtk.window_set_default_icon_from_file(SCB_LOGOFILE)
# Set global logging options
logging._srcfile = None
logging.logThreads = 0
logging.logProcesses = 0
# Check for data path and change working directory
mk_data_path()
os.chdir(DATA_PATH)
def __pick_theme(self, name=None):
name = name or gtk.settings_get_default().get_property("gtk-theme-name")
themes = PathBarThemes.DICT
if themes.has_key(name):
return themes[name]()
#print "No styling hints for %s are available" % name
return PathBarThemeHuman()
def __init__(self, icon_theme=None):
"""
Creates an enhanced IconEntry that supports a time out when typing
and uses a different background colour when the search is active.
"""
gtk.Entry.__init__(self)
if not icon_theme:
icon_theme = gtk.icon_theme_get_default()
self._handler_changed = self.connect_after('changed',
self._on_changed)
self.connect('icon-press', self._on_icon_pressed)
self.set_icon_from_stock(gtk.ENTRY_ICON_PRIMARY, gtk.STOCK_FIND)
self.set_icon_from_stock(gtk.ENTRY_ICON_SECONDARY, None)
# Do not draw a yellow bg if an a11y theme is used
settings = gtk.settings_get_default()
theme = settings.get_property('gtk-theme-name')
self._a11y = (theme.startswith('HighContrast') or
theme.startswith('LowContrast'))
# set sensible atk name
atk_desc = self.get_accessible()
atk_desc.set_name(_('Search'))
# data
self._timeout_id = 0
self._undo_stack = ['']
self._redo_stack = []
def __init__(self, parent, dictRes):
## STOCK ITEM
self.stock_items = (
("gtk-sendResult", "", 0, 0, None),
)
self.stock_aliases = (
("gtk-sendResult", gtk.STOCK_EXECUTE),
)
gtk.stock_add(self.stock_items)
factory = gtk.IconFactory()
factory.add_default()
style = gtk.Style()
for item, alias in self.stock_aliases:
icon_set = style.lookup_icon_set(alias)
factory.add(item, icon_set)
## FENETRE
self.parent=parent
Window.__init__(self, "Administration Oracle : Résultats")
self.fenetre.connect("delete_event", self.close_window)
settings = gtk.settings_get_default()
settings.props.gtk_button_images = True
self.vbox_main = gtk.VBox(False, 20)
self.fenetre.add(self.vbox_main)
self.frm_res=gtk.Frame("Résultats")
self.scrolled_window = gtk.ScrolledWindow()
self.scrolled_window.set_border_width(10)
self.scrolled_window.set_policy(gtk.POLICY_NEVER, gtk.POLICY_NEVER)
self.scrolled_window.add_with_viewport(self.frm_res)
self.tab_send = gtk.Table(2, 1, False)
self.frm_send=gtk.Frame("Envoi des résultats par mail ")
self.frm_send.add(self.tab_send)
self.vbox_main.pack_start(self.frm_send, False, False, 0)
self.vbox_main.pack_start(self.scrolled_window, True, True, 0)
self.vbox_resultats= gtk.VBox(False, 0)
self.entry_mail = gtk.Entry()
self.entry_mail.set_width_chars(50)
self.entry_mail.set_text("[email protected];[email protected];...")
self.but_mailRes = gtk.Button(stock="gtk-sendResult")
self.but_mailRes.modify_bg(gtk.STATE_NORMAL, self.but_color)
self.but_mailRes.connect("clicked", self.sendResult, dictRes)
self.tab_send.attach(self.entry_mail, 0, 1, 0, 1)
self.tab_send.attach(self.but_mailRes, 0, 1, 1, 2)
self.frm_res.add(self.vbox_resultats)
self.setResults(dictRes)
self.fenetre.show_all()
# Min Size
winSize=self.fenetre.get_size()
screen = self.fenetre.get_screen()
if winSize[0]+80 >= screen.get_width()-80:
newWidth = screen.get_width()-80
else:
newWidth = winSize[0]+80
if winSize[1]+80 >= screen.get_height()-80:
newHeight = screen.get_height()-80
else:
newHeight = winSize[1]+80
self.fenetre.resize(newWidth, newHeight)
self.scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
def set_theme_font(self):
# set ui theme
config = ConfigParser.ConfigParser()
fn = os.path.expanduser(".touchy_preferences")
config.read(fn)
theme_name = config.get("DEFAULT", 'gtk_theme')
settings = gtk.settings_get_default()
settings.set_string_property("gtk-theme-name", theme_name, "")
def on_skin2_activate(self, *args):
rc_defs = list(gtk.rc_get_default_files())
# rc_xtra = os.path.join(mysttop,'resources/mcao-eng.gtkrc')
rc_xtra = '/export/home/mcao/mcao-mascot/resources/mcao-eng.gtkrc'
if rc_xtra not in rc_defs: rc_defs.append(rc_xtra)
gtk.rc_set_default_files(rc_defs)
settings = gtk.settings_get_default()
gtk.rc_reparse_all_for_settings(settings, force_load=True)
def new_display(key, focus, comm2, **a):
if 'SCALE' in os.environ:
sc = int(os.environ['SCALE'])
s = gtk.settings_get_default()
s.set_long_property("gtk-xft-dpi",sc*pango.SCALE, "code")
disp = EdDisplay(focus)
comm2('callback', disp.pane)
return 1
def theme_clicked(self, widget, themedir):
# Use 'gtk.settings' instead of 'gtk.rc' By [email protected]
settings = gtk.settings_get_default()
if themedir:
settings.set_string_property("gtk-theme-name", themedir, "")
#gtk.rc_parse_string('gtk-theme-name = "%s"' % themedir)
else:
settings.set_string_property("gtk-theme-name", "Default", "")
def get_color(logicalcolorname):
settings = gtk.settings_get_default()
color_style = gtk.rc_get_style_by_paths(settings, 'GtkButton', \
'osso-logical-colors', gtk.Button)
if not color_style:
font_style = gtk.rc_get_style_by_paths(settings,
'GtkButton', 'GtkButton', gtk.Button)
return color_style.lookup_color(logicalcolorname)
def __init__(self):
self.init_mainwin()
self.init_status_icon()
self.init_category_treeview()
self.init_notebook()
settings = gtk.settings_get_default()
settings.props.gtk_button_images=True
def get_icon_theme(name):
if isinstance(name, gtk.IconTheme):
return name
theme = gtk.IconTheme()
if not name:
settings = gtk.settings_get_default()
name = settings.get_property('gtk-icon-theme-name')
theme.set_custom_theme(name)
return theme
def set_theme(self):
theme = gtk.settings_get_default().get_property('gtk-theme-name')
if os.path.exists(self.prefFile):
try:
with open(self.prefFile, 'r') as f_in:
for line in f_in:
if 'gtk_theme' in line and not 'Follow System Theme' in line:
(item, theme) = line.strip().replace(" ", "").split('=')
except:
print('*** configuration file, {} is invalid ***'.format(self.prefFile))
else:
theme = self.i.find('PLASMAC', 'THEME') or gtk.settings_get_default().get_property('gtk-theme-name')
font = self.i.find('PLASMAC', 'FONT') or gtk.settings_get_default().get_property('gtk-font-name')
fSize = int(font.split()[1])
# font = '{} {}'.format(font.split()[0],fSize - 1 if fSize < 12 else fSize - 2)
font = '{} {}'.format(font.split()[0],fSize - 1)
gtk.settings_get_default().set_property('gtk-font-name', font)
gtk.settings_get_default().set_property('gtk-theme-name', theme)
def init(withgtk=True):
"""Shared metarace program initialisation."""
# Check for data path and change working directory
mk_data_path()
os.chdir(DATA_PATH)
# Set global logging options
logging._srcfile = None
logging.logThreads = 0
logging.logProcesses = 0
# read in system configuration - errors here print to stderr, but
# are not necessarily fatal.
conffile = default_file(SYSCONF_FILE)
try:
if os.path.exists(conffile):
with open(conffile, 'rb') as f:
sysconf.read(f)
except Exception as e:
print(u'Error reading system config from ' + repr(conffile) + ': ' +
repr(e))
# Do GTK init unless disabled
if withgtk:
# Initialise threading in glib
try:
glib.threads_init()
except:
gobject.threads_init()
# Initialise threading in GDK
gtk.gdk.threads_init()
# Try some window methods, but don't worry if they fail
try:
# fix the gnome menubar accelerator mapping
mset = gtk.settings_get_default()
mset.set_string_property('gtk-menu-bar-accel', 'F24', 'override')
gtk.window_set_default_icon_from_file(default_file(LOGO_FILE))
except:
pass # but ignore errors
def __init__(self, parent, application_dir):
self.application_dir = application_dir
self.current_url = None
self.document = None
self.lang = None
self.lang_root = None
self.cached_internal_stream = ""
self.opener = None
self.parent = parent
self.start_page_uri = ""
self.view = None
self.page_bg = "#ffff"
self.page_fg = "#0000"
self.image_prefix = ""
s = gtk.settings_get_default()
self.theme_name = s.get_property("gtk-theme-name")
self.font_scale = 1.0
self.h3_fontsize = FONTSIZE_H3_DEFAULT
self.body_fontsize = FONTSIZE_BODY_DEFAULT
self.show_start_page = False
def __init__(self, tbl_version):
self.tbl_version = tbl_version
# initialize the app
self.default_mirror = 'https://dist.torproject.org/'
self.discover_arch_lang()
self.build_paths()
for d in self.paths['dirs']:
self.mkdir(self.paths['dirs'][d])
self.load_mirrors()
self.load_settings()
self.mkdir(self.paths['download_dir'])
self.mkdir(self.paths['tbb']['dir'])
self.init_gnupg()
# allow buttons to have icons
try:
gtk_settings = gtk.settings_get_default()
gtk_settings.props.gtk_button_images = True
except:
pass
def _run_xephyr(display, dpi, dimensions, fullscreen):
cmd = ['Xephyr']
cmd.append(':%d' % display)
cmd.append('-ac')
cmd += ['-title', _('Sugar in a window')]
screen_size = (gtk.gdk.screen_width(), gtk.gdk.screen_height())
if (not dimensions) and (fullscreen is None) and \
(screen_size <= default_dimensions):
# no forced settings, screen too small => fit screen
fullscreen = True
elif not dimensions:
# screen is big enough or user has en/disabled fullscreen manually
# => use default size (will get ignored for fullscreen)
dimensions = '%dx%d' % default_dimensions
if not dpi:
dpi = gtk.settings_get_default().get_property('gtk-xft-dpi') / 1024
if fullscreen:
cmd.append('-fullscreen')
if dimensions:
cmd.append('-screen')
cmd.append(dimensions)
if dpi:
cmd.append('-dpi')
cmd.append('%d' % dpi)
cmd.append('-noreset')
try:
pipe = subprocess.Popen(cmd)
except OSError, exc:
sys.stderr.write('Error executing server: %s\n' % (exc, ))
return None
def _setup_gtk(self):
import gtk
from kiwi.environ import environ
# Total madness to make sure we can draw treeview lines,
# this affects the GtkTreeView::grid-line-pattern style property
#
# Two bytes are sent in, see gtk_tree_view_set_grid_lines in gtktreeview.c
# Byte 1 should be as high as possible, gtk+ 0x7F appears to be
# the highest allowed for Gtk+ 2.22 while 0xFF worked in
# earlier versions
# Byte 2 should ideally be allowed to be 0, but neither C nor Python
# allows that.
#
data = environ.get_resource_string("stoq", "misc", "stoq.gtkrc")
data = data.replace('\\x7f\\x01', '\x7f\x01')
gtk.rc_parse_string(data)
# Creating a button as a temporary workaround for bug
# https://bugzilla.gnome.org/show_bug.cgi?id=632538, until gtk 3.0
gtk.Button()
settings = gtk.settings_get_default()
settings.props.gtk_button_images = True
from stoqlib.lib.environment import is_developer_mode
if is_developer_mode() and gtk.gtk_version[0] == 2:
from gtk import gdk
# Install a Control-Q handler that forcefully exits
# the program without saving any kind of state
def event_handler(event):
if (event.type == gdk.KEY_PRESS
and event.state & gdk.CONTROL_MASK
and event.keyval == gtk.keysyms.q):
os._exit(0)
gtk.main_do_event(event)
gdk.event_handler_set(event_handler)
def __init__(self):
builder = gtk.Builder()
builder.add_from_file("interface.glade")
#Interface configuration options
settings = gtk.settings_get_default()
settings.props.gtk_button_images = True
self.excavare = builder.get_object("Excavare")
self.excavare.set_title("Excavare")
self.excavare.maximize()
self.pdfda = builder.get_object("pdfda")
self.pageIndicator = builder.get_object("pageIndicator")
self.fileDisplayArea = builder.get_object("fileDisplayArea")
self.pdfDisplayArea = builder.get_object("pdfDisplayArea")
self.tab_name = builder.get_object("tab_name")
self.tab_widget = builder.get_object("tab_widget")
self.tabFileDictionary = {None: None}
self.scrolledwindow2 = builder.get_object("scrolledwindow2")
self.total_pages = 0
self.current_selection = None
self.treeview = builder.get_object("treeview1")
self.pdfda = builder.get_object("pdfda")
self.fileNavigator = builder.get_object("fileNavigator")
self.list_store = gtk.ListStore(str, int, str, int, int, bool)
self.treeview.set_model(self.list_store)
self.notebook = builder.get_object("notebook1")
self.column = gtk.TreeViewColumn('Files')
self.treeview.append_column(self.column)
self.cell = gtk.CellRendererText()
self.column.pack_start(self.cell, True)
self.column.set_attributes(self.cell, text=0)
self.tab_nums = -1
self.page = 0
self.scale = 1
self.is_workspace = False
builder.connect_signals(self)
self.textviews = []
def _set_colors(self, colors):
# See gtk.RcStyle docs for all values in RC file
rc = 'style "zim-colors"\n{\n'
for i, state in enumerate((
'NORMAL',
#'ACTIVE',
#'PRELIGHT',
#'SELECTED',
#'INSENSITIVE',
)):
values = colors[i]
values['state'] = state
rc += '\tbase[%(state)s] = "%(base)s"\n' \
'\ttext[%(state)s] = "%(text)s"\n' \
'\tbg[%(state)s] = "%(bg)s"\n' % values
#'\tfg[%(state)s] = "%(fg)s"\n' % values
#rc += '}\nclass "GtkWidget" style "zim-colors"'
rc += '}\nwidget "*.zim-pageview" style "zim-colors"\n'
logger.debug('Parse RC: >>>\n%s<<<', rc)
gtk.rc_parse_string(rc)
gtk.rc_reset_styles(gtk.settings_get_default())
def set_theme(self):
theme = gtk.settings_get_default().get_property('gtk-theme-name')
if os.path.exists(self.prefFile):
try:
with open(self.prefFile, 'r') as f_in:
for line in f_in:
if 'gtk_theme' in line and not 'Follow System Theme' in line:
(item, theme) = line.strip().replace(" ",
"").split('=')
except:
self.dialog_error('Preferences file, {} is invalid ***'.format(
self.prefFile))
print('*** preferences file, {} is invalid ***'.format(
self.prefFile))
else:
theme = self.i.find(
'PLASMAC', 'THEME') or gtk.settings_get_default().get_property(
'gtk-theme-name')
font = self.i.find('PLASMAC', 'FONT') or gtk.settings_get_default(
).get_property('gtk-font-name')
gtk.settings_get_default().set_property('gtk-font-name', font)
gtk.settings_get_default().set_property('gtk-theme-name', theme)
class Application:
def __init__(self):
self.Dead = False
self.ActiveProfile = None
# Figure out our installation paths
self.DATADIR = os.path.join(
os.path.dirname(os.path.abspath(sys.argv[0])),
"share").decode(FNENC)
if not os.path.exists(self.DATADIR):
self.DATADIR = os.path.join(os.path.normpath(sys.prefix),
"share/xpd").decode(FNENC)
if not os.path.exists(self.DATADIR):
self.DATADIR = os.path.join(
os.path.normpath(
os.path.join(
os.path.dirname(os.path.abspath(sys.argv[0])),
"..")), "share/xpd").decode(FNENC)
if not os.path.exists(self.DATADIR):
raise SystemExit, _("FATAL: Could not find data directory")
self.CONFIGDIR = os.path.join(glib.get_user_data_dir(),
"xpd").decode('utf-8')
if not os.access(self.CONFIGDIR, os.F_OK):
os.makedirs(self.CONFIGDIR, 0700)
def Initialize(self, textdomain):
# Load the widgets from the GtkBuilder file
self.builder = gtk.Builder()
self.builder.set_translation_domain(textdomain)
try:
self.builder.add_from_file(self.DATADIR + "/gui.xml")
except RuntimeError, e:
raise SystemExit(str(e))
# Cache most used widgets into variables
for widget in "MainWindow", "AboutDialog", "StatusBar", "SerialPortsList", \
"ProfileList", "EditProfileDialog", "ProfileName", "ParamDescLabel", \
"ParamVBox", "ControllerFamily", "UserChoice", "UserHints" :
setattr(self, widget, self.builder.get_object(widget))
# Due to a bug in libglade we can't embed controls into the status bar
self.ButtonCancelUpload = gtk.Button(stock="gtk-cancel")
self.StatusBar.pack_end(self.ButtonCancelUpload, False, True, 0)
self.ButtonCancelUpload.connect("clicked",
self.on_ButtonCancelUpload_clicked)
alignment = gtk.Alignment(0.5, 0.5)
self.StatusBar.pack_end(alignment, False, True, 0)
alignment.show()
self.ProgressBar = gtk.ProgressBar()
alignment.add(self.ProgressBar)
self.StatusCtx = self.StatusBar.get_context_id("")
self.builder.connect_signals(self)
self.InitProfileList()
self.LoadProfiles()
self.FillFamilies()
# Dynamic serial port list update worker
self.SerialPortsHash = None
self.UpdateSerialPorts()
glib.timeout_add_seconds(1, self.RefreshSerialPorts)
# Enable image buttons on Windows; on Linux you can change it via preferences
if os.name == "nt":
settings = gtk.settings_get_default()
settings.set_property("gtk-button-images", True)
self.MainWindow.show()
self.SetStatus(_("Ready"))
def __init__(self, handle, create_jobject=True):
"""Initialise the Activity
handle -- sugar.activity.activityhandle.ActivityHandle
instance providing the activity id and access to the
presence service which *may* provide sharing for this
application
create_jobject -- boolean
define if it should create a journal object if we are
not resuming
Side effects:
Sets the gdk screen DPI setting (resolution) to the
Sugar screen resolution.
Connects our "destroy" message to our _destroy_cb
method.
Creates a base gtk.Window within this window.
Creates an ActivityService (self._bus) servicing
this application.
Usage:
If your Activity implements __init__(), it should call
the base class __init()__ before doing Activity specific things.
"""
# Stuff that needs to be done early
icons_path = os.path.join(get_bundle_path(), 'icons')
gtk.icon_theme_get_default().append_search_path(icons_path)
sugar_theme = 'sugar-72'
if 'SUGAR_SCALING' in os.environ:
if os.environ['SUGAR_SCALING'] == '100':
sugar_theme = 'sugar-100'
# This code can be removed when we grow an xsettings daemon (the GTK+
# init routines will then automatically figure out the font settings)
settings = gtk.settings_get_default()
settings.set_property('gtk-font-name',
'%s %f' % (style.FONT_FACE, style.FONT_SIZE))
settings.set_property('gtk-theme-name', sugar_theme)
settings.set_property('gtk-icon-theme-name', 'sugar')
settings.set_property(
'gtk-icon-sizes', 'gtk-large-toolbar=%s,%s' %
(style.STANDARD_ICON_SIZE, style.STANDARD_ICON_SIZE))
Window.__init__(self)
if 'SUGAR_ACTIVITY_ROOT' in os.environ:
# If this activity runs inside Sugar, we want it to take all the
# screen. Would be better if it was the shell to do this, but we
# haven't found yet a good way to do it there. See #1263.
self.connect('window-state-event', self.__window_state_event_cb)
screen = gtk.gdk.screen_get_default()
screen.connect('size-changed', self.__screen_size_changed_cb)
self._adapt_window_to_screen()
# process titles will only show 15 characters
# but they get truncated anyway so if more characters
# are supported in the future we will get a better view
# of the processes
proc_title = '%s <%s>' % (get_bundle_name(), handle.activity_id)
util.set_proc_title(proc_title)
self.connect('realize', self.__realize_cb)
self.connect('delete-event', self.__delete_event_cb)
self._active = False
self._activity_id = handle.activity_id
self.shared_activity = None
self._join_id = None
self._updating_jobject = False
self._closing = False
self._quit_requested = False
self._deleting = False
self._max_participants = 0
self._invites_queue = []
self._jobject = None
self._read_file_called = False
self._session = _get_session()
self._session.register(self)
self._session.connect('quit-requested',
self.__session_quit_requested_cb)
self._session.connect('quit', self.__session_quit_cb)
accel_group = gtk.AccelGroup()
self.set_data('sugar-accel-group', accel_group)
self.add_accel_group(accel_group)
self._bus = ActivityService(self)
self._owns_file = False
share_scope = SCOPE_PRIVATE
if handle.object_id:
self._jobject = datastore.get(handle.object_id)
if 'share-scope' in self._jobject.metadata:
share_scope = self._jobject.metadata['share-scope']
if 'launch-times' in self._jobject.metadata:
self._jobject.metadata['launch-times'] += ', %d' % \
int(time.time())
else:
self._jobject.metadata['launch-times'] = \
str(int(time.time()))
self.shared_activity = None
self._join_id = None
if handle.object_id is None and create_jobject:
logging.debug('Creating a jobject.')
self._jobject = self._initialize_journal_object()
if handle.invited:
wait_loop = gobject.MainLoop()
self._client_handler = _ClientHandler(
self.get_bundle_id(), partial(self.__got_channel_cb,
wait_loop))
# FIXME: The current API requires that self.shared_activity is set
# before exiting from __init__, so we wait until we have got the
# shared activity. http://bugs.sugarlabs.org/ticket/2168
wait_loop.run()
else:
pservice = presenceservice.get_instance()
mesh_instance = pservice.get_activity(self._activity_id,
warn_if_none=False)
self._set_up_sharing(mesh_instance, share_scope)
if not create_jobject:
self.set_title(get_bundle_name())
return
if self.shared_activity is not None:
self._jobject.metadata['title'] = self.shared_activity.props.name
self._jobject.metadata['icon-color'] = \
self.shared_activity.props.color
else:
self._jobject.metadata.connect('updated',
self.__jobject_updated_cb)
self.set_title(self._jobject.metadata['title'])
bundle = get_bundle_instance(get_bundle_path())
self.set_icon_from_file(bundle.get_icon())
import gobject
import pango
try:
import gtkspell
except ImportError:
logging.warning(
'For spell checking, please install pygtkspellcheck (python-gtkspellcheck).')
gtkspell = None
from rednotebook.gui import t2t_highlight
from rednotebook import undo
from rednotebook.util import filesystem
DEFAULT_FONT = gtk.settings_get_default().get_property('gtk-font-name')
class Editor(object):
def __init__(self, day_text_view, undo_redo_manager):
self.day_text_view = day_text_view
self.day_text_buffer = t2t_highlight.get_highlight_buffer()
self.day_text_view.set_buffer(self.day_text_buffer)
self.undo_redo_manager = undo_redo_manager
self.changed_connection = self.day_text_buffer.connect('changed', self.on_text_change)
self.old_text = ''
self.search_text = ''
if USE_TEXTDOMAIN:
sys_locale = '/usr/share/locale'
all_dirs, all_files = treedir(sys_locale, False)
textdomain = CF.D.TEXTDOMAIN
if textdomain + '.mo' in all_files:
gettext.bindtextdomain(textdomain, sys_locale)
gettext.textdomain(textdomain)
else:
logger.w('Can not bind textdomain %s' % textdomain)
## We can use some custom style here.
#settings = gtk.settings_get_default()
#settings.set_string_property('gtk-theme-name', 'Default', '')
#gtk.rc_parse_string(open('style.rc', 'rt').read())
#print gtk.rc_get_theme_dir()
settings = gtk.settings_get_default()
settings.set_string_property("gtk-theme-name", "Gnursid", "")
step_name_list = [
(_('Welcome'), 'welcome'), # (group name, module name)
#'scsi',
(_('Package'), 'pkgselect'),
(_('Partition'), 'partition'),
(_('Partition'), 'dopartition'),
#(_('Setup'), 'startsetup'),
(_('Setup'), 'accounts'),
#'Xwindow',
(_('Setup'), 'bootloader'),
(_('Setup'), 'takeactions'),
#(_('Setup'), 'dosetup'),
(_('Finish'), 'finish')
def __init__(self):
# #################################################################################################################################
# # Load and apply gtkrc
# #################################################################
# # No exception control because rc_parse doesn't throw exception on fail... sad but true ;)
# ORIGDIR = os.getcwd()
# os.chdir('lib/ui/data/Brave/gtk-2.0/')
# gtk.rc_parse('gtkrc')
# os.chdir(ORIGDIR)
# Load Output Manager
self.gom = om.OutputManager('gui')
#################################################################################################################################
# Create a new window
#################################################################
splash.push(("Creatin main window..."))
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_focus = True
# self.window.connect("destroy", lambda w: gtk.main_quit())
self.window.connect("delete_event", self.quit)
splash.push(("Loading..."))
gtk.settings_get_default().set_long_property("gtk-button-images", True, "main")
# Title
self.window.set_title(MAINTITLE)
# Positions
self.window.resize(800, 600)
self.window.move(25, 25)
# Maximize window
self.window.maximize()
#################################################################################################################################
# Load core...
#################################################################
#Initialize KB
splash.push(("Loading KB..."))
self.uicore = core.UIcore()
self.uicore.add_local_asn()
self.gom.set_core(self.uicore)
# Check module window prefs
setattr(self.uicore, 'SHOW_MODULE_WIN', config.SHOW_MODULE_WIN)
self.uicore.set_om(self.gom)
#################################################################################################################################
# Main VBox
#################################################################
mainvbox = gtk.VBox(False, 1)
mainvbox.set_border_width(1)
self.window.add(mainvbox)
mainvbox.show()
#################################################################################################################################
# Tool Bars HBox
#################################################################
tbhbox = gtk.HBox(False, 1)
mainvbox.pack_start(tbhbox, False, False, 1)
tbhbox.show()
#################################################################################################################################
# UIManager for MAP Toolbar
#################################################################
# to make it nice we'll put the toolbar into the handle box,
# so that it can be detached from the main window
self.handlebox = gtk.HandleBox()
tbhbox.pack_start(self.handlebox, True, True, 1)
# Create a UIManager instance
splash.push(("Creating menu and toolbar..."))
uimanager = gtk.UIManager()
accelgroup = uimanager.get_accel_group()
self.window.add_accel_group(accelgroup)
self._actiongroup = actiongroup = gtk.ActionGroup('UIManager')
# Create actions
actiongroup.add_actions([
# xml_name, icon, real_menu_text, accelerator, tooltip, callback
('Load', gtk.STOCK_OPEN, ('Load'), None, (''), self.loadKB),
('Save', gtk.STOCK_SAVE, ('Save'), None, (''), self.saveKB),
('Import', gtk.STOCK_CONVERT, ('Import'), None, (''), self.importScan),
('Edit', gtk.STOCK_EDIT, ('Edit'), None, (''), self.loadEditor),
('Proxy', gtk.STOCK_CONNECT, ('Proxy'), None, (''), gtk.main_quit),
('Web Server', gtk.STOCK_EXECUTE, ('Web'), None, ('Web'), gtk.main_quit),
#('Sniffer', gtk.STOCK_NETWORK, ('Sniffer'), None, (''), gtk.main_quit),
('Sniffer', gtk.STOCK_NETWORK, ('Sniffer'), None, (''), self.run_sniffer),
('Scapy', gtk.STOCK_HELP, ('Scapy'), None, (''), self.show_term),
('Add Target', gtk.STOCK_ADD, ('Add Target'), None, (''), self.addTarget),
('Preferences', gtk.STOCK_PREFERENCES, ('Preferences'), None, (''), self.showPref),
('Show Log', gtk.STOCK_DND, ('Show Log'), None, (''), self.show_log),
('Show KB', gtk.STOCK_DND, ('Show KB'), None, (''), self.show_kb),
('Report', gtk.STOCK_DND, ('Report'), None, (''), self.report),
('Quit', gtk.STOCK_QUIT, ('Quit'), None, (''), gtk.main_quit),
])
# Add the actiongroup to the uimanager
uimanager.insert_action_group(actiongroup, 0)
uimanager.add_ui_from_string(ui_menu)
# Toolbar
toolbar = uimanager.get_widget('/Toolbar')
toolbar.set_style(gtk.TOOLBAR_BOTH)
# Disabled until I get them working
button_proxy = uimanager.get_widget('/Toolbar/Proxy')
button_proxy.set_sensitive(False)
button_web = uimanager.get_widget('/Toolbar/Web Server')
button_web.set_sensitive(False)
# Disable if not GtkSourceView2
if not config.HAS_SOURCEVIEW:
button_edit = uimanager.get_widget('/Toolbar/Edit')
button_edit.set_sensitive(False)
# Disable if not Vte
if not config.HAS_VTE:
button_sniffer = uimanager.get_widget('/Toolbar/Sniffer')
button_sniffer.set_sensitive(False)
button_scapy = uimanager.get_widget('/Toolbar/Scapy')
button_scapy.set_sensitive(False)
self.handlebox.add(toolbar)
toolbar.show()
self.handlebox.show()
#################################################################################################################################
# Map tab
#################################################################
# Will contain on top the notebook and on bottom log window
self.vpaned = gtk.VPaned()
# Will contain xdot widget and kb window
self.hpaned = gtk.HPaned()
#################################################################
# KB Textview
#################################################################
self.textview = kbwin.KBwindow()
#self.gom.set_kbwin(self.textview)
#################################################################
# KB TreeView
#################################################################
self.treeview = kbtree.KBtree()
self.tree = self.treeview.createTree()
self.treeview.updateTree()
self.gom.set_kbwin(self.treeview)
self.tree.show()
#################################################################
# xdot map
#################################################################
from . import inxdot
# self.context = cmenu.contextMenu()
# self.context.createMenus(self.textview, self.gom)
#
# self.xdotw = inxdot.MyDotWidget(self.context, self.uicore)
# nodeMenu initialization stuff
self.uiman = nodeMenu.UIManager(self.gom, self.uicore, config)
self.uiman.set_data(None)
accel = self.uiman.get_accel_group()
self.window.add_accel_group(accel)
# graphMenu initialization stuff
self.graph_uiman = graphMenu.UIManager(self.gom, self.uicore)
#self.graph_uiman.set_data(None)
graph_accel = self.graph_uiman.get_accel_group()
self.window.add_accel_group(graph_accel)
self.xdotw = inxdot.MyDotWidget(self.uiman, self.graph_uiman, self.uicore)
setattr(self.graph_uiman, 'xdot', self.xdotw)
self.xdotw.set_size_request(900,450)
self.gom.set_map(self.xdotw)
setattr(self.uicore, 'xdot', self.xdotw)
self.uicore.getDot(doASN=False)
self.xdotw.set_dotcode( self.uicore.get_kbfield('dotcode') )
self.xdotw.zoom_image(1.0)
#################################################################
# Graph Menu
#################################################################
gmenu = graphTBar.GraphMenu(self.xdotw, self.uicore)
#################################################################
# HBox for Map and GraphMenu
#################################################################
menubox = gtk.HBox()
menubox.pack_start(self.xdotw, True, True)
menubox.pack_start(gmenu, False, False)
# Show elements
gmenu.show()
menubox.show()
#################################################################
# Scrolled Window
#################################################################
self.scrolled_window = gtk.ScrolledWindow()
self.scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.scrolled_window.set_size_request(100,100)
# Add Textview to Scrolled Window
#self.scrolled_window.add_with_viewport(self.textview)
self.scrolled_window.add_with_viewport(self.tree)
#################################################################
# Map Iface
#################################################################
bufferf = "Map"
frame = gtk.Frame(bufferf)
frame.set_border_width(5)
frame.show()
label = gtk.Label('Map')
# Test XDOT MAP
frame.add(self.hpaned)
#self.hpaned.add1(self.xdotw)
self.hpaned.add1(menubox)
self.hpaned.add2(self.scrolled_window)
self.textview.show()
# Check visibility on config preferences
if config.SHOW_KBTREE:
self.scrolled_window.show()
self.scrolled_window.is_visible = True
else:
self.scrolled_window.is_visible = False
self.hpaned.show()
self.xdotw.show()
label = gtk.Label('Map')
label.set_angle(90)
b_factory = gtk.VBox
b = b_factory(spacing=1)
i = gtk.Image()
i.set_from_stock(gtk.STOCK_NETWORK, gtk.ICON_SIZE_SMALL_TOOLBAR)
b.pack_start(label)
b.pack_start(i)
b.show_all()
#################################################################
# Notebook
#################################################################
self.notebook = gtk.Notebook()
self.notebook.set_tab_pos(gtk.POS_LEFT)
#notebook.append_page(frame, label)
self.notebook.append_page(frame, b)
self.notebook.connect("switch_page", self.onSwitch)
#################################################################################################################################
# Consoles Tab
#################################################################
label = gtk.Label('Term')
label.set_angle(90)
b_factory = gtk.VBox
b = b_factory(spacing=1)
i = gtk.Image()
i.set_from_stock(gtk.STOCK_EXECUTE, gtk.ICON_SIZE_SMALL_TOOLBAR)
b.pack_start(label)
b.pack_start(i)
b.show_all()
term_box = gtk.VBox()
term_button = gtk.Button("New Tab")
# Disable if VTE not available
if not config.HAS_VTE:
term_button.set_sensitive(False)
term_box.pack_start(term_button,False)
self.term_notebook = libTerminal.TerminalNotebook()
#term_button.connect("clicked", term_notebook.new_tab)
term_button.connect("clicked", self.new_tab)
term_box.pack_start(self.term_notebook)
setattr(self.uiman, 'termnb', self.term_notebook)
setattr(self.uiman, 'mainnb', self.notebook)
self.notebook.append_page(term_box, b)
term_box.show_all()
#################################################################################################################################
# RCE Iface
#################################################################
# xdot rce
import xdot
self.xdotr = xdot.DotWidget()
self.xdotr.set_size_request(600,512)
self.xdotr.show()
bufferf = "RCE"
frame = gtk.Frame(bufferf)
frame.set_border_width(5)
frame.set_size_request(400, 400)
label = gtk.Label('RCE')
label.set_angle(90)
b_factory = gtk.VBox
b = b_factory(spacing=1)
i = gtk.Image()
i.set_from_stock(gtk.STOCK_REFRESH, gtk.ICON_SIZE_SMALL_TOOLBAR)
b.pack_start(label)
b.pack_start(i)
b.show_all()
self.notebook.append_page(frame, b)
# RCE graph menu
self.rmenu = rceTBar.RceMenu(self.xdotr, rcecore)
self.dasmenu = rceTBar.DasmMenu()
#################################################################################################################################
# UIManager for RCE Toolbar
#################################################################
# to make it nice we'll put the toolbar into the handle box,
# so that it can be detached from the main window
self.rcehb = gtk.HandleBox()
tbhbox.pack_start(self.rcehb, True, True, 1)
# Create a UIManager instance
rceuiman = gtk.UIManager()
rceaccelgroup = rceuiman.get_accel_group()
self.window.add_accel_group(rceaccelgroup)
self._actiongroup = actiongroup = gtk.ActionGroup('UIManager')
# Create actions
actiongroup.add_actions([
# xml_name, icon, real_menu_text, accelerator, tooltip, callback
('New', gtk.STOCK_NEW, ('New'), None, (''), self.newBin),
('Load', gtk.STOCK_OPEN, ('Load'), None, (''), self.loadBin),
('Show Log', gtk.STOCK_DND, ('Show Log'), None, (''), self.show_log),
#('Debugger', gtk.STOCK_EXECUTE, ('Debugger'), None, (''), gtk.main_quit),
('Debugger', gtk.STOCK_EXECUTE, ('Debugger'), None, (''), self.run_debugger),
#('Report', gtk.STOCK_DND, ('Report'), None, (''), gtk.main_quit),
('Quit', gtk.STOCK_QUIT, ('Quit'), None, (''), gtk.main_quit),
])
# Add the actiongroup to the rceuiman
rceuiman.insert_action_group(actiongroup, 0)
rceuiman.add_ui_from_string(rce_menu)
# Toolbar
rcetoolbar = rceuiman.get_widget('/RceToolbar')
self.rcehb.add(rcetoolbar)
self.rcehb.hide()
#################################################################
# RCE HBox and VBoxes
#################################################################
rcepaned = gtk.HPaned()
lrcevb = gtk.VBox(False, 1)
rrcevb = gtk.VBox(False, 1)
rcepaned.add1(lrcevb)
rcepaned.add2(rrcevb)
lrcevb.pack_start(self.rmenu, False, False, 1)
rrcevb.pack_start(self.dasmenu, False, False, 1)
rcepaned.show_all()
#################################################################
# Textview RCE
#################################################################
rcetv = gtk.TextView(buffer=None)
rcetv.set_wrap_mode(gtk.WRAP_NONE)
rcetv.set_editable(False)
fontdesc = pango.FontDescription("MonoSpace 10")
#fontdesc = pango.FontDescription("Purisa 10")
rcetv.modify_font(fontdesc)
rcetv.show()
self.textbuffer = rcetv.get_buffer()
# Scrolled Window
rce_scrolled_window = gtk.ScrolledWindow()
rce_scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
rce_scrolled_window.show()
# Add Textview to Scrolled Window
rce_scrolled_window.add_with_viewport(rcetv)
# Add xdotr and textview to rcehbox
lrcevb.pack_start(self.xdotr, True, True, 2)
rrcevb.pack_start(rce_scrolled_window, True, True, 2)
frame.add(rcepaned)
frame.show()
rcepaned.show()
#################################################################################################################################
# Xploit Iface
#################################################################
bufferf = "Exploit"
frame = gtk.Frame(bufferf)
frame.set_border_width(5)
frame.show()
label = gtk.Label('Exploit')
frame.add(label)
label.show()
label = gtk.Label('Exploit')
label.set_angle(90)
b_factory = gtk.VBox
b = b_factory(spacing=1)
i = gtk.Image()
i.set_from_stock(gtk.STOCK_PREFERENCES, gtk.ICON_SIZE_SMALL_TOOLBAR)
b.pack_start(label)
b.pack_start(i)
b.show_all()
self.exploitsInst = exploits.Exploits(config, self.term_notebook)
exploitsGui = self.exploitsInst.get_widget()
exploitsGui.show_all()
self.notebook.append_page(exploitsGui, b)
#mainvbox.pack_start(notebook, True, True, 1)
self.vpaned.add1(self.notebook)
self.notebook.show()
#################################################################################################################################
# Log Window
#################################################################
self.logtext = gtk.TextView(buffer=None)
self.logtext.set_wrap_mode(gtk.WRAP_NONE)
self.logtext.set_editable(False)
#self.logtext.set_size_request(40,40)
self.logbuffer = self.logtext.get_buffer()
self.logbuffer.set_text('Loading Inguma...\n')
self.logtext.show()
#################################################################
# Log Scrolled Window
#################################################################
self.log_scrolled_window = gtk.ScrolledWindow()
self.log_scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
self.log_scrolled_window.is_visible = True
#Always on bottom on change
self.vajd = self.log_scrolled_window.get_vadjustment()
self.vajd.connect('changed', lambda a, s=self.log_scrolled_window: self.rescroll(a,s))
#self.log_scrolled_window.set_size_request(40,40)
#self.logtext.set_size_request(20,20)
# Add Textview to Scrolled Window
self.log_scrolled_window.add_with_viewport(self.logtext)
# Set logtext as output for gui
self.gom.set_gui(self.logbuffer)
# Add Scrolled Log Window to Bottom Notebook
############################################
# Notebook for bottom panel
self.bottom_nb = gtk.Notebook()
self.bottom_nb.set_tab_pos(gtk.POS_LEFT)
# Icon and label for Logs tab
label = gtk.Label('Logs')
label.set_angle(90)
b_factory = gtk.VBox
b = b_factory(spacing=1)
i = gtk.Image()
i.set_from_stock(gtk.STOCK_JUSTIFY_FILL, gtk.ICON_SIZE_SMALL_TOOLBAR)
b.pack_start(label)
b.pack_start(i)
b.show_all()
self.bottom_nb.append_page(self.log_scrolled_window, b)
# Icon and label for Actions tab
label = gtk.Label('Actions')
label.set_angle(90)
b_factory = gtk.VBox
b = b_factory(spacing=1)
i = gtk.Image()
i.set_from_stock(gtk.STOCK_EXECUTE, gtk.ICON_SIZE_SMALL_TOOLBAR)
b.pack_start(label)
b.pack_start(i)
b.show_all()
# Add Threads TreeView
self.threadsInst = threadstv.ThreadsTv()
threadsGui = self.threadsInst.get_widget()
setattr(self.threadsInst, 'uicore', self.uicore)
threadsGui.show_all()
self.bottom_nb.append_page(threadsGui, b)
#self.bottom_nb.set_scrollable(True)
self.bottom_nb.set_current_page(0)
# Check visibility on config preferences
if config.SHOW_LOG:
self.bottom_nb.is_visible = True
self.bottom_nb.show()
else:
self.bottom_nb.is_visible = False
self.vpaned.add2(self.bottom_nb)
mainvbox.pack_start(self.vpaned, True, True, 1)
self.log_scrolled_window.show()
# Add threadtv to core
self.uicore.set_threadtv(self.threadsInst)
setattr(self.graph_uiman, 'threadtv', self.threadsInst)
# #################################################################################################################################
# # Progress Bar
# #################################################################
# self.progressbar = pbar.PBar()
# self.progressbar.set_stopped()
# mainvbox.pack_start(self.progressbar, False, False, 1)
#################################################################################################################################
#StatusBar
#################################################################
statusbar = gtk.Statusbar()
mainvbox.pack_end(statusbar, False, False, 1)
context_id = statusbar.get_context_id("Inguma 0.2")
message_id = statusbar.push(context_id, 'Inguma 0.2')
statusbar.show()
#################################################################################################################################
# finish it
#################################################################
self.vpaned.show()
self.window.show()
splash.destroy()
# Check for autosaved KB and ask for loading
libAutosave.checkDir()
if not libAutosave.checkKB():
print "Autosaved KB not found, skipping..."
else:
toload = libAutosave.askDialog()
if toload:
kbpath = libAutosave.getKbPath()
self.uicore.loadKB(kbpath)
libAutosave.removeKB()
# Update KB textview
self.textview.updateWin()
self.treeview.updateTree()
# Adding text to Log window
self.gom.echo( 'Loaded' , False)
else:
libAutosave.removeKB()
# Update Map
self.xdotw.set_dotcode( self.uicore.get_kbfield('dotcode') )
self.xdotw.zoom_image(1.0)
gtk.main()
def __init__(self, markup, parent_win=None):
gtk.Window.__init__(self, gtk.WINDOW_POPUP)
# Inherit the system theme for a tooltip
style = gtk.rc_get_style_by_paths(gtk.settings_get_default(),
'gtk-tooltip', 'gtk-tooltip',
gobject.TYPE_NONE)
self.set_style(style)
# The placement of the close button on the tip should reflect how the
# window manager of the users system places close buttons. Try to read
# the metacity gconf key to determine whether the close button is on the
# left or the right.
# In the case that we can't determine the users configuration we default
# to close buttons being on the right.
__button_right = True
try:
client = gconf.client_get_default()
order = client.get_string("/apps/metacity/general/button_layout")
if order and order.endswith(":"):
__button_right = False
except NameError:
pass
# We need to ensure we're only shown once
self.shown = False
# We don't want any WM decorations
self.set_decorated(False)
# We don't want to show in the taskbar or window switcher
self.set_skip_pager_hint(True)
self.set_skip_taskbar_hint(True)
# We must be modal to ensure we grab focus when presented from a gtk.Dialog
self.set_modal(True)
self.set_border_width(0)
self.set_position(gtk.WIN_POS_MOUSE)
self.set_opacity(0.95)
# Ensure a reasonable minimum size
self.set_geometry_hints(self, 100, 50)
# Set this window as a transient window for parent(main window)
if parent_win:
self.set_transient_for(parent_win)
self.set_destroy_with_parent(True)
# Draw our label and close buttons
hbox = gtk.HBox(False, 0)
hbox.show()
self.add(hbox)
img = gtk.Image()
img.set_from_stock(gtk.STOCK_CLOSE, gtk.ICON_SIZE_BUTTON)
self.button = gtk.Button()
self.button.set_image(img)
self.button.connect("clicked", self._dismiss_cb)
self.button.set_flags(gtk.CAN_DEFAULT)
self.button.grab_focus()
self.button.show()
vbox = gtk.VBox(False, 0)
vbox.show()
vbox.pack_start(self.button, False, False, 0)
if __button_right:
hbox.pack_end(vbox, True, True, 0)
else:
hbox.pack_start(vbox, True, True, 0)
self.set_default(self.button)
bin = gtk.HBox(True, 6)
bin.set_border_width(6)
bin.show()
self.label = gtk.Label()
self.label.set_line_wrap(True)
# We want to match the colours of the normal tooltips, as dictated by
# the users gtk+-2.0 theme, wherever possible - on some systems this
# requires explicitly setting a fg_color for the label which matches the
# tooltip_fg_color
settings = gtk.settings_get_default()
colours = settings.get_property('gtk-color-scheme').split('\n')
# remove any empty lines, there's likely to be a trailing one after
# calling split on a dictionary-like string
colours = filter(None, colours)
for col in colours:
item, val = col.split(': ')
if item == 'tooltip_fg_color':
style = self.label.get_style()
style.fg[gtk.STATE_NORMAL] = gtk.gdk.color_parse(val)
self.label.set_style(style)
break # we only care for the tooltip_fg_color
self.label.set_markup(markup)
self.label.show()
bin.add(self.label)
hbox.pack_end(bin, True, True, 6)
self.connect("key-press-event", self._catch_esc_cb)
def __init__(self, gladefile=GLADE_FILE):
SirannonBase.__init__(self, self)
self.__gladefile = gladefile
self.__tree = gtk.glade.XML(self.__gladefile)
self.registerEvents()
# Main window
self.window = self.__tree.get_widget("Main")
self.window.connect("delete-event", self.eventQuit)
self.window.set_title('Sirannon')
self.window.maximize()
# Notebook with file tabs
self.__notebook = self.__tree.get_widget("FileTabs")
self.__tabs = []
# Dialogs
self.xml_filter = gtk.FileFilter()
self.xml_filter.set_name('XML file')
self.xml_filter.add_pattern('*.xml')
dialog = self.__tree.get_widget("LoadDialog")
dialog.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
dialog.add_button(gtk.STOCK_OPEN, gtk.RESPONSE_OK)
dialog.set_current_folder(DEFAULT_XML_FOLDER)
dialog.add_filter(self.xml_filter)
dialog = self.__tree.get_widget("SaveDialog")
dialog.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
dialog.add_button(gtk.STOCK_SAVE, gtk.RESPONSE_OK)
dialog.set_current_folder(DEFAULT_XML_FOLDER)
dialog.add_filter(self.xml_filter)
dialog = self.__tree.get_widget("TripleDialog")
dialog.add_button(gtk.STOCK_NO, gtk.RESPONSE_NO)
dialog.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
dialog.add_button(gtk.STOCK_YES, gtk.RESPONSE_YES)
dialog = self.__tree.get_widget('RenameDialog')
self.renameEntry = gtk.Entry()
content = dialog.get_content_area()
content.pack_start(self.renameEntry, fill=False)
content.show()
accel = gtk.AccelGroup()
self.window.add_accel_group(accel)
self.undoButton = self.__tree.get_widget('MenuUndo')
self.undoButton.add_accelerator('activate', accel, ord('z'),
gtk.gdk.CONTROL_MASK,
gtk.ACCEL_VISIBLE | gtk.ACCEL_LOCKED)
self.redoButton = self.__tree.get_widget('MenuRedo')
self.redoButton.add_accelerator('activate', accel, ord('y'),
gtk.gdk.CONTROL_MASK,
gtk.ACCEL_VISIBLE | gtk.ACCEL_LOCKED)
commandXML = self.__tree.get_widget('CommandXML')
commandXML.add_filter(self.xml_filter)
# Simulate a new event
self.eventNew(None)
self.__notebook.remove_page(0)
gobject.timeout_add(100, self.update)
# Override some settings
settings = gtk.settings_get_default()
settings.props.gtk_button_images = True
def __init__(self, no_dialog=False):
self.settings = EventCore()
self.gui_is_active = False
# during initialization any dialog (e.g. "Unit change") is not allowed
# we set the final value later
self.no_dialog = True
self._batch_queue = []
self._undo_states = []
self.gui = gtk.Builder()
gtk_build_file = get_ui_file_location(GTKBUILD_FILE)
if gtk_build_file is None:
gtk.main_quit()
self.gui.add_from_file(gtk_build_file)
if pycam.Utils.get_platform() == pycam.Utils.PLATFORM_WINDOWS:
gtkrc_file = get_ui_file_location(GTKRC_FILE_WINDOWS)
if gtkrc_file:
gtk.rc_add_default_file(gtkrc_file)
gtk.rc_reparse_all_for_settings(gtk.settings_get_default(),
True)
self.window = self.gui.get_object("ProjectWindow")
self.settings.set("main_window", self.window)
# show stock items on buttons
# increase the initial width of the window (due to hidden elements)
self.window.set_default_size(400, -1)
# initialize the RecentManager (TODO: check for Windows)
if False and pycam.Utils.get_platform(
) == pycam.Utils.PLATFORM_WINDOWS:
# The pyinstaller binary for Windows fails mysteriously when trying
# to display the stock item.
# Error message: Gtk:ERROR:gtkrecentmanager.c:1942:get_icon_fallback: assertion failed: (retval != NULL)
self.recent_manager = None
else:
try:
self.recent_manager = gtk.recent_manager_get_default()
except AttributeError:
# GTK 2.12.1 seems to have problems with "RecentManager" on
# Windows. Sadly this is the version, that is shipped with the
# "appunti" GTK packages for Windows (April 2010).
# see http://www.daa.com.au/pipermail/pygtk/2009-May/017052.html
self.recent_manager = None
# file loading
self.last_dirname = None
self.last_task_settings_uri = None
self.last_model_uri = None
# define callbacks and accelerator keys for the menu actions
for objname, callback, data, accel_key in (
("LoadTaskSettings", self.load_task_settings_file, None,
"<Control>t"), ("SaveTaskSettings", self.save_task_settings_file,
lambda: self.last_task_settings_uri, None),
("SaveAsTaskSettings", self.save_task_settings_file, None,
None), ("OpenModel", self.load_model_file, None,
"<Control>o"), ("Quit", self.destroy, None, "<Control>q"),
("GeneralSettings", self.toggle_preferences_window, None,
"<Control>p"), ("UndoButton", self._restore_undo_state, None,
"<Control>z"), ("HelpUserManual", self.show_help,
"User_Manual", "F1"),
("HelpIntroduction", self.show_help, "Introduction", None),
("HelpSupportedFormats", self.show_help, "SupportedFormats",
None), ("HelpModelTransformations", self.show_help,
"ModelTransformations",
None), ("HelpToolTypes", self.show_help, "ToolTypes",
None), ("HelpProcessSettings", self.show_help,
"ProcessSettings", None),
("HelpBoundsSettings", self.show_help, "BoundsSettings",
None), ("HelpTaskSetup", self.show_help, "TaskSetup", None),
("HelpGCodeExport", self.show_help, "GCodeExport",
None), ("HelpTouchOff", self.show_help, "TouchOff",
None), ("HelpSimulation", self.show_help, "Simulation",
None), ("Help3DView", self.show_help, "3D_View",
None), ("HelpServerMode", self.show_help,
"ServerMode", None),
("HelpCommandLine", self.show_help, "CommandlineExamples",
None), ("HelpHotkeys", self.show_help, "KeyboardShortcuts",
None), ("ProjectWebsite", self.show_help,
"http://pycam.sourceforge.net",
None), ("DevelopmentBlog", self.show_help,
"http://fab.senselab.org/pycam", None),
("Forum", self.show_help,
"http://sourceforge.net/projects/pycam/forums", None),
("BugTracker", self.show_help,
"http://sourceforge.net/tracker/?group_id=237831&atid=1104176",
None),
("FeatureRequest", self.show_help,
"http://sourceforge.net/tracker/?group_id=237831&atid=1104179",
None)):
item = self.gui.get_object(objname)
action = "activate"
if data is None:
item.connect(action, callback)
else:
item.connect(action, callback, data)
if accel_key:
key, mod = gtk.accelerator_parse(accel_key)
accel_path = "<pycam>/%s" % objname
item.set_accel_path(accel_path)
gtk.accel_map_change_entry(accel_path, key, mod, True)
# LinkButton does not work on Windows: https://bugzilla.gnome.org/show_bug.cgi?id=617874
if pycam.Utils.get_platform() == pycam.Utils.PLATFORM_WINDOWS:
def open_url(widget, data=None):
webbrowser.open(widget.get_uri())
gtk.link_button_set_uri_hook(open_url)
# no undo is allowed at the beginning
self.gui.get_object("UndoButton").set_sensitive(False)
self.settings.register_event("model-change-before",
self._store_undo_state)
self.settings.register_event(
"model-change-after",
lambda: self.settings.emit_event("visual-item-updated"))
# set the availability of ODE
self.enable_ode_control = self.gui.get_object("SettingEnableODE")
self.settings.add_item("enable_ode",
self.enable_ode_control.get_active,
self.enable_ode_control.set_active)
self.settings.register_event("parallel-processing-changed",
self.update_ode_settings)
# configure drag-n-drop for config files and models
self.settings.set("configure-drag-drop-func",
self.configure_drag_and_drop)
self.settings.get("configure-drag-drop-func")(self.window)
# other events
self.window.connect("destroy", self.destroy)
self.window.connect("delete-event", self.destroy)
# the settings window
self.gui.get_object("CloseSettingsWindow").connect(
"clicked", self.toggle_preferences_window, False)
self.gui.get_object("ResetPreferencesButton").connect(
"clicked", self.reset_preferences)
self.preferences_window = self.gui.get_object("GeneralSettingsWindow")
self.preferences_window.connect("delete-event",
self.toggle_preferences_window, False)
self._preferences_window_position = None
self._preferences_window_visible = False
# "about" window
self.about_window = self.gui.get_object("AboutWindow")
self.about_window.set_version(VERSION)
self.gui.get_object("About").connect("activate",
self.toggle_about_window, True)
# we assume, that the last child of the window is the "close" button
# TODO: fix this ugly hack!
self.gui.get_object("AboutWindowButtons").get_children()[-1].connect(
"clicked", self.toggle_about_window, False)
self.about_window.connect("delete-event", self.toggle_about_window,
False)
# menu bar
uimanager = gtk.UIManager()
self.settings.set("gtk-uimanager", uimanager)
self._accel_group = uimanager.get_accel_group()
# send a "delete" event on "CTRL-w" for every window
def handle_window_close(accel_group, window, *args):
window.emit("delete-event", gtk.gdk.Event(gtk.gdk.DELETE))
self._accel_group.connect_group(ord('w'), gtk.gdk.CONTROL_MASK,
gtk.ACCEL_LOCKED, handle_window_close)
self.settings.add_item("gtk-accel-group", lambda: self._accel_group)
for obj in self.gui.get_objects():
if isinstance(obj, gtk.Window):
obj.add_accel_group(self._accel_group)
# preferences tab
preferences_book = self.gui.get_object("PreferencesNotebook")
def clear_preferences():
for child in preferences_book.get_children():
preferences_book.remove(child)
def add_preferences_item(item, name):
preferences_book.append_page(item, gtk.Label(name))
self.settings.register_ui_section("preferences", add_preferences_item,
clear_preferences)
for obj_name, label, priority in (("GeneralSettingsPrefTab", "General",
-50), ("ProgramsPrefTab",
"Programs", 50)):
obj = self.gui.get_object(obj_name)
obj.unparent()
self.settings.register_ui("preferences", label, obj, priority)
# general preferences
general_prefs = self.gui.get_object("GeneralPreferencesBox")
def clear_general_prefs():
for item in general_prefs.get_children():
general_prefs.remove(item)
def add_general_prefs_item(item, name):
general_prefs.pack_start(item, expand=False, padding=3)
self.settings.register_ui_section("preferences_general",
add_general_prefs_item,
clear_general_prefs)
for obj_name, priority in (("SettingEnableODE", 10),
("TaskSettingsDefaultFileBox", 30)):
obj = self.gui.get_object(obj_name)
obj.unparent()
self.settings.register_ui("preferences_general", None, obj,
priority)
# set defaults
self.cutter = None
# add some dummies - to be implemented later ...
self.settings.add_item("cutter", lambda: self.cutter)
main_tab = self.gui.get_object("MainTabs")
def clear_main_tab():
while main_tab.get_n_pages() > 0:
main_tab.remove_page(0)
def add_main_tab_item(item, name):
main_tab.append_page(item, gtk.Label(name))
# TODO: move these to plugins, as well
self.settings.register_ui_section("main", add_main_tab_item,
clear_main_tab)
main_window = self.gui.get_object("WindowBox")
def clear_main_window():
main_window.foreach(lambda x: main_window.remove(x))
def add_main_window_item(item, name, **extra_args):
# some widgets may want to override the defaults
args = {"expand": False, "fill": False}
args.update(extra_args)
main_window.pack_start(item, **args)
main_tab.unparent()
self.settings.register_ui_section("main_window", add_main_window_item,
clear_main_window)
self.settings.register_ui("main_window",
"Tabs",
main_tab,
-20,
args_dict={
"expand": True,
"fill": True
})
# autoload task settings file on startup
autoload_enable = self.gui.get_object("AutoLoadTaskFile")
autoload_box = self.gui.get_object("StartupTaskFileBox")
autoload_source = self.gui.get_object("StartupTaskFile")
# TODO: fix the extension filter
#for one_filter in get_filters_from_list(FILTER_CONFIG):
# autoload_source.add_filter(one_filter)
# autoload_source.set_filter(one_filter)
def get_autoload_task_file(autoload_source=autoload_source):
if autoload_enable.get_active():
return autoload_source.get_filename()
else:
return ""
def set_autoload_task_file(filename):
if filename:
autoload_enable.set_active(True)
autoload_box.show()
autoload_source.set_filename(filename)
else:
autoload_enable.set_active(False)
autoload_box.hide()
autoload_source.unselect_all()
def autoload_enable_switched(widget, box):
if not widget.get_active():
set_autoload_task_file(None)
else:
autoload_box.show()
autoload_enable.connect("toggled", autoload_enable_switched,
autoload_box)
self.settings.add_item("default_task_settings_file",
get_autoload_task_file, set_autoload_task_file)
def disable_gui():
self.menubar.set_sensitive(False)
main_tab.set_sensitive(False)
def enable_gui():
self.menubar.set_sensitive(True)
main_tab.set_sensitive(True)
self.settings.register_event("gui-disable", disable_gui)
self.settings.register_event("gui-enable", enable_gui)
# configure locations of external programs
for auto_control_name, location_control_name, browse_button, key in (
("ExternalProgramInkscapeAuto", "ExternalProgramInkscapeControl",
"ExternalProgramInkscapeBrowse", "inkscape"),
("ExternalProgramPstoeditAuto", "ExternalProgramPstoeditControl",
"ExternalProgramPstoeditBrowse", "pstoedit")):
self.gui.get_object(auto_control_name).connect(
"clicked", self._locate_external_program, key)
location_control = self.gui.get_object(location_control_name)
self.settings.add_item("external_program_%s" % key,
location_control.get_text,
location_control.set_text)
self.gui.get_object(browse_button).connect(
"clicked", self._browse_external_program_location, key)
# set the icons (in different sizes) for all windows
gtk.window_set_default_icon_list(*get_icons_pixbuffers())
# load menu data
gtk_menu_file = get_ui_file_location(GTKMENU_FILE)
if gtk_menu_file is None:
gtk.main_quit()
uimanager.add_ui_from_file(gtk_menu_file)
# make the actions defined in the GTKBUILD file available in the menu
actiongroup = gtk.ActionGroup("menubar")
for action in [
action for action in self.gui.get_objects()
if isinstance(action, gtk.Action)
]:
actiongroup.add_action(action)
# the "pos" parameter is optional since 2.12 - we can remove it later
uimanager.insert_action_group(actiongroup, pos=-1)
# the "recent files" sub-menu
if not self.recent_manager is None:
recent_files_menu = gtk.RecentChooserMenu(self.recent_manager)
recent_files_menu.set_name("RecentFilesMenu")
recent_menu_filter = gtk.RecentFilter()
case_converter = pycam.Utils.get_case_insensitive_file_pattern
for filter_name, patterns in FILTER_MODEL:
if not isinstance(patterns, (list, set, tuple)):
patterns = [patterns]
# convert it into a mutable list (instead of set/tuple)
patterns = list(patterns)
for index in range(len(patterns)):
patterns[index] = case_converter(patterns[index])
for pattern in patterns:
recent_menu_filter.add_pattern(pattern)
recent_files_menu.add_filter(recent_menu_filter)
recent_files_menu.set_show_numbers(True)
# non-local files (without "file://") are not supported. yet
recent_files_menu.set_local_only(False)
# most recent files to the top
recent_files_menu.set_sort_type(gtk.RECENT_SORT_MRU)
# show only ten files
recent_files_menu.set_limit(10)
uimanager.get_widget("/MenuBar/FileMenu/OpenRecentModelMenu")\
.set_submenu(recent_files_menu)
recent_files_menu.connect("item-activated",
self.load_recent_model_file)
else:
self.gui.get_object("OpenRecentModel").set_visible(False)
# load the menubar and connect functions to its items
self.menubar = uimanager.get_widget("/MenuBar")
# dict of all merge-ids
menu_merges = {}
def clear_menu(menu_key):
for merge in menu_merges.get(menu_key, []):
uimanager.remove_ui(merge)
def append_menu_item(menu_key, base_path, widget, name):
merge_id = uimanager.new_merge_id()
if widget:
action_group = widget.props.action_group
if not action_group in uimanager.get_action_groups():
uimanager.insert_action_group(action_group, -1)
widget_name = widget.get_name()
item_type = gtk.UI_MANAGER_MENUITEM
else:
widget_name = name
item_type = gtk.UI_MANAGER_SEPARATOR
uimanager.add_ui(merge_id, base_path, name, widget_name, item_type,
False)
if not menu_key in menu_merges:
menu_merges[menu_key] = []
menu_merges[menu_key].append(merge_id)
def get_menu_funcs(menu_key, base_path):
append_func = lambda widget, name: \
append_menu_item(menu_key, base_path, widget, name)
clear_func = lambda: clear_menu(menu_key)
return append_func, clear_func
for ui_name, base_path in (("view_menu", "/MenuBar/ViewMenu"),
("file_menu", "/MenuBar/FileMenu"),
("edit_menu", "/MenuBar/EditMenu"),
("export_menu",
"/MenuBar/FileMenu/ExportMenu")):
append_func, clear_func = get_menu_funcs(ui_name, base_path)
self.settings.register_ui_section(ui_name, append_func, clear_func)
self.settings.register_ui("file_menu", "Quit",
self.gui.get_object("Quit"), 100)
self.settings.register_ui("file_menu", "QuitSeparator", None, 95)
self.settings.register_ui("main_window", "Main", self.menubar, -100)
# initialize plugins
self.plugin_manager = pycam.Plugins.PluginManager(core=self.settings)
self.plugin_manager.import_plugins()
# some more initialization
self.reset_preferences()
# TODO: preferences are not loaded until the new format is stable
#self.load_preferences()
#self.load_task_settings()
self.settings.register_event("notify-file-saved",
self.add_to_recent_file_list)
self.settings.register_event("notify-file-opened",
self.add_to_recent_file_list)
# fallback - in case of a failure when opening a model file
model = pycam.Importers.TestModel.get_test_model()
self.settings.get("models").add_model(model, "Tiny pyramid")
# Without this "gkt.main_iteration" loop the task settings file
# control would not be updated in time.
while gtk.events_pending():
gtk.main_iteration()
autoload_task_filename = self.settings.get(
"default_task_settings_file")
if autoload_task_filename:
self.open_task_settings_file(autoload_task_filename)
self.update_all_controls()
self.no_dialog = no_dialog
if not self.no_dialog:
# register a logging handler for displaying error messages
pycam.Utils.log.add_gtk_gui(self.window, logging.ERROR)
self.window.show()
def setup_ui(self):
accelgroup = gtk.AccelGroup()
self.window.add_accel_group(accelgroup)
accelgroup.connect_group(gtk.keysyms.g, gtk.gdk.MOD1_MASK,
gtk.ACCEL_VISIBLE, self.on_g_accel)
accelgroup.connect_group(gtk.keysyms.n, gtk.gdk.MOD1_MASK,
gtk.ACCEL_VISIBLE, self.on_n_accel)
accelgroup.connect_group(gtk.keysyms.i, gtk.gdk.MOD1_MASK,
gtk.ACCEL_VISIBLE, self.on_i_accel)
accelgroup.connect_group(gtk.keysyms.F1, 0, gtk.ACCEL_VISIBLE,
self.on_f1_accel)
accelgroup.connect_group(gtk.keysyms.F1, gtk.gdk.SHIFT_MASK,
gtk.ACCEL_VISIBLE, self.on_shift_f1_accel)
accelgroup.connect_group(gtk.keysyms.c, gtk.gdk.MOD1_MASK,
gtk.ACCEL_VISIBLE, self.on_c_accel)
accelgroup.connect_group(gtk.keysyms.a, gtk.gdk.MOD1_MASK,
gtk.ACCEL_VISIBLE, self.on_a_accel)
accelgroup.connect_group(gtk.keysyms.e, gtk.gdk.MOD1_MASK,
gtk.ACCEL_VISIBLE, self.on_e_accel)
if have_mozembed:
self.mozembed = gtkmozembed.MozEmbed()
self.mozembed.load_url("file://" + mfeconst.helpfile +
"#using-cli")
self.optsscrolled.add_with_viewport(self.mozembed)
self.mozembed.show()
self.mozembed.connect("location", self.location_changed)
# ensure buttons have images...
settings = gtk.settings_get_default()
settings.set_long_property("gtk-button-images", True, "mfe")
text = self.aboutlabel.get_text() % (
mfeconst.infoheader, mfeutil.get_med_version(self.runner.mednafen))
self.aboutlabel.set_markup(text)
try:
self.snapchooser.set_current_folder(
os.path.expanduser(self.config["snap_path"]))
except:
pass
try:
self.savechooser.set_current_folder(
os.path.expanduser(self.config["save_path"]))
except:
pass
try:
self.statechooser.set_current_folder(
os.path.expanduser(self.config["state_path"]))
except:
pass
try:
self.moviechooser.set_current_folder(
os.path.expanduser(self.config["movie_path"]))
except:
pass
try:
self.cheatchooser.set_current_folder(
os.path.expanduser(self.config["cheat_path"]))
except:
pass
try:
self.palettechooser.set_current_folder(
os.path.expanduser(self.config["palette_path"]))
except:
pass
self.snapcheck.set_active(self.config["snap_path_sar"])
self.savecheck.set_active(self.config["save_path_sar"])
self.statecheck.set_active(self.config["state_path_sar"])
self.moviecheck.set_active(self.config["movie_path_sar"])
self.cheatcheck.set_active(self.config["cheat_path_sar"])
self.palettecheck.set_active(self.config["palette_path_sar"])
self.on_snapcheck_toggled(self.snapcheck)
self.on_savecheck_toggled(self.savecheck)
self.on_statecheck_toggled(self.statecheck)
self.on_moviecheck_toggled(self.moviecheck)
self.on_cheatcheck_toggled(self.cheatcheck)
self.on_palettecheck_toggled(self.palettecheck)
self.fscheck.set_active(self.config["fullscreen"])
self.soundcheck.set_active(self.config["sound"])
self.cheatscheck.set_active(self.config["cheats"])
self.glcheck.set_active(self.config["opengl"])
self.vsynccheck.set_active(self.config["vsync"])
# self.priorityspin.set_value(self.config["priority"])
self.autosavecheck.set_active(self.config["autosave"])
self.manualoptsentry.set_text(self.config["options"])
self.monocheck.set_active(self.config["mono"])
self.sratecombo.set_active(self.config["srate"])
self.sdrivercombo.set_active(self.config["sdriver"])
self.volumescale.set_value(self.config["volume"])
self.on_soundcheck_toggled(self.soundcheck)
self.on_glcheck_toggled(self.glcheck)
self.on_fscheck_toggled(self.fscheck)
self.xscalespin.set_value(self.config["xscale"])
self.yscalespin.set_value(self.config["yscale"])
self.xresspin.set_value(self.config["xres"])
self.yresspin.set_value(self.config["yres"])
self.stretchcheck.set_active(self.config["stretch"])
self.bilinearcheck.set_active(self.config["interpolate"])
self.scanlinespin.set_value(self.config["scanlines"])
# self.vblurcheck.set_active(self.config["vblur"])
# self.accumulatecheck.set_active(self.config["accumulate"])
self.amountspin.set_value(self.config["amount"])
self.filtercombo.set_active(self.config["filter"])
self.shadercombo.set_active(self.config["shader"])
# self.on_vblurcheck_toggled(self.vblurcheck)
self.backendcombo.set_active(self.config["backend"])
if self.config["rom"]:
self.guess_backend()
self.romchooser.set_filename(self.config["rom"])
# this comes after self.guess_backend() so it is accurate
self.set_monocheck_sensitive()
def parse_gtk_rcfiles():
gtk.rc_add_default_file(get_data_path('gtkrc-2.0'))
gtk.rc_add_default_file(home("gtkrc-2.0").strpath)
# we have to force reload the settings
gtk.rc_reparse_all_for_settings(gtk.settings_get_default(), True)
def setup():
"""
define all the components for a gtk environment
"""
global WEBKITERROR, INFOBARERROR
import gtk
gtk.settings_get_default().set_property("gtk-error-bell", False)
extension.register('quit', gtk.main_quit)
extension.category_register('dialog', Dialog.Dialog)
extension.category_register('avatar chooser', AvatarChooser.AvatarChooser)
extension.category_register('avatar', Avatar.Avatar)
extension.category_register('avatar manager', AvatarManager.AvatarManager)
extension.category_register('preferences',
Preferences.Preferences,
single_instance=True)
extension.category_register('login window', Login.Login)
extension.category_register('connecting window', Login.ConnectingWindow)
extension.category_register('window frame', Window.Window)
extension.category_register('main window', MainWindow.MainWindow)
extension.category_register('contact list', ContactList.ContactList)
extension.category_register('synch tool', SyncTool.SyncTool)
if not check_gtk3():
extension.category_register('avatar renderer',
Renderers.AvatarRenderer)
extension.category_register('nick renderer',
Renderers.CellRendererPlus)
extension.register('nick renderer', Renderers.CellRendererNoPlus)
extension.register('smiley label', Renderers.SmileyLabel)
else:
extension.category_register('avatar renderer',
RenderersNew.AvatarRenderer)
extension.category_register('nick renderer',
RenderersNew.CellRendererPlus)
extension.register('nick renderer', RenderersNew.CellRendererNoPlus)
extension.register('smiley label', RenderersNew.SmileyLabel)
extension.category_register('user panel', UserPanel.UserPanel)
extension.category_register('debug window', DebugWindow.DebugWindow)
if not INFOBARERROR:
extension.category_register('nice bar', InfoBar.NiceBar)
extension.register('nice bar', NiceBar.NiceBar)
else:
extension.category_register('nice bar', NiceBar.NiceBar)
extension.category_register('main menu', MainMenu.MainMenu)
extension.category_register('menu file', MainMenu.FileMenu)
extension.category_register('menu actions', MainMenu.ActionsMenu)
extension.category_register('menu options', MainMenu.OptionsMenu)
extension.category_register('menu contact', ContactMenu.ContactMenu)
extension.category_register('menu group', GroupMenu.GroupMenu)
extension.category_register('menu account', AccountMenu.AccountMenu)
extension.category_register('menu help', MainMenu.HelpMenu)
extension.category_register('menu status', StatusMenu.StatusMenu)
extension.category_register('below menu', EmptyWidget.EmptyWidget)
extension.category_register('below panel', EmptyWidget.EmptyWidget)
extension.category_register('below userlist', EmptyWidget.EmptyWidget)
extension.category_register('call widget', CallWidget.CallWindow)
extension.category_register('conversation window', \
ConversationManager.ConversationManager)
extension.category_register('conversation', Conversation.Conversation)
extension.category_register('conversation header', Header.Header)
extension.category_register('conversation info',
ContactInfoRotate.ContactInfoRotate)
extension.register('conversation info', ContactInfoList.ContactInfoList)
extension.category_register('conversation tab', TabWidget.TabWidget)
extension.category_register('conversation input', TextBox.InputText)
extension.category_register('conversation toolbar', \
ConversationToolbar.ConversationToolbar)
if not check_gtk3():
extension.category_register('image area selector',
ImageAreaSelector.ImageAreaSelectorDialog)
extension.category_register('tiny button', TinyButton.TinyButton)
else:
extension.category_register(
'image area selector',
ImageAreaSelectorNew.ImageAreaSelectorDialog)
extension.category_register('tiny button', TinyButtonNew.TinyButton)
extension.category_register('filetransfer pool',
FileTransferBarWidget.FileTransferBarWidget)
extension.category_register('filetransfer widget',
FileTransferWidget.FileTransferWidget)
if not WEBKITERROR:
extension.category_register('conversation output',
AdiumTextBox.OutputText)
extension.register('conversation output', TextBox.OutputText)
else:
extension.category_register('conversation output', TextBox.OutputText)
extension.category_register('picture handler',
PictureHandler.PictureHandler)
extension.category_register('toolkit tags', utils.GTKTags)
def get_screen_dpi():
''' Return screen DPI '''
xft_dpi = gtk.settings_get_default().get_property('gtk-xft-dpi')
dpi = float(xft_dpi / 1024)
return dpi
def __init_ui(self):
# add icon search path
self.__window = self.__builder.get_object("window_preferences")
self.__window.connect("delete-event", gtk.main_quit)
self.__button_close = self.__builder.get_object("button_close")
self.__button_close.connect("clicked", gtk.main_quit)
# auto start ibus
self.__checkbutton_auto_start = self.__builder.get_object("checkbutton_auto_start")
self.__checkbutton_auto_start.set_active(self.__is_auto_start())
self.__checkbutton_auto_start.connect("toggled", self.__checkbutton_auto_start_toggled_cb)
# keyboard shortcut
# trigger
self.__config = self.__bus.get_config()
shortcuts = self.__config.get_value(
"general/hotkey", "trigger",
ibus.CONFIG_GENERAL_SHORTCUT_TRIGGER_DEFAULT)
button = self.__builder.get_object("button_trigger")
entry = self.__builder.get_object("entry_trigger")
entry.set_text("; ".join(shortcuts))
entry.set_tooltip_text("\n".join(shortcuts))
button.connect("clicked", self.__shortcut_button_clicked_cb,
N_("trigger"), "general/hotkey", "trigger", entry)
# next engine
shortcuts = self.__config.get_value(
"general/hotkey", "next_engine_in_menu",
ibus.CONFIG_GENERAL_SHORTCUT_NEXT_ENGINE_DEFAULT)
button = self.__builder.get_object("button_next_engine")
entry = self.__builder.get_object("entry_next_engine")
entry.set_text("; ".join(shortcuts))
entry.set_tooltip_text("\n".join(shortcuts))
button.connect("clicked", self.__shortcut_button_clicked_cb,
N_("next input method"), "general/hotkey", "next_engine_in_menu", entry)
# prev engine
shortcuts = self.__config.get_value(
"general/hotkey", "previous_engine",
ibus.CONFIG_GENERAL_SHORTCUT_PREV_ENGINE_DEFAULT)
button = self.__builder.get_object("button_prev_engine")
entry = self.__builder.get_object("entry_prev_engine")
entry.set_text("; ".join(shortcuts))
entry.set_tooltip_text("\n".join(shortcuts))
button.connect("clicked", self.__shortcut_button_clicked_cb,
N_("previous input method"), "general/hotkey", "previous_engine", entry)
# lookup table orientation
self.__combobox_lookup_table_orientation = self.__builder.get_object("combobox_lookup_table_orientation")
self.__combobox_lookup_table_orientation.set_active(
self.__config.get_value("panel", "lookup_table_orientation", 0))
self.__combobox_lookup_table_orientation.connect("changed",
self.__combobox_lookup_table_orientation_changed_cb)
# auto hide
self.__combobox_panel_show = self.__builder.get_object("combobox_panel_show")
self.__combobox_panel_show.set_active(
self.__config.get_value("panel", "show", 0))
self.__combobox_panel_show.connect("changed", self.__combobox_panel_show_changed_cb)
# panel position
self.__combobox_panel_position = self.__builder.get_object("combobox_panel_position")
self.__combobox_panel_position.set_active(
self.__config.get_value("panel", "position", 3))
self.__combobox_panel_position.connect("changed", self.__combobox_panel_position_changed_cb)
# custom font
self.__checkbutton_custom_font = self.__builder.get_object("checkbutton_custom_font")
self.__checkbutton_custom_font.set_active(
self.__config.get_value("panel", "use_custom_font", False))
self.__checkbutton_custom_font.connect("toggled", self.__checkbutton_custom_font_toggled_cb)
self.__fontbutton_custom_font = self.__builder.get_object("fontbutton_custom_font")
if self.__config.get_value("panel", "use_custom_font", False):
self.__fontbutton_custom_font.set_sensitive(True)
else:
self.__fontbutton_custom_font.set_sensitive(False)
font_name = gtk.settings_get_default().get_property("gtk-font-name")
font_name = unicode(font_name, "utf-8")
font_name = self.__config.get_value("panel", "custom_font", font_name)
self.__fontbutton_custom_font.connect("notify::font-name", self.__fontbutton_custom_font_notify_cb)
self.__fontbutton_custom_font.set_font_name(font_name)
# show icon on system tray
self.__checkbutton_show_icon_on_systray = self.__builder.get_object("checkbutton_show_icon_on_systray")
self.__checkbutton_show_icon_on_systray.set_active(
self.__config.get_value("panel", "show_icon_on_systray", True))
self.__checkbutton_show_icon_on_systray.connect("toggled", self.__checkbutton_show_icon_on_systray_toggled_cb)
# show ime name
self.__checkbutton_show_im_name = self.__builder.get_object("checkbutton_show_im_name")
self.__checkbutton_show_im_name.set_active(
self.__config.get_value("panel", "show_im_name", False))
self.__checkbutton_show_im_name.connect("toggled", self.__checkbutton_show_im_name_toggled_cb)
# embed preedit text
self.__checkbutton_embed_preedit_text = self.__builder.get_object("checkbutton_embed_preedit_text")
self.__checkbutton_embed_preedit_text.set_active(
self.__config.get_value("general", "embed_preedit_text", True))
self.__checkbutton_embed_preedit_text.connect("toggled", self.__checkbutton_embed_preedit_text_toggled_cb)
# use system keyboard layout setting
self.__checkbutton_use_sys_layout = self.__builder.get_object("checkbutton_use_sys_layout")
self.__checkbutton_use_sys_layout.set_active(
self.__config.get_value("general", "use_system_keyboard_layout", True))
self.__checkbutton_use_sys_layout.connect("toggled", self.__checkbutton_use_sys_layout_toggled_cb)
# use global ime setting
self.__checkbutton_use_global_engine = self.__builder.get_object("checkbutton_use_global_engine")
self.__checkbutton_use_global_engine.set_active(
self.__config.get_value("general", "use_global_engine", False))
self.__checkbutton_use_global_engine.connect("toggled", self.__checkbutton_use_global_engine_toggled_cb)
# init engine page
self.__engines = self.__bus.list_engines()
self.__combobox = self.__builder.get_object("combobox_engines")
self.__combobox.set_engines(self.__engines)
tmp_dict = {}
for e in self.__engines:
tmp_dict[e.name] = e
engine_names = self.__config.get_value("general", "preload_engines", [])
engines = [tmp_dict[name] for name in engine_names if name in tmp_dict]
self.__treeview = self.__builder.get_object("treeview_engines")
self.__treeview.set_engines(engines)
button = self.__builder.get_object("button_engine_add")
button.connect("clicked", self.__button_engine_add_cb)
button = self.__builder.get_object("button_engine_remove")
button.connect("clicked", lambda *args:self.__treeview.remove_engine())
button = self.__builder.get_object("button_engine_up")
button.connect("clicked", lambda *args:self.__treeview.move_up_engine())
button = self.__builder.get_object("button_engine_down")
button.connect("clicked", lambda *args:self.__treeview.move_down_engine())
button = self.__builder.get_object("button_engine_about")
button.connect("clicked", self.__button_engine_about_cb)
self.__combobox.connect("notify::active-engine", self.__combobox_notify_active_engine_cb)
self.__treeview.connect("notify", self.__treeview_notify_cb)
def main():
""" creates a HAL component.
parsees a glade XML file with gtk.builder or libglade
calls gladevcp.makepins with the specified XML file
to create pins and register callbacks.
main window must be called "window1"
"""
global gladevcp_debug
(progdir, progname) = os.path.split(sys.argv[0])
usage = "usage: %prog [options] myfile.ui"
parser = OptionParser(usage=usage)
parser.disable_interspersed_args()
parser.add_options(options)
(opts, args) = parser.parse_args()
if not args:
parser.print_help()
sys.exit(1)
gladevcp_debug = debug = opts.debug
xmlname = args[0]
#if there was no component name specified use the xml file name
if opts.component is None:
opts.component = os.path.splitext(os.path.basename(xmlname))[0]
#try loading as a libglade project
try:
builder = gtk.glade.XML(xmlname)
builder = GladeBuilder(builder)
except:
try:
# try loading as a gtk.builder project
print "**** GLADE VCP INFO: Not a libglade project, trying to load as a GTK builder project"
builder = gtk.Builder()
builder.add_from_file(xmlname)
except:
print "**** GLADE VCP ERROR: With xml file: %s" % xmlname
sys.exit(0)
window = builder.get_object("window1")
window.set_title(opts.component)
try:
halcomp = hal.component(opts.component)
except:
print "*** GLADE VCP ERROR: Asking for a HAL component using a name that already exists."
sys.exit(0)
panel = gladevcp.makepins.GladePanel(halcomp, xmlname, builder, None)
# at this point, any glade HL widgets and their pins are set up.
handlers = load_handlers(opts.usermod, halcomp, builder, opts.useropts)
builder.connect_signals(handlers)
if opts.parent:
# block X errors since gdk error handling silently exits the
# program without even the atexit handler given a chance
gtk.gdk.error_trap_push()
window = xembed.reparent(window, opts.parent)
forward = os.environ.get('AXIS_FORWARD_EVENTS_TO', None)
if forward:
xembed.keyboard_forward(window, forward)
window.connect("destroy", on_window_destroy)
window.show()
# for window resize and or position options
if "+" in opts.geometry:
try:
j = opts.geometry.partition("+")
pos = j[2].partition("+")
window.move(int(pos[0]), int(pos[2]))
except:
print "**** GLADE VCP ERROR: With window position data"
parser.print_usage()
sys.exit(1)
if "x" in opts.geometry:
try:
if "+" in opts.geometry:
j = opts.geometry.partition("+")
t = j[0].partition("x")
else:
t = window_geometry.partition("x")
window.resize(int(t[0]), int(t[2]))
except:
print "**** GLADE VCP ERROR: With window resize data"
parser.print_usage()
sys.exit(1)
if opts.gtk_workaround:
# work around https://bugs.launchpad.net/ubuntu/+source/pygtk/+bug/507739
# this makes widget and widget_class matches in gtkrc and theme files actually work
dbg("activating GTK bug workaround for gtkrc files")
for o in builder.get_objects():
if isinstance(o, gtk.Widget):
# retrieving the name works only for GtkBuilder files, not for
# libglade files, so be cautious about it
name = gtk.Buildable.get_name(o)
if name: o.set_name(name)
if opts.gtk_rc:
dbg("**** GLADE VCP INFO: %s reading gtkrc file '%s'" %
(opts.component, opts.gtk_rc))
gtk.rc_add_default_file(opts.gtk_rc)
gtk.rc_parse(opts.gtk_rc)
if opts.theme:
dbg("**** GLADE VCP INFO: Switching %s to '%s' theme" %
(opts.component, opts.theme))
settings = gtk.settings_get_default()
settings.set_string_property("gtk-theme-name", opts.theme, "")
# This needs to be done after geometry moves so on dual screens the window maxumizes to the actual used screen size.
if opts.maximum:
window.window.maximize()
if opts.halfile:
cmd = ["halcmd", "-f", opts.halfile]
res = subprocess.call(cmd, stdout=sys.stdout, stderr=sys.stderr)
if res:
print >> sys.stderr, "'%s' exited with %d" % (' '.join(cmd), res)
sys.exit(res)
# User components are set up so report that we are ready
halcomp.ready()
if handlers.has_key(signal_func):
dbg("Register callback '%s' for SIGINT and SIGTERM" % (signal_func))
signal.signal(signal.SIGTERM, handlers[signal_func])
signal.signal(signal.SIGINT, handlers[signal_func])
try:
gtk.main()
except KeyboardInterrupt:
sys.exit(0)
finally:
halcomp.exit()
if opts.parent:
gtk.gdk.flush()
error = gtk.gdk.error_trap_pop()
if error:
print "**** GLADE VCP ERROR: X Protocol Error: %s" % str(error)
def __init__(self, target, backend):
self.dependency_check = dependency_check
self.target = target
self.backend = backend
self.empty_gui = False
# Variable to hold the Process object in case we choose to disassemble a binary.
self.dasm_process = False
# Check if we have, at least, one core; else: exit
if not dependency_check.HAS_PYEW and not dependency_check.HAS_RADARE:
md = gtk.MessageDialog(None, gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_ERROR, gtk.BUTTONS_CLOSE, None)
md.set_markup("<big><b>No backend engines found!</b></big>")
md.format_secondary_markup("Install either pyew or radare to run bokken:\n\n<b>Pyew:</b>\t\t<a href=\"http://code.google.com/p/pyew/\">http://code.google.com/p/pyew/</a>\n<b>Radare:</b>\t<a href=\"http://radare.org/\">http://radare.org</a>")
md.run()
md.destroy()
sys.exit(1)
# Launch file selection dialog
dialog = file_dialog.FileDialog(dependency_check.HAS_PYEW, dependency_check.HAS_RADARE, self.backend, self.target)
resp = dialog.run()
if resp == gtk.RESPONSE_DELETE_EVENT or resp == gtk.RESPONSE_REJECT:
sys.exit(1)
# Get dialog selected file, backend and options
self.target = dialog.file
self.backend = dialog.backend
# Load selected core
if self.backend == 'pyew':
import ui.core as core
self.uicore = core.Core(dialog.case, dialog.deep, dialog.progress_bar)
elif self.backend == 'radare':
import ui.radare_core as radare_core
self.uicore = radare_core.Core(dialog.radare_lower, dialog.analyze_bin, dialog.asm_syn ,dialog.use_va, dialog.asm_byt, dialog.progress_bar)
self.uicore.backend = self.backend
# Check if target name is an URL, pyew stores it as 'raw'
self.uicore.is_url(self.target)
if self.target:
# Just open the target if path is correct or an url
if self.uicore.core.format != 'URL' and not os.path.isfile(self.target):
print "Incorrect file argument:", FAIL, self.target, ENDC
sys.exit(1)
self.load_file(self.target)
import ui.core_functions
ui.core_functions.repaint()
else:
self.empty_gui = True
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_focus = True
self.window.connect("delete_event", self.quit)
self.window.set_icon_from_file(os.path.dirname(__file__)+os.sep+'data'+os.sep+'bokken.svg')
gtk.settings_get_default().set_long_property("gtk-button-images", True, "main")
# Title
self.window.set_title(MAINTITLE)
# Positions
self.window.resize(800, 600)
self.window.move(25, 25)
# Maximize window
self.window.maximize()
# Create VBox to contain top buttons and other VBox
self.supervb = gtk.VBox(False, 1)
# Menu bar
self.mbar = menu_bar.MenuBar(self)
self.supervb.pack_start(self.mbar, False, False, 1)
# Create top buttons and add to VBox
if self.backend == 'pyew':
import ui.pyew_toolbar as toolbar
self.topbuttons = toolbar.TopButtons(self.uicore, self)
elif self.backend == 'radare':
import ui.radare_toolbar as toolbar
self.topbuttons = toolbar.TopButtons(self.uicore, self)
self.supervb.pack_start(self.topbuttons, False, True, 1)
# Create VBox to contain textviews and statusbar
self.mainvb = gtk.VBox(False, 1)
self.supervb.pack_start(self.mainvb, True, True, 1)
# Initialize and add TextViews
self.tviews = textviews.TextViews(self.uicore, self)
# Create toolbar show/hide tabs menu
self.mbar.create_view_menu()
# Initialize and add Statusbar
self.sbar = statusbar.Statusbar(self.uicore, self.tviews)
self.sbar.create_statusbar()
# Add textviews and statusbar to the VBox
self.mainvb.pack_start(self.tviews, True, True, 1)
self.mainvb.pack_start(self.sbar, False, True, 1)
self.window.add(self.supervb)
# Disable all until file loads
self.disable_all()
if self.empty_gui:
self.show_empty_gui()
self.show_file_data()
self.window.show_all()
# Hide left tree for plain or unsupported formats
if self.uicore.core.format in ['Hexdump', 'Plain Text', 'OLE2']:
self.tviews.left_scrolled_window.hide()
if self.uicore.backend == 'radare':
if not self.uicore.do_anal:
self.topbuttons.diff_tb.set_sensitive(False)
dialog.destroy()
# We make sure that we remove the reference to the scrollbar to avoid errors.
self.uicore.core.progress_bar = None
gtk.main()
def __init__(self, inifile):
# System default Glade file:
self.gladefile = os.path.join(datadir, "touchy.glade")
if inifile:
self.ini = linuxcnc.ini(inifile)
alternate_gladefile = self.ini.find("DISPLAY", "GLADEFILE")
if alternate_gladefile:
self.gladefile = alternate_gladefile
else:
self.ini = None
self.wTree = gtk.glade.XML(self.gladefile)
for w in [
'wheelinc1', 'wheelinc2', 'wheelinc3', 'wheelx', 'wheely',
'wheelz', 'wheela', 'wheelb', 'wheelc', 'wheelu', 'wheelv',
'wheelw'
]:
self.wTree.get_widget(w).get_child().set_property('width-chars', 6)
for widget in self.wTree.get_widget_prefix(''):
widget.unset_flags(gtk.CAN_FOCUS)
self.wTree.get_widget('MainWindow').set_flags(gtk.CAN_FOCUS)
self.wTree.get_widget('MainWindow').grab_focus()
self.num_mdi_labels = 11
self.num_filechooser_labels = 11
self.num_listing_labels = 20
self.wheelxyz = 0
self.wheelinc = 0
self.wheel = "fo"
self.radiobutton_mask = 0
self.resized_wheelbuttons = 0
self.tab = 0
self.fo_val = 100
self.so_val = 100
self.g10l11 = 0
self.prefs = preferences.preferences()
self.mv_val = self.prefs.getpref('maxvel', 100, int)
self.control_font_name = self.prefs.getpref('control_font', 'Sans 18',
str)
self.dro_font_name = self.prefs.getpref('dro_font',
'Courier 10 Pitch Bold 16',
str)
self.error_font_name = self.prefs.getpref('error_font', 'Sans Bold 10',
str)
self.listing_font_name = self.prefs.getpref('listing_font', 'Sans 10',
str)
self.theme_name = self.prefs.getpref('gtk_theme',
'Follow System Theme', str)
self.abs_textcolor = self.prefs.getpref('abs_textcolor', 'default',
str)
self.rel_textcolor = self.prefs.getpref('rel_textcolor', 'default',
str)
self.dtg_textcolor = self.prefs.getpref('dtg_textcolor', 'default',
str)
self.err_textcolor = self.prefs.getpref('err_textcolor', 'default',
str)
self.window_geometry = self.prefs.getpref('window_geometry', 'default',
str)
self.window_max = self.prefs.getpref('window_force_max', 'False', bool)
# initial screen setup
if os.path.exists(themedir):
model = self.wTree.get_widget("theme_choice").get_model()
model.clear()
model.append((_("Follow System Theme"), ))
temp = 0
names = os.listdir(themedir)
names.sort()
for search, dirs in enumerate(names):
model.append((dirs, ))
if dirs == self.theme_name:
temp = search + 1
self.wTree.get_widget("theme_choice").set_active(temp)
if self.window_geometry == "default":
self.wTree.get_widget("MainWindow").window.maximize()
else:
self.wTree.get_widget("MainWindow").parse_geometry(
self.window_geometry)
if self.window_max:
self.wTree.get_widget("MainWindow").window.maximize()
self.invisible_cursor = self.prefs.getpref('invisible_cursor', 0)
if self.invisible_cursor:
self.wTree.get_widget("MainWindow").window.set_cursor(invisible)
else:
self.wTree.get_widget("MainWindow").window.set_cursor(None)
self.wTree.get_widget("controlfontbutton").set_font_name(
self.control_font_name)
self.control_font = pango.FontDescription(self.control_font_name)
self.wTree.get_widget("drofontbutton").set_font_name(
self.dro_font_name)
self.dro_font = pango.FontDescription(self.dro_font_name)
self.wTree.get_widget("errorfontbutton").set_font_name(
self.error_font_name)
self.error_font = pango.FontDescription(self.error_font_name)
self.wTree.get_widget("listingfontbutton").set_font_name(
self.listing_font_name)
self.listing_font = pango.FontDescription(self.listing_font_name)
settings = gtk.settings_get_default()
self.system_theme = settings.get_property("gtk-theme-name")
if not self.theme_name == "Follow System Theme":
settings.set_string_property("gtk-theme-name", self.theme_name, "")
# interactive mdi command builder and issuer
mdi_labels = []
mdi_eventboxes = []
for i in range(self.num_mdi_labels):
mdi_labels.append(self.wTree.get_widget("mdi%d" % i))
mdi_eventboxes.append(self.wTree.get_widget("eventbox_mdi%d" % i))
self.mdi_control = mdi.mdi_control(gtk, linuxcnc, mdi_labels,
mdi_eventboxes)
if self.ini:
macros = self.ini.findall("TOUCHY", "MACRO")
if len(macros) > 0:
self.mdi_control.mdi.add_macros(macros)
else:
self.wTree.get_widget("macro").set_sensitive(0)
listing_labels = []
listing_eventboxes = []
for i in range(self.num_listing_labels):
listing_labels.append(self.wTree.get_widget("listing%d" % i))
listing_eventboxes.append(
self.wTree.get_widget("eventbox_listing%d" % i))
self.listing = listing.listing(gtk, linuxcnc, listing_labels,
listing_eventboxes)
# emc interface
self.linuxcnc = emc_interface.emc_control(
linuxcnc, self.listing, self.wTree.get_widget("error"))
self.linuxcnc.continuous_jog_velocity(self.mv_val)
self.hal = hal_interface.hal_interface(self, self.linuxcnc,
self.mdi_control, linuxcnc)
# silly file chooser
filechooser_labels = []
filechooser_eventboxes = []
for i in range(self.num_filechooser_labels):
filechooser_labels.append(
self.wTree.get_widget("filechooser%d" % i))
filechooser_eventboxes.append(
self.wTree.get_widget("eventbox_filechooser%d" % i))
self.filechooser = filechooser.filechooser(gtk, linuxcnc,
filechooser_labels,
filechooser_eventboxes,
self.listing)
relative = ['xr', 'yr', 'zr', 'ar', 'br', 'cr', 'ur', 'vr', 'wr']
absolute = ['xa', 'ya', 'za', 'aa', 'ba', 'ca', 'ua', 'va', 'wa']
distance = ['xd', 'yd', 'zd', 'ad', 'bd', 'cd', 'ud', 'vd', 'wd']
relative = [self.wTree.get_widget(i) for i in relative]
absolute = [self.wTree.get_widget(i) for i in absolute]
distance = [self.wTree.get_widget(i) for i in distance]
estops = ['estop_reset', 'estop']
estops = dict((i, self.wTree.get_widget(i)) for i in estops)
machines = ['on', 'off']
machines = dict(
(i, self.wTree.get_widget("machine_" + i)) for i in machines)
floods = ['on', 'off']
floods = dict((i, self.wTree.get_widget("flood_" + i)) for i in floods)
mists = ['on', 'off']
mists = dict((i, self.wTree.get_widget("mist_" + i)) for i in mists)
spindles = ['forward', 'off', 'reverse']
spindles = dict(
(i, self.wTree.get_widget("spindle_" + i)) for i in spindles)
stats = [
'file', 'file_lines', 'line', 'id', 'dtg', 'velocity', 'delay',
'onlimit', 'spindledir', 'spindlespeed', 'loadedtool',
'preppedtool', 'xyrotation', 'tlo', 'activecodes', 'spindlespeed2',
'label_g5xoffset', 'g5xoffset', 'g92offset', 'tooltable'
]
stats = dict((i, self.wTree.get_widget("status_" + i)) for i in stats)
prefs = ['actual', 'commanded', 'inch', 'mm']
prefs = dict((i, self.wTree.get_widget("dro_" + i)) for i in prefs)
opstop = ['on', 'off']
opstop = dict(
(i, self.wTree.get_widget("opstop_" + i)) for i in opstop)
blockdel = ['on', 'off']
blockdel = dict(
(i, self.wTree.get_widget("blockdel_" + i)) for i in blockdel)
self.status = emc_interface.emc_status(
gtk, linuxcnc, self.listing, relative, absolute, distance,
self.wTree.get_widget("dro_table"),
self.wTree.get_widget("error"), estops, machines,
self.wTree.get_widget("override_limits"), stats, floods, mists,
spindles, prefs, opstop, blockdel)
self.current_file = self.status.emcstat.file
# check the ini file if UNITS are set to mm"
# first check the global settings
units = self.ini.find("TRAJ", "LINEAR_UNITS")
if units == None:
units = self.ini.find("AXIS_X", "UNITS")
if units == "mm" or units == "metric" or units == "1.0":
self.machine_units_mm = 1
conversion = [1.0 / 25.4] * 3 + [1] * 3 + [1.0 / 25.4] * 3
else:
self.machine_units_mm = 0
conversion = [25.4] * 3 + [1] * 3 + [25.4] * 3
self.status.set_machine_units(self.machine_units_mm, conversion)
if self.prefs.getpref('toolsetting_fixture', 0):
self.g10l11 = 1
else:
self.g10l11 = 0
if self.prefs.getpref('dro_mm', 0):
self.status.dro_mm(0)
else:
self.status.dro_inch(0)
if self.prefs.getpref('dro_actual', 0):
self.status.dro_actual(0)
else:
self.status.dro_commanded(0)
if self.prefs.getpref('blockdel', 0):
self.linuxcnc.blockdel_on(0)
else:
self.linuxcnc.blockdel_off(0)
if self.prefs.getpref('opstop', 1):
self.linuxcnc.opstop_on(0)
else:
self.linuxcnc.opstop_off(0)
self.linuxcnc.emccommand.program_open(empty_program.name)
self.linuxcnc.max_velocity(self.mv_val)
gobject.timeout_add(50, self.periodic_status)
gobject.timeout_add(100, self.periodic_radiobuttons)
# event bindings
dic = {
"quit": self.quit,
"on_pointer_show_clicked": self.pointer_show,
"on_pointer_hide_clicked": self.pointer_hide,
"on_opstop_on_clicked": self.opstop_on,
"on_opstop_off_clicked": self.opstop_off,
"on_blockdel_on_clicked": self.blockdel_on,
"on_blockdel_off_clicked": self.blockdel_off,
"on_reload_tooltable_clicked": self.linuxcnc.reload_tooltable,
"on_notebook1_switch_page": self.tabselect,
"on_controlfontbutton_font_set": self.change_control_font,
"on_drofontbutton_font_set": self.change_dro_font,
"on_dro_actual_clicked": self.dro_actual,
"on_dro_commanded_clicked": self.dro_commanded,
"on_dro_inch_clicked": self.dro_inch,
"on_dro_mm_clicked": self.dro_mm,
"on_errorfontbutton_font_set": self.change_error_font,
"on_listingfontbutton_font_set": self.change_listing_font,
"on_estop_clicked": self.linuxcnc.estop,
"on_estop_reset_clicked": self.linuxcnc.estop_reset,
"on_machine_off_clicked": self.linuxcnc.machine_off,
"on_machine_on_clicked": self.linuxcnc.machine_on,
"on_mdi_clear_clicked": self.mdi_control.clear,
"on_mdi_back_clicked": self.mdi_control.back,
"on_mdi_next_clicked": self.mdi_control.next,
"on_mdi_decimal_clicked": self.mdi_control.decimal,
"on_mdi_minus_clicked": self.mdi_control.minus,
"on_mdi_keypad_clicked": self.mdi_control.keypad,
"on_mdi_g_clicked": self.mdi_control.g,
"on_mdi_gp_clicked": self.mdi_control.gp,
"on_mdi_m_clicked": self.mdi_control.m,
"on_mdi_t_clicked": self.mdi_control.t,
"on_mdi_select": self.mdi_control.select,
"on_mdi_set_tool_clicked": self.mdi_set_tool,
"on_mdi_set_origin_clicked": self.mdi_set_origin,
"on_mdi_macro_clicked": self.mdi_macro,
"on_filechooser_select": self.fileselect,
"on_filechooser_up_clicked": self.filechooser.up,
"on_filechooser_down_clicked": self.filechooser.down,
"on_filechooser_reload_clicked": self.filechooser.reload,
"on_listing_up_clicked": self.listing.up,
"on_listing_down_clicked": self.listing.down,
"on_listing_previous_clicked": self.listing.previous,
"on_listing_next_clicked": self.listing.next,
"on_mist_on_clicked": self.linuxcnc.mist_on,
"on_mist_off_clicked": self.linuxcnc.mist_off,
"on_flood_on_clicked": self.linuxcnc.flood_on,
"on_flood_off_clicked": self.linuxcnc.flood_off,
"on_home_all_clicked": self.linuxcnc.home_all,
"on_unhome_all_clicked": self.linuxcnc.unhome_all,
"on_home_selected_clicked": self.home_selected,
"on_unhome_selected_clicked": self.unhome_selected,
"on_fo_clicked": self.fo,
"on_so_clicked": self.so,
"on_mv_clicked": self.mv,
"on_jogging_clicked": self.jogging,
"on_scrolling_clicked": self.scrolling,
"on_wheelx_clicked": self.wheelx,
"on_wheely_clicked": self.wheely,
"on_wheelz_clicked": self.wheelz,
"on_wheela_clicked": self.wheela,
"on_wheelb_clicked": self.wheelb,
"on_wheelc_clicked": self.wheelc,
"on_wheelu_clicked": self.wheelu,
"on_wheelv_clicked": self.wheelv,
"on_wheelw_clicked": self.wheelw,
"on_wheelinc1_clicked": self.wheelinc1,
"on_wheelinc2_clicked": self.wheelinc2,
"on_wheelinc3_clicked": self.wheelinc3,
"on_override_limits_clicked": self.linuxcnc.override_limits,
"on_spindle_forward_clicked": self.linuxcnc.spindle_forward,
"on_spindle_off_clicked": self.linuxcnc.spindle_off,
"on_spindle_reverse_clicked": self.linuxcnc.spindle_reverse,
"on_spindle_slower_clicked": self.linuxcnc.spindle_slower,
"on_spindle_faster_clicked": self.linuxcnc.spindle_faster,
"on_toolset_fixture_clicked": self.toolset_fixture,
"on_toolset_workpiece_clicked": self.toolset_workpiece,
"on_changetheme_clicked": self.change_theme,
}
self.wTree.signal_autoconnect(dic)
for widget in self.wTree.get_widget_prefix(''):
if isinstance(widget, gtk.Button):
widget.connect_after('released', self.hack_leave)
self._dynamic_childs = {}
atexit.register(self.kill_dynamic_childs)
self.set_dynamic_tabs()
atexit.register(self.save_maxvel_pref)
self.setfont()
def read(self):
self.min_mainWindowX = 580
self.min_mainWindowY = 640
self.min_panedWindowX = 440
self.max_panedWindowX = 640
self.min_treeX = 240
self.max_treeX = 440
self.mainWindowX = int(self.read_config("window","main_window_x"))
self.mainWindowY = int(self.read_config("window","main_window_y"))
self.window_x = self.mainWindowX
self.window_y = self.mainWindowY
self.panedWindowX = int(self.read_config("window","paned_window_x"))
self.treeX = int(self.read_config("window","tree_x"))
y = get_workspace()[1]
if ( self.mainWindowY > y ):
self.mainWindowY = y
if ( self.min_mainWindowY > y ):
self.min_mainWindowY = y
self.mainWindowLastX = self.mainWindowX
self.window.move(0,0)
self.window.set_resizable(True)
self.window.resize(self.mainWindowX, self.mainWindowY)
self.window.set_size_request(self.min_mainWindowX, self.min_mainWindowY)
self.fontDefault = self.read_config("tree","font_default")
gtk.settings_get_default().props.gtk_font_name = self.fontDefault
# IP адрес
self.localIp = ""
if ( self.read_config("local","local_ip") == "" ):
self.local_ip = socket.gethostbyname(self.local_hostname)
else:
self.local_ip = self.read_config("local","local_ip")
self.localIp = self.local_ip
##########################################
self.messageList.clear()
for i in range(20):
text = self.read_config("command","f"+str(i+1))
if ( text != "" ):
self.messageList.append([text])
self.logoutCommandUse = self.read_config("system","logout_command_use")
self.logoutCommand = self.read_config("system","logout_command")
self.vncThumbnailsX = int(self.read_config("vnc","vnc_thumbnails_x"))
self.vncThumbnailsY = int(self.read_config("vnc","vnc_thumbnails_y"))
self.vncThumbnailsToolbar = self.read_config("vnc","vnc_thumbnails_toolbar")
self.vncShotFolder = self.read_config("vnc","vnc_shot_folder")
self.vncShotFolder = os.path.expanduser(self.vncShotFolder)
self.vncGtk = self.read_config("vnc","vnc_gtk")
self.vncGtkX = int(self.read_config("vnc","vnc_gtk_x"))
self.vncGtkY = int(self.read_config("vnc","vnc_gtk_y"))
self.demoSsh = self.read_config("vnc","demo_ssh")
self.demoVlc = self.read_config("vnc","demo_vlc")
self.demoVlcRtp = self.read_config("vnc","demo_vlc_rtp")
self.demoVlcAudio = self.read_config("vnc","demo_vlc_audio")
self.demoVlcFps = self.read_config("vnc","demo_vlc_fps")
self.demoVlcVcodec = self.read_config("vnc","demo_vlc_vcodec")
self.demoVlcScaleFull = self.read_config("vnc","demo_vlc_scale_full")
self.demoVlcScaleWindow = self.read_config("vnc","demo_vlc_scale_window")
self.demoVlcCaching = self.read_config("vnc","demo_vlc_caching")
self.vncServer = self.read_config("vnc","vnc_server")
self.vncServerWindow = self.read_config("vnc","vnc_server_window")
self.gecosAlias = self.read_config("tree","gecos_alias")
self.treeShow = self.read_config("tree","tree_show")
self.treeInfo = self.read_config("tree","tree_info")
self.treeInfoTooltip = self.read_config("tree","tree_info_tooltip")
self.fontTree = self.read_config("tree","font_tree")
self.fontStatus = self.read_config("tree","font_status")
self.fontThumbnails = self.read_config("tree","font_thumbnails")
self.checkDhcp = self.read_config("tree","check_dhcp")
self.checkStatusInterval = self.read_config("tree","check_status_interval")
self.f1 = self.read_config("command","f1")
self.f2 = self.read_config("command","f2")
self.f3 = self.read_config("command","f3")
self.f4 = self.read_config("command","f4")
self.f5 = self.read_config("command","f5")
self.f6 = self.read_config("command","f6")
self.f7 = self.read_config("command","f7")
self.f8 = self.read_config("command","f8")
self.f9 = self.read_config("command","f9")
self.f10 = self.read_config("command","f10")
self.f11 = self.read_config("command","f11")
self.f12 = self.read_config("command","f12")
self.f13 = self.read_config("command","f13")
self.f14 = self.read_config("command","f14")
self.f15 = self.read_config("command","f15")
self.f16 = self.read_config("command","f16")
self.f17 = self.read_config("command","f17")
self.f18 = self.read_config("command","f18")
self.f19 = self.read_config("command","f19")
self.f20 = self.read_config("command","f20")
self.ltspInfo = self.read_config("system","ltspinfo")
# Тема
self.gtkrc = self.read_config("window","gtkrc")
self.ssh_options = self.read_config("ssh","ssh_options")
self.ssh = "ssh "+self.ssh_options+" -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -o PasswordAuthentication=no "
self.scp = "scp "+self.ssh_options+" -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -o PasswordAuthentication=no -r "
self.sshfs = "sshfs "+self.ssh_options+" -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -o PasswordAuthentication=no "
def __init__(self):
self.lcnc = labvCNC()
gtk.settings_get_default().set_property(
'gtk-theme-name', self.lcnc.iniFile.find('PLASMAC', 'THEME'))
self.gui = "./test/plasmac_test.glade"
self.B = gtk.Builder()
self.B.add_from_file(self.gui)
self.B.connect_signals(self)
self.W = self.B.get_object("window1")
self.halcomp = hal.component('plasmactest')
self.panel = gladevcp.makepins.GladePanel(self.halcomp, self.gui,
self.B, None)
self.torch = hal_glib.GPin(
self.halcomp.newpin('torch-on', hal.HAL_BIT, hal.HAL_IN))
self.halcomp.ready()
sp.Popen(['halcmd net plasmac:torch-on plasmactest.torch-on'],
shell=True)
self.torch.connect('value-changed', self.torch_changed)
if not hal.pin_has_writer('plasmac.arc-ok-in'):
sp.Popen([
'halcmd net p_test:arc-ok-in plasmactest.arcOk plasmac.arc-ok-in'
],
shell=True)
if not hal.pin_has_writer('plasmac.arc-voltage-in'):
sp.Popen([
'halcmd net p_test:arc-voltage-in plasmactest.arcVoltage plasmac.arc-voltage-in'
],
shell=True)
if not hal.pin_has_writer('debounce.0.0.in'):
sp.Popen([
'halcmd net p_test:float-switch plasmactest.floatSwitch debounce.0.0.in'
],
shell=True)
if not hal.pin_has_writer('debounce.0.1.in'):
sp.Popen([
'halcmd net p_test:breakaway-switch plasmactest.breakawaySwitch debounce.0.1.in'
],
shell=True)
if not hal.pin_has_writer('debounce.0.2.in'):
sp.Popen([
'halcmd net p_test:ohmic-probe plasmactest.ohmicProbe debounce.0.2.in'
],
shell=True)
if not hal.pin_has_writer('plasmac.move-down'):
sp.Popen([
'halcmd net p_test:move-down plasmactest.moveDown plasmac.move-down'
],
shell=True)
if not hal.pin_has_writer('plasmac.move-up'):
sp.Popen([
'halcmd net p_test:move-up plasmactest.moveUp plasmac.move-up'
],
shell=True)
self.W.connect('delete_event', self.ignore)
self.W.set_type_hint(gdk.WINDOW_TYPE_HINT_MENU)
self.W.set_keep_above(True)
self.W.show_all()
mode = self.lcnc.iniFile.find('PLASMAC', 'MODE') or '0'
if mode not in '012':
mode = 0
self.B.get_object('mode' + mode).set_active(1)
functions = {
'0': self.on_mode0_toggled(0),
'1': self.on_mode1_toggled(0),
'2': self.on_mode2_toggled(0),
}
if mode in functions:
functions[mode]
def main_show(self, parent):
self.parent = parent
self.W = gtk.Dialog('PlasmaC Conversational',
None,
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
buttons=None)
self.W.set_keep_above(True)
self.W.set_position(gtk.WIN_POS_CENTER)
self.W.set_default_size(890, 663)
self.W.connect('delete_event', self.on_delete_event)
top = gtk.HBox(True, 2)
bottom = gtk.HBox()
self.W.vbox.pack_start(top, expand=False, fill=True)
self.W.vbox.pack_start(bottom, expand=True, fill=True)
self.left = gtk.VBox()
right = gtk.Frame()
bottom.pack_start(self.left, expand=False, fill=True)
bottom.pack_start(right, expand=True, fill=True)
self.line = gtk.Button()
self.line.connect('clicked', self.on_line_clicked)
self.circle = gtk.Button()
self.circle.connect('clicked', self.on_circle_clicked)
self.triangle = gtk.Button()
self.triangle.connect('clicked', self.on_triangle_clicked)
self.rectangle = gtk.Button()
self.rectangle.connect('clicked', self.on_rectangle_clicked)
self.polygon = gtk.Button()
self.polygon.connect('clicked', self.on_polygon_clicked)
self.bolt_circle = gtk.Button()
self.bolt_circle.connect('clicked', self.on_bolt_circle_clicked)
self.slot = gtk.Button()
self.slot.connect('clicked', self.on_slot_clicked)
self.star = gtk.Button()
self.star.connect('clicked', self.on_star_clicked)
self.gusset = gtk.Button()
self.gusset.connect('clicked', self.on_gusset_clicked)
self.sector = gtk.Button()
self.sector.connect('clicked', self.on_sector_clicked)
self.rotate = gtk.Button()
self.rotate.connect('clicked', self.on_rotate_clicked)
self.array = gtk.Button()
self.array.connect('clicked', self.on_array_clicked)
buttons = [self.line, self.circle, self.triangle, self.rectangle, \
self.polygon, self.bolt_circle, self.slot, self.star, \
self.gusset, self.sector, self.rotate, self.array]
bunames = ['line', 'circle', 'triangle', 'rectangle', 'polygon', \
'bolt_circle', 'slot', 'star', 'gusset', 'sector', \
'rotate', 'array']
for wizard in bunames:
if bunames.index(wizard) <= 11:
pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(
filename='./wizards/images/{}-thumb.png'.format(wizard),
width=60,
height=60)
image = gtk.Image()
image.set_from_pixbuf(pixbuf)
buttons[bunames.index(wizard)].set_image(image)
top.add(buttons[bunames.index(wizard)])
right.add(self.preview)
self.entries = gtk.Table(1, 1, True)
self.entries.set_row_spacings(self.rowSpace)
self.left.pack_start(self.entries, expand=False, fill=True)
spaceFrame = gtk.Frame()
spaceFrame.set_shadow_type(gtk.SHADOW_NONE)
self.left.pack_start(spaceFrame, expand=True, fill=True)
self.button_frame = gtk.Frame()
self.button_frame.set_shadow_type(gtk.SHADOW_ETCHED_IN)
self.left.pack_start(self.button_frame, expand=False, fill=True)
self.button_box = gtk.Table(1, 5, True)
self.button_frame.add(self.button_box)
bLabel1 = gtk.Label()
bLabel1.set_width_chars(9)
self.button_box.attach(bLabel1, 0, 1, 0, 1)
self.new = gtk.Button('New')
self.new.connect('clicked', self.on_new_clicked)
self.button_box.attach(self.new, 0, 1, 0, 1)
self.save = gtk.Button('Save')
self.save.connect('clicked', self.on_save_clicked)
self.button_box.attach(self.save, 1, 2, 0, 1)
self.settings = gtk.Button('Settings')
self.settings.connect('clicked', self.on_settings_clicked)
self.button_box.attach(self.settings, 2, 3, 0, 1)
self.quit = gtk.Button('Quit')
self.quit.connect('clicked', self.on_quit_clicked)
self.button_box.attach(self.quit, 3, 4, 0, 1)
self.send = gtk.Button('Send')
self.send.connect('clicked', self.on_send_clicked)
self.button_box.attach(self.send, 4, 5, 0, 1)
if self.scale == 1:
unitCode = ['21', '0.25', 32]
else:
unitCode = ['20', '0.004', 1.26]
self.preamble = 'G{} G64P{} G40 G49 G80 G90 G92.1 G94 G97'.format(
unitCode[0], unitCode[1])
self.postamble = 'G{} G64P{} G40 G49 G80 G90 G92.1 G94 G97'.format(
unitCode[0], unitCode[1])
self.origin = False
self.leadin = 0
self.leadout = 0
self.holeRadius = unitCode[2] / 2.0
self.holeSpeed = 60.0
wWidth = 890
wHeight = 582
gSize = 0
fSize = '9'
if os.path.exists(self.configFile):
f_in = open(self.configFile, 'r')
try:
for line in f_in:
if line.startswith('preamble'):
self.preamble = line.strip().split('=')[1]
elif line.startswith('postamble'):
self.postamble = line.strip().split('=')[1]
elif line.startswith('origin') and line.strip().split(
'=')[1] == 'True':
self.origin = True
elif line.startswith('lead-in'):
self.leadIn = line.strip().split('=')[1]
elif line.startswith('lead-out'):
self.leadOut = line.strip().split('=')[1]
elif line.startswith('hole-diameter'):
self.holeRadius = float(line.strip().split('=')[1]) / 2
elif line.startswith('hole-speed'):
self.holeSpeed = float(line.strip().split('=')[1])
elif line.startswith('window-width'):
wWidth = int(line.strip().split('=')[1])
elif line.startswith('window-height'):
wHeight = int(line.strip().split('=')[1])
elif line.startswith('grid-size'):
# glcanon has a reversed scale to just about everything else... :(
gSize = float(line.strip().split('=')[1]) * (
0.03937000787402 / self.scale)
elif line.startswith('font-size'):
fSize = line.strip().split('=')[1]
except:
print('Using default wizard settings')
if wWidth and wHeight:
self.resize_window(wWidth, wHeight)
if gSize:
self.preview.grid_size = gSize
gtk.settings_get_default().set_property('gtk-font-name',
'sans {}'.format(fSize))
self.W.show_all()
self.s.poll()
if self.s.file:
try:
shutil.copyfile(self.s.file, self.fNgc)
shutil.copyfile(self.s.file, self.fNgcBkp)
self.preview.load(self.fNgc)
except:
self.on_new_clicked(None)
else:
self.on_new_clicked(None)
#hal.set_p('plasmac_run.preview-tab', '1')
self.s.poll()
self.xOrigin = float(self.s.actual_position[0] - self.s.g5x_offset[0] -
self.s.g92_offset[0])
self.yOrigin = float(self.s.actual_position[1] - self.s.g5x_offset[1] -
self.s.g92_offset[1])
self.xSaved = '0.000'
self.ySaved = '0.000'
self.oSaved = self.origin
self.on_line_clicked(None)
response = self.W.run()
def set_fonts():
client = gconf.client_get_default()
face = client.get_string('/desktop/sugar/font/default_face')
size = client.get_float('/desktop/sugar/font/default_size')
settings = gtk.settings_get_default()
settings.set_property("gtk-font-name", "%s %f" % (face, size))
if __name__ == "__main__":
import gui.main_loop as main_loop
#from gui.main_gui import Gui, excepthook, halt, init_gettext
sys.excepthook = excepthook #capturar exceptiones unhandled.
warnings.showwarning = self.redirect_warnings #capturar pygtk warnings.
init_gettext() #internacionalization
try:
#select ms-windows theme (pyinstaller 1.5.1 fix)
if cons.OS_WIN:
try:
basedir = os.environ['_MEIPASS2']
gtkrc = os.path.join(basedir, 'share/themes/MS-Windows/gtk-2.0/gtkrc')
gtk.rc_set_default_files([gtkrc])
gtk.rc_reparse_all_for_settings(gtk.settings_get_default(), True)
except KeyError as err:
#self.logger.warning(err)
pass
#
#self.logger.info("New app gui instance")
gobject.threads_init() #permitir threading en pygtk
gui_istance = Gui()
main_loop.run()
except Exception as err:
#self.logger.exception(err)
halt() #close gui.
