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.