def __init__(self, config, module_list=None, module_set=None):
self.orig_modulelist = module_list
self.module_set = jhbuild.moduleset.load(config)
buildscript.BuildScript.__init__(self, config, module_list, module_set=self.module_set)
self.config = config
gtk.Window.__init__(self)
self.set_resizable(False)
theme = gtk.icon_theme_get_default()
if theme.has_icon('applications-development'):
gtk.window_set_default_icon_list(
theme.load_icon('applications-development', 16, ()),
theme.load_icon('applications-development', 24, ()),
theme.load_icon('applications-development', 32, ()),
theme.load_icon('applications-development', 48, ()),
theme.load_icon('applications-development', 64, ()),
theme.load_icon('applications-development', 128, ())
)
self.set_title('JHBuild')
self.create_modules_list_model()
self.create_ui()
self.notify = notify.Notify(config)
if self.default_module_iter:
self.module_combo.set_active_iter(self.default_module_iter)
self.connect('delete-event', self.on_delete_event)
def __init__(self, cb_on_close, height=410, width=250,
posx=100, posy=100):
gtk.Window.__init__(self)
self.set_location(width, height, posx, posy)
self.set_title("emesene")
image_theme = gui.theme.image_theme
try:
gtk.window_set_default_icon_list(
utils.safe_gtk_image_load(image_theme.logo16).get_pixbuf(),
utils.safe_gtk_image_load(image_theme.logo32).get_pixbuf(),
utils.safe_gtk_image_load(image_theme.logo48).get_pixbuf(),
utils.safe_gtk_image_load(image_theme.logo96).get_pixbuf())
except:
gtk.window_set_default_icon(
utils.safe_gtk_image_load(image_theme.logo).get_pixbuf())
self.cb_on_close = cb_on_close
self.cb_on_quit = cb_on_close
self._state = 0
self.connect('delete-event', self._on_delete_event)
self.connect('key-press-event', self._on_key_press)
self.connect('window-state-event', self._on_window_state_event)
self.content = None
self.content_type = 'empty'
def __init__(self, path):
self.icon_path_small = path + "resources/icons/small.png"
self.icon_path_empty = path + "resources/icons/empty.png"
self.icon_path_notempty = path + "resources/icons/notempty.png"
self.icon_path_new = path + "resources/icons/new.png"
self.icon_path_warning = path + "resources/icons/warning.png"
self.sound_path_incoming = path + "resources/sounds/incoming.wav"
self.constants = Constants()
self.critical_errors = [self.constants.get_auterror(), self.constants.get_nologin()]
self.status = self.constants.get_nologin()
logging.info("Simple Gmail Notifier (" + time.strftime("%Y/%m/%d %H:%M:%S", time.localtime()) + ")")
self.config = ConfigWindow(path)
self.options = self.config.options
self.lang = self.config.get_lang()
logging.info("Selected language: " + self.config.get_lang_name())
self.mails = []
self.mailcheck = False
self.maintimer = None
self.tray = gtk.StatusIcon()
self.tray.set_title(self.lang["program"])
self.tray.connect("button_press_event", self.tray_icon_clicked)
self.icon_small = gtk.gdk.pixbuf_new_from_file(self.icon_path_small)
self.icon_empty = gtk.gdk.pixbuf_new_from_file(self.icon_path_empty)
self.icon_notempty = gtk.gdk.pixbuf_new_from_file(self.icon_path_notempty)
self.icon_warning = gtk.gdk.pixbuf_new_from_file(self.icon_path_warning)
gtk.window_set_default_icon_list(self.icon_small)
self.icon_size = self.tray.get_size()
scaled_buf = self.scale_icon_to_system_tray(self.icon_empty)
self.tray.set_from_pixbuf(scaled_buf)
while gtk.events_pending():
gtk.main_iteration(gtk.TRUE)
self.connection = Receiver(self.options['gmailusername'], self.options['gmailpassword'])
self.status = self.constants.get_ok()
self.start_update()
def _set_default_icon():
import gtk
from gtk import gdk
import os.path
def_icon = gdk.pixbuf_new_from_file(
os.path.join(paths.DATA_DIR, 'pixmaps', 'mascot.png')
)
gtk.window_set_default_icon_list(def_icon)
def set_icon(self):
return # can't get this to work
try:
gtk.window_set_default_icon_list([icons.logo.pixbuf])
except Exception,err:
print err
# not supported in this pygtk. Oh well...
pass
def __init__(self, controller):
'''Constructor'''
gtk.Window.__init__(self)
self.controller = controller
self.config = controller.config
# accelerators
accelGroup = gtk.AccelGroup()
self.add_accel_group(accelGroup)
self.accelGroup = accelGroup
accelGroup.connect_group(ord('M'), gtk.gdk.CONTROL_MASK, \
gtk.ACCEL_LOCKED, self.on_toggle_menu)
self.set_title('emesene')
self.set_role('main')
self.geometry = self.config.glob['mainWindowGeometry']
self.parse_geometry(self.geometry)
self.on_size_alloc
self.x, self.y = self.get_position()
self.connect('size-allocate', self.on_size_alloc)
theme = controller.theme
gtk.window_set_default_icon_list(theme.getImage('icon16'),
theme.getImage('icon32'),
theme.getImage('icon48'),
theme.getImage('icon96'))
self.windowVBox = None
self.vbox = None
self.login = None
self.userList = None
#The next generates a variable with letters and numbers to manage the searches
self.acceptedCharacters = map(chr, range(97, 123)) + map(chr, range(65, 91)) \
+ ['0','1','2','3','4','5','6','7','8','9']
self.disconectionMessage = None
self.currentInterface = 'login'
self.buildInterface('login')
self.itemSelectedId = 0
self.signals = []
sap = self.signals.append
sap(self.config.connect('change::showUserPanel',
self.updateConfig))
sap(self.config.connect('change::showSearchEntry',
self.updateConfig))
sap(self.config.connect('change::showStatusCombo',
self.updateConfig))
sap(self.config.connect('change::showMenu',
self.updateConfig))
sap(self.config.connect('change::userListAvatarSize',
self.updateSize))
sap(self.config.connect('change::smallIcons', self.updateSize))
def show_main_window(self, basedir):
self.window.set_title('Tunalyzer')
icon_16 = gtk.gdk.pixbuf_new_from_file(os.path.join(basedir, 'icons', 'icon-16.png'))
icon_32 = gtk.gdk.pixbuf_new_from_file(os.path.join(basedir, 'icons', 'icon-32.png'))
icon_64 = gtk.gdk.pixbuf_new_from_file(os.path.join(basedir, 'icons', 'icon-64.png'))
icon_128 = gtk.gdk.pixbuf_new_from_file(os.path.join(basedir, 'icons', 'icon-128.png'))
icon_256 = gtk.gdk.pixbuf_new_from_file(os.path.join(basedir, 'icons', 'icon-256.png'))
gtk.window_set_default_icon_list(icon_256, icon_128, icon_64, icon_32, icon_16)
self.window.show()
def _setUpIcons(self):
try:
icon16x16 = gtk.gdk.pixbuf_new_from_file(
'/usr/share/pixmaps/geximon-16x16.xpm')
icon32x32 = gtk.gdk.pixbuf_new_from_file(
'/usr/share/pixmaps/geximon-32x32.xpm')
except gobject.GError:
pass
else:
gtk.window_set_default_icon_list(icon32x32, icon16x16)
def __init__(self, controller):
'''Constructor'''
gtk.Window.__init__(self)
self.controller = controller
self.config = controller.config
# accelerators
accelGroup = gtk.AccelGroup()
self.add_accel_group(accelGroup)
self.accelGroup = accelGroup
accelGroup.connect_group(ord('M'), gtk.gdk.CONTROL_MASK, \
gtk.ACCEL_LOCKED, self.on_toggle_menu)
self.set_title('emesene')
self.set_role('main')
self.x = self.config.glob['mainWindowX']
self.y = self.config.glob['mainWindowY']
self.set_geometry_hints(self, -1, -1)
self.width = self.config.glob['mainWindowWidth']
self.height = self.config.glob['mainWindowHeight']
self.set_default_size(self.width , self.height)
self.connect('size-allocate', self.on_size_alloc)
theme = controller.theme
gtk.window_set_default_icon_list(theme.getImage('icon16'),
theme.getImage('icon32'),
theme.getImage('icon48'),
theme.getImage('icon96'))
self.vbox = None
self.login = None
self.userList = None
self.currentInterface = 'login'
self.buildInterface('login')
self.itemSelectedId = 0
self.signals = []
sap = self.signals.append
sap(self.config.connect('change::showUserPanel',
self.updateConfig))
sap(self.config.connect('change::showSearchEntry',
self.updateConfig))
sap(self.config.connect('change::showStatusCombo',
self.updateConfig))
sap(self.config.connect('change::showMenu',
self.updateConfig))
sap(self.config.connect('change::userListAvatarSize',
self.updateSize))
sap(self.config.connect('change::smallIcons', self.updateSize))
def main():
log.logger.info('Started')
# Localization
locale.setlocale(locale.LC_ALL, '')
gettext.textdomain(consts.appNameShort)
gettext.bindtextdomain(consts.appNameShort, consts.dirLocale)
# Command line
prefs.setCmdLine((optOptions, optArgs))
# PyGTK initialization
gobject.threads_init()
gtk.window_set_default_icon_list(
gtk.gdk.pixbuf_new_from_file(consts.fileImgIcon16),
gtk.gdk.pixbuf_new_from_file(consts.fileImgIcon24),
gtk.gdk.pixbuf_new_from_file(consts.fileImgIcon32),
gtk.gdk.pixbuf_new_from_file(consts.fileImgIcon48),
gtk.gdk.pixbuf_new_from_file(consts.fileImgIcon64),
gtk.gdk.pixbuf_new_from_file(consts.fileImgIcon128))
# Create the GUI
wTree = loadGladeFile('MainWindow.ui')
paned = wTree.get_object('pan-main')
window = wTree.get_object('win-main')
prefs.setWidgetsTree(wTree)
# RGBA support
try:
colormap = window.get_screen().get_rgba_colormap()
if colormap:
gtk.widget_set_default_colormap(colormap)
except:
log.logger.info('No RGBA support (requires PyGTK 2.10+)')
# Show all widgets and restore the window size BEFORE hiding some of them
# when restoring the view mode
# Resizing must be done before showing the window to make sure that the WM
# correctly places the window
if prefs.get(__name__, 'win-is-maximized', DEFAULT_MAXIMIZED_STATE):
window.maximize()
height = prefs.get(__name__, 'win-height', DEFAULT_WIN_HEIGHT)
window.resize(prefs.get(__name__, 'win-width', DEFAULT_WIN_WIDTH), height)
window.show_all()
# Restore sizes once more
#window.resize(prefs.get(__name__, 'win-width', DEFAULT_WIN_WIDTH), height)
paned.set_position(prefs.get(__name__, 'paned-pos', DEFAULT_PANED_POS))
# Initialization done, let's continue the show
gobject.idle_add(realStartup, window, paned)
gtk.main()
def run(self):
self.__init_i18n()
[args, headers] = self.__get_options()
gnome.init(NAME, VERSION)
gtk.gdk.threads_init()
gtk.window_set_default_icon_list(*gui.get_icon_list([16, 22, 24, 32]))
self.download_list = DownloadList()
self.download_manager = DownloadManager()
self.dbus_service = dbus_service.DBusService()
# If the DBus service is already running, add downloads using it
if not self.dbus_service.register():
for uri in args:
self.dbus_service.download_manager.AddDownload(uri,
os.getcwd(), headers)
return 0
self.dbus_service.register_object(dbus_service.DOWNLOAD_MGR_OBJ_PATH,
self.download_list)
self.main_window = MainWindow(self.config, self.download_list)
self.dbus_service.register_object(dbus_service.MAIN_WINDOW_OBJ_PATH,
self.main_window)
if self.config.show_main_window:
self.main_window.window.show()
self.status_icon = TrayIcon(self.main_window)
if not self.config.show_status_icon:
self.status_icon.icon.hide_all()
sys.excepthook = self.main_window.on_unhandled_exception
self.download_list.load_from_xml()
for uri in args:
if self.config.ask_for_location:
add = AddDownloadDialog(uri, headers)
add.dialog.run()
else:
self.download_list.add_download(uri,
self.config.default_folder, headers)
gtk.main()
def load_icons():
_icons = (('gimp-flip-horizontal.png', 'mcomix-flip-horizontal'),
('gimp-flip-vertical.png', 'mcomix-flip-vertical'),
('gimp-rotate-180.png', 'mcomix-rotate-180'),
('gimp-rotate-270.png', 'mcomix-rotate-270'),
('gimp-rotate-90.png', 'mcomix-rotate-90'),
('gimp-thumbnails.png', 'mcomix-thumbnails'),
('gimp-transform.png', 'mcomix-transform'),
('tango-enhance-image.png', 'mcomix-enhance-image'),
('tango-add-bookmark.png', 'mcomix-add-bookmark'),
('tango-archive.png', 'mcomix-archive'),
('tango-image.png', 'mcomix-image'),
('library.png', 'mcomix-library'),
('comments.png', 'mcomix-comments'),
('zoom.png', 'mcomix-zoom'),
('lens.png', 'mcomix-lens'),
('double-page.png', 'mcomix-double-page'),
('manga.png', 'mcomix-manga'),
('fitbest.png', 'mcomix-fitbest'),
('fitwidth.png', 'mcomix-fitwidth'),
('fitheight.png', 'mcomix-fitheight'),
('fitmanual.png', 'mcomix-fitmanual'),
('goto-first-page.png', 'mcomix-goto-first-page'),
('goto-last-page.png', 'mcomix-goto-last-page'),
('next-page.png', 'mcomix-next-page'),
('previous-page.png', 'mcomix-previous-page'),
('next-archive.png', 'mcomix-next-archive'),
('previous-archive.png', 'mcomix-previous-archive'),
('next-directory.png', 'mcomix-next-directory'),
('previous-directory.png', 'mcomix-previous-directory'))
# Load window title icons.
pixbufs = mcomix_icons()
gtk.window_set_default_icon_list(*pixbufs)
# Load application icons.
factory = gtk.IconFactory()
for filename, stockid in _icons:
try:
icon_data = resource_string('mcomix.images', filename)
pixbuf = image_tools.load_pixbuf_data(icon_data)
iconset = gtk.IconSet(pixbuf)
factory.add(stockid, iconset)
except Exception:
log.warning(_('! Could not load icon "%s"'), filename)
factory.add_default()
def setup_icons(self):
"""Set the application icons at different sizes"""
iconDirectory = os.path.join(sys.path[0], 'icons')
#FIXME probably there is a better way to do this
iconFilename = os.path.join(iconDirectory, 'moshpytt-logo-16.svg')
iconPixBuf16 = gtk.gdk.pixbuf_new_from_file(iconFilename)
iconFilename = os.path.join(iconDirectory, 'moshpytt-logo-22.svg')
iconPixBuf22 = gtk.gdk.pixbuf_new_from_file(iconFilename)
iconFilename = os.path.join(iconDirectory, 'moshpytt-logo-32.svg')
iconPixBuf32 = gtk.gdk.pixbuf_new_from_file(iconFilename)
iconFilename = os.path.join(iconDirectory, 'moshpytt-logo-48.svg')
iconPixBuf48 = gtk.gdk.pixbuf_new_from_file(iconFilename)
gtk.window_set_default_icon_list( iconPixBuf16, iconPixBuf22, iconPixBuf32, iconPixBuf48)
def _gtk_init(icon=None):
import pygtk
pygtk.require('2.0')
import gtk
import gobject
gobject.threads_init()
pygtk_ver = Version(gtk.pygtk_version)
if pygtk_ver < MinVersions.PYGTK:
print_w("PyGTK %s required. %s found."% (MinVersions.PYGTK, pygtk_ver))
def warn_threads(func):
def w():
name = func.__module__ + "." + func.__name__
print_w("Don't use %r. Use idle_add instead." % name)
func()
return w
gtk.gdk.threads_init = warn_threads(gtk.gdk.threads_init)
gtk.gdk.threads_enter = warn_threads(gtk.gdk.threads_enter)
gtk.gdk.threads_leave = warn_threads(gtk.gdk.threads_leave)
theme = gtk.icon_theme_get_default()
theme.append_search_path(quodlibet.const.IMAGEDIR)
if icon:
pixbufs = []
for size in [64, 48, 32, 16]:
try: pixbufs.append(theme.load_icon(icon, size, 0))
except gobject.GError: pass
gtk.window_set_default_icon_list(*pixbufs)
def website_wrap(activator, link):
if not quodlibet.util.website(link):
from quodlibet.qltk.msg import ErrorMessage
ErrorMessage(
main, _("Unable to start web browser"),
_("A web browser could not be found. Please set "
"your $BROWSER variable, or make sure "
"/usr/bin/sensible-browser exists.")).run()
# only works with a running main loop
gobject.idle_add(gtk.about_dialog_set_url_hook, website_wrap)
def load(
self,
name="Untitled",
menu=None,
accelerators=None,
toolbar=None,
nav_panel=None,
status_bar=None,
notebook=None,
page_change_func=rose.config_editor.false_function,
save_func=rose.config_editor.false_function,
):
self.window = gtk.Window()
self.window.set_title(name + " - " + rose.config_editor.LAUNCH_COMMAND)
self.util = rose.config_editor.util.Lookup()
self.window.set_icon(rose.gtk.util.get_icon())
gtk.window_set_default_icon_list(self.window.get_icon())
self.window.set_default_size(*rose.config_editor.SIZE_WINDOW)
self.window.set_destroy_with_parent(False)
self.save_func = save_func
self.top_vbox = gtk.VBox()
self.log_window = None # The stack viewer.
self.window.add(self.top_vbox)
# Load the menu bar
if menu is not None:
menu.show()
self.top_vbox.pack_start(menu, expand=False)
if accelerators is not None:
self.window.add_accel_group(accelerators)
if toolbar is not None:
toolbar.show()
self.top_vbox.pack_start(toolbar, expand=False)
# Load the nav_panel and notebook
for signal in ["switch-page", "focus-tab", "select-page", "change-current-page"]:
notebook.connect_after(signal, page_change_func)
self.generate_main_hbox(nav_panel, notebook)
self.top_vbox.pack_start(self.main_hbox, expand=True)
self.top_vbox.pack_start(status_bar, expand=False, fill=False)
self.top_vbox.show()
self.window.show()
nav_panel.tree.columns_autosize()
nav_panel.grab_focus()
def __init__(self):
pixs = []
for size in (16, 32, 48, 64, 128):
pix = gtkgui_helpers.get_icon_pixmap("gajim", size)
if pix:
pixs.append(pix)
if pixs:
# set the icon to all windows
gtk.window_set_default_icon_list(*pixs)
if not os.path.exists(LOG_DB_PATH):
dialogs.ErrorDialog(_("Cannot find history logs database"), "%s does not exist." % LOG_DB_PATH)
sys.exit()
xml = gtkgui_helpers.get_gtk_builder("history_manager.ui")
self.window = xml.get_object("history_manager_window")
self.jids_listview = xml.get_object("jids_listview")
self.logs_listview = xml.get_object("logs_listview")
self.search_results_listview = xml.get_object("search_results_listview")
self.search_entry = xml.get_object("search_entry")
self.logs_scrolledwindow = xml.get_object("logs_scrolledwindow")
self.search_results_scrolledwindow = xml.get_object("search_results_scrolledwindow")
self.welcome_vbox = xml.get_object("welcome_vbox")
self.jids_already_in = [] # holds jids that we already have in DB
self.AT_LEAST_ONE_DELETION_DONE = False
self.con = sqlite.connect(LOG_DB_PATH, timeout=20.0, isolation_level="IMMEDIATE")
self.cur = self.con.cursor()
self._init_jids_listview()
self._init_logs_listview()
self._init_search_results_listview()
self._fill_jids_listview()
self.search_entry.grab_focus()
self.window.show_all()
xml.connect_signals(self)
def __init__(self, cb_on_close, height=410, width=250,
posx=100, posy=100):
gtk.Window.__init__(self)
self.box = gtk.HPaned()
self.box.set_can_focus(False)
# HACK! a bunch of properties/methods accessed by the outside
self.box.add_accel_group = self.add_accel_group
self.box.set_title = self.set_title
self.box.set_icon = self.set_icon
self.box.set_urgency_hint = self.set_urgency_hint
self.box.present = self.present
self.box.is_active = self.is_active
self.box.get_dimensions = self.get_dimensions
self.box.is_maximized = self.is_maximized
self._content_main = None
self._content_conv = None
self.set_location(width, height, posx, posy)
self.set_title("emesene")
image_theme = gui.theme.image_theme
try:
gtk.window_set_default_icon_list(
utils.safe_gtk_image_load(image_theme.logo16).get_pixbuf(),
utils.safe_gtk_image_load(image_theme.logo32).get_pixbuf(),
utils.safe_gtk_image_load(image_theme.logo48).get_pixbuf(),
utils.safe_gtk_image_load(image_theme.logo96).get_pixbuf())
except:
gtk.window_set_default_icon(
utils.safe_gtk_image_load(image_theme.logo).get_pixbuf())
self.cb_on_close = cb_on_close
self.cb_on_close_conv = cb_on_close
self.cb_on_quit = cb_on_close
self._state = 0
self.accel_group = None
self.add(self.box)
self.connect('delete-event', self._on_delete_event)
self.connect('window-state-event', self._on_window_state_event)
def __init__(self):
f = file(os.path.expanduser("~/.gmailnotify"), "r")
for line in f:
attr, val = map(str.strip, line.split(":"))
if attr == "poll interval":
self.interval = int(val)
else:
setattr(self, attr, val)
# Lame ass error checking
assert hasattr(self, "username")
assert hasattr(self, "password")
assert hasattr(self, "interval")
# Put gmail-notify icon to all application windows
icon = gtk.gdk.pixbuf_new_from_file(ICON_DISCONNECTED_PATH)
gtk.window_set_default_icon_list((icon))
# Create the tray icon
self.tray_icon = GmailTrayIcon.GmailTrayIcon()
self.tray_icon.set_icon(ICON_PATH)
pixmap = gtk.Image()
pixmap.set_from_file(POPUP_IMAGE)
self.notifyIcon = pixmap.get_pixbuf()
self.notify = pynotify.Notification("No new mail", "")
self.notify.set_icon_from_pixbuf(self.notifyIcon)
# Create the connection
self.account = libgmail.GmailAccount(self.username, self.password)
# Check mail for first time
self.check()
# Schedule mail check
self.timer = gtk.timeout_add(self.interval, self.check)
gtk.main()
def load(self, name='Untitled', menu=None, accelerators=None, toolbar=None,
hyper_panel=None, notebook=None,
page_change_func=rose.config_editor.false_function,
save_func=rose.config_editor.false_function):
self.window = gtk.Window()
self.window.set_title(name + ' - ' + rose.config_editor.LAUNCH_COMMAND)
self.util = rose.config_editor.util.Lookup()
locator = rose.resource.ResourceLocator(paths=sys.path)
icon_path = locator.locate('etc/images/rose-icon-trim.png')
self.window.set_icon_from_file(icon_path)
gtk.window_set_default_icon_list(self.window.get_icon())
self.window.set_default_size(*rose.config_editor.SIZE_WINDOW)
self.window.set_destroy_with_parent(False)
self.save_func = save_func
self.top_vbox = gtk.VBox()
self.log_window = None # The stack viewer.
self.window.add(self.top_vbox)
# Load the menu bar
if menu is not None:
menu.show()
self.top_vbox.pack_start(menu, expand=False)
if accelerators is not None:
self.window.add_accel_group(accelerators)
if toolbar is not None:
toolbar.show()
self.top_vbox.pack_start(toolbar, expand=False)
# Load the hyper_panel and notebook
for signal in ['switch-page', 'focus-tab', 'select-page',
'change-current-page']:
notebook.connect_after(signal, page_change_func)
self.generate_main_hbox(hyper_panel, notebook)
self.top_vbox.pack_start(self.main_hbox, expand=True)
self.top_vbox.show()
self.window.show()
hyper_panel.tree.columns_autosize()
hyper_panel.grab_focus()
def __init__(self, path):
logging.debug("Creating configuration dialog")
self.lang_path = path + "resources/langs.xml"
self.icon_path = path + "resources/icons/small.png"
self.config_path = os.path.expanduser(
"~/.config/simple-gmail-notifier/notifier.conf")
self.read_config()
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_title(self.lang["config_title"])
self.window.set_border_width(5)
self.window.set_position(gtk.WIN_POS_CENTER)
self.window.set_modal(gtk.TRUE)
self.window.set_resizable(gtk.FALSE)
icon = gtk.gdk.pixbuf_new_from_file(self.icon_path)
gtk.window_set_default_icon_list(icon)
self.window.connect("delete_event", self.on_delete)
# elements = [ [Option Name, String ID, Entry, Label ], ... ]
self.elements = [["gmailusername", "config_username", None, None],
["gmailpassword", "config_password", None, None],
["browserpath", "config_browser", None, None],
[
"checkinterval", "config_check_interval", None,
None
], ["popuptimespan", "config_popup_time", None, None]]
table = gtk.Table(rows=8, columns=2, homogeneous=gtk.FALSE)
self.window.add(table)
for i, element in enumerate(self.elements):
element_name = element[0]
label = gtk.Label(self.lang[element[1]])
label.set_alignment(0, 0.5)
textbox = gtk.Entry(max=0)
if self.options[element_name] is not None:
textbox.set_text(str(self.options[element_name]))
if element_name == "gmailpassword":
textbox.set_visibility(gtk.FALSE)
textbox.set_invisible_char('*')
element[2] = textbox
element[3] = label
table.attach(label, 0, 1, i, i + 1, xpadding=2, ypadding=1)
table.attach(textbox, 1, 2, i, i + 1, xpadding=2, ypadding=1)
label.show()
textbox.show()
alignment = gtk.Alignment(0.5, 0.5, 0.0, 0.0)
self.save = gtk.CheckButton(label=self.lang["menu_save"])
alignment.add(self.save)
if self.options["gmailusername"] is not None and self.options[
"gmailpassword"] is not None:
self.save.set_active(gtk.TRUE)
else:
self.save.set_active(gtk.FALSE)
self.save.show()
table.attach(alignment, 0, 2, 6, 7)
alignment.show()
self.lbl_langs = gtk.Label(self.lang["menu_language"])
self.lbl_langs.set_alignment(0, 0.5)
self.cbo_langs = gtk.combo_box_new_text()
self.cbo_langs.connect('changed', self.update_labels)
for one_lang in self.langs:
if one_lang == self.options["lang"]:
self.cbo_langs.prepend_text(one_lang)
else:
self.cbo_langs.append_text(one_lang)
self.cbo_langs.set_active(0)
table.attach(self.lbl_langs, 0, 1, 5, 6)
self.lbl_langs.show()
table.attach(self.cbo_langs, 1, 2, 5, 6, ypadding=5)
self.cbo_langs.show()
button = gtk.Button(stock=gtk.STOCK_OK)
table.attach(button, 0, 2, 7, 8, ypadding=2)
button.connect("clicked", self.on_ok)
button.show()
table.show()
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import gtk
import os
import sys
# Set the location of the GUI image files depending on whether we're
# running as a normal Python program or a "frozen" binary.
if hasattr(sys, 'frozen'):
images_folder = os.path.join(os.path.dirname(sys.executable), 'images')
else:
images_folder = os.path.dirname(__file__) + '/images'
# set up the icons for use by all application windows
gtk.window_set_default_icon_list(
gtk.gdk.pixbuf_new_from_file(images_folder + '/icons/16.png'),
gtk.gdk.pixbuf_new_from_file(images_folder + '/icons/32.png'),
gtk.gdk.pixbuf_new_from_file(images_folder + '/icons/48.png'),
gtk.gdk.pixbuf_new_from_file(images_folder + '/icons/64.png'))
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import gtk
import os
import sys
# Set the location of the GUI image files depending on whether we're
# running as a normal Python program or a "frozen" binary.
if hasattr(sys, 'frozen'):
images_folder = os.path.join(os.path.dirname(sys.executable), 'images')
else:
images_folder = os.path.dirname(__file__) + '/images'
# set up the icons for use by all application windows
gtk.window_set_default_icon_list(
gtk.gdk.pixbuf_new_from_file(images_folder + '/icons/16.png'),
gtk.gdk.pixbuf_new_from_file(images_folder + '/icons/32.png'),
gtk.gdk.pixbuf_new_from_file(images_folder + '/icons/48.png'),
gtk.gdk.pixbuf_new_from_file(images_folder + '/icons/64.png'))
def main():
GPyFSA()
gtk.window_set_default_icon_list(
gtk.gdk.pixbuf_new_from_file(conf.SCALABLE_ICON))
gtk.main()
def uiInit(ui):
from gobject import TYPE_STRING as goStr, TYPE_INT as goInt
apw = ui.apw
ui.callDir = ph.dirname(ph.abspath(__file__))
cd(ui.callDir)
ui.version = .86
ui.title = "PCBnew python module based Panelizator v.%0.2f. For BZR>5161" % ui.version
ui.mainWindow = gtk.Window(gtk.WINDOW_TOPLEVEL)
ui.wdhMain, ui.hgtMain = (580, 300)
ui.mainWindow.set_geometry_hints(min_width=ui.wdhMain,
min_height=ui.hgtMain)
ui.mainWindow.set_size_request(ui.wdhMain, ui.hgtMain)
ui.mainWindow.set_title(ui.title)
ui.mainWindow.set_border_width(5)
accGroup = gtk.AccelGroup()
ui.mainWindow.add_accel_group(accGroup)
mainFrame = ui.mainFrame = gtk.Fixed()
ui.logView = ui.apw.TextView(mainFrame,
5,
5,
0,
0,
bEditable=False,
tabSpace=4,
fontDesc=ui.fontFixedDesc)
lsAngle = map(
lambda n: ((u"{}°".format(n * 90)), (int(
(n * 90 + 360) % 360 * 10))), (range(-1, 3)))
ui.rfAngle = radioFrame("Rotate:",
mainFrame,
lsAngle,
0,
0,
20,
active=1,
wrap=2,
fontDesc=ui.fontDesc)
ui.labFilename = apw.Label("File:", mainFrame, 0, 0, 30)
if __name__ == "__main__":
ui.txtFilename = apw.Butt('Test', mainFrame, 0, 0, 0)
else:
ui.txtFilename = apw.Label(
u'Drag file to log view or use „Open” button →',
mainFrame,
0,
0,
0,
xalign=0.,
selectable=True)
ui.buttonFileName = ui.apw.Butt(None,
mainFrame,
0,
0,
30,
stockID=gtk.STOCK_OPEN)
ui.Margin = rasterMetricMils("Margin:", mainFrame, apw, 0, 0)
ui.SpaceX = rasterMetricMils("SpaceX:", mainFrame, apw, 0, 0)
ui.SpaceY = rasterMetricMils("SpaceY:", mainFrame, apw, 0, 0)
ui.buttonProceed = ui.apw.Butt("Proceed",
mainFrame,
0,
0,
80,
stockID=gtk.STOCK_MEDIA_PLAY)
ui.logoBigPixbuf = gtk.gdk.pixbuf_new_from_file(
ph.realpath(ph.expanduser("pics/panelize-pcb.svg")))
gtk.window_set_default_icon_list(ui.logoBigPixbuf, )
ui.imageLogo = gtk.Image()
ui.imageLogo.set_from_pixbuf(ui.logoBigPixbuf)
mainFrame.put(ui.imageLogo, 0, 0)
ui.labCols = apw.Label("Columns:", mainFrame, 0, 0, 45)
ui.Cols = apw.Num((1, 1, 999, 1), mainFrame, 0, 0, 37)
ui.buttonClear = ui.apw.Butt("Clear log view", mainFrame, 0, 0, 80)
ui.buttonClear.connect("clicked",
lambda xargs: ui.logView.clear_text())
ui.labRows = apw.Label("Rows:", mainFrame, 0, 0, 30)
ui.Rows = apw.Num((1, 1, 999, 1), mainFrame, 0, 0, 37)
ui.buttonExit = ui.apw.Butt("Exit (Ctrl+Q)", mainFrame, 0, 0, 80)
ui.buttonExit.add_accelerator("clicked", accGroup, ord('Q'),
gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)
ui.mainWindow.add(mainFrame)
ui.mainWindow.show_all()
ui.mainWindow.set_keep_above(True)
ui.lastWinSize = None
ui.mainWindow.connect("configure-event", ui.uiSize)
log.logger.info('Started')
prefs.setCmdLine((optOptions, optArgs))
# Localization
locale.setlocale(locale.LC_ALL, '')
gettext.textdomain(consts.appNameShort)
gettext.bindtextdomain(consts.appNameShort, consts.dirLocale)
# PyGTK initialization
gobject.threads_init()
gtk.window_set_default_icon_list(gtk.gdk.pixbuf_new_from_file(consts.fileImgIcon16),
gtk.gdk.pixbuf_new_from_file(consts.fileImgIcon24),
gtk.gdk.pixbuf_new_from_file(consts.fileImgIcon32),
gtk.gdk.pixbuf_new_from_file(consts.fileImgIcon48),
gtk.gdk.pixbuf_new_from_file(consts.fileImgIcon64),
gtk.gdk.pixbuf_new_from_file(consts.fileImgIcon128))
# Create the GUI
wtree = loadGladeFile('MainWindow.ui')
window = wtree.get_object('win-main')
prefs.setWidgetsTree(wtree)
# RGBA support
try:
colormap = window.get_screen().get_rgba_colormap()
if colormap:
gtk.widget_set_default_colormap(colormap)
locale.setlocale(locale.LC_ALL, '')
gettext.bindtextdomain(APP, i18n_DIR)
gettext.textdomain(APP)
gettext.install(APP, i18n_DIR, unicode=1)
gtk.glade.bindtextdomain(APP, i18n_DIR)
gtk.glade.textdomain(APP)
# make sure gtk lets threads run
#os.putenv("PYGTK_USE_GIL_STATE_API", "True")
gtk.gdk.threads_init()
debug.dprint("CHRYSALIS: process id = %d ****************" % os.getpid())
# setup our app icon
myicon = gtk.gdk.pixbuf_new_from_file(DATA_PATH +
"pixmaps/porthole-icon.png")
gtk.window_set_default_icon_list(myicon)
# load config info
config.Config.set_path(DATA_PATH)
config.Config.load()
config.Prefs.use_gladefile = "not assigned"
# create the main window
myapp = MainWindow() #config.Prefs, config.Config)
# start the program loop
gtk.main()
# save the prefs to disk for next time
config.Prefs.save()
# check if directory exists, if not create it
for _dir in DIR_LIST:
if not os.access(_dir, os.F_OK):
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 __init__( self):
# Read configuration
self.readConfig()
self.window = gtk.Window( gtk.WINDOW_TOPLEVEL )
self.window.set_title( self.lang.get_string(1) )
self.window.set_border_width( 5 )
self.window.set_position( gtk.WIN_POS_CENTER )
self.window.set_modal( gtk.TRUE )
self.window.set_resizable(gtk.FALSE)
icon = gtk.gdk.pixbuf_new_from_file(ICON_PATH)
gtk.window_set_default_icon_list( (icon) )
# Register events
self.window.connect( "delete_event", self.onDelete )
# configElements = [ [Option Name, String ID, Entry, Label ], ... ]
self.configElements = [
["gmailusername",2,None,None],
["gmailpassword",22,None,None],
["browserpath",3,None,None],
["proxy",36,None,None],
["voffset",28,None,None],
["hoffset",27,None,None],
["checkinterval",31,None,None],
["animationdelay",29,None,None],
["popuptimespan",30,None,None]
]
# Create table and attach to window
table = gtk.Table( rows=12, columns=2, homogeneous=gtk.FALSE )
self.window.add(table)
# Create and attach widgets
for i in range( len(self.configElements) ):
curVar = self.configElements[i][0]
curLabel = self.configElements[i][1]
label = gtk.Label( self.lang.get_string(curLabel) )
label.set_alignment(0, 0.5)
textbox = gtk.Entry( max=0 )
if ( self.options[curVar] != None ):
textbox.set_text( str( self.options[curVar] ) )
if ( curVar == "gmailpassword" ):
textbox.set_visibility( gtk.FALSE )
textbox.set_invisible_char( '*' )
# Store widget in element array
self.configElements[i][2] = textbox
self.configElements[i][3] = label
table.attach(
label,
0, 1, i, i+1,
xpadding=2,
ypadding=1
)
table.attach(
textbox,
1,2, i, i+1,
xpadding=2,
ypadding=1
)
label.show()
textbox.show()
# Add checkbox to save username/pass to file
alignment = gtk.Alignment( 0.5, 0.5, 0.0, 0.0 )
self.savePassword = gtk.CheckButton( label=self.lang.get_string(34) )
alignment.add( self.savePassword )
if ( self.readLoginFromFile == None and ( self.options["gmailusername"] != None and self.options["gmailpassword"] != None ) ):
self.readLoginFromFile = True
else:
self.readLoginFromFile = False
if ( self.readLoginFromFile ):
self.savePassword.set_active( gtk.TRUE )
else:
self.savePassword.set_active( gtk.FALSE )
self.savePassword.show()
table.attach( alignment, 0, 2, 10, 11 )
alignment.show()
# Add combobox to select language
self.lbl_langs=gtk.Label(self.lang.get_string(4))
self.lbl_langs.set_alignment(0, 0.5)
self.cbo_langs=gtk.combo_box_new_text()
self.cbo_langs.connect( 'changed', self.update_labels)
for one_lang in self.langs:
if one_lang==self.lang:
self.cbo_langs.prepend_text( one_lang.get_name())
else:
self.cbo_langs.append_text( one_lang.get_name())
self.cbo_langs.set_active(0)
# Attach combobox and label
table.attach( self.lbl_langs, 0, 1, 9, 10 )
self.lbl_langs.show()
table.attach( self.cbo_langs, 1, 2, 9, 10, xpadding=5, ypadding=5 )
self.cbo_langs.show()
# Add 'Close' button
button = gtk.Button( stock=gtk.STOCK_OK )
table.attach( button, 0, 2, 11, 12, xpadding=2, ypadding=2 )
button.connect( "clicked", self.onOkay )
button.show()
table.show()
def __init_ui(self):
"Sets up the main ui"
gtk.about_dialog_set_url_hook(lambda d,l: gtk.show_uri(None, l, gtk.get_current_event_time()))
gtk.about_dialog_set_email_hook(lambda d,l: gtk.show_uri(None, "mailto:" + l, gtk.get_current_event_time()))
# set up applet
self.applet.set_flags(gnomeapplet.EXPAND_MINOR)
# set up window icons
pixbufs = [ self.items.get_pixbuf("revelation", size) for size in ( 48, 32, 24, 16) ]
pixbufs = [ pixbuf for pixbuf in pixbufs if pixbuf != None ]
if len(pixbufs) > 0:
gtk.window_set_default_icon_list(*pixbufs)
# set up popup menu
self.applet.setup_menu("""
<popup name="button3">
<menuitem name="file-unlock" verb="file-unlock" label=\"""" + _('Unlock File') + """\" pixtype="stock" pixname="revelation-unlock" />
<menuitem name="file-lock" verb="file-lock" label=\"""" + _('Lock File') + """\" pixtype="stock" pixname="revelation-lock" />
<menuitem name="file-reload" verb="file-reload" label=\"""" + _('Reload File') + """\" pixtype="stock" pixname="revelation-reload" />
<separator />
<menuitem name="revelation" verb="revelation" label=\"""" + _('Start Revelation') + """\" pixtype="stock" pixname="revelation-revelation" />
<menuitem name="prefs" verb="prefs" label=\"""" + _('Preferences') + """\" pixtype="stock" pixname="gtk-properties" />
<menuitem name="about" verb="about" label=\"""" + _('About') + """\" pixtype="stock" pixname="gnome-stock-about" />
</popup>
""", (
( "about", lambda w,d=None: self.about() ),
( "file-lock", lambda w,d=None: self.file_close() ),
( "file-reload", lambda w,d=None: self.file_reload() ),
( "file-unlock", lambda w,d=None: self.file_open(self.config.get("file")) ),
( "prefs", lambda w,d=None: self.prefs() ),
( "revelation", lambda w,d=None: util.execute_child("@bindir@/revelation") ),
), None)
# set up ui items
self.entry = ui.Entry()
self.entry.set_width_chars(14)
self.entry.connect("activate", self.__cb_entry_activate)
self.entry.connect("button_press_event", self.__cb_entry_buttonpress)
self.entry.connect("key_press_event", lambda w,d=None: self.locktimer.reset())
self.icon = ui.Image()
self.icon.set_from_stock(ui.STOCK_REVELATION, ui.ICON_SIZE_APPLET)
self.eventbox = ui.EventBox(self.icon)
self.eventbox.connect("button_press_event", self.__cb_icon_buttonpress)
self.hbox = ui.HBox(self.eventbox, self.entry)
self.applet.add(self.hbox)
# handle Gnome Panel background
self.applet.connect("change-background",self.panel_bg)
self.applet.show_all()
# set up various ui element holders
self.popup_entryview = None
self.popup_entrylist = None
self.entrymenu = None
def __init__(self):
# Read configuration
self.readConfig()
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_title(self.lang.get_string(1))
self.window.set_border_width(5)
self.window.set_position(gtk.WIN_POS_CENTER)
self.window.set_modal(gtk.TRUE)
self.window.set_resizable(gtk.FALSE)
icon = gtk.gdk.pixbuf_new_from_file(ICON_PATH)
gtk.window_set_default_icon_list((icon))
# Register events
self.window.connect("delete_event", self.onDelete)
# configElements = [ [Option Name, String ID, Entry, Label ], ... ]
self.configElements = [["gmailusername", 2, None, None],
["gmailpassword", 22, None, None],
["browserpath", 3, None, None],
["proxy", 36, None, None],
["voffset", 28, None, None],
["hoffset", 27, None, None],
["checkinterval", 31, None, None],
["animationdelay", 29, None, None],
["popuptimespan", 30, None, None]]
# Create table and attach to window
table = gtk.Table(rows=12, columns=2, homogeneous=gtk.FALSE)
self.window.add(table)
# Create and attach widgets
for i in range(len(self.configElements)):
curVar = self.configElements[i][0]
curLabel = self.configElements[i][1]
label = gtk.Label(self.lang.get_string(curLabel))
label.set_alignment(0, 0.5)
textbox = gtk.Entry(max=0)
if (self.options[curVar] != None):
textbox.set_text(str(self.options[curVar]))
if (curVar == "gmailpassword"):
textbox.set_visibility(gtk.FALSE)
textbox.set_invisible_char('*')
# Store widget in element array
self.configElements[i][2] = textbox
self.configElements[i][3] = label
table.attach(label, 0, 1, i, i + 1, xpadding=2, ypadding=1)
table.attach(textbox, 1, 2, i, i + 1, xpadding=2, ypadding=1)
label.show()
textbox.show()
# Add checkbox to save username/pass to file
alignment = gtk.Alignment(0.5, 0.5, 0.0, 0.0)
self.savePassword = gtk.CheckButton(label=self.lang.get_string(34))
alignment.add(self.savePassword)
if (self.readLoginFromFile == None
and (self.options["gmailusername"] != None
and self.options["gmailpassword"] != None)):
self.readLoginFromFile = True
else:
self.readLoginFromFile = False
if (self.readLoginFromFile):
self.savePassword.set_active(gtk.TRUE)
else:
self.savePassword.set_active(gtk.FALSE)
self.savePassword.show()
table.attach(alignment, 0, 2, 10, 11)
alignment.show()
# Add combobox to select language
self.lbl_langs = gtk.Label(self.lang.get_string(4))
self.lbl_langs.set_alignment(0, 0.5)
self.cbo_langs = gtk.combo_box_new_text()
self.cbo_langs.connect('changed', self.update_labels)
for one_lang in self.langs:
if one_lang == self.lang:
self.cbo_langs.prepend_text(one_lang.get_name())
else:
self.cbo_langs.append_text(one_lang.get_name())
self.cbo_langs.set_active(0)
# Attach combobox and label
table.attach(self.lbl_langs, 0, 1, 9, 10)
self.lbl_langs.show()
table.attach(self.cbo_langs, 1, 2, 9, 10, xpadding=5, ypadding=5)
self.cbo_langs.show()
# Add 'Close' button
button = gtk.Button(stock=gtk.STOCK_OK)
table.attach(button, 0, 2, 11, 12, xpadding=2, ypadding=2)
button.connect("clicked", self.onOkay)
button.show()
table.show()
def main():
# Command line
optparser = optparse.OptionParser(usage='Usage: %prog [options] [FILE(s)]')
optparser.add_option('-p', '--playbin', action='store_true', default=False, help='use the playbin GStreamer component instead of playbin2')
optparser.add_option('--multiple-instances', action='store_true', default=False, help='start a new instance even if one is already running')
optparser.add_option('--no-glossy-cover', action='store_true', default=False, help='disable the gloss effect applied to covers')
optparser.add_option('--volume-button', action='store_true', default=False, help='always show the volume button')
(optOptions, optArgs) = optparser.parse_args()
# Check whether DAP is already running?
if not optOptions.multiple_instances:
shouldStop = False
dbusSession = None
try:
dbusSession = dbus.SessionBus()
activeServices = dbusSession.get_object('org.freedesktop.DBus', '/org/freedesktop/DBus').ListNames()
if consts.dbusService in activeServices:
shouldStop = True
# Raise the window of the already running instance
dbus.Interface(dbusSession.get_object(consts.dbusService, '/'), consts.dbusInterface).RaiseWindow()
# Fill the current instance with the given tracks, if any
if len(optArgs) != 0:
dbus.Interface(dbusSession.get_object(consts.dbusService, '/TrackList'), consts.dbusInterface).SetTracks(optArgs, True)
except:
pass
if dbusSession is not None:
dbusSession.close()
if shouldStop:
sys.exit(1)
log.logger.info('Started')
prefs.setCmdLine((optOptions, optArgs))
# Localization
locale.setlocale(locale.LC_ALL, '')
gettext.textdomain(consts.appNameShort)
gettext.bindtextdomain(consts.appNameShort, consts.dirLocale)
# PyGTK initialization
gobject.threads_init()
gtk.window_set_default_icon_list(
gtk.gdk.pixbuf_new_from_file(consts.fileImgIcon16),
gtk.gdk.pixbuf_new_from_file(consts.fileImgIcon24),
gtk.gdk.pixbuf_new_from_file(consts.fileImgIcon32),
gtk.gdk.pixbuf_new_from_file(consts.fileImgIcon48),
gtk.gdk.pixbuf_new_from_file(consts.fileImgIcon64),
gtk.gdk.pixbuf_new_from_file(consts.fileImgIcon128))
# Create the GUI
wtree = loadGladeFile('MainWindow.ui')
window = wtree.get_object('win-main')
prefs.setWidgetsTree(wtree)
# RGBA support
try:
colormap = window.get_screen().get_rgba_colormap()
if colormap:
gtk.widget_set_default_colormap(colormap)
except:
log.logger.info('No RGBA support (requires PyGTK 2.10+)')
# This object takes care of the window (mainly event handlers)
mainWindow.MainWindow(wtree, window)
def delayedStartup():
"""
Perform all the initialization stuff that is not mandatory to display the window
This function should be called within the GTK main loop, once the window has been displayed
"""
import atexit, dbus.mainloop.glib, signal
from . import modules
def atExit():
""" Final function, called just before exiting the Python interpreter """
prefs.save()
log.logger.info('Stopped')
def onInterrupt(window):
""" Handler for interrupt signals e.g., Ctrl-C """
window.hide()
modules.postQuitMsg()
# D-Bus
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
# Register a few handlers
atexit.register(atExit)
signal.signal(signal.SIGINT, lambda sig, frame: onInterrupt(window))
signal.signal(signal.SIGTERM, lambda sig, frame: onInterrupt(window))
# Now we can start all modules
gobject.idle_add(modules.postMsg, consts.MSG_EVT_APP_STARTED)
# Immediately show the preferences the first time the application is started
if prefs.get(__name__, 'first-time', True):
prefs.set(__name__, 'first-time', False)
gobject.idle_add(modules.showPreferences)
# Let's go
gobject.idle_add(delayedStartup)
gtk.main()
def __init__(self, path):
logging.debug("Creating configuration dialog")
self.lang_path = path + "resources/langs.xml"
self.icon_path = path + "resources/icons/small.png"
self.config_path = os.path.expanduser("~/.config/simple-gmail-notifier/notifier.conf")
self.read_config()
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_title(self.lang["config_title"])
self.window.set_border_width(5)
self.window.set_position(gtk.WIN_POS_CENTER)
self.window.set_modal(gtk.TRUE)
self.window.set_resizable(gtk.FALSE)
icon = gtk.gdk.pixbuf_new_from_file(self.icon_path)
gtk.window_set_default_icon_list(icon)
self.window.connect("delete_event", self.on_delete)
# elements = [ [Option Name, String ID, Entry, Label ], ... ]
self.elements = [
["gmailusername", "config_username", None, None],
["gmailpassword", "config_password", None, None],
["browserpath", "config_browser", None, None],
["checkinterval", "config_check_interval", None, None],
["popuptimespan", "config_popup_time", None, None]]
table = gtk.Table(rows=8, columns=2, homogeneous=gtk.FALSE)
self.window.add(table)
for i, element in enumerate(self.elements):
element_name = element[0]
label = gtk.Label(self.lang[element[1]])
label.set_alignment(0, 0.5)
textbox = gtk.Entry(max=0)
if self.options[element_name] is not None:
textbox.set_text(str(self.options[element_name]))
if element_name == "gmailpassword":
textbox.set_visibility(gtk.FALSE)
textbox.set_invisible_char('*')
element[2] = textbox
element[3] = label
table.attach(label, 0, 1, i, i + 1, xpadding=2, ypadding=1)
table.attach(textbox, 1, 2, i, i + 1, xpadding=2, ypadding=1)
label.show()
textbox.show()
alignment = gtk.Alignment(0.5, 0.5, 0.0, 0.0)
self.save = gtk.CheckButton(label=self.lang["menu_save"])
alignment.add(self.save)
if self.options["gmailusername"] is not None and self.options["gmailpassword"] is not None:
self.save.set_active(gtk.TRUE)
else:
self.save.set_active(gtk.FALSE)
self.save.show()
table.attach(alignment, 0, 2, 6, 7)
alignment.show()
self.lbl_langs = gtk.Label(self.lang["menu_language"])
self.lbl_langs.set_alignment(0, 0.5)
self.cbo_langs = gtk.combo_box_new_text()
self.cbo_langs.connect('changed', self.update_labels)
for one_lang in self.langs:
if one_lang == self.options["lang"]:
self.cbo_langs.prepend_text(one_lang)
else:
self.cbo_langs.append_text(one_lang)
self.cbo_langs.set_active(0)
table.attach(self.lbl_langs, 0, 1, 5, 6)
self.lbl_langs.show()
table.attach(self.cbo_langs, 1, 2, 5, 6, ypadding=5)
self.cbo_langs.show()
button = gtk.Button(stock=gtk.STOCK_OK)
table.attach(button, 0, 2, 7, 8, ypadding=2)
button.connect("clicked", self.on_ok)
button.show()
table.show()
def __init__(self):
self.window = window
try: #load icons as pixbufs and set as default icon
print " gpytagemain: PIXMAPS =", PIXMAPS
self.i16 = gtk.gdk.pixbuf_new_from_file(PIXMAPS + "gpytage-16x16.png")
self.i24 = gtk.gdk.pixbuf_new_from_file(PIXMAPS + "gpytage-24x24.png")
self.i32 = gtk.gdk.pixbuf_new_from_file(PIXMAPS + "gpytage-32x32.png")
self.i48 = gtk.gdk.pixbuf_new_from_file(PIXMAPS + "gpytage-48x48.png")
self.i64 = gtk.gdk.pixbuf_new_from_file(PIXMAPS + "gpytage-64x64.png")
self.i128 = gtk.gdk.pixbuf_new_from_file(PIXMAPS + "gpytage-128x128.png")
gtk.window_set_default_icon_list(self.i16, self.i24, self.i32, self.i48, self.i64, self.i128)
except:
print "GPytage could not find its icons!"
self.window.set_default_size(800, 500)
self.datastore = folderModel
self.files = config_files
initData()
initTreeModel()
self.uimanager = gtk.UIManager()
self.accelgroup = self.uimanager.get_accel_group()
self.actiongroup = gtk.ActionGroup('GPytage')
self.ui = '''
<ui>
<menubar name="MenuBar">
<menu action="File">
<menuitem action="New"/>
<separator/>
<menuitem action="Save"/>
<menuitem action="Save All"/>
<menuitem action="Revert"/>
<menuitem action="Revert All"/>
<separator/>
<menuitem action="Delete File/Folder"/>
<menuitem action="Rename"/>
<separator/>
<menuitem action="Quit"/>
</menu>
<menu action="Edit">
<menuitem action="Add Package"/>
<menuitem action="Remove Package"/>
<menuitem action="Toggle Comment"/>
</menu>
<menu action="View">
<menuitem action="Expand All"/>
<menuitem action="Collapse All"/>
</menu>
<menu action="Help">
<menuitem action="About"/>
</menu>
</menubar>
<toolbar name="ToolBar">
<toolitem action="New"/>
<toolitem action="Save"/>
<toolitem action="Revert"/>
<toolitem action="Add Package"/>
<toolitem action="Remove Package"/>
<toolitem action="Comment"/>
<toolitem action="Uncomment"/>
</toolbar>
</ui>'''
#This controls the MenuBar and the ToolBar
self.actiongroup.add_actions([
('File', None, '_File'),
('New', gtk.STOCK_NEW, '_New File', '<Control>n', 'New file', newFile),
('Save', gtk.STOCK_SAVE, '_Save', '<Control>s', 'Save changes',
saveModifiedFile),
('Save All', gtk.STOCK_SAVE_AS, 'Save _All', None, 'Save all changes', saveModifiedFiles),
('Revert', gtk.STOCK_REVERT_TO_SAVED, '_Revert', None, 'Revert changes', revertSelected),
('Revert All', gtk.STOCK_REVERT_TO_SAVED, 'Re_vert All', None, 'Revert all changes', revertAllModified),
('Quit', gtk.STOCK_QUIT, '_Quit', None, 'Quit GPytage', self.destroy),
('Edit', None, '_Edit'),
('Add Package', gtk.STOCK_ADD, '_Add Package', '<Control>e', 'Add a package', insertRow),
('Remove Package', gtk.STOCK_REMOVE, '_Remove Package', '<Control>d', "Remove a package", deleteRow),
('Delete File/Folder', gtk.STOCK_DELETE, '_Delete File/Folder', None, 'Delete currently selected file or folder', deleteFile),
('Rename', gtk.STOCK_SAVE_AS, '_Rename', None, 'Rename file', renameFile),
('Comment', gtk.STOCK_INDENT, '_Comment', None, "Comment a package", commentRow),
('Uncomment', gtk.STOCK_UNINDENT, '_Uncomment', None, "Uncomment a package", uncommentRow),
('Toggle Comment', gtk.STOCK_CONVERT, '_Toggle Comment', '<Control><Shift>c', "Toggle comment packages", toggleComment),
('View', None, '_View'),
('Expand All', None, '_Expand All', '<Control>slash', 'Expand Rows', expandRows),
('Collapse All', None, '_Collapse All', '<Control>backslash', 'Collapse Rows', collapseRows),
('Help',None,'_Help'),
('About', gtk.STOCK_ABOUT, '_About', None, 'About GPytage', self.about)
])
#Add the UI XML
self.uimanager.insert_action_group(self.actiongroup, 0)
self.uimanager.add_ui_from_string(self.ui)
#Menubar
self.menubar = self.uimanager.get_widget('/MenuBar')
self.toolbar = self.uimanager.get_widget('/ToolBar')
self.vbox = gtk.VBox() #the master Widget
self.vbox.pack_start(self.menubar, False)
self.vbox.pack_start(self.toolbar, False)
#allow the program to quit
self.window.connect("destroy", self.destroy)
self.window.connect("delete_event", self.delete_event)
#Show Widgets
self.pane = gtk.HPaned()
self.pane.pack1(lScroll, True, True)
self.pane.pack2(rScroll, True, True)
self.pane.set_position(200)
self.vbox.pack_start(self.pane)
self.window.add_accel_group(self.accelgroup)
self.window.add(self.vbox)
self.window.show_all()
return True
except Exception:
return False
if pid_alive():
if (show_remote_gajim_roster()):
print("Gajim is already running, bringing the roster to front...")
sys.exit(0)
pixs = []
for size in (16, 32, 48, 64, 128):
pix = gtkgui_helpers.get_icon_pixmap('gajim', size)
if pix:
pixs.append(pix)
if pixs:
# set the icon to all windows
gtk.window_set_default_icon_list(*pixs)
pritext = _('Gajim is already running')
sectext = _('Another instance of Gajim seems to be running\nRun anyway?')
dialog = dialogs.YesNoDialog(pritext, sectext)
dialog.popup()
if dialog.run() != gtk.RESPONSE_YES:
sys.exit(3)
dialog.destroy()
# run anyway, delete pid and useless global vars
if os.path.exists(pid_filename):
os.remove(pid_filename)
del pix
del pritext
del sectext
dialog.destroy()
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()
